protected override void CombatNoTarget()
        {
            base.CombatNoTarget();

            if (settings.PartyTankSwitchTarget)
            {
                AIOParty.SwitchTarget(cast, null);
            }
        }
        protected override void CombatNoTarget()
        {
            base.CombatNoTarget();

            if (settings.PartyTankSwitchTarget)
            {
                AIOParty.SwitchTarget(cast, RighteousDefense);
            }
        }
        protected override void CombatRotation()
        {
            base.CombatRotation();

            bool    _shouldBeInterrupted = ToolBox.TargetIsCasting();
            bool    _inMeleeRange        = ObjectManager.Target.GetDistance < 6f;
            WoWUnit Target = ObjectManager.Target;

            if (settings.PartyTankSwitchTarget)
            {
                AIOParty.SwitchTarget(cast, null);
            }

            // Force melee
            if (_combatMeleeTimer.IsReady)
            {
                RangeManager.SetRangeToMelee();
            }

            // Check if fighting a caster
            if (_shouldBeInterrupted)
            {
                _fightingACaster = true;
                RangeManager.SetRangeToMelee();
                if (!_casterEnemies.Contains(Target.Name))
                {
                    _casterEnemies.Add(Target.Name);
                }
            }

            // Check Auto-Attacking
            ToolBox.CheckAutoAttack(Attack);

            // Party Tranquility
            if (settings.PartyTranquility && !AIOParty.GroupAndRaid.Any(e => e.IsTargetingMe))
            {
                bool needTranquility = AIOParty.GroupAndRaid
                                       .FindAll(m => m.HealthPercent < 50)
                                       .Count > 2;
                if (needTranquility &&
                    cast.OnTarget(Tranquility))
                {
                    Usefuls.WaitIsCasting();
                    return;
                }
            }

            // PARTY Rebirth
            if (settings.PartyUseRebirth)
            {
                WoWPlayer needRebirth = AIOParty.GroupAndRaid
                                        .Find(m => m.IsDead);
                if (needRebirth != null && cast.OnFocusUnit(Rebirth, needRebirth))
                {
                    return;
                }
            }

            // PARTY Innervate
            if (settings.PartyUseInnervate)
            {
                WoWPlayer needInnervate = AIOParty.GroupAndRaid
                                          .Find(m => m.ManaPercentage < 10 && !m.HaveBuff("Innervate"));
                if (needInnervate != null && cast.OnFocusUnit(Innervate, needInnervate))
                {
                    return;
                }
            }

            if (settings.PartyRemoveCurse)
            {
                // PARTY Remove Curse
                WoWPlayer needRemoveCurse = AIOParty.GroupAndRaid
                                            .Find(m => ToolBox.HasCurseDebuff(m.Name));
                if (needRemoveCurse != null && cast.OnFocusUnit(RemoveCurse, needRemoveCurse))
                {
                    return;
                }
            }

            if (settings.PartyAbolishPoison)
            {
                // PARTY Abolish Poison
                WoWPlayer needAbolishPoison = AIOParty.GroupAndRaid
                                              .Find(m => ToolBox.HasPoisonDebuff(m.Name));
                if (needAbolishPoison != null && cast.OnFocusUnit(AbolishPoison, needAbolishPoison))
                {
                    return;
                }
            }

            // Dire Bear Form
            if (DireBearForm.KnownSpell &&
                !Me.HaveBuff("Dire Bear Form") &&
                cast.OnSelf(DireBearForm))
            {
                return;
            }

            // Bear Form
            if (!DireBearForm.KnownSpell &&
                !Me.HaveBuff("Bear Form") &&
                cast.OnSelf(BearForm))
            {
                return;
            }

            // Feral Charge
            if (Target.GetDistance > 10 &&
                cast.OnTarget(FeralCharge))
            {
                return;
            }

            // Interrupt with Bash
            if (_shouldBeInterrupted &&
                cast.OnTarget(Bash))
            {
                return;
            }

            // Taunt
            if (_inMeleeRange &&
                !Target.IsTargetingMe &&
                Target.Target > 0 &&
                cast.OnTarget(Growl))
            {
                return;
            }

            // Challenging roar
            if (_inMeleeRange &&
                !Target.IsTargetingMe &&
                Target.Target > 0 &&
                ToolBox.GetNbEnemiesClose(8) > 2 &&
                cast.OnTarget(ChallengingRoar))
            {
                return;
            }

            // Maul
            if (!MaulOn() &&
                Me.Rage > 70)
            {
                cast.OnTarget(Maul);
            }

            // Frenzied Regeneration
            if (Me.HealthPercent < 50 &&
                cast.OnSelf(FrenziedRegeneration))
            {
                return;
            }

            // Enrage
            if (settings.UseEnrage &&
                cast.OnSelf(Enrage))
            {
                return;
            }

            // Faerie Fire
            if (!Target.HaveBuff("Faerie Fire (Feral)") &&
                cast.OnTarget(FaerieFireFeral))
            {
                return;
            }

            // Demoralizing Roar
            if (!Target.HaveBuff("Demoralizing Roar") &&
                !Target.HaveBuff("Demoralizing Shout") &&
                Target.GetDistance < 9f &&
                cast.OnTarget(DemoralizingRoar))
            {
                return;
            }

            // Mangle
            if (MangleBear.KnownSpell &&
                Me.Rage > 15 &&
                _inMeleeRange &&
                !Target.HaveBuff("Mangle (Bear)") &&
                cast.OnTarget(MangleBear))
            {
                return;
            }

            // Swipe
            List <WoWUnit> closeEnemies = AIOParty.EnemiesFighting
                                          .FindAll(e => e.GetDistance < 10)
                                          .ToList();

            if (closeEnemies.Count > 1 &&
                Target.IsTargetingMe &&
                cast.OnTarget(Swipe))
            {
                return;
            }

            // Lacerate
            if (ToolBox.CountDebuff("Lacerate", "target") < 5 &&
                cast.OnTarget(Lacerate))
            {
                return;
            }
        }
