Esempio n. 1
0
        private static async Task <bool> Indomitability()
        {
            if (!SuritoSettingsModel.Instance.UseIndomitability || ActionResourceManager.Arcanist.Aetherflow.Equals(0))
            {
                return(false);
            }

            return(await Spells.Indomitability.Use(Me, HealManager.Count(hm => hm.Distance2D(Me) <= 15 && hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.IndomitabilityHpPct) >= SuritoSettingsModel.Instance.IndomitabilityPlayerCount));
        }
Esempio n. 2
0
        private static async Task <bool> Succor()
        {
            if (!SuritoSettingsModel.Instance.UseSuccor)
            {
                return(false);
            }

            if (HealManager.Count(hm => hm.Distance2D(Me) <= 15 && hm.CurrentHealthPercent <= SuritoSettingsModel.Instance.SuccorHpPct && (!hm.HasAura(Auras.Adloquium) || Me.HasAura(Auras.EmergencyTactics) && SuritoSettingsModel.Instance.UseEmergencyTacticsSuccor)) >= SuritoSettingsModel.Instance.SuccorPlayerCount)
            {
                return(await Spells.Succor.Use(Me, true, true));
            }
            return(false);
        }
Esempio n. 3
0
        private static async Task <bool> Assize()
        {
            if (!MikotoSettingsModel.Instance.UseAssize || (Me.CurrentManaPercent >= 90 && MikotoSettingsModel.Instance.AssizeBelow90))
            {
                return(false);
            }

            if (MikotoSettingsModel.Instance.AssizeHealOnly)
            {
                return(await Spells.Assize.Use(Me, HealManager.Count(hm => hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.AssizeHpPct && Me.Distance(hm) <= 15) >= MikotoSettingsModel.Instance.AssizeHealPlayerCount));
            }

            return(await Spells.Assize.Use(Me, (Me.CurrentManaPercent <= MikotoSettingsModel.Instance.AssizeManaPct && MikotoSettingsModel.Instance.AssizeManaRegen) || (Me.EnemiesInRange(8) <= MikotoSettingsModel.Instance.AssizeDpsEnemyCount && MikotoSettingsModel.Instance.AssizeToDamage)));
        }
Esempio n. 4
0
        private static async Task <bool> Asylum()
        {
            if (!MikotoSettingsModel.Instance.UseAsylum)
            {
                return(false);
            }

            var target = HealManager.FirstOrDefault(pm1 => HealManager.Count(pm2 => pm2.CurrentHealthPercent <= MikotoSettingsModel.Instance.AsylumHpPct) >= MikotoSettingsModel.Instance.AsylumPlayerCount);

            if (target != null)
            {
                return(await Spells.Asylum.Use(target, target.AlliesInRange(6) >= MikotoSettingsModel.Instance.AsylumPlayerCount));
            }
            return(false);
        }
Esempio n. 5
0
        private static async Task <bool> CureIII()
        {
            if (!MikotoSettingsModel.Instance.UseCure3)
            {
                return(false);
            }

            var target = HealManager.FirstOrDefault(pm1 => HealManager.Count(pm2 => pm1.Distance(pm2) <= 6 && pm2.CurrentHealthPercent <= MikotoSettingsModel.Instance.Cure3HpPct) >= MikotoSettingsModel.Instance.Cure3PlayerCount);

            if (target != null)
            {
                return(await Spells.CureIII.Use(target, true, true));
            }
            return(false);
        }
Esempio n. 6
0
        private static async Task <bool> Medica()
        {
            if (!MikotoSettingsModel.Instance.UseMedica)
            {
                return(false);
            }

            if (HealManager.Count(hm =>
                                  hm.Distance(Me) <= 15 &&
                                  hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.MedicaHpPct) >= MikotoSettingsModel.Instance.MedicaPlayerCount &&
                MikotoSettingsModel.Instance.UseMedica)
            {
                return(await Spells.Medica.Use(Me, true, true));
            }
            return(false);
        }
Esempio n. 7
0
        private static async Task <bool> MedicaII()
        {
            if (!MikotoSettingsModel.Instance.UseMedica2)
            {
                return(false);
            }

            if (HealManager.Count(hm =>
                                  hm.Distance(Me) <= 20 &&
                                  hm.CurrentHealthPercent <= MikotoSettingsModel.Instance.Medica2HpPct &&
                                  !hm.HasAura(Auras.MedicaII)) >= MikotoSettingsModel.Instance.Medica2PlayerCount &&
                ActionManager.LastSpell != Spells.MedicaII && CombatHelper.LastSpell != Spells.MedicaII)
            {
                return(await Spells.MedicaII.CastHeal(Me, true, Auras.MedicaII));
            }
            return(false);
        }
Esempio n. 8
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));
        }
Esempio n. 9
0
        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));
        }
Esempio n. 10
0
        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));
        }
Esempio n. 11
0
        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);
        }
Esempio n. 12
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);
        }
Esempio n. 13
0
        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));
        }