private static async Task <bool> Excogitation()
{
if (!SuritoSettingsModel.Instance.UseExcogitation || ActionResourceManager.Arcanist.Aetherflow.Equals(0))
{
return(false);
}
var target = HealManager.FirstOrDefault(hm => !hm.IsMe &&
hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.ExcogitationHpPct &&
(hm.IsTank() || !SuritoSettingsModel.Instance.UseExcogitationOnTankOnly));
if (target == null)
{
return(false);
}
return(await Spells.Excogitation.CastBuff(target, true, Auras.Excogitation));
}
private static async Task <bool> PlenaryIndulgence()
{
if (!MikotoSettingsModel.Instance.UsePlenaryIndulgence)
{
return(false);
}
if (!HealManager.Any(hm => hm.HasAura(Auras.Confession)))
{
return(false);
}
if (HealManager.Count(hm => hm.CurrentHealthPercent < MikotoSettingsModel.Instance.PlenaryIndulgenceHpPct) < MikotoSettingsModel.Instance.PlenaryIndulgencePlayerCount)
{
return(false);
}
return(await Spells.PlenaryIndulgence.Use(Me, true));
}
private static async Task <bool> PresenceOfMind()
{
if (!MikotoSettingsModel.Instance.UsePresenceofMind)
{
return(false);
}
if (HealManager.Count(hm => hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.PresenceofMindHpPct) < MikotoSettingsModel.Instance.PresenceofMindPlayerCount && !MikotoSettingsModel.Instance.UsePresenceofMindOnTankOnly)
{
return(false);
}
if (MikotoSettingsModel.Instance.UsePresenceofMindOnTankOnly && !HealManager.Any(hm => hm.IsTank() && hm.CurrentHealthPercent < MikotoSettingsModel.Instance.PresenceofMindHpPct))
{
return(false);
}
return(await Spells.PresenceofMind.CastBuff(Me, true, Auras.PresenceofMind));
}
private static async Task <bool> Largesse()
{
if (!SuritoSettingsModel.Instance.UseLargesse)
{
return(false);
}
if (HealManager.Count(hm => hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.LargesseHpPct) < SuritoSettingsModel.Instance.LargessePlayerCount && !SuritoSettingsModel.Instance.UseLargesseOnTankOnly)
{
return(false);
}
if (SuritoSettingsModel.Instance.UseLargesseOnTankOnly && !HealManager.Any(hm => hm.IsTank() && hm.CurrentHealthPercent < SuritoSettingsModel.Instance.LargesseHpPct))
{
return(false);
}
return(await Spells.Largesse.CastBuff(Me, true, Auras.Largesse));
}
internal static async Task <bool> Swap()
{
if (!CecilSettingsModel.Instance.Swap)
{
return(false);
}
var OtherTank = HealManager.FirstOrDefault(hm => hm.IsTank() && !hm.IsMe);
if (OtherTank == null)
{
CecilSettingsModel.Instance.Swap = false;
return(false);
}
if (!CecilSettingsModel.Instance.MainTank)
{
var provokeTarget = OtherTank.TargetGameObject;
if (provokeTarget != null)
{
if (await Spells.Provoke.Use(provokeTarget, true))
{
Logger.CecilLog(@"====> Provoking {0} to Pull Aggro From {1}", provokeTarget.Name, OtherTank.Name);
CecilSettingsModel.Instance.MainTank = true;
CecilSettingsModel.Instance.Swap = false;
return(true);
}
}
}
if (CecilSettingsModel.Instance.MainTank)
{
if (await Shirk(OtherTank))
{
Logger.CecilLog(@"====> Shirking to {0} to lose Aggro from {1}", OtherTank.Name, Target.Name);
CecilSettingsModel.Instance.MainTank = false;
CecilSettingsModel.Instance.Swap = false;
return(true);
}
}
return(false);
}
private static async Task <bool> CureII()
{
if (!MikotoSettingsModel.Instance.UseCure2)
{
return(false);
}
var target = HealManager.FirstOrDefault(hm => hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.Cure2HpPct);
if (Me.HasAura(Auras.Freecure))
{
target = HealManager.FirstOrDefault(hm => hm.CurrentHealthPercent < (MikotoSettingsModel.Instance.CureHpPct));
}
if (target != null)
{
return(await Spells.CureII.Use(target, true, true));
}
return(false);
}
private static async Task <bool> EyeForAnEye()
{
if (!SuritoSettingsModel.Instance.UseEyeforanEye)
{
return(false);
}
var target = HealManager.FirstOrDefault(hm => hm.IsTank() && (!SuritoSettingsModel.Instance.UseEyeforanEyeOnlyAfterAdloquium || hm.HasAura(Auras.Adloquium, true)));
if (target == null)
{
target = HealManager.FirstOrDefault(hm => !hm.IsMe && (!SuritoSettingsModel.Instance.UseEyeforanEyeOnlyAfterAdloquium || hm.HasAura(Auras.Adloquium, true)));
}
if (target != null)
{
return(await Spells.EyeforanEye.Use(target, !target.HasAura(Auras.EyeforanEye)));
}
return(false);
}
private static async Task <bool> Cure()
{
var target = HealManager.FirstOrDefault(hm => hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.CureHpPct);
if (target == null)
{
return(false);
}
if (target.IsTank())
{
if (MikotoSettingsModel.Instance.RegenCureFloorTanks && target.HasAura(Auras.Regen) && target.CurrentHealthPercent > MikotoSettingsModel.Instance.RegenCureFloorPct)
{
return(false);
}
return(await Spells.Cure.Use(target, true, true));
}
if (target.IsHealer())
{
if (MikotoSettingsModel.Instance.RegenCureFloorHealers && target.HasAura(Auras.Regen) && target.CurrentHealthPercent > MikotoSettingsModel.Instance.RegenCureFloorPct)
{
return(false);
}
return(await Spells.Cure.Use(target, true, true));
}
if (!target.IsDps())
{
return(false);
}
if (MikotoSettingsModel.Instance.RegenCureFloorDps && target.HasAura(Auras.Regen) && target.CurrentHealthPercent > MikotoSettingsModel.Instance.RegenCureFloorPct)
{
return(false);
}
return(await Spells.Cure.Use(target, true, true));
}
private static async Task <bool> EyeForAnEye()
{
if (!MikotoSettingsModel.Instance.UseEyeforanEye)
{
return(false);
}
var target = HealManager.FirstOrDefault(hm => hm.IsTank() && !hm.HasAura(Auras.EyeforanEye) && hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.EyeforanEyeHpPct);
if (target == null)
{
target = HealManager.FirstOrDefault(hm => !hm.IsMe && !hm.HasAura(Auras.EyeforanEye) && hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.EyeforanEyeHpPct);
}
if (target == null)
{
return(false);
}
return(await Spells.EyeforanEye.Use(target, true));
}
private static async Task <bool> EmergencyTactics()
{
if (!SuritoSettingsModel.Instance.UseEmergencyTactics)
{
return(false);
}
if (!SuritoSettingsModel.Instance.UseEmergencyTacticsOnTankOnly && HealManager.Count(hm => hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.EmergencyTacticsSuccorHpPct) >= SuritoSettingsModel.Instance.SuccorPlayerCount)
{
return(await Spells.EmergencyTactics.CastBuff(Me, true, Auras.EmergencyTactics));
}
var target = HealManager.FirstOrDefault(hm =>
hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.EmergencyTacticsAdloquiumHpPct);
if (target != null && (target.IsTank() || !SuritoSettingsModel.Instance.UseEmergencyTacticsOnTankOnly))
{
return(await Spells.EmergencyTactics.CastBuff(Me, true, Auras.EmergencyTactics));
}
return(false);
}
private static void OnUpdate(EventArgs args)
{
HealManager.Heal();
Killsteal.KillSteal();
Modes.Flee();
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
Modes.Combo();
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
Modes.Harass();
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
{
Modes.Lane();
Modes.Jungle();
}
}
private static async Task <bool> Aetherpact()
{
if (!SuritoSettingsModel.Instance.UseAetherpact || Me.Pet == null)
{
return(false);
}
if (ActionResourceManager.Scholar.FaerieGauge < SuritoSettingsModel.Instance.AetherpactMinGuage)
{
return(false);
}
var target = HealManager.FirstOrDefault(hm => hm.Distance(Me.Pet) <= 12 &&
hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.AetherpactHpPct &&
(hm.IsTank() || !SuritoSettingsModel.Instance.UseAetherpactOnTankOnly));
if (target == null)
{
return(false);
}
return(await Spells.Aetherpact2.CastBuff(target, true, Auras.FeyUnion));
}
private static void OnUpdate(EventArgs args)
{
// var target = TargetSelector.GetSelectedTarget();
// Chat.Print("Buffs: {0}", string.Join(" | ", target.Buffs.Where(b => b.Caster.NetworkId == Player.NetworkId).Select(b => b.DisplayName)));
HealManager.Heal();
Killsteal.KillSteal();
Modes.Flee();
switch (Orb.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
Modes.Combo();
break;
case Orbwalking.OrbwalkingMode.LaneClear:
Modes.Lane();
Modes.Jungle();
break;
case Orbwalking.OrbwalkingMode.Mixed:
Modes.Harass();
break;
}
}
public static async Task <bool> ExecuteOpener()
{
if (OpenerFinished || Me.ClassLevel < 70)
{
return(false);
}
if (ShinraEx.Settings.CooldownMode == CooldownModes.Disabled)
{
AbortOpener("Please enable cooldown mode to use an opener.");
return(false);
}
#region GetOpener
switch (Me.CurrentJob)
{
case ClassJobType.Bard:
current = BardOpener.List;
usePotion = ShinraEx.Settings.BardPotion;
potionStep = 0;
potionType = PotionIds.Dex;
break;
case ClassJobType.BlackMage:
current = BlackMageOpener.List;
usePotion = ShinraEx.Settings.BlackMagePotion;
potionStep = 7;
potionType = PotionIds.Int;
break;
case ClassJobType.DarkKnight:
current = DarkKnightOpener.List;
usePotion = ShinraEx.Settings.DarkKnightPotion;
potionStep = 3;
potionType = PotionIds.Str;
break;
case ClassJobType.Dragoon:
current = DragoonOpener.List;
usePotion = ShinraEx.Settings.DragoonPotion;
potionStep = 7;
potionType = PotionIds.Str;
break;
case ClassJobType.Machinist:
current = MachinistOpener.List;
usePotion = ShinraEx.Settings.MachinistPotion;
potionStep = 0;
potionType = PotionIds.Dex;
break;
case ClassJobType.Monk:
current = MonkOpener.List;
usePotion = ShinraEx.Settings.MonkPotion;
potionStep = 4;
potionType = PotionIds.Str;
break;
case ClassJobType.Ninja:
current = NinjaOpener.List;
usePotion = ShinraEx.Settings.NinjaPotion;
potionStep = 7;
potionType = PotionIds.Dex;
break;
case ClassJobType.Paladin:
current = PaladinOpener.List;
usePotion = ShinraEx.Settings.PaladinPotion;
potionStep = 8;
potionType = PotionIds.Str;
break;
case ClassJobType.RedMage:
current = RedMageOpener.List;
usePotion = ShinraEx.Settings.RedMagePotion;
potionStep = 3;
potionType = PotionIds.Int;
break;
case ClassJobType.Samurai:
current = SamuraiOpener.List;
usePotion = ShinraEx.Settings.SamuraiPotion;
potionStep = 4;
potionType = PotionIds.Str;
break;
case ClassJobType.Summoner:
current = SummonerOpener.List;
usePotion = ShinraEx.Settings.SummonerPotion;
potionStep = 2;
potionType = PotionIds.Int;
break;
case ClassJobType.Warrior:
current = WarriorOpener.List;
usePotion = ShinraEx.Settings.WarriorPotion;
potionStep = 5;
potionType = PotionIds.Str;
break;
default:
current = null;
break;
}
if (current == null)
{
return(false);
}
#endregion
if (OpenerStep >= current.Count)
{
AbortOpener("ShinraEx >>> Opener Finished");
return(false);
}
if (usePotion && OpenerStep == potionStep)
{
if (await UsePotion(potionType))
{
return(true);
}
}
var spell = current.ElementAt(OpenerStep);
resetTime = DateTime.Now.AddSeconds(10);
#region Job-Specific
switch (Me.CurrentJob)
{
case ClassJobType.Bard:
if (Resource.Bard.Repertoire == 3)
{
await Bard.PitchPerfect.Cast(null, false);
}
break;
case ClassJobType.BlackMage:
if ((spell.Name == BlackMage.BlizzardIV.Name || spell.Name == BlackMage.FireIV.Name) && !Resource.BlackMage.Enochian)
{
AbortOpener("Aborted opener due to Enochian.");
return(true);
}
break;
case ClassJobType.DarkKnight:
if (spell.Name == DarkKnight.BloodWeapon.Name && Me.HasAura(DarkKnight.Grit.Name))
{
Debug($"Skipping opener step {OpenerStep} due to Grit >>> {spell.Name}");
OpenerStep++;
return(true);
}
if ((spell.Name == DarkKnight.Bloodspiller.Name || spell.Name == DarkKnight.Delirium.Name) &&
Resource.DarkKnight.BlackBlood < 50)
{
Debug($"Skipping opener step {OpenerStep} due to Blood >>> {spell.Name}");
OpenerStep++;
return(true);
}
if (spell.Name == DarkKnight.BlackestNight.Name && ShinraEx.Settings.DarkKnightOffTank)
{
await UpdateHealManager();
var target = HealManager.FirstOrDefault(hm => hm.IsTank() && !hm.IsMe);
if (target != null && await DarkKnight.BlackestNight.Cast(target, false))
{
Debug($"Casting opener step {OpenerStep} on the main tank >>> {spell.Name}");
OpenerStep++;
return(true);
}
}
break;
case ClassJobType.Dragoon:
if (OpenerStep > 4 && Resource.Dragoon.Timer == TimeSpan.Zero)
{
AbortOpener("Aborted opener due to Blood of the Dragon.");
return(true);
}
if (spell.Name == Dragoon.DragonSight.Name)
{
var target = Managers.DragonSight.FirstOrDefault();
if (target == null)
{
break;
}
if (await Dragoon.DragonSight.Cast(target, false))
{
Debug($"Executed opener step {OpenerStep} >>> {spell.Name}");
OpenerStep++;
return(true);
}
}
break;
case ClassJobType.Machinist:
if (PetManager.ActivePetType != PetType.Rook_Autoturret)
{
var castLocation = ShinraEx.Settings.MachinistTurretLocation == CastLocations.Self ? Me : Target;
if (await Machinist.RookAutoturret.Cast(castLocation, false))
{
return(true);
}
}
if (Pet != null)
{
if (await Machinist.Hypercharge.Cast(null, false))
{
return(true);
}
}
break;
case ClassJobType.Monk:
switch (OpenerStep)
{
case 0 when !Me.HasAura(109):
if (Me.HasAura(108))
{
await Monk.TwinSnakes.Cast();
}
await Monk.Bootshine.Cast();
return(true);
case 0 when !Me.HasAura(105):
await Monk.FistsOfWind.Cast(null, false);
return(true);
}
if (spell.Name == Monk.RiddleOfWind.Name && Monk.RiddleOfWind.Cooldown() > 0)
{
return(true);
}
if (spell.Name == Monk.ForbiddenChakra.Name && Resource.Monk.FithChakra != 5)
{
Debug($"Skipping opener step {OpenerStep} due to Chakras >>> {spell.Name}");
OpenerStep++;
return(true);
}
if (spell.Name == Monk.TornadoKick.Name && Resource.Monk.GreasedLightning != 3)
{
Debug($"Skipping opener step {OpenerStep} due to Greased Lightning >>> {spell.Name}");
OpenerStep++;
return(true);
}
if (spell.Name == Monk.PerfectBalance.Name)
{
if (Monk.PerfectBalance.Cooldown() <= 0)
{
AbortOpener("Aborted opener due to Perfect Balance.");
return(true);
}
if (Monk.Bootshine.Cooldown() > 700)
{
return(true);
}
}
if (ShinraEx.LastSpell.Name != Monk.PerfectBalance.Name && Monk.PerfectBalance.Cooldown() > 0 &&
ActionManager.CanCast(Monk.Bootshine.Name, Target) && !ActionManager.CanCast(spell.Name, Target) &&
!ActionManager.CanCast(spell.Name, Me))
{
AbortOpener("Aborted opener due to Perfect Balance.");
return(true);
}
break;
case ClassJobType.Ninja:
if (OpenerStep == 1 && (Resource.Ninja.HutonTimer == TimeSpan.Zero || Ninja.Ninjutsu.Cooldown() > 0))
{
AbortOpener("Aborted opener due to Ninjutsu.");
return(true);
}
if (spell.Name == Ninja.Kassatsu.Name && Ninja.Kassatsu.Cooldown() > 0)
{
AbortOpener("Aborted opener due to Kassatsu.");
return(true);
}
if (spell.Name == Ninja.TrickAttack.Name && !Me.HasAura(Ninja.Suiton.Name))
{
Debug($"Skipping opener step {OpenerStep} due to Suiton >>> {spell.Name}");
OpenerStep++;
return(true);
}
break;
case ClassJobType.RedMage:
if (!ActionManager.HasSpell("Swiftcast"))
{
AbortOpener("Aborting opener as Swiftcast is not set.");
return(false);
}
if (spell.Name == RedMage.Verstone.Name && !Me.HasAura("Verstone Ready"))
{
AbortOpener("Aborting opener due to cooldowns.");
return(false);
}
if (spell.Name == RedMage.EnchantedRiposte.Name && (Resource.RedMage.WhiteMana < 80 || Resource.RedMage.BlackMana < 80))
{
AbortOpener("Aborted opener due to mana levels.");
return(true);
}
break;
case ClassJobType.Samurai:
if (spell.Name == Samurai.MeikyoShisui.Name && Samurai.MeikyoShisui.Cooldown() > 0 ||
OpenerStep > 9 && !Me.HasAura(Samurai.MeikyoShisui.Name))
{
AbortOpener("Aborted opener due to Meikyo Shisui.");
return(true);
}
if (spell.Name == Samurai.HissatsuGuren.Name && Resource.Samurai.Kenki < 70)
{
Debug($"Skipping opener step {OpenerStep} due to Kenki >>> {spell.Name}");
OpenerStep++;
return(true);
}
if (spell.Name == Samurai.Higanbana.Name && MovementManager.IsMoving)
{
return(true);
}
break;
case ClassJobType.Summoner:
if (!ActionManager.HasSpell("Swiftcast"))
{
AbortOpener("Aborting opener as Swiftcast is not set.");
return(false);
}
if (PetManager.ActivePetType == PetType.Ifrit_Egi && PetManager.PetMode != PetMode.Sic)
{
if (await Coroutine.Wait(1000, () => PetManager.DoAction("Sic", Me)))
{
Logging.Write(Colors.GreenYellow, @"[ShinraEx] Casting >>> Sic");
return(await Coroutine.Wait(3000, () => PetManager.PetMode == PetMode.Sic));
}
}
if (OpenerStep == 1)
{
if (PetManager.ActivePetType == PetType.Garuda_Egi && PetManager.PetMode == PetMode.Obey)
{
if (await Summoner.Contagion.Cast())
{
return(true);
}
}
if (Resource.Arcanist.Aetherflow < 3 && Summoner.Aetherflow.Cooldown() > 15000)
{
AbortOpener("Aborting opener due to Aetherflow charges.");
return(false);
}
}
if (spell.Name == Summoner.SummonIII.Name)
{
if (!ShinraEx.Settings.SummonerOpenerGaruda || PetManager.ActivePetType == PetType.Ifrit_Egi ||
!Me.HasAura(Summoner.Role.Swiftcast.Name))
{
Debug($"Skipping opener step {OpenerStep} due to Swiftcast/not using Garuda >>> {spell.Name}");
OpenerStep++;
return(true);
}
}
if (spell.Name == Summoner.Fester.Name)
{
if (Resource.Arcanist.Aetherflow > 0 && spell.Cooldown() > 0)
{
return(true);
}
if (Resource.Arcanist.Aetherflow == 0)
{
Debug($"Skipping opener step {OpenerStep} due to Aetherflow charges >>> {spell.Name}");
OpenerStep++;
return(true);
}
}
if (spell.Name == Summoner.DreadwyrmTrance.Name && Resource.Arcanist.AetherAttunement < 3)
{
await Coroutine.Wait(2000, () => Resource.Arcanist.AetherAttunement == 3);
if (Resource.Arcanist.AetherAttunement < 3)
{
AbortOpener("Aborting opener due to Aethertrail Attunement.");
return(false);
}
}
break;
case ClassJobType.Warrior:
if (OpenerStep == 0 && !Me.HasAura(Warrior.Deliverance.Name))
{
if (ShinraEx.LastSpell.Name != Warrior.Deliverance.Name && Warrior.Deliverance.Cooldown() > 3000)
{
AbortOpener("Aborting opener due to Deliverance cooldown.");
return(false);
}
await Warrior.Deliverance.Cast();
return(true);
}
if (spell.Name == Warrior.FellCleave.Name)
{
if (Resource.Warrior.BeastGauge < 50 && !Me.HasAura(1177))
{
Debug($"Skipping opener step {OpenerStep} due to Beast Gauge >>> {spell.Name}");
OpenerStep++;
return(true);
}
}
if (spell.Name == Warrior.InnerRelease.Name)
{
if (DataManager.GetSpellData(31).Cooldown.TotalMilliseconds > 700)
{
return(true);
}
}
break;
}
#endregion
if (await spell.Cast(null, false))
{
Debug($"Executed opener step {OpenerStep} >>> {spell.Name}");
OpenerStep++;
if (spell.Name == "Swiftcast")
{
await Coroutine.Wait(3000, () => Me.HasAura("Swiftcast"));
}
if (OpenerStep == 1)
{
DisplayToast("ShinraEx >>> Opener Started", 2500);
}
#region Job-Specific
// Bard
if (spell.Name == Bard.IronJaws.Name)
{
DotManager.Add(Target);
}
// Machinist
if (spell.Name == Machinist.Flamethrower.Name)
{
await Coroutine.Wait(3000, () => Me.HasAura(Machinist.Flamethrower.Name));
await Coroutine.Wait(5000, () => Resource.Machinist.Heat == 100 || !Me.HasAura(Machinist.Flamethrower.Name));
}
// Red Mage
if (spell.Name == RedMage.Manafication.Name)
{
await Coroutine.Wait(3000, () => ActionManager.CanCast(RedMage.CorpsACorps.Name, Target));
}
#endregion
}
else if (spell.Cooldown(true) > 3000 && spell.Cooldown() > 500 && !Me.IsCasting)
{
Debug($"Skipped opener step {OpenerStep} due to cooldown >>> {spell.Name}");
OpenerStep++;
}
return(true);
}
private static async Task <bool> ExProvoke()
{
if (Target == null || !Target.CanAttack || !CecilSettingsModel.Instance.UseProvoke)
{
return(false);
}
if (!PartyManager.IsInParty)
{
return(false);
}
if (CecilSettingsModel.Instance.MainTank)
{
if (GameObjectManager.Attackers.Count(r => r.Distance(Me) <= 5 && r.TargetGameObject == HealManager.FirstOrDefault(hm => hm.BeingTargeted() && !hm.IsMe && !hm.IsTank())) > 1)
{
if (await Ultimatum())
{
Logger.CecilLog(@"====> Ultimatum used to regain Aggro");
Logger.CecilLog(@"====> Unleashing to establish Aggro");
return(await Spells.Unleash.Use(Me, true));
}
}
var provokeTarget = GameObjectManager.Attackers.FirstOrDefault(r => r.Distance(Me) <= 25 && r.TargetGameObject == HealManager.FirstOrDefault(hm => hm.BeingTargeted() && !hm.IsMe && !hm.IsTank()));
if (provokeTarget != null)
{
if (await Spells.Provoke.Use(provokeTarget, true))
{
Logger.CecilLog(@"====> Provoking {0} to Pull Aggro From {1}", provokeTarget.Name, provokeTarget.TargetGameObject.Name);
if (provokeTarget?.Distance(Me) > 5 && CecilSettingsModel.Instance.UseUnmend)
{
Logger.CecilLog(@"====> Unmending {0} to Pull Aggro From {1}", provokeTarget.Name, provokeTarget.TargetGameObject.Name);
return(await Spells.Unmend.Use(provokeTarget, true));
}
return(true);
}
}
}
if (!CecilSettingsModel.Instance.MainTank)
{
var OtherTank = HealManager.FirstOrDefault(hm => hm.IsTank() && !hm.IsMe);
if (OtherTank == null)
{
return(false);
}
if (await Shirk(OtherTank))
{
Logger.CecilLog(@"====> Shirking Aggro from {0} to Main Tank, {1}", Target.Name, OtherTank.SafeName());
return(true);
}
}
return(false);
}
private static async Task <bool> Intervention()
{
var target = HealManager.FirstOrDefault(hm => hm.Distance2D(Me) <= 30 && hm.CurrentHealthPercent <= BeatrixSettingsModel.Instance.InterventionHpPct);
return(await Spells.Intervention.CastDot(Target, true, Auras.Intervention));
}
private static async Task <bool> PetAction()
{
if (Me.HasAura(Auras.Dissipation) || Me.Pet == null || HealManager.Any(hm => hm.HasAura(Auras.FeyUnion)) || CombatHelper.GcdTimeRemaining < 10)
{
return(false);
}
var target = HealManager.FirstOrDefault(hm => hm.InCombat);
switch (SuritoSettingsModel.Instance.SelectedSuritoSummon)
{
case SuritoSummonMode.Eos:
if (SuritoSettingsModel.Instance.UseWhisperingDawn &&
PetManager.CanCast(Spells.WhisperingDawn.LocalizedName, Me.Pet) &&
HealManager.Count(hm => hm.Distance2D(Me.Pet) <= 15 && hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.WhisperingDawnHpPct) >= SuritoSettingsModel.Instance.PetAoEPlayerCount)
{
return(PetManager.DoAction(Spells.WhisperingDawn.LocalizedName, Me.Pet));
}
if (SuritoSettingsModel.Instance.UseFeyCovenant &&
PetManager.CanCast(Spells.FeyCovenant.LocalizedName, Me.Pet) &&
HealManager.Count(hm => hm.Distance2D(Me.Pet) <= 15 && hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.FeyCovenantHpPct) >= SuritoSettingsModel.Instance.PetAoEPlayerCount)
{
return(PetManager.DoAction(Spells.FeyCovenant.LocalizedName, Me.Pet));
}
if (SuritoSettingsModel.Instance.UseFeyIllumination &&
PetManager.CanCast(Spells.FeyIllumination.LocalizedName, Me.Pet) &&
HealManager.Count(hm => hm.Distance2D(Me.Pet) <= 15 && hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.FeyIlluninationHpPct) >= SuritoSettingsModel.Instance.PetAoEPlayerCount)
{
return(PetManager.DoAction(Spells.FeyIllumination.LocalizedName, Me.Pet));
}
if (SuritoSettingsModel.Instance.UseEmbrace)
{
target = HealManager.FirstOrDefault(hm => hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.EmbraceHpPct);
if (target != null && PetManager.CanCast(Spells.Embrace.LocalizedName, target))
{
return(PetManager.DoAction(Spells.Embrace.LocalizedName, target));
}
}
break;
case SuritoSummonMode.Selene:
if (SuritoSettingsModel.Instance.UseEmbrace)
{
target = HealManager.FirstOrDefault(hm => hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.EmbraceHpPct);
if (target != null && PetManager.CanCast(Spells.Embrace.LocalizedName, target))
{
return(PetManager.DoAction(Spells.Embrace.LocalizedName, target));
}
}
if (SuritoSettingsModel.Instance.UseSilentDusk)
{
target = HealManager.FirstOrDefault(hm => hm.CanSilence());
if (target != null && PetManager.CanCast(Spells.SilentDusk.LocalizedName, target))
{
return(PetManager.DoAction(Spells.SilentDusk.LocalizedName, target));
}
}
if (SuritoSettingsModel.Instance.UseFeyCaress &&
PetManager.CanCast(Spells.FeyCaress.LocalizedName, Me.Pet) &&
HealManager.Count(hm => hm.Distance2D(Me.Pet) <= 20) >= SuritoSettingsModel.Instance.PetAoEPlayerCount)
{
return(await CleanseManager.PetCleanse());
}
if (SuritoSettingsModel.Instance.UseFeyWind &&
PetManager.CanCast(Spells.FeyWind.LocalizedName, Me.Pet) &&
HealManager.Count(hm => hm.IsDps() && hm.Distance2D(Me.Pet) <= 20) >= SuritoSettingsModel.Instance.PetAoEPlayerCount)
{
return(PetManager.DoAction(Spells.FeyWind.LocalizedName, Me.Pet));
}
break;
}
return(false);
}
private static async Task <bool> ExProvoke()
{
if (Target == null || !Target.CanAttack || !BeatrixSettingsModel.Instance.UseProvoke || CombatHelper.LastSpell == Spells.Flash)
{
return(false);
}
if (!PartyManager.IsInParty)
{
return(false);
}
if (BeatrixSettingsModel.Instance.MainTank)
{
if (GameObjectManager.Attackers.Count(r => r.Distance(Me) <= 5 && r.TargetGameObject == HealManager.FirstOrDefault(hm => hm.BeingTargeted() && !hm.IsMe) && (!r.TargetGameObject.HasAura(Auras.ShieldOath) && !r.TargetGameObject.HasAura(Auras.Defiance) && !r.TargetGameObject.HasAura(Auras.Grit))) > 1)
{
if (await Ultimatum())
{
Logger.BeatrixLog(@"====> Ultimatum used to regain Aggro");
FlashCount = 0;
}
}
var provokeTarget = GameObjectManager.Attackers.FirstOrDefault(r => r.Distance(Me) <= 25 && r.TargetGameObject == HealManager.FirstOrDefault(hm => hm.BeingTargeted() && !hm.IsMe) && (!r.TargetGameObject.HasAura(Auras.ShieldOath) && !r.TargetGameObject.HasAura(Auras.Defiance) && !r.TargetGameObject.HasAura(Auras.Grit)));
if (provokeTarget != null)
{
if (await Spells.Provoke.Use(provokeTarget, true))
{
Logger.BeatrixLog(@"====> Provoking {0} to Pull Aggro From {1}", provokeTarget.Name, provokeTarget.TargetGameObject.Name);
if (provokeTarget?.Distance(Me) > 5 && BeatrixSettingsModel.Instance.UseShieldLob)
{
Logger.BeatrixLog(@"====> Sheild Lobbing {0} to Pull Aggro From {1}", provokeTarget.Name, provokeTarget.TargetGameObject.Name);
return(await Spells.ShieldLob.Use(provokeTarget, true));
}
return(true);
}
}
}
if (!BeatrixSettingsModel.Instance.MainTank)
{
var OtherTank = HealManager.FirstOrDefault(hm => hm.IsTank() && !hm.IsMe);
if (OtherTank == null)
{
return(false);
}
if (await Shirk(OtherTank))
{
Logger.BeatrixLog(@"====> Shirking Aggro from {0} to Main Tank, {1}", Target.Name, OtherTank.SafeName());
return(true);
}
}
return(false);
}
public static async Task <bool> Heal()
{
if (await Resurrection())
{
return(true);
}
if (Me.HasAura(Auras.Swiftcast) && HealManager.Any(hm => hm.IsDead && !hm.HasAura(Auras.Raise) && !hm.HasAura(Auras.Raise2)))
{
return(false);
}
if (await Healbusters())
{
return(true);
}
if (await Indomitability())
{
return(true);
}
if (await Largesse())
{
return(true);
}
if (await Lustrate())
{
return(true);
}
if (await Aetherpact())
{
return(true);
}
if (await Excogitation())
{
return(true);
}
if (await SacredSoil())
{
return(true);
}
if (await Rouse())
{
return(true);
}
if (await Dissipation())
{
return(true);
}
if (await EyeForAnEye())
{
return(true);
}
if (await DeploymentTactics())
{
return(true);
}
if (await EmergencyTactics())
{
return(true);
}
if (await LucidDreaming())
{
return(true);
}
if (await Succor())
{
return(true);
}
if (await Adloquium())
{
return(true);
}
if (await Physick())
{
return(true);
}
if (await Esuna())
{
return(true);
}
if (await Protect())
{
return(true);
}
if (Me.ClassLevel <= 2)
{
return(await Common_Utils.HpPotion());
}
return(await PetAction());
}
private static async Task <bool> ClericStance()
{
return(await Spells.ClericStance.CastBuff(Me, HealManager.All(hm => hm.CurrentHealthPercent > SuritoSettingsModel.Instance.PhysickHpPct) && Me.CurrentManaPercent >= SuritoSettingsModel.Instance.DamageMinMpPct, Auras.ClericStance));
}
private static async Task <bool> SacredSoil()
{
if (!SuritoSettingsModel.Instance.UseSacredSoil || ActionResourceManager.Arcanist.Aetherflow.Equals(0))
{
return(false);
}
var target = HealManager.FirstOrDefault(hm => hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.SacredSoilHpPct && HealManager.Count(hm2 => hm2.CurrentHealthPercent <= SuritoSettingsModel.Instance.SacredSoilHpPct && hm2.Distance2D(hm) <= 8) >= SuritoSettingsModel.Instance.SacredSoilPlayerCount);
return(await Spells.SacredSoil.Use(target, true, true));
}
