Example #1
0
        private static async Task <bool> Onslaught()
        {
            if (!PaineSettingsModel.Instance.UseOnslaught || Target == null || !Target.CanAttack)
            {
                return(false);
            }

            if (ActionResourceManager.Warrior.BeastGauge < 20 && !Me.HasAura(Auras.InnerRelease))
            {
                return(false);
            }

            if (Me.HasAura(Auras.Berserk))
            {
                return(false);
            }

            if (Target.Distance(Me) > 20)
            {
                return(false);
            }

            if (!Me.InCombat || (PaineSettingsModel.Instance.MainTank && await KefkaEnmityManager.EnmityDifference() < PaineSettingsModel.Instance.ButchersBlockCount) || (Target.Distance(Me) - Target.CombatReach < 3 && Me.HasAura(Auras.InnerRelease)))
            {
                return(await Spells.Onslaught.Use(Target, !((Character)Target).IsCasting));
            }

            return(await Spells.Onslaught.Use(Target, ActionResourceManager.Warrior.BeastGauge >= 90 && Spells.Berserk.Cooldown.TotalMilliseconds >= 8000 && !((Character)Target).IsCasting));
        }
Example #2
0
        private static async Task <bool> Upheaval()
        {
            if (!PaineSettingsModel.Instance.UseUpheaval || Target == null || !Target.CanAttack)
            {
                return(false);
            }

            if (ActionResourceManager.Warrior.BeastGauge < 20 && !Me.HasAura(Auras.InnerRelease))
            {
                return(false);
            }

            if (PaineSettingsModel.Instance.MainTank && await KefkaEnmityManager.EnmityDifference() < PaineSettingsModel.Instance.ButchersBlockCount)
            {
                return(await Spells.Upheaval.Use(Target, true));
            }

            if (Me.ClassLevel < 70 && (Spells.Berserk.Cooldown.TotalMilliseconds <= 25000 || Spells.InnerRelease.Cooldown.TotalMilliseconds <= 25000) && PaineSettingsModel.Instance.UseBuffs)
            {
                return(false);
            }

            return(await Spells.Upheaval.Use(Target, (ActionResourceManager.Warrior.BeastGauge >= 80) ||
                                             (Me.HasAura(Auras.InnerRelease) && (CombatHelper.LastSpell == Spells.FellCleave || ActionManager.LastSpell == Spells.FellCleave)) ||
                                             (Me.HasAura(Auras.Berserk) && (CombatHelper.LastSpell == Spells.StormsPath || ActionManager.LastSpell == Spells.StormsPath))));
        }
Example #3
0
        private static async Task <bool> Provoke()
        {
            if (!BeatrixSettingsModel.Instance.MainTank || await KefkaEnmityManager.EnmityDifference() >= 0)
            {
                return(false);
            }

            return(await Spells.Provoke.Use(Target, true));
        }
Example #4
0
        private static async Task <bool> SkullSunder()
        {
            if (!PaineSettingsModel.Instance.MainTank || await KefkaEnmityManager.EnmityDifference() >= PaineSettingsModel.Instance.ButchersBlockCount)
            {
                return(false);
            }

            if (CombatHelper.LastSpell != Spells.HeavySwing && ActionManager.LastSpell != Spells.HeavySwing)
            {
                return(false);
            }

            return(await Spells.SkullSunder.Use(Target, true));
        }
Example #5
0
        private static async Task <bool> SyphonStrike()
        {
            if (CombatHelper.LastSpell != Spells.HardSlash && ActionManager.LastSpell != Spells.HardSlash)
            {
                return(false);
            }

            if ((Me.ClassLevel >= 38 && await KefkaEnmityManager.EnmityDifference() < CecilSettingsModel.Instance.PowerSlashCount && CecilSettingsModel.Instance.MainTank) || (Me.ClassLevel < 38 && Me.CurrentManaPercent >= 65))
            {
                return(false);
            }

            return(await Spells.SyphonStrike.Use(Target, true));
        }
