Ejemplo n.º 1
0
        public override void Pulse()
        {
            if (combatRoutine.Type == RotationType.SingleTarget)  // Do Single Target Stuff here
            {
                if (WoW.HasTarget && WoW.TargetIsEnemy)
                {
                    if (WoW.CanCast("Kill Command") && WoW.Focus >= 40) // Kill Command
                    {
                        WoW.CastSpellByName("Kill Command");
                        return;
                    }

                    if (WoW.CanCast("Arcane Shot") && WoW.Focus >= 30) // Arcane Shot
                    {
                        WoW.CastSpellByName("Arcane Shot");
                        return;
                    }

                    if (WoW.CanCast("Steady Shot")) // Steady Shot
                    {
                        WoW.CastSpellByName("Steady Shot");
                        Thread.Sleep(1000);
                        return;
                    }
                }
            }
            if (combatRoutine.Type == RotationType.AOE)
            {
                // Do AOE Stuff here

                // Log.Write("Has Aura: " + WoW.HasAura("Furious Howl"));
                // Log.Write("Aura Count: " + WoW.GetAuraCount("Furious Howl"));
                // Log.Write("Aura Count: " + WoW.GetAuraCount("Taste for Blood"));
            }
        }
        public override void Pulse()
        {
            new Thread(PulseUpdateSpells).Start();

            PulseTick    = Environment.TickCount;
            Gcd          = CooldownWithHaste(1500);
            HolyPower    = WoW.CurrentHolyPower;
            InMeleeRange = WoW.CanCast("Templar Verdict", false, false, true, false, true);
            BloodLustUp  = WoW.PlayerHasBuff("Bloodlust") || WoW.PlayerHasBuff("Time Warp") || WoW.PlayerHasBuff("Netherwinds") || WoW.PlayerHasBuff("Drums of War");


            //Log.Write("11 " + BladeOfJustice.SpellCanCast);

            if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.IsInCombat && !WoW.PlayerIsChanneling && !WoW.PlayerIsCasting && !WoW.PlayerHasBuff("Mount"))
            {
                if (false)
                {
                    //System.Diagnostics.Stopwatch sw = new Stopwatch();
                    //sw.Start();

                    //PulseRotattion();

                    //sw.Stop();
                    //Log.Write("## " + sw.ElapsedMilliseconds);
                }
                PulseRotattion();
            }
        }
Ejemplo n.º 3
0
 public override void Pulse()
 {
     if (combatRoutine.Type == RotationType.SingleTarget)
     {
         if (WoW.HasTarget && WoW.TargetIsEnemy && !WoW.PlayerIsChanneling && !WoW.PlayerIsCasting && !WoW.HasDebuff("Paralysis"))
         {
             if (WoW.CanCast("Energizing Elixir") && WoW.IsSpellInRange("Tiger Palm") && !WoW.IsSpellOnCooldown("Energizing Elixir") && !WoW.IsSpellOnCooldown("Fists of Fury") && WoW.CurrentChi <= 1)
             {
                 WoW.CastSpellByName("Energizing Elixir");
                 return;
             }
             if (WoW.CanCast("Strike of the Windlord") && WoW.CurrentChi >= 2 && !WoW.lastSpell.Equals("Strike of the Windlord") && WoW.IsSpellInRange("Tiger Palm"))
             {
                 WoW.CastSpellByName("Strike of the Windlord");
                 return;
             }
             if (WoW.CanCast("Fists of Fury") && WoW.CurrentChi >= 3 && !WoW.lastSpell.Equals("Fists of Fury") && WoW.IsSpellInRange("Tiger Palm"))
             {
                 WoW.CastSpellByName("Fists of Fury");
                 return;
             }
             if (WoW.CanCast("Rising Sun Kick") && !WoW.lastSpell.Equals("Rising Sun Kick") && WoW.CurrentChi >= 2 && WoW.IsSpellInRange("Tiger Palm"))
             {
                 WoW.CastSpellByName("Rising Sun Kick");
                 return;
             }
             if (WoW.CanCast("Whirling Dragon Punch") && WoW.IsSpellOnCooldown("Rising Sun Kick") && WoW.IsSpellOnCooldown("Fists of Fury") && WoW.IsSpellInRange("Tiger Palm"))
             {
                 WoW.CastSpellByName("Whirling Dragon Punch");
                 return;
             }
             if (WoW.CanCast("Chi Wave") && !WoW.lastSpell.Equals("Chi Wave"))
             {
                 WoW.CastSpellByName("Chi Wave");
                 return;
             }
             if (WoW.CanCast("Touch of Death") && !WoW.lastSpell.Equals("Touch of Death") && WoW.IsSpellInRange("Tiger Palm"))
             {
                 WoW.CastSpellByName("Touch of Death");
                 return;
             }
             if (WoW.CanCast("Blackout Kick") && !WoW.lastSpell.Equals("Blackout Kick") && (WoW.CurrentChi >= 1 || WoW.HasBuff("Blackout Kick!")) && WoW.IsSpellInRange("Tiger Palm"))
             {
                 WoW.CastSpellByName("Blackout Kick");
                 return;
             }
             if (WoW.CanCast("Tiger Palm") && !WoW.lastSpell.Equals("Tiger Palm") && WoW.CurrentChi < 4 && WoW.Energy >= 50 && WoW.IsSpellInRange("Tiger Palm"))
             {
                 WoW.CastSpellByName("Tiger Palm");
                 return;
             }
         }
     }
     if (combatRoutine.Type == RotationType.AOE)
     {
         if (WoW.HasTarget && WoW.TargetIsEnemy)
         {
         }
     }
 }
Ejemplo n.º 4
0
        public override void Pulse()
        {
            if (WoW.TargetHealthPercent == 0)
            {
                return;
            }

            if (!WoW.TargetIsEnemy)
            {
                return;
            }
            WoW.CastSpell("Rebuke", WoW.TargetIsCastingAndSpellIsInterruptible && WoW.TargetPercentCast > 60);
            WoW.CastSpell("ArdentDefender", WoW.PlayerHealthPercent < 15);
            WoW.CastSpell("LayOnHands", WoW.CanCast("LayOnHands") && !WoW.PlayerHasDebuff("Forbearance") && WoW.PlayerHealthPercent < 20 && !WoW.PlayerHasBuff("ArdentDefender"));
            WoW.CastSpell("GuardianOfAncientKings", WoW.PlayerHealthPercent < 50 && !WoW.PlayerHasBuff("ArdentDefender"));
            if (!WoW.HasTarget)
            {
                return;
            }
            WoW.CastSpell("AvengingWrath", UseCooldowns, false); // Off the GCD no return needed.
            WoW.CastSpell("AvengersShield", true);
            WoW.CastSpell("EyeOfTyr", WoW.PlayerHealthPercent < 100);
            WoW.CastSpell("Judgment", true);
            WoW.CastSpell("Consecration", true);
            WoW.CastSpell("LightOfTheProtector", WoW.PlayerHasBuff("Consecration") && WoW.PlayerHealthPercent < 70);
            WoW.CastSpell("BlessedHammer", WoW.Talent(1) == 2);
            WoW.CastSpell("BastionOfLight", WoW.PlayerSpellCharges("ShieldOfTheRighteous") == 0 && !WoW.PlayerHasBuff("ShieldOfTheRighteous"));
            WoW.CastSpell("ShieldOfTheRighteous", WoW.PlayerHasBuff("Consecration") &&
                          WoW.PlayerSpellCharges("ShieldOfTheRighteous") > 0 &&
                          !WoW.PlayerHasBuff("ShieldOfTheRighteous"));
            WoW.CastSpell("Seraphim", WoW.Talent(7) == 2);
            WoW.CastSpell("BlessedHammer", true);
        }
Ejemplo n.º 5
0
        public override void OutOfCombatPulse()
        {
            if (doneOpener)
            {
                doneOpener = false;
            }

            if (WoW.CanCast("Greater Blessing of Kings") && WoW.Level >= 58 && (!WoW.HasTarget || WoW.TargetIsFriend) && !WoW.PlayerHasBuff("Greater Blessing of Kings"))

            {
                WoW.CastSpell("Greater Blessing of Kings");
                return;
            }

            if (WoW.CanCast("Greater Blessing of Wisdom") && WoW.Level >= 65 && (!WoW.HasTarget || WoW.TargetIsFriend) && !WoW.PlayerHasBuff("Greater Blessing of Wisdom"))

            {
                WoW.CastSpell("Greater Blessing of Wisdom");
                return;
            }

            if (WoW.CanCast("Flash of Light") && WoW.PlayerHealthPercent < 80)
            {
                WoW.CastSpell("Flash of Light");
                return;
            }
        }
        private void interruptcast()
        {
            Random random       = new Random();
            int    randomNumber = random.Next(interMin, interMax);

            if (WoW.TargetPercentCast > randomNumber && WoW.TargetIsCastingAndSpellIsInterruptible)
            {
                if (WoW.CanCast("Wind Shear") && !WoW.IsSpellOnCooldown("Wind Shear") && WoW.TargetIsCasting && WoW.IsSpellInRange("Wind Shear")) //interupt every spell, not a boss.
                {
                    WoW.CastSpell("Wind Shear");
                    return;
                }
                if (WoW.PlayerRace == "BloodElf" && WoW.CanCast("Arcane Torrent", true, true, false, false, true) && !WoW.IsSpellOnCooldown("Wind Shear") && WoW.IsSpellInRange("Stormstrike")) //interupt every spell, not a boss.
                {
                    WoW.CastSpell("Arcane Torrent");
                    return;
                }
                if (WoW.PlayerRace == "Pandaren" && WoW.CanCast("Quaking palm", true, true, true, false, true)) //interupt every spell, not a boss.
                {
                    WoW.CastSpell("Quaking palm");
                    return;
                }
            }

            /*  for (int i = 1; i < 5; i++)
             *    if (WoW.BossPercentCast(i) > randomNumber && WoW.BossIsCastingAndSpellIsInterruptible(i))
             *    {
             *
             *        if (WoW.CanCast("Wind Shear")) //interupt every spell, not a boss.
             *        {
             *            WoW.CastSpell("Wind Shear");
             *            return;
             *        }
             *    }*/
        }
Ejemplo n.º 7
0
        public override void Pulse()
        {
            var lowest          = WoW.PartyLowestHealthPercent;
            int currentTargetId = WoW.PartyMemberIdWithLowestHealthPercent;

            if (WoW.PartyMemberIsNeedingADispel != 0)
            {
                currentTargetId = WoW.PartyMemberIsNeedingADispel;
            }

            var test      = WoW.TargetIsPlayer;
            var averageHp = WoW.PartyAverageHealthPercent;

            WoW.TargetMember(currentTargetId);


            /*-----------------------------Cooldowns-------------------------------------*/
            WoW.CastSpell("HealingTideTotem", WoW.CountAlliesUnderHealthPercentage(40) >= 5 && !WoW.PlayerHasBuff("Ascendence"));
            WoW.CastSpell("Ascendence", WoW.CountAlliesUnderHealthPercentage(40) >= 5 && WoW.IsSpellOnCooldown("HealingTideTotem"));
            WoW.CastSpell("AncestrialGuidance", WoW.CountAlliesUnderHealthPercentage(75) >= 3 && WoW.IsSpellOnCooldown("HealingTideTotem") && !WoW.PlayerHasBuff("Ascendence"));
            /*-----------------------------Cooldowns-------------------------------------*/

            if (WoW.PartyMemberIsNeedingADispel != 0 && WoW.CanCast("Purify Spirit"))
            {
                WoW.CastSpell("Purify Spirit");
                return;
            }

            WoW.CastSpell("Riptide", lowest < 99 && !WoW.TargetHasBuff("Riptide"));
            WoW.CastSpell("HealingStreamTotem", lowest < 99);
            WoW.CastSpell("HealingSurge", lowest < 35);
            WoW.CastSpell("ChainHeal", WoW.CountAlliesUnderHealthPercentage(85) >= 3);
            WoW.CastSpell("HealingWave", lowest < 90);
        }
