protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                base.BuffRotation();

                // PARTY Circle of Healing
                if (AoEHeal(false))
                {
                    return;
                }

                List <AIOPartyMember> membersByMissingHealth = AIOParty.ClosePartyMembers
                                                               .OrderBy(m => m.HealthPercent)
                                                               .ToList();

                foreach (var member in membersByMissingHealth)
                {
                    if (SingleTargetHeal(member))
                    {
                        return;
                    }
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
        protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                base.BuffRotation();

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

                // Frost Armor
                if (!Me.HaveBuff("Frost Armor") &&
                    !IceArmor.KnownSpell &&
                    cast.OnSelf(FrostArmor))
                {
                    return;
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
        protected override void BuffRotation()
        {
            base.BuffRotation();

            if (!Me.HaveBuff("Ghost Wolf") && (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95))
            {
                // Ghost Wolf
                if (settings.GhostWolfMount &&
                    wManager.wManagerSetting.CurrentSetting.GroundMountName == "" &&
                    GhostWolf.KnownSpell)
                {
                    ToolBox.SetGroundMount(GhostWolf.Name);
                }

                // Lesser Healing Wave OOC
                if (Me.HealthPercent < settings.OOCHealThreshold &&
                    cast.OnSelf(LesserHealingWave))
                {
                    return;
                }

                // Healing Wave OOC
                if (Me.HealthPercent < settings.OOCHealThreshold &&
                    cast.OnSelf(HealingWave))
                {
                    return;
                }

                // Water Shield
                if (!Me.HaveBuff("Water Shield") &&
                    !Me.HaveBuff("Lightning Shield") &&
                    (settings.UseWaterShield || !settings.UseLightningShield || Me.ManaPercentage < 20) &&
                    cast.OnSelf(WaterShield))
                {
                    return;
                }

                // PARTY Cure poison
                WoWPlayer needCurePoison = AIOParty.GroupAndRaid
                                           .Find(m => ToolBox.HasPoisonDebuff(m.Name));
                if (needCurePoison != null && cast.OnFocusUnit(CurePoison, needCurePoison))
                {
                    return;
                }

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

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
        protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                base.BuffRotation();

                // OOC Shadowguard
                if (!Me.HaveBuff("Shadowguard") &&
                    settings.UseShadowGuard &&
                    cast.OnSelf(Shadowguard))
                {
                    return;
                }

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

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
Beispiel #5
0
        protected override void BuffRotation()
        {
            base.BuffRotation();

            if (!Me.HaveBuff("Ghost Wolf") && (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95))
            {
                // Ghost Wolf
                if (settings.GhostWolfMount &&
                    wManager.wManagerSetting.CurrentSetting.GroundMountName == "" &&
                    GhostWolf.KnownSpell)
                {
                    ToolBox.SetGroundMount(GhostWolf.Name);
                }

                // PARTY Healing Wave
                List <AIOPartyMember> alliesNeedingHealWave = AIOParty.GroupAndRaid
                                                              .FindAll(a => a.IsAlive && a.HealthPercent < 70)
                                                              .OrderBy(a => a.HealthPercent)
                                                              .ToList();
                if (alliesNeedingHealWave.Count > 0 &&
                    cast.OnFocusUnit(HealingWave, alliesNeedingHealWave[0]))
                {
                    return;
                }

                // Water Shield
                if (!Me.HaveBuff("Water Shield") &&
                    !Me.HaveBuff("Lightning Shield") &&
                    (settings.UseWaterShield || !settings.UseLightningShield || Me.ManaPercentage < 20) &&
                    cast.OnSelf(WaterShield))
                {
                    return;
                }

                // PARTY Cure poison
                WoWPlayer needCurePoison = AIOParty.GroupAndRaid
                                           .Find(m => ToolBox.HasPoisonDebuff(m.Name));
                if (needCurePoison != null && cast.OnFocusUnit(CurePoison, needCurePoison))
                {
                    return;
                }

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

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
        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);
            }
        }
Beispiel #8
0
        protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                base.BuffRotation();

                // PARTY Greater heal
                List <AIOPartyMember> needGreaterHeal = AIOParty.GroupAndRaid
                                                        .FindAll(m => m.IsAlive && m.HealthPercent < 50)
                                                        .OrderBy(m => m.HealthPercent)
                                                        .ToList();
                if (needGreaterHeal.Count > 0 && cast.OnFocusUnit(GreaterHeal, needGreaterHeal[0]))
                {
                    return;
                }

                // PARTY Heal
                List <AIOPartyMember> needHeal = AIOParty.GroupAndRaid
                                                 .FindAll(m => m.HealthPercent < 80)
                                                 .OrderBy(m => m.HealthPercent)
                                                 .ToList();
                if (needHeal.Count > 0 && cast.OnFocusUnit(FlashHeal, needHeal[0]))
                {
                    return;
                }

                if (!FlashHeal.KnownSpell)
                {
                    // PARTY Lesser Heal
                    List <AIOPartyMember> needLesserHeal = AIOParty.GroupAndRaid
                                                           .FindAll(m => m.HealthPercent < 80)
                                                           .OrderBy(m => m.HealthPercent)
                                                           .ToList();
                    if (needLesserHeal.Count > 0 && cast.OnFocusUnit(LesserHeal, needLesserHeal[0]))
                    {
                        return;
                    }
                }

                // PARTY Renew
                List <AIOPartyMember> needRenew = AIOParty.GroupAndRaid
                                                  .FindAll(m => m.HealthPercent < 90 && !m.HaveBuff(Renew.Name))
                                                  .OrderBy(m => m.HealthPercent)
                                                  .ToList();
                if (needRenew.Count > 0 && cast.OnFocusUnit(Renew, needRenew[0]))
                {
                    return;
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
        protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                base.BuffRotation();

                if (_knowImprovedScorch)
                {
                    RangeManager.SetRange(Scorch.MaxRange);
                }
                else
                {
                    RangeManager.SetRange(Fireball.MaxRange);
                }

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

                // Mage Armor
                if (!Me.HaveBuff("Mage Armor") &&
                    !MoltenArmor.KnownSpell &&
                    cast.OnSelf(MageArmor))
                {
                    return;
                }

                // Ice Armor
                if (!Me.HaveBuff("Ice Armor") &&
                    (!MoltenArmor.KnownSpell && !MageArmor.KnownSpell) &&
                    cast.OnSelf(IceArmor))
                {
                    return;
                }

                // Frost Armor
                if (!Me.HaveBuff("Frost Armor") &&
                    (!MoltenArmor.KnownSpell && !MageArmor.KnownSpell && !IceArmor.KnownSpell) &&
                    cast.OnSelf(FrostArmor))
                {
                    return;
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
Beispiel #10
0
    public void Initialize()
    {
        AIOTBCSettings.Load();
        AutoUpdater.CheckUpdate(version);
        Logger.Log($"Launching version {version} on client {Lua.LuaDoString<string>("v, b, d, t = GetBuildInfo(); return v")}");

        selectedRotation = ChooseRotation();

        if (selectedRotation != null)
        {
            isLaunched = true;

            FightEvents.OnFightLoop  += FightLoopHandler;
            FightEvents.OnFightStart += FightStartHandler;
            FightEvents.OnFightEnd   += FightEndHandler;
            LoggingEvents.OnAddLog   += AddLogHandler;
            EventsLua.AttachEventLua("RESURRECT_REQUEST", e => ResurrectionEventHandler(e));
            EventsLua.AttachEventLua("PLAYER_DEAD", e => PlayerDeadHandler(e));
            EventsLua.AttachEventLua("READY_CHECK", e => ReadyCheckHandler(e));
            EventsLua.AttachEventLua("INSPECT_TALENT_READY", e => AIOParty.InspectTalentReadyHandler());
            EventsLua.AttachEventLua("PARTY_MEMBERS_CHANGED", e => AIOParty.GroupRosterChangedHandler());
            EventsLua.AttachEventLua("PARTY_MEMBER_DISABLE", e => AIOParty.GroupRosterChangedHandler());
            EventsLua.AttachEventLua("PARTY_MEMBER_ENABLE", e => AIOParty.GroupRosterChangedHandler());
            EventsLuaWithArgs.OnEventsLuaStringWithArgs += EventsWithArgsHandler;
            AIOParty.UpdateParty();

            if (!TalentsManager._isRunning)
            {
                _talentThread.DoWork += TalentsManager.DoTalentPulse;
                _talentThread.RunWorkerAsync();
            }

            if (!_racials._isRunning && CombatSettings.UseRacialSkills)
            {
                _racialsThread.DoWork += _racials.DoRacialsPulse;
                _racialsThread.RunWorkerAsync();
            }

            if (!AIORadar._isRunning)
            {
                _partyThread.DoWork += AIORadar.Pulse;
                _partyThread.RunWorkerAsync();
            }

            selectedRotation.Initialize(selectedRotation);
        }
        else
        {
            Logger.LogError("Class not supported.");
        }
    }
Beispiel #11
0
        protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                // Aspect of the Cheetah
                if (!Me.IsMounted &&
                    !Me.HaveBuff("Aspect of the Cheetah") &&
                    MovementManager.InMoveTo &&
                    Me.ManaPercentage > 60 &&
                    settings.UseAspectOfTheCheetah &&
                    cast.OnSelf(AspectCheetah))
                {
                    return;
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
Beispiel #12
0
        protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                base.BuffRotation();

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

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

                // PARTY Mark of the Wild
                WoWPlayer needMotW = AIOParty.GroupAndRaid
                                     .Find(m => !m.HaveBuff(MarkOfTheWild.Name));
                if (needMotW != null && cast.OnFocusUnit(MarkOfTheWild, needMotW))
                {
                    return;
                }

                // PARTY Thorns
                WoWPlayer needThorns = AIOParty.GroupAndRaid
                                       .Find(m => !m.HaveBuff(Thorns.Name));
                if (needThorns != null && cast.OnFocusUnit(Thorns, needThorns))
                {
                    return;
                }

                // Omen of Clarity
                if (!Me.HaveBuff("Omen of Clarity") &&
                    OmenOfClarity.IsSpellUsable &&
                    cast.OnTarget(OmenOfClarity))
                {
                    return;
                }

                // Regrowth
                WoWPlayer needRegrowth = AIOParty.GroupAndRaid
                                         .Find(m => m.HealthPercent < 80 && !m.HaveBuff("Regrowth"));
                if (needRegrowth != null &&
                    cast.OnFocusUnit(Regrowth, needRegrowth))
                {
                    return;
                }

                // Rejuvenation
                WoWPlayer needRejuvenation = AIOParty.GroupAndRaid
                                             .Find(m => m.HealthPercent < 80 && !m.HaveBuff("Rejuvenation"));
                if (needRejuvenation != null &&
                    cast.OnFocusUnit(Rejuvenation, needRejuvenation))
                {
                    return;
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }

                // Tree form
                if (!Me.HaveBuff("Tree of Life") &&
                    cast.OnSelf(TreeOfLife))
                {
                    return;
                }
            }
        }
        protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                base.BuffRotation();

                // Unending Breath
                if (!Me.HaveBuff("Unending Breath") &&
                    settings.UseUnendingBreath &&
                    cast.OnSelf(UnendingBreath))
                {
                    return;
                }

                // Demon Skin
                if (!Me.HaveBuff("Demon Skin") &&
                    !DemonArmor.KnownSpell &&
                    !FelArmor.KnownSpell &&
                    cast.OnSelf(DemonSkin))
                {
                    return;
                }

                // Demon Armor
                if ((!Me.HaveBuff("Demon Armor")) &&
                    !FelArmor.KnownSpell &&
                    cast.OnSelf(DemonArmor))
                {
                    return;
                }

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

                // Health Funnel OOC
                if (ObjectManager.Pet.HealthPercent < 50 &&
                    Me.HealthPercent > 40 &&
                    ObjectManager.Pet.GetDistance < 19 &&
                    !ObjectManager.Pet.InCombatFlagOnly &&
                    settings.HealthFunnelOOC)
                {
                    Lua.LuaDoString("PetWait();");
                    MovementManager.StopMove();
                    Fight.StopFight();

                    if (WarlockPetAndConsumables.MyWarlockPet().Equals("Voidwalker"))
                    {
                        cast.PetSpell("Consume Shadows", false, true);
                    }

                    if (cast.OnSelf(HealthFunnel))
                    {
                        Thread.Sleep(500);
                        Usefuls.WaitIsCasting();
                        Lua.LuaDoString("PetFollow();");
                        return;
                    }
                    Lua.LuaDoString("PetFollow();");
                }

                // Health Stone
                if (!WarlockPetAndConsumables.HaveHealthstone() &&
                    cast.OnSelf(CreateHealthStone))
                {
                    return;
                }

                // Create Soul Stone
                if (!WarlockPetAndConsumables.HaveSoulstone() &&
                    cast.OnSelf(CreateSoulstone))
                {
                    return;
                }

                // PARTY Soul Stone
                if (CreateSoulstone.KnownSpell &&
                    ToolBox.HaveOneInList(WarlockPetAndConsumables.SoulStones()) &&
                    ToolBox.GetItemCooldown(WarlockPetAndConsumables.SoulStones()) <= 0)
                {
                    WoWPlayer noSoulstone = AIOParty.GroupAndRaid
                                            .Find(m => !m.HaveBuff("Soulstone Resurrection") &&
                                                  m.GetDistance < 20 &&
                                                  m.Name != "Unknown" &&
                                                  !TraceLine.TraceLineGo(Me.Position, m.Position) &&
                                                  (m.WowClass == WoWClass.Paladin || m.WowClass == WoWClass.Priest || m.WowClass == WoWClass.Shaman || m.WowClass == WoWClass.Druid));
                    if (noSoulstone != null)
                    {
                        Logger.Log($"Using Soulstone on {noSoulstone.Name}");
                        MovementManager.StopMoveNewThread();
                        MovementManager.StopMoveToNewThread();
                        Lua.RunMacroText($"/target {noSoulstone.Name}");
                        if (ObjectManager.Target.Name == noSoulstone.Name)
                        {
                            ToolBox.UseFirstMatchingItem(WarlockPetAndConsumables.SoulStones());
                            Usefuls.WaitIsCasting();
                            Lua.RunMacroText("/cleartarget");
                            ToolBox.ClearCursor();
                        }
                    }
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }

                // Life Tap
                if (Me.HealthPercent > Me.ManaPercentage &&
                    settings.UseLifeTap &&
                    cast.OnSelf(LifeTap))
                {
                    return;
                }
            }
        }
        protected override void BuffRotation()
        {
            if (!Me.HaveBuff("Drink") || Me.ManaPercentage > 95)
            {
                base.BuffRotation();

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

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

                // PARTY Mark of the Wild
                WoWPlayer needMotW = AIOParty.GroupAndRaid
                                     .Find(m => !m.HaveBuff(MarkOfTheWild.Name));
                if (needMotW != null && cast.OnFocusUnit(MarkOfTheWild, needMotW))
                {
                    return;
                }

                // PARTY Thorns
                WoWPlayer needThorns = AIOParty.GroupAndRaid
                                       .Find(m => !m.HaveBuff(Thorns.Name));
                if (needThorns != null && cast.OnFocusUnit(Thorns, needThorns))
                {
                    return;
                }

                // Omen of Clarity
                if (!Me.HaveBuff("Omen of Clarity") &&
                    OmenOfClarity.IsSpellUsable &&
                    cast.OnSelf(OmenOfClarity))
                {
                    return;
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }

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

                // Cat Form
                if (!Me.HaveBuff(CatForm.Name) &&
                    cast.OnSelf(CatForm))
                {
                    return;
                }
            }
        }
        protected virtual void BuffRotation()
        {
            // PARTY buff rotations
            if (specialization.RotationType == Enums.RotationType.Party)
            {
                // Aura
                if (!Me.HaveBuff(settings.PartyAura) &&
                    cast.OnSelf(AIOSpell.GetSpellByName(settings.PartyAura)))
                {
                    return;
                }

                // PARTY Resurrection
                List <AIOPartyMember> needRes = AIOParty.GroupAndRaid
                                                .FindAll(m => m.IsDead)
                                                .OrderBy(m => m.GetDistance)
                                                .ToList();
                if (needRes.Count > 0 && cast.OnFocusUnit(Redemption, needRes[0]))
                {
                    return;
                }

                if (settings.PartyHealOOC || specialization is PaladinHolyParty)
                {
                    // PARTY Heal
                    List <AIOPartyMember> needHeal = AIOParty.GroupAndRaid
                                                     .FindAll(m => m.HealthPercent < 70)
                                                     .OrderBy(m => m.HealthPercent)
                                                     .ToList();
                    if (needHeal.Count > 0 && cast.OnFocusUnit(HolyLight, needHeal[0]))
                    {
                        return;
                    }

                    // PARTY Flash of Light
                    List <AIOPartyMember> needFoL = AIOParty.GroupAndRaid
                                                    .FindAll(m => m.HealthPercent < 85)
                                                    .OrderBy(m => m.HealthPercent)
                                                    .ToList();
                    if (needFoL.Count > 0 && cast.OnFocusUnit(FlashOfLight, needFoL[0]))
                    {
                        return;
                    }
                }

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

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

                // Blessings
                if (PartyBlessingBuffs())
                {
                    return;
                }

                // PARTY Drink
                if (AIOParty.PartyDrink(settings.PartyDrinkName, settings.PartyDrinkThreshold))
                {
                    return;
                }
            }
        }
        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 #17
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;
            }
        }