Example #6
0
        private static async Task <bool> SpinningSlash()
        {
            if (!CecilSettingsModel.Instance.MainTank || await KefkaEnmityManager.EnmityDifference() > CecilSettingsModel.Instance.PowerSlashCount)
            {
                return(false);
            }

            if (CombatHelper.LastSpell != Spells.HardSlash && ActionManager.LastSpell != Spells.HardSlash)
            {
                return(false);
            }

            return(await Spells.SpinningSlash.Use(Target, true));
        }
Example #7
0
        private static async Task <bool> Refresh()
        {
            if (!EdwardSettingsModel.Instance.UseRefresh || !PartyManager.IsInParty || !Target.HealthCheck(false) || !Target.TimeToDeathCheck() || ActionManager.LastSpell == Spells.Tactician || CombatHelper.LastSpell == Spells.Tactician)
            {
                return(false);
            }

            if (PartyMembers.Count(pm => pm.IsCaster() && pm.IsAlive && pm.CurrentManaPercent <= EdwardSettingsModel.Instance.RefreshMpPct) >= EdwardSettingsModel.Instance.RefreshMemberCount)
            {
                return(await Spells.Refresh.Use(Me, true));
            }

            return(await Spells.Refresh.Use(Me, await KefkaEnmityManager.TargetingMeCount() > 0));
        }
Example #8
0
        private static async Task <bool> RiotBlade()
        {
            if ((CombatHelper.LastSpell != Spells.FastBlade && ActionManager.LastSpell != Spells.FastBlade))
            {
                return(false);
            }

            if (await KefkaEnmityManager.EnmityDifference() < BeatrixSettingsModel.Instance.RageofHaloneCount && BeatrixSettingsModel.Instance.MainTank)
            {
                return(false);
            }

            return(await Spells.RiotBlade.Use(Target, !Target.HasAura(Auras.GoringBlade, true, 6000) && Me.ClassLevel >= 54 && Target.HealthCheck(false) && Target.TimeToDeathCheck() || Me.ClassLevel >= 60));
        }
Example #9
0
        private static async Task <bool> SavageBlade()
        {
            if (!BeatrixSettingsModel.Instance.MainTank || CombatHelper.LastSpell != Spells.FastBlade && ActionManager.LastSpell != Spells.FastBlade)
            {
                return(false);
            }

            if (await KefkaEnmityManager.EnmityDifference() >= BeatrixSettingsModel.Instance.RageofHaloneCount && Me.ClassLevel >= 54)
            {
                return(false);
            }

            return(await Spells.SavageBlade.Use(Target, true));
        }
Example #10
0
        private static async Task <bool> Maim()
        {
            if (CombatHelper.LastSpell != Spells.HeavySwing && ActionManager.LastSpell != Spells.HeavySwing)
            {
                return(false);
            }

            if (Me.ClassLevel < 38 && !Target.HasAura(Auras.Maim, true, 4500))
            {
                return(await Spells.Maim.CastDot(Target, true, Auras.Maim));
            }
            if (Me.ClassLevel >= 38)
            {
                return(await Spells.Maim.CastDot(Target, (await KefkaEnmityManager.EnmityDifference() >= PaineSettingsModel.Instance.ButchersBlockCount && PaineSettingsModel.Instance.MainTank) || ((!Me.HasAura(Auras.StormsEye, true, PaineSettingsModel.Instance.StormsEyeRefresh) || (Me.HasAura(Auras.Berserk) && !Me.HasAura(Auras.StormsEye, true, PaineSettingsModel.Instance.StormsEyeRefreshBerserk))) && Me.ClassLevel >= 50), Auras.Maim));
            }

            return(false);
        }