Ejemplo n.º 8
0
 public override void OutOfCombatPulse()
 {
     if (!WoW.PlayerHasBuff("Prowl") && WoW.CanCast("Prowl"))
     {
         WoW.CastSpell("Prowl");
         return;
     }
 }
 private void Stuns()
 {
     if (!WoW.PlayerIsCasting)
     {
         if (WoW.PlayerRace == "Tauren​" && !WoW.IsMoving && WoW.CanCast("War Stomp") && !WoW.IsSpellOnCooldown("War Stomp"))
         {
             WoW.CastSpell("War Stomp");
             return;
         }
     }
 }
Ejemplo n.º 10
0
        public override void OutOfCombatPulse()
        {
            //level = WoW.Level;
            battlecrycount = 0;

            //Automount add Mount spellID to Spellbook at bottom (replace mana ray with your own) and force bind a key in options
            if (!WoW.IsInCombat && WoW.CanCast("Mount") && WoW.IsOutdoors && !WoW.IsMoving && !WoW.PlayerIsChanneling && !WoW.IsMounted && ConfigFile.ReadValue <bool>("Fury-Warrior-Lelefi", "Automount"))
            {
                WoW.CastSpell("Mount");
                return;
            }
        }
        private static void Generic()
        {
            if (WoW.CanCast("SoulReaper") && WoW.CanCast("Apocalipse") && WoW.CurrentRunes >= 1 && WoW.TargetDebuffStacks("Festering Wound") >= 7)
            {
                WoW.CastSpell("SoulReaper");
                Thread.Sleep(800);
                WoW.CastSpell("Apocalipse");
                Thread.Sleep(200);
                WoW.CastSpell("Apocalipse");
                Thread.Sleep(200);
                WoW.CastSpell("Apocalipse");
                Thread.Sleep(100);
                WoW.CastSpell("Apocalipse");
                stopwatch.Reset();
                stopwatch.Start();
                return;
            }

            if (WoW.CanCast("SoulReaper") && !WoW.CanCast("Apocalipse") && WoW.CurrentRunes >= 1 && WoW.TargetDebuffStacks("Festering Wound") >= 3 && stopwatch.ElapsedMilliseconds < 50000)
            {
                WoW.CastSpell("SoulReaper");
                return;
            }

            if ((WoW.CanCast("SoulReaper") && WoW.CanCast("Apocalipse") || WoW.CanCast("SoulReaper")) && WoW.CurrentRunes >= 1 && WoW.TargetDebuffStacks("Festering Wound") <= 7)
            {
                WoW.CastSpell("Festering Strike");
                return;
            }

            if (WoW.CanCast("Death Coil") && (WoW.RunicPower > 85 || WoW.PlayerHasBuff("Sudden Doom")))
            {
                WoW.CastSpell("Death Coil");
                return;
            }

            if (WoW.CanCast("Festering Strike") && WoW.CurrentRunes >= 2 && (!WoW.TargetHasDebuff("Festering Wound") || WoW.TargetDebuffStacks("Festering Wound") <= 4))
            {
                WoW.CastSpell("Festering Strike");
                return;
            }

            if (WoW.CanCast("Scourge Strike") && WoW.CurrentRunes >= 1 && WoW.TargetHasDebuff("Festering Wound"))
            {
                WoW.CastSpell("Scourge Strike");
                return;
            }

            if (WoW.CanCast("Death Coil") && WoW.RunicPower > 35)
            {
                WoW.CastSpell("Death Coil");
            }
        }
Ejemplo n.º 12
0
 public override void Pulse()
 {
     if (!coolDownStopWatch.IsRunning || coolDownStopWatch.ElapsedMilliseconds > 60000)
     {
         coolDownStopWatch.Restart();
     }
     if (DetectKeyPress.GetKeyState(cooldownKey) < 0 && (cooldownModifier == -1 || cooldownModifier != -1 && DetectKeyPress.GetKeyState(cooldownModifier) < 0))
     {
         if (coolDownStopWatch.ElapsedMilliseconds > 1000)
         {
             combatRoutine.UseCooldowns = !combatRoutine.UseCooldowns;
             coolDownStopWatch.Restart();
         }
     }
     if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.IsInCombat && WoW.TargetIsVisible)
     {
         isMelee      = WoW.CanCast("Obliterate", false, false, true, false, false);
         currentRunes = WoW.CurrentRunes;
         runicPower   = WoW.RunicPower;
         if (WoW.TargetIsCasting && WoW.TargetIsCastingAndSpellIsInterruptible && WoW.TargetPercentCast >= 40 && WoW.Level >= 62 && WoW.CanCast("Mind Freeze", false, true, true, false, false) &&
             isCastingListedSpell())
         {
             WoW.CastSpell("Mind Freeze");
         }
         if (WoW.CanCast("Sindragosa's Fury") && (DetectKeyPress.GetKeyState(0x5A) < 0) && WoW.Level >= 110)
         {
             WoW.CastSpell("Sindragosa's Fury");
             return;
         }
         if (CanCastNoRange("Anti-Magic Shell") && WoW.HealthPercent <= FrostAMSHPPercent && !WoW.IsSpellOnCooldown("Anti-Magic Shell") && isCheckHotkeysFrostIceboundFortitude && WoW.Level >= 57)
         {
             WoW.CastSpell("Anti-Magic Shell");
         }
         if (CanCastNoRange("Icebound Fortitude") && WoW.HealthPercent < FrostIceboundHPPercent && !WoW.IsSpellOnCooldown("Icebound Fortitude") && isCheckHotkeysFrostAntiMagicShield && WoW.Level >= 65)
         {
             WoW.CastSpell("Icebound Fortitude");
         }
         if (useChainofIce && CanCastInRange("ChainofIce") && !isMelee && !WoW.TargetHasDebuff("ChainofIce") && currentRunes >= 1 && WoW.Level >= 63)
         {
             WoW.CastSpell("ChainofIce");
             return;
         }
         if (WoW.Talent(7) == 2)
         {
             BreathRotation();
         }
         else
         {
             MGRotation();
         }
     }
 }
 private void EnhancementBuffs()
 {
     //actions +=/ windstrike,if= (variable.heartEquipped | set_bonus.tier19_2pc) & (!talent.earthen_spike.enabled | (cooldown.earthen_spike.remains > 1 & cooldown.doom_winds.remains > 1) | debuff.earthen_spike.up)
     if (WoW.CanCast("Windstrike", true, true, true) && WoW.PlayerHasBuff("Ascendance") && WoW.Maelstrom >= 8 && (/*heart equip place holder*/ WoW.SetBonus(19) >= 2) && (WoW.Talent(7) != 3 || (WoW.SpellCooldownTimeRemaining("Earthen spike") > 1 && WoW.SpellCooldownTimeRemaining("Doom winds") > 1 || WoW.TargetHasDebuff("Earthen spike"))))
     {
         WoW.CastSpell("Windstrike", "Top prioity spell");
         return;
     }
     //actions.buffs = rockbiter,if= talent.landslide.enabled & !buff.landslide.up
     if (WoW.CanCast("Rockbiter", true, true, true) && WoW.Talent(1) == 3 && !WoW.PlayerHasBuff("Landslide"))
     {
         WoW.CastSpell("Rockbiter", "Buff spell");
         return;
     }
     //actions.buffs +=/ fury_of_air,if= buff.ascendance.up | (feral_spirit.remains > 5) | level < 100
     if (WoW.CanCast("FoA") && WoW.Maelstrom >= 5 && WoW.Talent(6) == 2 && !WoW.PlayerHasBuff("FoA") && (WoW.PlayerHasBuff("Ascendance") && Pets.IsRunning))
     {
         WoW.CastSpell("FoA", "Buff spell");
         return;
     }
     //actions.buffs +=/ crash_lightning,if= artifact.alpha_wolf.rank & prev_gcd.1.feral_spirit
     if (WoW.CanCast("Crash lightning") && WoW.Maelstrom >= 20 && WoW.IsSpellInRange("Rockbiter") && Pets.IsRunning && !Crash.IsRunning)
     {
         Crash.Restart();
         WoW.CastSpell("Crash lightning", "Buff spell");
         return;
     }
     //actions.buffs +=/ flametongue,if= !buff.flametongue.up
     if (!WoW.PlayerHasBuff("Flametongue") && WoW.CanCast("Flametongue", true, true, true))
     {
         WoW.CastSpell("Flametongue", "Buff spell");
         return;
     }
     //actions.buffs +=/ frostbrand,if= talent.hailstorm.enabled & !buff.frostbrand.up & variable.furyCheck45
     if (WoW.CanCast("Frostbrand", true, true, true) && WoW.Maelstrom >= 20 && WoW.Talent(4) == 3 && !WoW.PlayerHasBuff("Frostbrand") && furyCheck45)
     {
         WoW.CastSpell("Frostbrand", "Buff spell");
         return;
     }
     //actions.buffs +=/ flametongue,if= buff.flametongue.remains < 6 + gcd & cooldown.doom_winds.remains < gcd * 2
     if (WoW.CanCast("Flametongue", true, true, true) && WoW.PlayerBuffTimeRemaining("Flametongue") < 600 + GCD && WoW.SpellCooldownTimeRemaining("Doom Winds") < GCD * 2)
     {
         WoW.CastSpell("Flametongue", "Buff spell");
         return;
     }
     //actions.buffs +=/ frostbrand,if= talent.hailstorm.enabled & buff.frostbrand.remains < 6 + gcd & cooldown.doom_winds.remains < gcd * 2
     if (WoW.CanCast("Frostbrand", true, true, true) && WoW.Maelstrom >= 20 && WoW.PlayerBuffTimeRemaining("Frostbrand") < 600 + GCD && WoW.SpellCooldownTimeRemaining("Doom Winds") < GCD * 2)
     {
         WoW.CastSpell("Frostbrand", "Buff spell");
         return;
     }
 }