Beispiel #4
0
        protected override void CombatRotation()
        {
            base.CombatRotation();
            WoWUnit Target = ObjectManager.Target;
            bool    _shouldBeInterrupted = ToolBox.TargetIsCasting();
            bool    _inMeleeRange        = Target.GetDistance < RangeManager.GetMeleeRangeWithTarget();

            // Force melee
            if (_combatMeleeTimer.IsReady)
            {
                RangeManager.SetRangeToMelee();
            }

            // Check if we need to interrupt
            if (_shouldBeInterrupted)
            {
                _fightingACaster = true;
                RangeManager.SetRangeToMelee();
                if (!_casterEnemies.Contains(Target.Name))
                {
                    _casterEnemies.Add(Target.Name);
                }
            }

            if (settings.PartyTankSwitchTarget)
            {
                AIOParty.SwitchTarget(cast, settings.PartyUseIntervene ? Intervene : null);
            }

            // Defensive Stance
            if (InBattleStance())
            {
                cast.OnTarget(DefensiveStance);
            }

            // Check Auto-Attacking
            ToolBox.CheckAutoAttack(Attack);

            // Taunt
            if (_inMeleeRange &&
                !Target.IsTargetingMe &&
                Target.Target > 0 &&
                cast.OnTarget(Taunt))
            {
                return;
            }

            // Cleave
            List <WoWUnit> closeEnemies = AIOParty.EnemiesFighting
                                          .FindAll(e => e.GetDistance < 10);

            if (_inMeleeRange &&
                closeEnemies.Count > 1 &&
                ObjectManager.Me.Rage > 70)
            {
                cast.OnTarget(Cleave);
            }

            // Heroic Strike
            if (_inMeleeRange &&
                !HeroicStrikeOn() &&
                Me.Rage > 90)
            {
                cast.OnTarget(HeroicStrike);
            }

            // Last Stand
            if (Me.HealthPercent < 20 &&
                cast.OnSelf(LastStand))
            {
                return;
            }

            // Shied Bash
            if (ToolBox.TargetIsCasting() &&
                cast.OnTarget(ShieldBash))
            {
                return;
            }

            // Demoralizing Shout
            if (settings.UseDemoralizingShout &&
                !Target.HaveBuff("Demoralizing Shout") &&
                !Target.HaveBuff("Demoralizing Roar") &&
                _inMeleeRange &&
                cast.OnSelf(DemoralizingShout))
            {
                return;
            }

            // Thunderclap
            if (_inMeleeRange &&
                !ObjectManager.Target.HaveBuff(ThunderClap.Name) &&
                cast.OnSelf(ThunderClap))
            {
                return;
            }

            // Shield Slam
            if (_inMeleeRange &&
                Me.Rage > 70 &&
                ShieldSlam.IsSpellUsable &&
                cast.OnTarget(ShieldSlam))
            {
                return;
            }

            // Revenge
            if (_inMeleeRange &&
                ToolBox.GetPetSpellCooldown(Revenge.Name) <= 0 &&
                cast.OnTarget(Revenge))
            {
                return;
            }

            // Devastate
            if (_inMeleeRange &&
                cast.OnTarget(Devastate))
            {
                return;
            }

            // Sunder Armor
            if (_inMeleeRange &&
                cast.OnTarget(SunderArmor))
            {
                return;
            }

            // Shield Block
            if (ObjectManager.Me.HealthPercent < 50 &&
                cast.OnSelf(ShieldBlock))
            {
                return;
            }

            // Spell Reflection
            if (ToolBox.TargetIsCasting() &&
                cast.OnSelf(SpellReflection))
            {
                return;
            }

            // Commanding Shout
            if (!Me.HaveBuff("Commanding Shout") &&
                settings.UseCommandingShout &&
                cast.OnSelf(CommandingShout))
            {
                return;
            }
        }
        protected override void CombatRotation()
        {
            base.CombatRotation();

            WoWUnit Target = ObjectManager.Target;

            // Force melee
            if (_combatMeleeTimer.IsReady)
            {
                RangeManager.SetRangeToMelee();
            }

            ToolBox.CheckAutoAttack(Attack);

            if (settings.PartyTankSwitchTarget)
            {
                AIOParty.SwitchTarget(cast, RighteousDefense);
            }

            // Righteous Defense
            if (!Target.IsTargetingMe &&
                Target.Target > 0 &&
                AIOParty.GroupAndRaid.Contains(Target.TargetObject) &&
                cast.OnFocusUnit(RighteousDefense, Target.TargetObject))
            {
                return;
            }

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

            // PARTY Lay On Hands
            List <AIOPartyMember> needsLoH = AIOParty.GroupAndRaid
                                             .FindAll(m => m.HealthPercent < 10)
                                             .OrderBy(m => m.HealthPercent)
                                             .ToList();

            if (needsLoH.Count > 0 && cast.OnFocusUnit(LayOnHands, needsLoH[0]))
            {
                return;
            }

            // PARTY Purifiy
            if (settings.PartyPurify)
            {
                WoWPlayer needsPurify = AIOParty.GroupAndRaid
                                        .Find(m => ToolBox.HasDiseaseDebuff(m.Name) || ToolBox.HasPoisonDebuff(m.Name));
                if (needsPurify != null && cast.OnFocusUnit(Purify, needsPurify))
                {
                    return;
                }
            }

            // PARTY Cleanse
            if (settings.PartyCleanse)
            {
                WoWPlayer needsCleanse = AIOParty.GroupAndRaid
                                         .Find(m => ToolBox.HasMagicDebuff(m.Name));
                if (needsCleanse != null && cast.OnFocusUnit(Cleanse, needsCleanse))
                {
                    return;
                }
            }

            // Consecration
            if (!settings.PartyConsecrationRank1 &&
                ToolBox.GetNbEnemiesClose(7) > 1 &&
                cast.OnSelf(Consecration))
            {
                return;
            }

            // Consecration Rank 1
            if (settings.PartyConsecrationRank1 &&
                ToolBox.GetNbEnemiesClose(7) > 1 &&
                cast.OnSelf(ConsecrationRank1))
            {
                return;
            }

            // Avenging Wrath
            if (cast.OnSelf(AvengingWrath))
            {
                return;
            }

            // Hammer of Justice
            if (ToolBox.TargetIsCasting() &&
                cast.OnTarget(HammerOfJustice))
            {
                return;
            }

            // Judgement
            if (Target.GetDistance < Judgement.MaxRange &&
                (!Target.HaveBuff("Judgement of Wisdom") || Me.ManaPercentage > settings.PartyProtSealOfWisdom) &&
                cast.OnTarget(Judgement))
            {
                return;
            }

            // Seal of Righteousness
            if (Me.ManaPercentage > settings.PartyProtSealOfWisdom &&
                !Me.HaveBuff("Seal of Righteousness") &&
                cast.OnSelf(SealOfRighteousness))
            {
                return;
            }

            // Seal of Wisdom
            if (Me.ManaPercentage <= settings.PartyProtSealOfWisdom &&
                !Me.HaveBuff("Seal of Wisdom") &&
                cast.OnSelf(SealOfWisdom))
            {
                return;
            }

            // Holy Shield
            if (!settings.PartyHolyShieldRank1 &&
                !Me.HaveBuff("Holy Shield") &&
                cast.OnSelf(HolyShield))
            {
                return;
            }

            // Holy Shield Rank 1
            if (settings.PartyHolyShieldRank1 &&
                !Me.HaveBuff("Holy Shield") &&
                cast.OnSelf(HolyShieldRank1))
            {
                return;
            }

            // Avenger's Shield
            if (!settings.PartyAvengersShieldnRank1 &&
                !Target.IsTargetingMe &&
                cast.OnTarget(AvengersShield))
            {
                return;
            }

            // Avenger's Shield Rank 1
            if (settings.PartyAvengersShieldnRank1 &&
                !Target.IsTargetingMe &&
                cast.OnTarget(AvengersShieldRank1))
            {
                return;
            }

            // Hammer of Wrath
            if (settings.UseHammerOfWrath &&
                cast.OnTarget(HammerOfWrath))
            {
                return;
            }

            // Exorcism
            if ((Target.CreatureTypeTarget == "Undead" || Target.CreatureTypeTarget == "Demon") &&
                settings.UseExorcism &&
                cast.OnTarget(Exorcism))
            {
                return;
            }
        }