Example #11
0
        private static async Task <bool> DarkArts()
        {
            if (Target == null || !Target.CanAttack)
            {
                return(false);
            }

            if (!CecilSettingsModel.Instance.UseDarkArts || Me.HasAura(Auras.DarkArts))
            {
                return(false);
            }

            if (Me.CurrentManaPercent <= CecilSettingsModel.Instance.DarkArtsStopMpPct && (CombatHelper.LastSpell != Spells.SyphonStrike && ActionManager.LastSpell != Spells.SyphonStrike))
            {
                Recovering = true;
            }

            if (Me.CurrentManaPercent >= CecilSettingsModel.Instance.DarkArtsStartMpPct)
            {
                Recovering = false;
            }

            if (CecilSettingsModel.Instance.UseDABloodspiller && Me.ClassLevel >= 68 && ActionResourceManager.DarkKnight.BlackBlood >= 50)
            {
                return(await Spells.DarkArts.CastBuff(Me, true, Auras.DarkArts));
            }

            if (Recovering == false)
            {
                if (CecilSettingsModel.Instance.UseDASyphonStrike && ((CombatHelper.LastSpell == Spells.HardSlash || ActionManager.LastSpell == Spells.HardSlash) && CecilSettingsModel.Instance.PowerSlashCount > await KefkaEnmityManager.EnmityDifference()) && Me.CurrentManaPercent >= CecilSettingsModel.Instance.DASyphonStrikeMpPct)
                {
                    return(await Spells.DarkArts.CastBuff(Me, true, Auras.DarkArts));
                }

                if (CecilSettingsModel.Instance.UseDASouleater && (CombatHelper.LastSpell == Spells.SyphonStrike || ActionManager.LastSpell == Spells.SyphonStrike))
                {
                    return(await Spells.DarkArts.CastBuff(Me, true, Auras.DarkArts));
                }

                if (CecilSettingsModel.Instance.UseDarkPassenger && Target.EnemiesInRange(5) >= CecilSettingsModel.Instance.AoEMinEnemies && Spells.DarkPassenger.Cooldown.TotalMilliseconds < 2000)
                {
                    return(await Spells.DarkArts.CastBuff(Me, true, Auras.DarkArts));
                }

                if (CecilSettingsModel.Instance.UseDAQuietus && Me.ClassLevel >= 64 && Me.EnemiesInRange(5) >= CecilSettingsModel.Instance.AoEMinEnemies && ActionResourceManager.DarkKnight.BlackBlood >= 50)
                {
                    return(await Spells.DarkArts.CastBuff(Me, true, Auras.DarkArts));
                }

                if (CecilSettingsModel.Instance.UseDACarveandSpit && Spells.CarveandSpit.Cooldown.TotalMilliseconds < 2000 && (CecilSettingsModel.Instance.PowerSlashCount > await KefkaEnmityManager.EnmityDifference() || !CecilSettingsModel.Instance.MainTank))
                {
                    return(await Spells.DarkArts.CastBuff(Me, true, Auras.DarkArts));
                }

                if (CecilSettingsModel.Instance.UseDAAbyssalDrain && CecilSettingsModel.Instance.UseAbyssalDrain && Me.ClassLevel >= 56 && Me.CurrentHealthPercent <= CecilSettingsModel.Instance.AbyssalDrainHpPct && Target.EnemiesInRange(5) >= CecilSettingsModel.Instance.AoEMinEnemies)
                {
                    return(await Spells.DarkArts.CastBuff(Me, true, Auras.DarkArts));
                }
            }
            return(false);
        }
Example #12
0
        private static async Task <bool> CircleOfScorn()
        {
            if (!Target.HealthCheck(false) || !Target.TimeToDeathCheck())
            {
                return(false);
            }

            if ((Spells.FightorFlight.Cooldown.TotalMilliseconds < 20000 && BeatrixSettingsModel.Instance.UseFightorFlight) && (await KefkaEnmityManager.EnmityDifference() > BeatrixSettingsModel.Instance.RageofHaloneCount || Me.ClassLevel < 54))
            {
                return(false);
            }

            return(await Spells.CircleofScorn.Use(Me, Target.Distance(Me) < 5));
        }
Example #13
0
        private static async Task <bool> SpiritsWithin()
        {
            if ((Spells.FightorFlight.Cooldown.TotalMilliseconds < 20000 && BeatrixSettingsModel.Instance.UseFightorFlight) && (await KefkaEnmityManager.EnmityDifference() > BeatrixSettingsModel.Instance.RageofHaloneCount || Me.ClassLevel < 54))
            {
                return(false);
            }

            return(await Spells.SpiritsWithin.Use(Target, true));
        }