Ejemplo n.º 14
0
 /// <summary>
 ///     Cast a spell by name. Will check range, cooldown, and visibility. After the spell is cast, the thread will sleep
 ///     for GCD.
 /// </summary>
 /// <param name="spellName">The name of the spell in the spell databse.</param>
 /// <param name="ignoreMovement">Can we cast while moving.</param>
 /// <param name="ignoreChanneling"></param>
 /// <returns>True if the spell was cast, false if it was not.</returns>
 private bool castWithRangeCheck(string spellName, bool ignoreMovement = false, bool ignoreChanneling = true)
 {
     //Can't do range check.
     if (!isPlayerBusy(ignoreMovement, ignoreChanneling) && WoW.CanCast(spellName))
     {
         WoW.CastSpell(spellName);
         if (WoW.IsSpellOnGCD(spellName))
         {
             Thread.Sleep(WoW.SpellCooldownTimeRemaining(spellName));
         }
         return(true);
     }
     return(false);
 }
        public override void Pulse()                             // Updated for Legion (tested and working for single target)
        {
            if (combatRoutine.Type == RotationType.SingleTarget) // Do Single Target Stuff here
            {
                if (WoW.HasTarget && !WoW.PlayerIsChanneling && WoW.TargetIsEnemy && WoW.IsInCombat)
                {
                    if (DetectKeyPress.GetKeyState(DetectKeyPress.VK_XBUTTON1) < 0)
                    {
                        if (!WoW.CanCast("DnD"))
                        {
                            return;
                        }

                        WoW.CastSpell("DnD");

                        Mouse.RightRelease();
                        Thread.Sleep(50);
                        Mouse.LeftClick(Cursor.Position.X, Cursor.Position.Y);
                        Thread.Sleep(50);
                        Mouse.RightDown();
                        Thread.Sleep(50);
                        Mouse.RightRelease();
                        return;
                    }

                    if (WoW.CanCast("Outbreak") && WoW.CurrentRunes >= 1 && !WoW.TargetHasDebuff("Virulent Plague"))
                    {
                        WoW.CastSpell("Outbreak");
                        return;
                    }

                    if (WoW.CanCast("Dark Transformation") && WoW.TargetHasDebuff("Virulent Plague"))
                    {
                        WoW.CastSpell("Dark Transformation");
                        return;
                    }

                    Generic();
                }
            }
            if (combatRoutine.Type == RotationType.AOE)
            {
                // Do AOE stuff here
            }
            if (combatRoutine.Type == RotationType.SingleTargetCleave)
            {
                // Do Single Target Cleave stuff here if applicable else ignore this one
            }
        }
        private void DPSRacial()
        {
            if (!WoW.PlayerIsCasting)
            {
                if (WoW.PlayerRace == "Troll" && WoW.CanCast("Berserking") && !WoW.IsSpellOnCooldown("Berserking"))
                {
                    WoW.CastSpell("Berserking");
                    return;
                }

                if (WoW.PlayerRace == "Orc" && WoW.CanCast("Blood Fury") && !WoW.IsSpellOnCooldown("Blood Fury"))
                {
                    WoW.CastSpell("Blood Fury");
                    return;
                }
            }
        }
 private void EnhancementBuffs()
 {
     //actions.buffs = rockbiter,if= talent.landslide.enabled & !buff.landslide.up
     if (WoW.CanCast("Rockbiter", true, true, true) && WoW.Talent(1) == 3 && !WoW.PlayerHasBuff("Landslide"))
     {
         WoW.CastSpell("Rockbiter", "Buff spell");
         return;
     }
     //actions.buffs +=/ fury_of_air,if= buff.ascendance.up | (feral_spirit.remains > 5) | level < 100
     if (WoW.CanCast("FoA") && WoW.Talent(6) == 2 && !WoW.PlayerHasBuff("FoA") && (WoW.PlayerHasBuff("Ascendance") && Pets.IsRunning))
     {
         WoW.CastSpell("FoA", "Buff spell");
         return;
     }
     //actions.buffs +=/ crash_lightning,if= artifact.alpha_wolf.rank & prev_gcd.1.feral_spirit
     if (WoW.CanCast("Crash lightning") && WoW.IsSpellInRange("Rockbiter") && Pets.IsRunning && !Crash.IsRunning)
     {
         Crash.Restart();
         WoW.CastSpell("Crash lightning", "Buff spell");
         return;
     }
     //actions.buffs +=/ flametongue,if= !buff.flametongue.up
     if (!WoW.PlayerHasBuff("Flametongue") && WoW.CanCast("Flametongue", true, true, true))
     {
         WoW.CastSpell("Flametongue", "Buff spell");
         return;
     }
     //actions.buffs +=/ frostbrand,if= talent.hailstorm.enabled & !buff.frostbrand.up & variable.furyCheck45
     if (WoW.CanCast("Frostbrand", true, true, true) && WoW.Talent(4) == 3 && !WoW.PlayerHasBuff("Frostbrand") && furyCheck45)
     {
         WoW.CastSpell("Frostbrand", "Buff spell");
         return;
     }
     //actions.buffs +=/ flametongue,if= buff.flametongue.remains < 6 + gcd & cooldown.doom_winds.remains < gcd * 2
     if (WoW.CanCast("Flametongue", true, true, true) && WoW.PlayerBuffTimeRemaining("Flametongue") < 600 + GCD && WoW.SpellCooldownTimeRemaining("Doom Winds") < GCD * 2)
     {
         WoW.CastSpell("Flametongue", "Buff spell");
         return;
     }
     //actions.buffs +=/ frostbrand,if= talent.hailstorm.enabled & buff.frostbrand.remains < 6 + gcd & cooldown.doom_winds.remains < gcd * 2
     if (WoW.CanCast("Frostbrand", true, true, true) && WoW.PlayerBuffTimeRemaining("Frostbrand") < 600 + GCD && WoW.SpellCooldownTimeRemaining("Doom Winds") < GCD * 2)
     {
         WoW.CastSpell("Frostbrand", "Buff spell");
         return;
     }
 }
Ejemplo n.º 18
0
 private void SpellCast(string spellName)
 {
     if (WoW.PlayerIsCasting || (WoW.LastSpell == VOID_TORRENT && WoW.PlayerIsChanneling))
     {
         return;
     }
     if (spellName == MIND_FLAY && WoW.LastSpell == MIND_FLAY && WoW.PlayerIsChanneling)
     {
         return;
     }
     if (WoW.CanCast(spellName) && WoW.IsSpellInRange(SHADOW_WORD_PAIN))
     {
         WoW.CastSpell(spellName);
         if (WoW.IsSpellOnGCD(spellName))
         {
             Thread.Sleep(WoW.SpellCooldownTimeRemaining(spellName));
         }
     }
 }
        private void interruptcast()
        {
            Random random       = new Random();
            int    randomNumber = random.Next(60, 80);

            if (WoW.TargetPercentCast > randomNumber && WoW.TargetIsCastingAndSpellIsInterruptible)
            {
                if (WoW.PlayerRace == "BloodElf" && WoW.CanCast("Arcane Torrent", true, true, false, false, true) && !WoW.IsSpellOnCooldown("Wind Shear") && WoW.TargetIsCastingAndSpellIsInterruptible) //interupt every spell, not a boss.
                {
                    WoW.CastSpell("Arcane Torrent");
                    return;
                }
                if (WoW.PlayerRace == "Pandaren" && WoW.CanCast("Quaking palm", true, true, true, false, true)) //interupt every spell, not a boss.
                {
                    WoW.CastSpell("Quaking palm");
                    return;
                }
            }
        }
        public void EnhancementCD()
        {
            if (UseCooldowns)
            {
                //actions.CDs = bloodlust,if= target.health.pct < 25 | time > 0.500

                //actions.CDs +=/ berserking,if= buff.ascendance.up | (feral_spirit.remains > 5)
                if (WoW.PlayerRace == "Troll" && WoW.CanCast("Berserking") && !WoW.IsSpellOnCooldown("Berserking") && ((WoW.Talent(7) != 1 || WoW.PlayerHasBuff("Ascendance")) || Pets.ElapsedMilliseconds < 10000))
                {
                    WoW.CastSpell("Berserking");
                    return;
                }
                //actions.CDs +=/ blood_fury,if= buff.ascendance.up | (feral_spirit.remains > 5) | level < 100
                if (WoW.PlayerRace == "Orc" && WoW.CanCast("Blood Fury") &&
                    ((WoW.Talent(7) != 1 || WoW.PlayerHasBuff("Ascendance")) || Pets.ElapsedMilliseconds < 10000))
                {
                    WoW.CastSpell("Blood Fury");
                    return;
                }
                //actions.CDs +=/ feral_spirit
                if (WoW.CanCast("Feral Spirit", true, true, false, false, true) && WoW.IsSpellInRange("Rockbiter") && WoW.Maelstrom >= 20 && (WoW.CanCast("Crash lightning", true, true, false, false, true) || WoW.SpellCooldownTimeRemaining("Crash lightning") < GCD))  //feral spirit on boss - normally cast manually
                {
                    Pets.Start();
                    WoW.CastSpell("Feral Spirit");
                    return;
                }
                //actions.CDs +=/ potion,if= buff.ascendance.up | !talent.ascendance.enabled & feral_spirit.remains > 5 | target.time_to_die <= 60

                //actions.CDs +=/ doom_winds,if= debuff.earthen_spike.up & talent.earthen_spike.enabled | !talent.earthen_spike.enabled
                if (WoW.CanCast("Doom Winds") && WoW.IsSpellInRange("Rockbiter") && (WoW.Talent(7) == 3 && WoW.TargetHasDebuff("Earthen spike") || WoW.Talent(7) != 3))
                {
                    WoW.CastSpell("Doom Winds");
                    return;
                }
                //actions.CDs +=/ ascendance,if= buff.doom_winds.up
                if (WoW.CanCast("Ascendance") && WoW.PlayerHasBuff("Doom Winds"))
                {
                    WoW.CastSpell("Ascendance");
                    return;
                }
            }
        }
Ejemplo n.º 21
0
        public override void Pulse()
        {
            if (combatRoutine.Type == RotationType.SingleTarget)  // Do Single Target Stuff here
            {
                if (WoW.HasTarget && WoW.TargetIsEnemy)
                {
                    if (WoW.CanCast("Stormstrike", true, true, false, false))
                    {
                        WoW.CastSpellByName("Stormstrike");
                    }

                    if (WoW.CanCast("Boulderfist", true, true, false, false) && !WoW.HasBuff("Boulderfist"))
                    {
                        WoW.CastSpellByName("Boulderfist");
                    }

                    if (WoW.CanCast("Flametounge", true, true, false, false))
                    {
                        WoW.CastSpellByName("Flametounge");
                    }

                    if (WoW.CanCast("Crash Lightning", true, true, false, false) && WoW.Power > 80)
                    {
                        WoW.CastSpellByName("Crash Lightning");
                    }

                    if (WoW.CanCast("Lava Lash", true, true, false, false) && WoW.Power > 90)
                    {
                        WoW.CastSpellByName("Lava Lash");
                    }

                    if (WoW.CanCast("Boulderfist", true, true, false, false))
                    {
                        WoW.CastSpellByName("Boulderfist");
                    }
                }
            }
            if (combatRoutine.Type == RotationType.AOE)
            {
            }
        }
