Exemple #1
0
        private static async Task <bool> Protect()
        {
            if (!SuritoSettingsModel.Instance.UseProtect)
            {
                return(false);
            }

            if (PartyManager.IsInParty)
            {
                if (CombatHelper.LastSpell == Spells.Protect || ActionManager.LastSpell == Spells.Protect ||
                    !SuritoSettingsModel.Instance.UseProtectInCombat && PartyMembers.Any(pm => pm.InCombat) ||
                    PartyMembers.Any(pm => pm.Icon == PlayerIcon.Viewing_Cutscene) ||
                    HealManager.All(hm => hm.HasAura(Auras.Protect)) ||
                    HealManager.Any(hm => hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.PhysickHpPct || hm.IsDead))
                {
                    return(false);
                }
            }

            var target = HealManager.FirstOrDefault(hm => !hm.HasAura(Auras.Protect));

            if (target == null)
            {
                return(false);
            }

            return(await Spells.Protect.CastBuff(target, CombatHelper.LastSpell != Spells.Protect, Auras.Protect));
        }
Exemple #2
0
        private static async Task <bool> Resurrection()
        {
            if (!SuritoSettingsModel.Instance.UseResurrection)
            {
                return(false);
            }

            if (!HealManager.Any(hm => hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.PhysickHpPct))
            {
                var target = ResManager.FirstOrDefault(pm => pm.IsDead &&
                                                       !pm.HasAura(Auras.Raise) &&
                                                       !pm.HasAura(Auras.Raise2));

                if (target != null &&
                    ActionManager.CanCast(Spells.Resurrection, target))
                {
                    if (SuritoSettingsModel.Instance.UseSwiftcastResurrection)
                    {
                        if (ActionManager.CanCast(Spells.Swiftcast, Me))
                        {
                            await Spells.Swiftcast.CastBuff(Me, true, Auras.Swiftcast);
                        }

                        if (Spells.Swiftcast.Cooldown.TotalMilliseconds > 5800 && !Me.HasAura(Auras.Swiftcast))
                        {
                            return(false);
                        }
                    }
                    return(await Spells.Resurrection.Use(target, true, true));
                }
            }
            return(false);
        }
        private static async Task <bool> Raise()
        {
            if (!MikotoSettingsModel.Instance.UseRaise)
            {
                return(false);
            }

            if (!HealManager.Any(hm => hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.CureHpPct))
            {
                var target = ResManager.FirstOrDefault(pm => pm.IsDead &&
                                                       !pm.HasAura(Auras.Raise) &&
                                                       !pm.HasAura(Auras.Raise2));

                if (target != null &&
                    ActionManager.CanCast(Spells.Raise, target))
                {
                    if (MikotoSettingsModel.Instance.UseSwiftcastRaise && ActionManager.CanCast(Spells.Swiftcast, Me))
                    {
                        await Spells.Swiftcast.CastBuff(Me, true, Auras.Swiftcast);
                    }

                    return(await Spells.Raise.Use(target, true, true));
                }
            }
            return(false);
        }
Exemple #4
0
        private static async Task <bool> Esuna()
        {
            if (!SuritoSettingsModel.Instance.UseCleanse || HealManager.Any(hm => hm.CurrentHealthPercent < SuritoSettingsModel.Instance.CleanseHP))
            {
                return(false);
            }

            return(await CleanseManager.DoCleanses());
        }
Exemple #5
0
        public static async Task <bool> Combat()
        {
            if (await Healbusters())
            {
                return(true);
            }

            if (!SuritoSettingsModel.Instance.DoDamage ||
                Target == null || !Target.CanAttack || Target.Distance(Me) > 25 ||
                (Me.CurrentManaPercent < SuritoSettingsModel.Instance.DamageMinMpPct && PartyManager.IsInParty && !MainSettingsModel.Instance.DestroyTarget) ||
                (HealManager.Any(hm => hm.CurrentHealthPercent < SuritoSettingsModel.Instance.PhysickHpPct) && (PartyManager.IsInParty || Me.ClassLevel > 3)))
            {
                return(false);
            }

            if (await ClericStance())
            {
                return(true);
            }
            if (await Summon())
            {
                return(true);
            }
            if (await EnergyDrain())
            {
                return(true);
            }
            if (await ShadowFlare())
            {
                return(true);
            }
            if (await MiasmaII())
            {
                return(true);
            }
            if (await Miasma())
            {
                return(true);
            }
            if (await Bio())
            {
                return(true);
            }
            if (await Broil())
            {
                return(true);
            }
            if (await PetAction())
            {
                return(true);
            }
            return(await Ruin());
        }
Exemple #6
0
        private static async Task <bool> Dissipation()
        {
            if (!SuritoSettingsModel.Instance.UseDissipation || Me.Pet == null || Me.ClassLevel < 60)
            {
                return(false);
            }

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

            return(await Spells.Dissipation.CastBuff(Me, HealManager.Any(hm => hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.DissipationHpPct), Auras.Dissipation));
        }
Exemple #7
0
        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));
        }
        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));
        }
Exemple #10
0
        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);
        }
Exemple #11
0
        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());
        }