Ejemplo n.º 22
0
        public override void Pulse()                             // Updated for Legion (tested and working for single target)
        {
            if (combatRoutine.Type == RotationType.SingleTarget) // Do Single Target Stuff here
            {
                Log.Write("Runes: " + WoW.CurrentRunes);
                Log.Write("Health: " + WoW.HealthPercent);

                if (WoW.HasTarget && WoW.TargetIsEnemy)
                {
                    if (!WoW.TargetHasDebuff("Virulent Plague") && WoW.CurrentRunes >= 1 && WoW.CanCast("Outbreak", true, false, true))
                    {
                        WoW.CastSpell("Outbreak");
                    }
                    if (WoW.CanCast("Dark Transformation", true, true, true))
                    {
                        WoW.CastSpell("Dark Transformation");
                    }
                    if ((WoW.CanCast("Death Coil") && (WoW.RunicPower >= 80)) || (WoW.PlayerHasBuff("Sudden Doom") && WoW.IsSpellOnCooldown("Dark Arbiter")))
                    {
                        WoW.CastSpell("Death Coil");
                    }
                    if (WoW.CanCast("Festering Strike", true, true, true) && WoW.TargetDebuffStacks("Festering Wound") <= 4)
                    {
                        WoW.CastSpell("Festering Strike");
                    }
                    if (WoW.CanCast("Clawing Shadows") && WoW.CurrentRunes >= 3)
                    {
                        WoW.CastSpell("Clawing Shadows");
                    }
                }
            }
            if (combatRoutine.Type == RotationType.AOE)
            {
                // Do AOE stuff here
            }
            if (combatRoutine.Type == RotationType.SingleTargetCleave)
            {
                // Do Single Target Cleave stuff here if applicable else ignore this one
            }
        }
        private void Defensive()
        {
            if (WoW.Talent(2) == 1 && WoW.CanCast("Rainfall") && !WoW.PlayerHasBuff("Rainfall") && !WoW.IsSpellOnCooldown("Rainfall")) //ASTRAL SHIFT - DMG REDUCTION if we are below 60% of HP
            {
                WoW.CastSpell("Rainfall");
                return;
            }

            /* if (CharInfo.Mana > 21 && WoW.Maelstrom > 20 && WoW.CanCast("Healing Surge") && WoW.HealthPercent < EnhLowHp && !WoW.IsSpellOnCooldown("Healing Surge")) //ASTRAL SHIFT - DMG REDUCTION if we are below 60% of HP
             * {
             *   WoW.CastSpell("Healing Surge");
             *   return;
             * }*/
            if (WoW.CanCast("Astral Shift") && WoW.HealthPercent < 60 && !WoW.IsSpellOnCooldown("Astral Shift")) //ASTRAL SHIFT - DMG REDUCTION if we are below 60% of HP
            {
                WoW.CastSpell("Astral Shift");
                return;
            }
            if (WoW.PlayerRace == "Dreanei" && WoW.HealthPercent < 80 && !WoW.IsSpellOnCooldown("Gift Naaru"))
            {
                WoW.CastSpell("Gift Naaru");
            }
        }
Ejemplo n.º 24
0
        public override void Pulse()
        {
            if (combatRoutine.Type == RotationType.SingleTarget)              // Do Single Target Stuff here
            {
                if (WoW.HasTarget && WoW.TargetIsEnemy)
                {
                    if (WoW.CanCast("Chaos Strike") && WoW.Fury >= 40) // Fury Spender
                    {
                        WoW.CastSpellByName("Chaos Strike");
                        return;
                    }

                    if (WoW.CanCast("Demons Bite") && WoW.Fury <= 60)  // Fury Generator
                    {
                        WoW.CastSpellByName("Demons Bite");
                        return;
                    }
                }
            }
            if (combatRoutine.Type == RotationType.AOE)
            {
                // Do AOE Stuff here
            }
        }
Ejemplo n.º 25
0
        public override void Pulse()
        {
            if (combatRoutine.Type == RotationType.SingleTarget) // Do Single Target Stuff here
            {
                if (WoW.CanCast("Arcane Familiar") && !WoW.PlayerIsCasting && !WoW.PlayerIsChanneling && !WoW.PlayerHasBuff("Arcane Familiar"))
                {
                    WoW.CastSpell("Arcane Familiar");
                    return;
                }

                if (WoW.HasTarget && !WoW.PlayerIsCasting && !WoW.PlayerIsChanneling && !WoW.PlayerHasBuff("Greater Invisibility"))

                {
                    if (WoW.CanCast("Ice Floes") && WoW.IsMoving && !WoW.PlayerHasBuff("Ice Floes"))
                    {
                        WoW.CastSpell("Ice Floes");
                        return;
                    }
                    if (WoW.CanCast("Evocation") && WoW.Mana <= 5)
                    {
                        WoW.CastSpell("Evocation");
                        return;
                    }

                    if (WoW.CanCast("Nether Tempest") && WoW.CurrentArcaneCharges == 4 && !WoW.TargetHasDebuff("Nether Tempest"))
                    {
                        WoW.CastSpell("Nether Tempest");
                        return;
                    }
                    if (WoW.CanCast("Arcane Blast") && WoW.CurrentArcaneCharges < 4)
                    {
                        WoW.CastSpell("Arcane Blast");
                        return;
                    }

                    if (WoW.CanCast("Supernova"))
                    {
                        WoW.CastSpell("Supernova");
                        return;
                    }

                    if (WoW.CanCast("Arcane Missiles") && WoW.PlayerHasBuff("Arcane Missiles") && WoW.CurrentArcaneCharges == 4)
                    {
                        WoW.CastSpell("Arcane Missiles");
                        return;
                    }

                    if (WoW.CanCast("Arcane Barrage") && !WoW.PlayerHasBuff("Arcane Missiles") && WoW.CurrentArcaneCharges == 4)
                    {
                        WoW.CastSpell("Arcane Barrage");
                        return;
                    }
                }
            }
            if (combatRoutine.Type == RotationType.AOE)
            {
                //Easiest and most DPS increasing way to dps as Arcane is to have a burn phase and a conserv phase.
                //To Simplify things, i turned AOE rotation into Burn.

                if (WoW.CanCast("Arcane Familiar") && !WoW.PlayerIsCasting && !WoW.PlayerIsChanneling && !WoW.PlayerHasBuff("Arcane Familiar"))
                {
                    WoW.CastSpell("Arcane Familiar");
                    return;
                }

                if (WoW.HasTarget && !WoW.PlayerIsCasting && !WoW.PlayerIsChanneling && !WoW.PlayerHasBuff("Greater Invisibility"))
                {
                    if (WoW.CanCast("Ice Floes") && WoW.IsMoving && !WoW.PlayerHasBuff("Ice Floes"))
                    {
                        WoW.CastSpell("Ice Floes");
                        return;
                    }
                    if (WoW.CanCast("Nether Tempest") && WoW.CurrentArcaneCharges == 4 && !WoW.TargetHasDebuff("Nether Tempest"))
                    {
                        WoW.CastSpell("Nether Tempest");
                        return;
                    }
                    if (WoW.CanCast("Rune of Power") && !WoW.PlayerHasBuff("Rune Of Power") && WoW.CurrentArcaneCharges == 4)
                    {
                        WoW.CastSpell("Rune of Power");
                        return;
                    }
                    if (WoW.CanCast("Arcane Power") && WoW.PlayerHasBuff("Rune Of Power"))
                    {
                        WoW.CastSpell("Arcane Power");
                        return;
                    }
                    if (WoW.CanCast("Mark Of Aluneth") && WoW.PlayerHasBuff("Rune of Power"))
                    {
                        WoW.CastSpell("Mark Of Aluneth");
                        return;
                    }
                    if (WoW.CanCast("Supernova"))
                    {
                        WoW.CastSpell("Supernova");
                        return;
                    }
                    if (WoW.CanCast("Arcane Blast") && !WoW.PlayerHasBuff("Arcane Missiles"))
                    {
                        WoW.CastSpell("Arcane Blast");
                        return;
                    }
                    if (WoW.CanCast("Arcane Missiles") && WoW.PlayerHasBuff("Arcane Missiles"))
                    {
                        WoW.CastSpell("Arcane Missiles");
                        return;
                    }
                }
            }
            if (combatRoutine.Type == RotationType.SingleTargetCleave)
            {
                // Do Single Target Cleave stuff here if applicable else ignore this one
            }
        }
Ejemplo n.º 26
0
        public override void Pulse()
        {
            if (combatRoutine.Type == RotationType.SingleTarget) // Do Single Target Stuff here
            {
                validtarget = WoW.HasTarget && !WoW.PlayerIsCasting && !WoW.PlayerIsChanneling && !WoW.PlayerHasBuff("Greater Invisibility") && !WoW.TargetHasDebuff("Polymorph") && WoW.RangeToTarget < 41;

                // Prismatic Barrier if health < 80%
                WoW.CastSpell("Prismatic Barrier", WoW.PlayerHealthPercent <= 80 && !WoW.PlayerHasBuff("Prismatic Barrier"));
                // Arcane Familiar if not up
                WoW.CastSpell("Arcane Familiar", WoW.Talent(1) == 1 && !WoW.PlayerIsCasting && !WoW.PlayerIsChanneling && !WoW.PlayerHasBuff("Arcane Familiar"));

                // Single Target Combat Begins - No casting if Invisible or Target is Polymorphed
                if (validtarget)
                {
                    // Arcane Barrage when moving without Ice Floes
                    WoW.CastSpell("Arcane Barrage", WoW.CanCast("Arcane Barrage") && WoW.IsMoving && !WoW.PlayerHasBuff("Ice Floes") && WoW.PlayerBuffStacks("Arcane Missiles") == 0);

                    //Burn Phase
                    //----------------------------------------------------------

                    // BURN BEGIN - Only use Burn if Burn is selected and Arcane Power is available or active
                    // Charged Up if zero arcane charges
                    if (UseCooldowns)
                    {
                        // BURN - Arcane Missle if you can
                        WoW.CastSpell("Arcane Missiles", WoW.PlayerHasBuff("Arcane Missiles!") && WoW.PlayerBuffStacks("Arcane Missiles!") == 3, true);
                        WoW.CastSpell("Arcane Missiles", WoW.LastSpell == ("Arcane Missiles") && WoW.PlayerHasBuff("Arcane Missiles!") && WoW.PlayerBuffStacks("Arcane Missiles!") >= 1, true);
                        // Mark Of Aluneth is up
                        WoW.CastSpell("Mark Of Aluneth", WoW.CanCast("Mark Of Aluneth"));
                        // Cast Arcane Blast if < 4 charges
                        WoW.CastSpell("Arcane Blast", WoW.CurrentArcaneCharges < 4);
                        // BURN - Rune of Power at 4 Arcane Blast Charges
                        WoW.CastSpell("Rune of Power", !WoW.PlayerHasBuff("Rune of Power") && WoW.CurrentArcaneCharges == 4);

                        // BURN - Rune of Power if >30% mana
                        WoW.CastSpell("Rune of Power", WoW.PlayerHasBuff("Arcane Power") && !WoW.PlayerHasBuff("Rune of Power") && WoW.Mana >= 30);
                        // BURN - Arcane Power if Rune of Power down and 4 Arcane Blast Charges
                        WoW.CastSpell("Arcane Power", WoW.PlayerHasBuff("Rune of Power") && WoW.CurrentArcaneCharges == 4);

                        // Evocate if low on mana
                        WoW.CastSpell("Evocation", WoW.Mana <= 5);
                        // Arcane Blast otherwise
                        WoW.CastSpell("Arcane Blast", validtarget);
                    }
                    // BURN END
                    // Conserve Begin
                    if (!UseCooldowns)
                    {
                        WoW.CastSpell("Rune of Power", WoW.PlayerSpellCharges("Rune of Power") == 2);
                        // Mark Of Aluneth is up - If no Rune of Power...cast Rune of Power - If Rune of Power...cast Mark Of Aluneth
                        WoW.CastSpell("Rune of Power", WoW.CanCast("Mark Of Aluneth") && !WoW.PlayerHasBuff("Rune of Power"));
                        WoW.CastSpell("Mark Of Aluneth", WoW.CanCast("Mark Of Aluneth") && WoW.PlayerHasBuff("Rune of Power"));


                        // Arcane Missles with 4 Arcane Blast Charges
                        WoW.CastSpell("Arcane Missiles", WoW.PlayerHasBuff("Arcane Missiles!") && WoW.CurrentArcaneCharges == 4);
                        // Arcane Missles with 3 stacks of Arcane Missiles! Buff - Not sure how to check buff stacks *NEED FIXED*
                        WoW.CastSpell("Arcane Missiles", WoW.PlayerHasBuff("Arcane Missiles!") && WoW.PlayerBuffStacks("Arcane Missiles!") == 3);

                        WoW.CastSpell("Arcane Barrage", WoW.Mana < 55);
                        // Arcane Blast otherwise
                        WoW.CastSpell("Arcane Blast", validtarget);
                    }
                    // SingleTarget Combat Ends
                }
            }


            if (combatRoutine.Type == RotationType.AOE)
            {
                // Do Single Target Cleave stuff here if applicable else ignore this one
            }
            if (combatRoutine.Type == RotationType.Cleave)
            {
                // Do Single Target Cleave stuff here if applicable else ignore this one
            }
        }
Ejemplo n.º 27
0
 public override void Pulse()
 {
     if (combatRoutine.Type == RotationType.SingleTarget)
     {
         if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.HasBuff("Moonkin") && !WoW.IsMoving())
         {
             if (WoW.IsSpellInRange("Moonfire") && WoW.CanCast("Moonfire") && !WoW.HasDebuff("Moonfire"))
             {
                 WoW.CastSpellByName("Moonfire");
                 return;
             }
             if (WoW.IsSpellInRange("Sunfire") && WoW.CanCast("Sunfire") && !WoW.HasDebuff("Sunfire"))
             {
                 WoW.CastSpellByName("Sunfire");
                 return;
             }
             if (WoW.IsSpellInRange("LStrike") && WoW.CanCast("LStrike") && WoW.GetBuffStacks("LunarEmp") == 3 && WoW.Astral <= 80)
             {
                 WoW.CastSpellByName("LStrike");
                 return;
             }
             if ((WoW.IsSpellInRange("SolarW") && WoW.CanCast("SolarW") && WoW.HasBuff("SolarEmp") && WoW.Astral <= 80) || (WoW.IsSpellInRange("SolarW") &&
                                                                                                                            WoW.Astral <= 40 && WoW.GetSpellCharges("Moon") < 1 && WoW.GetSpellCharges("HalfMoon") < 1 && WoW.GetSpellCharges("FullMoon") < 1 && WoW.GetBuffStacks("LunarEmp") <= 2))
             {
                 WoW.CastSpellByName("SolarW");
                 return;
             }
             if (WoW.IsSpellInRange("StarSurge") && WoW.CanCast("StarSurge") && WoW.Astral >= 40 && !(WoW.GetBuffStacks("LunarEmp") == 3) && !(WoW.GetBuffStacks("SolarEmp") == 3))
             {
                 WoW.CastSpellByName("StarSurge");
                 return;
             }
             if (WoW.IsSpellInRange("Moon") && WoW.CanCast("Moon") && WoW.Astral <= 60 && WoW.HasDebuff("Moonfire") && WoW.HasDebuff("Sunfire"))
             {
                 WoW.CastSpellByName("Moon");
                 return;
             }
         }
         if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.HasBuff("Moonkin") && WoW.IsMoving())
         {
             if (WoW.IsSpellInRange("Moonfire") && WoW.CanCast("Moonfire") && WoW.Astral <= 40)
             {
                 WoW.CastSpellByName("Moonfire");
                 return;
             }
             if (WoW.IsSpellInRange("StarSurge") && WoW.CanCast("StarSurge") && WoW.Astral >= 40)
             {
                 WoW.CastSpellByName("StarSurge");
                 return;
             }
             if (WoW.IsSpellInRange("Sunfire") && WoW.CanCast("Sunfire") && !WoW.HasDebuff("Sunfire"))
             {
                 WoW.CastSpellByName("Sunfire");
                 return;
             }
         }
     }
     //12 e 18
     if (combatRoutine.Type == RotationType.AOE)
     {
         if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.HasBuff("Moonkin") && !WoW.IsMoving())
         {
             if (WoW.CanCast("Moonfire") && !WoW.HasDebuff("Moonfire"))
             {
                 WoW.CastSpellByName("Moonfire");
                 return;
             }
             if (WoW.CanCast("Sunfire") && !WoW.HasDebuff("Sunfire"))
             {
                 WoW.CastSpellByName("Sunfire");
                 return;
             }
             if (WoW.CanCast("SolarW") && WoW.GetBuffStacks("SolarEmp") == 3 && WoW.Astral <= 80)
             {
                 WoW.CastSpellByName("SolarW");
                 return;
             }
             if ((WoW.CanCast("LStrike") && WoW.HasBuff("LunarEmp") && WoW.Astral <= 80) || (
                     WoW.Astral <= 40 && WoW.GetSpellCharges("Moon") < 1 && WoW.GetSpellCharges("HalfMoon") < 1 && WoW.GetSpellCharges("FullMoon") < 1 && WoW.GetBuffStacks("SolarEmp") <= 2))
             {
                 WoW.CastSpellByName("LStrike");
                 return;
             }
             if (WoW.CanCast("StarSurge") && WoW.Astral >= 40 && !(WoW.GetBuffStacks("LunarEmp") == 3) && !(WoW.GetBuffStacks("SolarEmp") == 3))
             {
                 WoW.CastSpellByName("StarSurge");
                 return;
             }
             if (WoW.CanCast("Moon") && WoW.Astral <= 60 && WoW.HasDebuff("Sunfire") && WoW.HasDebuff("Moonfire"))
             {
                 WoW.CastSpellByName("Moon");
                 return;
             }
         }
         if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.HasBuff("Moonkin") && WoW.IsMoving())
         {
             if (WoW.IsSpellInRange("Moonfire") && WoW.CanCast("Moonfire") && WoW.Astral <= 40)
             {
                 WoW.CastSpellByName("Moonfire");
                 return;
             }
             if (WoW.IsSpellInRange("StarSurge") && WoW.CanCast("StarSurge") && WoW.Astral >= 40)
             {
                 WoW.CastSpellByName("StarSurge");
                 return;
             }
             if (WoW.IsSpellInRange("Sunfire") && WoW.CanCast("Sunfire") && !WoW.HasDebuff("Sunfire"))
             {
                 WoW.CastSpellByName("Sunfire");
                 return;
             }
         }
     }
 }
Ejemplo n.º 28
0
        public override void Pulse()
        {
            {
                if (combatRoutine.Type == RotationType.SingleTarget)
                {
                    if (WoW.IsSpellInRange("Rupture") && WoW.IsInCombat && !WoW.IsMounted)
                    {
                        if (UseCooldowns &&
                            WoW.CanCast("Kingsbane") && WoW.CurrentComboPoints <= 4 && WoW.Energy >= 35 && WoW.PlayerHasBuff("Envenom") && WoW.PlayerBuffTimeRemaining("Envenom") >= 150 &&
                            !WoW.IsSpellOnCooldown("Kingsbane") && WoW.TargetHasDebuff("Rupture") && WoW.TargetDebuffTimeRemaining("Rupture") >= 1400 &&
                            (
                                WoW.SpellCooldownTimeRemaining("Vendetta") >= 1000 ||
                                WoW.TargetHasDebuff("Vendetta")
                            ))
                        {
                            WoW.CastSpell("Kingsbane");
                            return;
                        }
                        if (!WoW.PlayerHasBuff("Vanish") && WoW.CanCast("Garrote") && WoW.Energy >= 45 && !WoW.TargetHasDebuff("Garrote") && !WoW.IsSpellOnCooldown("Garrote") && WoW.CurrentComboPoints <= 4 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Garrote");
                            return;
                        }
                        if (WoW.TargetHasDebuff("Vendetta") && WoW.CanCast("Fan Of Knives") && WoW.Energy >= 35 && WoW.PlayerHasBuff("FoK") && WoW.PlayerBuffStacks("FoK") == 30 && WoW.CurrentComboPoints <= 4)
                        {
                            WoW.CastSpell("Fan Of Knives");
                            return;
                        }
                        if (!WoW.PlayerHasBuff("Vanish") && WoW.CanCast("Garrote") && WoW.Energy >= 45 && WoW.TargetHasDebuff("Garrote") && WoW.TargetDebuffTimeRemaining("Garrote") <= 300 && WoW.CurrentComboPoints <= 4 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Garrote");
                            return;
                        }
                        if (WoW.CurrentComboPoints == 4 && WoW.Energy >= 25 && WoW.CanCast("Rupture") && !WoW.TargetHasDebuff("Rupture") && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Rupture");
                            return;
                        }
                        if (WoW.CurrentComboPoints == 4 && WoW.Energy >= 25 && WoW.TargetHasDebuff("Rupture") && WoW.TargetDebuffTimeRemaining("Rupture") <= 600 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Rupture");
                            return;
                        }
                        if (WoW.CurrentComboPoints == 5 && WoW.Energy >= 25 && WoW.CanCast("Rupture") && !WoW.TargetHasDebuff("Rupture") && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Rupture");
                            return;
                        }
                        if (WoW.CurrentComboPoints == 5 && WoW.Energy >= 25 && WoW.TargetHasDebuff("Rupture") && WoW.TargetDebuffTimeRemaining("Rupture") <= 600 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Rupture");
                            return;
                        }
                        if (!WoW.PlayerHasBuff("Vanish") && WoW.TargetHasDebuff("Toxins") && WoW.TargetDebuffTimeRemaining("Toxins") <= 150 && WoW.Energy >= 35 && WoW.CurrentComboPoints == 4 && WoW.CanCast("Envenom") && WoW.TargetHasDebuff("Rupture") && WoW.TargetDebuffTimeRemaining("Rupture") > 600 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Envenom");
                            return;
                        }
                        if (!WoW.PlayerHasBuff("Vanish") && WoW.TargetHasDebuff("Toxins") && WoW.TargetDebuffTimeRemaining("Toxins") <= 150 && WoW.Energy >= 35 && WoW.CurrentComboPoints == 5 && WoW.CanCast("Envenom") && WoW.TargetHasDebuff("Rupture") && WoW.TargetDebuffTimeRemaining("Rupture") > 600 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Envenom");
                            return;
                        }
                        if (WoW.TargetHasDebuff("Kingsbane") && WoW.TargetDebuffTimeRemaining("Rupture") >= 400 && WoW.Energy >= 35 && WoW.CurrentComboPoints >= 2 && WoW.PlayerHasBuff("Envenom") && WoW.PlayerBuffTimeRemaining("Envenom") <= 150)
                        {
                            WoW.CastSpell("Envenom");
                            Log.Write("Extend Envenom remaining");
                            return;
                        }
                        if (WoW.TargetHasDebuff("Kingsbane") && WoW.TargetDebuffTimeRemaining("Rupture") >= 400 && WoW.Energy >= 35 && WoW.CurrentComboPoints >= 2 && !WoW.PlayerHasBuff("Envenom"))
                        {
                            WoW.CastSpell("Envenom");
                            Log.Write("Getting Envenom up for kingsbane");
                            return;
                        }
                        if (!WoW.PlayerHasBuff("Vanish") && !WoW.TargetHasDebuff("Toxins") && WoW.Energy >= 35 && WoW.CurrentComboPoints == 4 && WoW.CanCast("Envenom") && WoW.TargetHasDebuff("Rupture") && WoW.TargetDebuffTimeRemaining("Rupture") > 600 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Envenom");
                            return;
                        }
                        if (!WoW.PlayerHasBuff("Vanish") && !WoW.TargetHasDebuff("Toxins") && WoW.Energy >= 35 && WoW.CurrentComboPoints == 5 && WoW.CanCast("Envenom") && WoW.TargetHasDebuff("Rupture") && WoW.TargetDebuffTimeRemaining("Rupture") > 600 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Envenom");
                            return;
                        }
                        if (!WoW.PlayerHasBuff("Vanish") && WoW.TargetHasDebuff("Toxins") && WoW.TargetHasDebuff("Vendetta") && WoW.Energy >= 140 && WoW.CurrentComboPoints >= 4 && WoW.CanCast("Envenom") && WoW.TargetHasDebuff("Rupture") && WoW.TargetDebuffTimeRemaining("Rupture") > 600 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Envenom");
                            return;
                        }
                        if (WoW.CanCast("Mutilate") && WoW.Energy >= 55 && WoW.CurrentComboPoints <= 3)
                        {
                            WoW.CastSpell("Mutilate");
                            return;
                        }
                        if (UseCooldowns && WoW.CanCast("Vendetta") &&
                            !WoW.IsSpellOnCooldown("Vendetta") &&
                            WoW.Energy <= 50
                            )
                        {
                            WoW.CastSpell("Vendetta");
                            return;
                        }

                        /*if (UseCooldowns &&
                         * WoW.CanCast("Vanish") &&
                         * WoW.CurrentComboPoints >= 5 &&
                         * WoW.Energy >= 25 && WoW.TargetHasDebuff("Vendetta") &&
                         * (
                         * WoW.TargetHasDebuff("Rupture") &&
                         * WoW.TargetDebuffTimeRemaining("Rupture") < 10
                         * )
                         * ) {
                         * WoW.CastSpell("Vanish");
                         * return;
                         * }*/
                        if (!WoW.PlayerHasBuff("Critbuff") && UseCooldowns && WoW.CurrentComboPoints == 5 && !WoW.IsSpellOnCooldown("Vanish") && WoW.Energy >= 35 && WoW.TargetHasDebuff("Vendetta"))
                        {
                            WoW.CastSpell("Vanish");
                            return;
                        }
                        if (UseCooldowns && WoW.CurrentComboPoints == 5 && WoW.PlayerHasBuff("Vanish") && WoW.Energy >= 35 && WoW.TargetHasDebuff("Vendetta"))
                        {
                            WoW.CastSpell("Rupture");
                            return;
                        }
                        if (UseCooldowns && WoW.CanCast("Berserk") && !WoW.IsSpellOnCooldown("Berserk") && WoW.TargetHasDebuff("Vendetta") && WoW.PlayerRace == "Troll")
                        {
                            WoW.CastSpell("Berserk");
                            return;
                        }
                    }
                }


                if (combatRoutine.Type == RotationType.AOE || combatRoutine.Type == RotationType.SingleTargetCleave) // Do AoE Target Stuff here
                {
                    if (WoW.HasTarget && WoW.IsSpellInRange("Rupture") && WoW.IsInCombat && !WoW.IsMounted)
                    {
                        if (WoW.Energy >= 35 && WoW.CurrentComboPoints <= 4 && WoW.CanCast("Fan Of Knives"))
                        {
                            WoW.CastSpell("Fan Of Knives");
                            return;
                        }
                        if (WoW.Energy >= 35 && WoW.CurrentComboPoints == 4 && WoW.TargetHealthPercent <= 35 && WoW.CanCast("Envenom"))
                        {
                            WoW.CastSpell("Envenom");
                            return;
                        }
                        if (WoW.Energy >= 35 && WoW.CurrentComboPoints == 5 && WoW.TargetHealthPercent <= 35 && WoW.CanCast("Envenom"))
                        {
                            WoW.CastSpell("Envenom");
                            return;
                        }
                        if (WoW.Energy >= 25 && WoW.CurrentComboPoints == 4 && WoW.TargetHealthPercent >= 36 && WoW.CanCast("Rupture") && !WoW.TargetHasDebuff("Rupture"))
                        {
                            WoW.CastSpell("Rupture");
                            return;
                        }
                        if (WoW.Energy >= 25 && WoW.CurrentComboPoints == 5 && WoW.TargetHealthPercent >= 36 && WoW.CanCast("Rupture") && !WoW.TargetHasDebuff("Rupture"))
                        {
                            WoW.CastSpell("Rupture");
                            return;
                        }
                        if (WoW.Energy >= 35 && WoW.CurrentComboPoints >= 4 && WoW.TargetHealthPercent >= 36 && WoW.TargetHasDebuff("Rupture") && WoW.CanCast("Envenom"))
                        {
                            WoW.CastSpell("Envenom");
                            return;
                        }
                        if (WoW.CanCast("Garrote") && WoW.Energy >= 45 && !WoW.TargetHasDebuff("Garrote") && !WoW.IsSpellOnCooldown("Garrote") && WoW.CurrentComboPoints <= 4 && WoW.IsSpellInRange("Garrote"))
                        {
                            WoW.CastSpell("Garrote");
                            return;
                        }
                        if (UseCooldowns && WoW.CanCast("Berserk") && !WoW.IsSpellOnCooldown("Berserk"))
                        {
                            WoW.CastSpell("Berserk");
                            return;
                        }
                    }
                }
            }
        }
Ejemplo n.º 29
0
        public override void Pulse()
        {
            //Combat Time
            if (CombatTime.IsRunning && !WoW.IsInCombat)
            {
                CombatTime.Reset();
            }
            if (!CombatTime.IsRunning && WoW.IsInCombat)
            {
                CombatTime.Start();
            }

            //Dreadstalkers Time Remaining (12000 ms) (EXPERIMENTAL)
            if (DreadstalkersTime.IsRunning && WoW.DreadstalkersCount == 0)
            {
                DreadstalkersTime.Reset();
            }
            if (!DreadstalkersTime.IsRunning && WoW.DreadstalkersCount >= 1)
            {
                DreadstalkersTime.Start();
            }

            //Imp Time Remaining (12000 ms) (EXPERIMENTAL)
            if (ImpTime.IsRunning && WoW.WildImpsCount == 0)
            {
                ImpTime.Reset();
            }
            if (!ImpTime.IsRunning && WoW.WildImpsCount >= 1)
            {
                ImpTime.Start();
            }

            var DreadstalkersRemainingDuration = Convert.ToSingle((12000f - DreadstalkersTime.ElapsedMilliseconds) / 1000f);
            var ImpsRemainingDuration          = Convert.ToSingle((12000f - ImpTime.ElapsedMilliseconds) / 1000f + OneFiveCast);

            // Single Target Rotation
            if (combatRoutine.Type == RotationType.SingleTarget)
            {
                // Normal Rotation
                if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.IsInCombat && !WoW.PlayerIsCasting)
                {
                    Log.Write("Imp Time: " + ImpsRemainingDuration, Color.DarkViolet);
                    Log.Write("Dread Time: " + DreadstalkersRemainingDuration, Color.DarkViolet);
                    //Implosion (if talent)
                    if (WoW.CanCast("Implosion") && Implosion && WoW.IsSpellInRange("Doom"))
                    {
                        if (ImpsRemainingDuration <= SBExecuteTime && WoW.PlayerHasBuff("DemonicSynergy"))
                        {
                            WoW.CastSpell("Implosion");
                            return;
                        }
                        if (WoW.LastSpell == "HandOfGuldan" && WoW.WildImpsCount == 1 && WoW.PlayerHasBuff("DemonicSynergy"))
                        {
                            WoW.CastSpell("Implosion");
                            return;
                        }
                    }

                    //Shadowflame (if talent)
                    if (WoW.CanCast("Shadowflame") && Shadowflame && WoW.IsSpellInRange("Doom") && WoW.TargetHasDebuff("Shadowflame") &&
                        WoW.TargetDebuffTimeRemaining("Shadowflame") < TwoSecondCast + 2)
                    {
                        WoW.CastSpell("Shadowflame");
                        return;
                    }

                    //Service Pet (if talent)
                    if (WoW.CanCast("GrimoireFelguard") && GrimoireOfService && WoW.IsSpellInRange("Doom") && WoW.CurrentSoulShards >= 1 && boss)
                    {
                        WoW.CastSpell("GrimoireFelguard");
                        empowered = false;
                        return;
                    }

                    // Doomguard
                    if (WoW.CanCast("Doomguard") && WoW.CurrentSoulShards >= 1 && boss && WoW.IsSpellInRange("Doom"))
                    {
                        WoW.CastSpell("Doomguard");
                        empowered = false;
                        return;
                    }

                    //Felstorm
                    if (WoW.CanCast("Felstorm") && WoW.HasPet && WoW.PetHasBuff("DemonicEmpowerment"))
                    {
                        WoW.CastSpell("Felstorm");
                        return;
                    }

                    //Call Dreadstalkers (if NOT talent Summon Darkglare)
                    if (WoW.CanCast("CallDreadstalkers") && !SummonDarkglare && (WoW.CurrentSoulShards >= 2 || WoW.PlayerHasBuff("DemonicCalling")) && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("CallDreadstalkers");
                        empowered = false;
                        DreadstalkersTime.Restart();
                        return;
                    }

                    //Hand Of Guldan (if NOT talent Summon Darkglare)
                    if (WoW.CanCast("HandOfGuldan") && !SummonDarkglare && WoW.LastSpell != "HandOfGuldan" && WoW.CurrentSoulShards >= 4 && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("HandOfGuldan");
                        empowered = false;
                        threeimps = false;
                        ImpTime.Restart();
                        return;
                    }

                    //Summon Darkglare (if talent)
                    if (WoW.CanCast("SummonDarkglare") && SummonDarkglare && WoW.CurrentSoulShards >= 1 && WoW.TargetHasDebuff("Doom") && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        if (WoW.LastSpell == "HandOfGuldan" || WoW.LastSpell == "CallDreadstalkers")
                        {
                            WoW.CastSpell("SummonDarkglare");
                            Log.Write("1", Color.Red);
                            empowered = false;
                            return;
                        }
                        if (WoW.SpellCooldownTimeRemaining("CallDreadstalkers") > 5 && WoW.CurrentSoulShards < 3)
                        {
                            WoW.CastSpell("SummonDarkglare");
                            Log.Write("2", Color.Red);
                            empowered = false;
                            return;
                        }
                        if (WoW.SpellCooldownTimeRemaining("CallDreadstalkers") <= gcd && WoW.CurrentSoulShards >= 3)
                        {
                            WoW.CastSpell("SummonDarkglare");
                            Log.Write("3", Color.Red);
                            empowered = false;
                            return;
                        }
                        if (WoW.SpellCooldownTimeRemaining("CallDreadstalkers") <= gcd && WoW.CurrentSoulShards >= 1 && WoW.PlayerHasBuff("DemonicCalling"))
                        {
                            WoW.CastSpell("SummonDarkglare");
                            Log.Write("4", Color.Red);
                            empowered = false;
                            return;
                        }
                    }

                    //Call Dreadstalkers (if talent Summon Darkglare)
                    if (WoW.CanCast("CallDreadstalkers") && SummonDarkglare && (WoW.CurrentSoulShards >= 2 || WoW.PlayerHasBuff("DemonicCalling")) && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        if (WoW.SpellCooldownTimeRemaining("SummonDarkglare") <= TwoSecondCast && WoW.CurrentSoulShards >= 3)
                        {
                            WoW.CastSpell("CallDreadstalkers");
                            empowered = false;
                            DreadstalkersTime.Restart();
                            return;
                        }
                        if (WoW.SpellCooldownTimeRemaining("SummonDarkglare") <= TwoSecondCast && WoW.CurrentSoulShards >= 1 && WoW.PlayerHasBuff("DemonicCalling"))
                        {
                            WoW.CastSpell("CallDreadstalkers");
                            empowered = false;
                            DreadstalkersTime.Restart();
                            return;
                        }
                    }

                    //Hand Of Guldan
                    if (WoW.CanCast("HandOfGuldan") && WoW.LastSpell != "HandOfGuldan" && WoW.CurrentSoulShards >= 3 && WoW.LastSpell == "CallDreadstalkers" && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("HandOfGuldan");
                        empowered = false;
                        threeimps = true;
                        ImpTime.Restart();
                        return;
                    }

                    //Hand Of Guldan (if talent Summon Darkglare)
                    if (WoW.CanCast("HandOfGuldan") && SummonDarkglare && WoW.LastSpell != "HandOfGuldan" && WoW.CurrentSoulShards >= 5 &&
                        WoW.SpellCooldownTimeRemaining("SummonDarkglare") <= OneFiveCast && WoW.IsSpellInRange("Doom") && (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("HandOfGuldan");
                        threeimps = false;
                        empowered = false;
                        ImpTime.Restart();
                        return;
                    }

                    //Hand Of Guldan (if talent Summon Darkglare)
                    if (WoW.CanCast("HandOfGuldan") && SummonDarkglare && WoW.LastSpell != "HandOfGuldan" && WoW.CurrentSoulShards >= 4 && WoW.SpellCooldownTimeRemaining("SummonDarkglare") > 2 &&
                        WoW.IsSpellInRange("Doom") && (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("HandOfGuldan");
                        threeimps = false;
                        empowered = false;
                        ImpTime.Restart();
                        return;
                    }

                    //Demonic Empowerment (if last spell was Hand Of Guldan)
                    if (WoW.CanCast("DemonicEmpowerment") && WoW.LastSpell == "HandOfGuldan" && WoW.LastSpell != "DemonicEmpowerment" && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("DemonicEmpowerment");
                        empowered = true;
                        return;
                    }

                    //Demonic Empowerment
                    if (WoW.CanCast("DemonicEmpowerment") && (!empowered || !WoW.PetHasBuff("DemonicEmpowerment")) && WoW.LastSpell != "DemonicEmpowerment" && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("DemonicEmpowerment");
                        empowered = true;
                        return;
                    }

/*
 *                                      //Doom (if NOT talent Hand of Doom)
 *                                      if(WoW.CanCast("Doom") && (!WoW.TargetHasDebuff("Doom") || WoW.TargetDebuffTimeRemaining("Doom") < 5) && WoW.IsSpellInRange("Doom"))
 *                                      {
 *                                              WoW.CastSpell("Doom");
 *                                              return;
 *                                      }
 *
 *                                      //Soul Harvest
 *                                      if(WoW.CanCast("SoulHarvest") && WoW.IsSpellInRange("Doom"))
 *                                      {
 *                                              WoW.CastSpell("SoulHarvest");
 *                                              return;
 *                                      }
 */
                    //Shadowflame (if talent)
                    if (WoW.CanCast("Shadowflame") && Shadowflame && WoW.IsSpellInRange("Doom") && WoW.PlayerSpellCharges("Shadowflame") == 2)
                    {
                        WoW.CastSpell("Shadowflame");
                        return;
                    }

                    //Thal'kiel's Consumption
                    if (WoW.CanCast("TK") && WoW.DreadstalkersCount >= 1 && DreadstalkersRemainingDuration > TwoSecondCast && ((WoW.WildImpsCount >= 1 && !threeimps) || WoW.WildImpsCount >= 2) &&
                        ImpsRemainingDuration > TwoSecondCast && WoW.IsSpellInRange("Doom") && (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("TK");
                        return;
                    }

                    //Life Tap
                    if (WoW.CanCast("LifeTap") && WoW.Mana <= 30)
                    {
                        WoW.CastSpell("LifeTap");
                        return;
                    }

                    //Demonwrath (if moving)
                    if (WoW.CanCast("Demonwrath") && WoW.IsMoving && !WoW.PlayerHasBuff("Norgannon"))
                    {
                        WoW.CastSpell("Demonwrath");
                        return;
                    }

                    //Demonbolt (if talent)
                    if (WoW.CanCast("Demonbolt") && Demonbolt && WoW.IsSpellInRange("Doom") && (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("Demonbolt");
                        return;
                    }

                    //Shadowbolt (if NOT Demonbolt talent)
                    if (WoW.CanCast("Shadowbolt") && !Demonbolt && WoW.IsSpellInRange("Doom") && (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("Demonbolt");
                        return;
                    }

                    //Life Tap
                    if (WoW.CanCast("LifeTap") && WoW.Mana < 100)
                    {
                        WoW.CastSpell("LifeTap");
                        return;
                    }
                }
            }

            // AoE Rotation
            if (combatRoutine.Type == RotationType.AOE)
            {
                Log.Write("Imp Time: " + ImpsRemainingDuration, Color.DarkViolet);
                // AoE Rotation
                if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.IsInCombat && !WoW.PlayerIsCasting)
                {
                    //Implosion (if talent)
                    if (WoW.CanCast("Implosion") && Implosion && WoW.IsSpellInRange("Doom"))
                    {
                        if (ImpsRemainingDuration <= SBExecuteTime && WoW.PlayerHasBuff("DemonicSynergy"))
                        {
                            WoW.CastSpell("Implosion");
                            return;
                        }
                        if (WoW.LastSpell == "HandOfGuldan" && WoW.WildImpsCount == 1 && WoW.PlayerHasBuff("DemonicSynergy"))
                        {
                            WoW.CastSpell("Implosion");
                            return;
                        }
                        if (WoW.WildImpsCount == 1 && ImpsRemainingDuration <= SBExecuteTime)
                        {
                            WoW.CastSpell("Implosion");
                            return;
                        }
                        if (WoW.LastSpell == "HandOfGuldan" && WoW.WildImpsCount == 1)
                        {
                            WoW.CastSpell("Implosion");
                            return;
                        }
                    }

                    //Shadowflame (if talent)
                    if (WoW.CanCast("Shadowflame") && Shadowflame && WoW.IsSpellInRange("Doom") && WoW.TargetHasDebuff("Shadowflame") &&
                        WoW.TargetDebuffTimeRemaining("Shadowflame") < TwoSecondCast + 2)
                    {
                        WoW.CastSpell("Shadowflame");
                        return;
                    }

                    //Felstorm
                    if (WoW.CanCast("Felstorm") && WoW.HasPet && WoW.PetHasBuff("DemonicEmpowerment"))
                    {
                        WoW.CastSpell("Felstorm");
                        return;
                    }

                    //Call Dreadstalkers (if NOT talent Summon Darkglare or Implosion)
                    if (WoW.CanCast("CallDreadstalkers") && !SummonDarkglare && (WoW.CurrentSoulShards >= 2 || WoW.PlayerHasBuff("DemonicCalling")) && !Implosion && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("CallDreadstalkers");
                        empowered = false;
                        DreadstalkersTime.Restart();
                        return;
                    }

                    //Hand Of Guldan (if NOT talent Summon Darkglare)
                    if (WoW.CanCast("HandOfGuldan") && !SummonDarkglare && WoW.LastSpell != "HandOfGuldan" && WoW.CurrentSoulShards >= 4 && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("HandOfGuldan");
                        empowered = false;
                        threeimps = false;
                        ImpTime.Restart();
                        return;
                    }

                    //Summon Darkglare (if talent)
                    if (WoW.CanCast("SummonDarkglare") && SummonDarkglare && WoW.CurrentSoulShards >= 1 && WoW.TargetHasDebuff("Doom") && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        if (WoW.LastSpell == "HandOfGuldan" || WoW.LastSpell == "CallDreadstalkers")
                        {
                            WoW.CastSpell("SummonDarkglare");
                            Log.Write("1", Color.Red);
                            empowered = false;
                            return;
                        }
                        if (WoW.SpellCooldownTimeRemaining("CallDreadstalkers") > 5 && WoW.CurrentSoulShards < 3)
                        {
                            WoW.CastSpell("SummonDarkglare");
                            Log.Write("2", Color.Red);
                            empowered = false;
                            return;
                        }
                        if (WoW.SpellCooldownTimeRemaining("CallDreadstalkers") <= gcd && WoW.CurrentSoulShards >= 3)
                        {
                            WoW.CastSpell("SummonDarkglare");
                            Log.Write("3", Color.Red);
                            empowered = false;
                            return;
                        }
                        if (WoW.SpellCooldownTimeRemaining("CallDreadstalkers") <= gcd && WoW.CurrentSoulShards >= 1 && WoW.PlayerHasBuff("DemonicCalling"))
                        {
                            WoW.CastSpell("SummonDarkglare");
                            Log.Write("4", Color.Red);
                            empowered = false;
                            return;
                        }
                    }

                    //Call Dreadstalkers (if talent Summon Darkglare and not Implosion)
                    if (WoW.CanCast("CallDreadstalkers") && SummonDarkglare && (WoW.CurrentSoulShards >= 2 || WoW.PlayerHasBuff("DemonicCalling")) && !Implosion && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        if (WoW.SpellCooldownTimeRemaining("SummonDarkglare") <= TwoSecondCast && WoW.CurrentSoulShards >= 3)
                        {
                            WoW.CastSpell("CallDreadstalkers");
                            empowered = false;
                            DreadstalkersTime.Restart();
                            return;
                        }
                        if (WoW.SpellCooldownTimeRemaining("SummonDarkglare") <= TwoSecondCast && WoW.CurrentSoulShards >= 1 && WoW.PlayerHasBuff("DemonicCalling"))
                        {
                            WoW.CastSpell("CallDreadstalkers");
                            empowered = false;
                            DreadstalkersTime.Restart();
                            return;
                        }
                    }

                    //Hand Of Guldan
                    if (WoW.CanCast("HandOfGuldan") && WoW.LastSpell != "HandOfGuldan" && WoW.CurrentSoulShards >= 3 && WoW.LastSpell == "CallDreadstalkers" && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("HandOfGuldan");
                        empowered = false;
                        threeimps = true;
                        ImpTime.Restart();
                        return;
                    }

                    //Hand Of Guldan (if talent Summon Darkglare)
                    if (WoW.CanCast("HandOfGuldan") && SummonDarkglare && WoW.LastSpell != "HandOfGuldan" && WoW.CurrentSoulShards >= 5 &&
                        WoW.SpellCooldownTimeRemaining("SummonDarkglare") <= OneFiveCast && WoW.IsSpellInRange("Doom") && (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("HandOfGuldan");
                        threeimps = false;
                        empowered = false;
                        ImpTime.Restart();
                        return;
                    }

                    //Hand Of Guldan (if talent Summon Darkglare)
                    if (WoW.CanCast("HandOfGuldan") && SummonDarkglare && WoW.LastSpell != "HandOfGuldan" && WoW.CurrentSoulShards >= 4 && WoW.SpellCooldownTimeRemaining("SummonDarkglare") > 2 &&
                        WoW.IsSpellInRange("Doom") && (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("HandOfGuldan");
                        threeimps = false;
                        empowered = false;
                        ImpTime.Restart();
                        return;
                    }

                    //Demonic Empowerment (if last spell was Hand Of Guldan)
                    if (WoW.CanCast("DemonicEmpowerment") && WoW.LastSpell == "HandOfGuldan" && WoW.LastSpell != "DemonicEmpowerment" && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("DemonicEmpowerment");
                        empowered = true;
                        return;
                    }

                    //Demonic Empowerment
                    if (WoW.CanCast("DemonicEmpowerment") && (!empowered || !WoW.PetHasBuff("DemonicEmpowerment")) && WoW.LastSpell != "DemonicEmpowerment" && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("DemonicEmpowerment");
                        empowered = true;
                        return;
                    }

/*
 *                                      //Doom (if NOT talent Hand of Doom)
 *                                      if(WoW.CanCast("Doom") && (!WoW.TargetHasDebuff("Doom") || WoW.TargetDebuffTimeRemaining("Doom") < 5) && WoW.IsSpellInRange("Doom"))
 *                                      {
 *                                              WoW.CastSpell("Doom");
 *                                              return;
 *                                      }
 *
 *                                      //Soul Harvest
 *                                      if(WoW.CanCast("SoulHarvest") && WoW.IsSpellInRange("Doom"))
 *                                      {
 *                                              WoW.CastSpell("SoulHarvest");
 *                                              return;
 *                                      }
 */
                    //Shadowflame (if talent)
                    if (WoW.CanCast("Shadowflame") && Shadowflame && WoW.IsSpellInRange("Doom") && WoW.PlayerSpellCharges("Shadowflame") == 2)
                    {
                        WoW.CastSpell("Shadowflame");
                        return;
                    }

                    //Thal'kiel's Consumption
                    if (WoW.CanCast("TK") && ((WoW.DreadstalkersCount >= 1 && DreadstalkersRemainingDuration > TwoSecondCast) || Implosion) &&
                        ((WoW.WildImpsCount >= 1 && !threeimps) || WoW.WildImpsCount >= 2) && ImpsRemainingDuration > TwoSecondCast && WoW.IsSpellInRange("Doom") &&
                        (!WoW.IsMoving || WoW.PlayerHasBuff("Norgannon")))
                    {
                        WoW.CastSpell("TK");
                        return;
                    }

                    //Life Tap
                    if (WoW.CanCast("LifeTap") && WoW.Mana <= 30)
                    {
                        WoW.CastSpell("LifeTap");
                        return;
                    }

                    //Demonwrath
                    if (WoW.CanCast("Demonwrath") && !WoW.PlayerIsChanneling)
                    {
                        WoW.CastSpell("Demonwrath");
                        return;
                    }

                    //Life Tap
                    if (WoW.CanCast("LifeTap") && WoW.Mana < 100 && !WoW.PlayerIsChanneling)
                    {
                        WoW.CastSpell("LifeTap");
                    }
                }
            }
        }
        public override void Pulse() // Updated for Legion (tested and working for single target)
        {
            if (WoW.IsInCombat && Control.IsKeyLocked(Keys.Scroll) && !WoW.TargetIsPlayer && !WoW.IsMounted)
            {
                SelectRotation(4, 9999, 1);
            }

            if (combatRoutine.Type == RotationType.SingleTarget) // Do Single Target Stuff here
            {
                if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.IsInCombat && !WoW.PlayerIsCasting && !WoW.IsMounted)
                {
                    if ((!WoW.TargetHasDebuff("Agony") || WoW.TargetDebuffTimeRemaining("Agony") <= 540) &&
                        (!WoW.PlayerIsChanneling || WoW.TargetDebuffTimeRemaining("Agony") <= 150) &&
                        WoW.CanCast("Agony") &&
                        WoW.IsSpellInRange("Agony"))
                    {
                        WoW.CastSpell("Agony");
                        return;
                    }

                    if ((WoW.CurrentSoulShards >= 3 || (WoW.CurrentSoulShards >= 2 && WoW.WasLastCasted("Unstable Affliction"))) &&
                        !WoW.IsMoving &&
                        WoW.CanCast("Unstable Affliction") &&
                        WoW.IsSpellInRange("Agony"))
                    {
                        WoW.CastSpell("Unstable Affliction");
                        Thread.Sleep(200);
                        return;
                    }

                    if ((WoW.TargetHasDebuff("Unstable Affliction1") && WoW.TargetHasDebuff("Unstable Affliction2") ||
                         WoW.TargetHasDebuff("Unstable Affliction1") && WoW.TargetHasDebuff("Unstable Affliction3") ||
                         WoW.TargetHasDebuff("Unstable Affliction1") && WoW.TargetHasDebuff("Unstable Affliction4") ||
                         WoW.TargetHasDebuff("Unstable Affliction1") && WoW.TargetHasDebuff("Unstable Affliction5") ||
                         WoW.TargetHasDebuff("Unstable Affliction2") && WoW.TargetHasDebuff("Unstable Affliction3") ||
                         WoW.TargetHasDebuff("Unstable Affliction2") && WoW.TargetHasDebuff("Unstable Affliction4") ||
                         WoW.TargetHasDebuff("Unstable Affliction2") && WoW.TargetHasDebuff("Unstable Affliction5") ||
                         WoW.TargetHasDebuff("Unstable Affliction3") && WoW.TargetHasDebuff("Unstable Affliction4") ||
                         WoW.TargetHasDebuff("Unstable Affliction3") && WoW.TargetHasDebuff("Unstable Affliction5") ||
                         WoW.TargetHasDebuff("Unstable Affliction4") && WoW.TargetHasDebuff("Unstable Affliction5") ||
                         WoW.PlayerBuffStacks("Reap Souls") >= 12) &&
                        !WoW.PlayerIsCasting &&
                        WoW.CanCast("Reap Souls") &&
                        !WoW.PlayerHasBuff("Deadwind Harvester") &&
                        WoW.PlayerHasBuff("Tormented Souls"))
                    {
                        WoW.CastSpell("Reap Souls");
                        return;
                    }

                    if (WoW.CanCast("Life Tap") && !WoW.PlayerIsChanneling && WoW.Talent(2) == 3 && !WoW.PlayerHasBuff("Empowered Life Tap"))
                    {
                        WoW.CastSpell("Life Tap");
                        return;
                    }

                    if ((!WoW.TargetHasDebuff("Corruption") || WoW.TargetDebuffTimeRemaining("Corruption") <= 420) &&
                        (!WoW.PlayerIsChanneling || WoW.TargetDebuffTimeRemaining("Corruption") <= 150) &&
                        WoW.CanCast("Corruption") &&
                        WoW.IsSpellInRange("Agony"))
                    {
                        WoW.CastSpell("Corruption");
                        return;
                    }

                    if ((!WoW.TargetHasDebuff("Siphon Life") || WoW.TargetDebuffTimeRemaining("Siphon Life") <= 420) &&
                        (!WoW.PlayerIsChanneling || WoW.TargetDebuffTimeRemaining("Siphon Life") <= 150) &&
                        WoW.Talent(4) == 1 &&
                        WoW.CanCast("Siphon Life") &&
                        WoW.IsSpellInRange("Agony"))
                    {
                        WoW.CastSpell("Siphon Life");
                        return;
                    }

                    if (WoW.CanCast("Felhunter") && WoW.Talent(6) == 2 && !WoW.IsSpellOnCooldown("Felhunter") && WoW.IsSpellInRange("Agony") && !WoW.PlayerIsChanneling && !WoW.PlayerIsCasting)
                    {
                        WoW.CastSpell("Felhunter");
                        return;
                    }

                    if (WoW.CanCast("Unstable Affliction") && !WoW.IsMoving && WoW.Talent(2) == 1 && !WoW.IsMoving && WoW.IsSpellInRange("Unstable Affliction") && !WoW.PlayerIsChanneling && WoW.CurrentSoulShards >= 1 &&
                        (!WoW.TargetHasDebuff("Unstable Affliction1") || !WoW.TargetHasDebuff("Unstable Affliction2") || !WoW.TargetHasDebuff("Unstable Affliction3") || !WoW.TargetHasDebuff("Unstable Affliction4") || !WoW.TargetHasDebuff("Unstable Affliction5") ||
                         (WoW.TargetDebuffTimeRemaining("Unstable Affliction1") <= 150) || (WoW.TargetDebuffTimeRemaining("Unstable Affliction2") <= 150) || (WoW.TargetDebuffTimeRemaining("Unstable Affliction3") <= 150) ||
                         (WoW.TargetDebuffTimeRemaining("Unstable Affliction4") <= 150) || (WoW.TargetDebuffTimeRemaining("Unstable Affliction5") <= 150)))
                    {
                        WoW.CastSpell("Unstable Affliction");
                        Thread.Sleep(200);
                        return;
                    }

                    if (WoW.IsInCombat && WoW.Mana < 70 && WoW.HealthPercent > 70 && WoW.CanCast("Life Tap"))
                    {
                        WoW.CastSpell("Life Tap");
                        return;
                    }

                    if (WoW.CanCast("Haunt") && WoW.Talent(1) == 1 && !WoW.IsSpellOnCooldown("Haunt") && WoW.IsSpellInRange("Agony") && !WoW.PlayerIsChanneling && !WoW.PlayerIsCasting && !WoW.IsMoving)
                    {
                        WoW.CastSpell("Haunt");
                        return;
                    }

                    if (WoW.CanCast("Drain Soul") && WoW.IsSpellInRange("Agony") && !WoW.PlayerIsChanneling && !WoW.PlayerIsCasting && !WoW.IsMoving)
                    {
                        WoW.CastSpell("Drain Soul");
                        return;
                    }
                }
            }
            if (combatRoutine.Type == RotationType.AOE)
            {
                if (WoW.HasTarget && WoW.TargetIsEnemy && WoW.IsInCombat && !WoW.PlayerIsChanneling && !WoW.PlayerIsCasting && !WoW.IsMounted) // Do AOE stuff here
                {
                    if (WoW.CanCast("Agony") && WoW.IsSpellInRange("Agony") && WoW.TargetHasDebuff("Seed of Corruption") && (!WoW.TargetHasDebuff("Agony") || (WoW.TargetDebuffTimeRemaining("Agony") <= 540)))
                    {
                        WoW.CastSpell("Agony");
                        return;
                    }

                    if (WoW.CanCast("Corruption") && WoW.IsSpellInRange("Agony") && WoW.TargetHasDebuff("Seed of Corruption") && (!WoW.TargetHasDebuff("Corruption") || (WoW.TargetDebuffTimeRemaining("Corruption") <= 420)))
                    {
                        WoW.CastSpell("Corruption");
                        return;
                    }

                    if (WoW.CanCast("Seed of Corruption") && WoW.IsSpellInRange("Agony") && !WoW.TargetHasDebuff("Seed of Corruption") && !WoW.IsMoving && WoW.CurrentSoulShards >= 1)
                    {
                        WoW.CastSpell("Seed of Corruption");
                        return;
                    }
                }
            }
            if (combatRoutine.Type == RotationType.SingleTargetCleave)
            {
                // Do Single Target Cleave stuff here if applicable else ignore this one
            }
        }