Exemplo n.º 1
0
        private static async Task <bool> SpellQueueMethod()
        {
            InSpellQueue = true;
            var spell = SpellQueue.Peek();

            if (spell.Wait != null)
            {
                if (await Coroutine.Wait(spell.Wait.WaitTime, spell.Wait.Check))
                {
                    Logger.Write($"Spell Queue Wait: {spell.Wait.Name}");
                }
                else
                {
                    SpellQueue.Dequeue();
                    return(true);
                }
            }

            if (spell.Checks.Any(x => !x.Check.Invoke()))
            {
                SpellQueue.Dequeue();
                Logger.Write($"Removing {spell.Spell.LocalizedName} from the Spell Queue because it failed it's checks.");
                foreach (var check in spell.Checks.Where(x => !x.Check.Invoke()))
                {
                    Logger.Write($"Failed Check: {check.Name}");
                }
                return(true);
            }

            var target = spell.Target();

            if (target != null)
            {
                if (await spell.Spell.Cast(target))
                {
                    SpellQueue.Dequeue();
                    return(true);
                }
            }

            return(SpellQueue.Any());
        }
Exemplo n.º 2
0
        public static async Task <bool> Execute()
        {
            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (await CustomOpenerLogic.Opener())
            {
                return(true);
            }

            if (!SpellQueue.Any())
            {
                InSpellQueue = false;
            }

            if (SpellQueue.Any())
            {
                if (await SpellQueueMethod())
                {
                    return(true);
                }
            }

            if (await Defensive.ExecuteTankBusters())
            {
                return(true);
            }

            if (BotManager.Current.IsAutonomous)
            {
                Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3);
            }

            if (await Buff.Grit())
            {
                return(true);
            }
            if (await Defensive.TheBlackestNight())
            {
                return(true);
            }
            if (await Buff.Delirium())
            {
                return(true);
            }
            if (await Buff.BloodWeapon())
            {
                return(true);
            }

            if (Utilities.Routines.DarkKnight.OnGcd)
            {
                if (await Tank.Provoke(DarkKnightSettings.Instance))
                {
                    return(true);
                }
                if (await Defensive.Execute())
                {
                    return(true);
                }
                if (await Buff.LivingShadow())
                {
                    return(true);
                }
                if (await SingleTarget.CarveAndSpit())
                {
                    return(true);
                }

                if (AoeCheck)
                {
                    if (await Aoe.SaltedEarth())
                    {
                        return(true);
                    }
                    if (await Aoe.AbyssalDrain())
                    {
                        return(true);
                    }
                    if (await Aoe.FloodofDarknessShadow())
                    {
                        return(true);
                    }
                }

                if (await SingleTarget.EdgeofDarknessShadow())
                {
                    return(true);
                }
                if (await SingleTarget.Plunge())
                {
                    return(true);
                }
                if (await SingleTarget.Reprisal())
                {
                    return(true);
                }
            }

            if (await SingleTarget.Unmend())
            {
                return(true);
            }

            if (AoeCheck)
            {
                if (await Aoe.Quietus())
                {
                    return(true);
                }
                if (await Aoe.StalwartSoul())
                {
                    return(true);
                }
                if (await Aoe.Unleash())
                {
                    return(true);
                }
            }

            if (await SingleTarget.Bloodspiller())
            {
                return(true);
            }
            if (await SingleTarget.SoulEater())
            {
                return(true);
            }
            if (await SingleTarget.SyphonStrike())
            {
                return(true);
            }
            return(await SingleTarget.HardSlash());
        }
Exemplo n.º 3
0
        public static async Task <bool> SpellQueueMethod()
        {
            if (!InSpellQueue)
            {
                Logger.WriteInfo("Starting Spell Queue");
                Casting.LastSpell = null;
            }

            Debug.Instance.Queue = new AsyncObservableCollection <QueueSpell>(SpellQueue);
            InSpellQueue         = true;

            if (CancelSpellQueue.Invoke())
            {
                SpellQueueStop();
                Logger.WriteInfo("Had To Cancel Spell Queue");
                return(true);
            }

            var spell = SpellQueue.Peek();

            if (NeedToDequeueSuccessfulCast)
            {
                if (Casting.LastSpell != null && Casting.LastSpell.Id == spell.Spell.Id)
                {
                    SpellQueue.Dequeue();
                    NeedToDequeueSuccessfulCast = false;
                    if (!SpellQueue.Any())
                    {
                        Logger.WriteInfo("Spell Queue Complete");
                        SpellQueueStop();
                    }
                    return(true);
                }
            }

            if (spell.SleepBefore)
            {
                await Coroutine.Sleep(spell.SleepMilliseconds);
            }

            if (spell.Wait != null)
            {
                if (await Coroutine.Wait(spell.Wait.WaitTime, spell.Wait.Check))
                {
                    Logger.Write($"Spell Queue Wait: {spell.Wait.Name}");
                }
                else
                {
                    SpellQueue.Dequeue();
                    Logger.Error($"Spell Wait Expired or Otherwise Unable to Cast: {spell.Wait.Name}");
                    return(true);
                }
            }

            if (spell.Checks.Any(x => !x.Check.Invoke()))
            {
                SpellQueue.Dequeue();

                Logger.Write($"Removing {spell.Spell.LocalizedName} From The Spell Queue Because It Failed It's Checks.");

                foreach (var check in spell.Checks.Where(x => !x.Check.Invoke()))
                {
                    if (!check.SilentMode)
                    {
                        Logger.Write($"Failed Check: {check.Name}");
                    }
                }

                return(true);
            }

            var target = spell.Target();

            if (target == null)
            {
                return(SpellQueue.Any());
            }

            if (!await spell.Spell.Cast(target))
            {
                return(SpellQueue.Any());
            }



            Logger.WriteInfo($@"Queue Cast: {spell.Spell.LocalizedName}");

            NeedToDequeueSuccessfulCast = true;
            return(SpellQueue.Any());
        }
Exemplo n.º 4
0
        public static async Task <bool> Execute()
        {
            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (await CustomOpenerLogic.Opener())
            {
                return(true);
            }

            if (!SpellQueue.Any())
            {
                InSpellQueue = false;
            }

            if (SpellQueue.Any())
            {
                if (await SpellQueueMethod())
                {
                    return(true);
                }
            }

            if (await Defensive.ExecuteTankBusters())
            {
                return(true);
            }

            if (BotManager.Current.IsAutonomous)
            {
                Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3);
            }

            Logger.Write($"Blood: {ActionResourceManager.DarkKnight.BlackBlood}, Darkside: {ActionResourceManager.DarkKnight.Darkside.TotalMilliseconds}, DarkArts: {ActionResourceManager.DarkKnight.DarkArts}");

            if (await Buff.Grit())
            {
                return(true);
            }
            if (await Defensive.TheBlackestNight())
            {
                return(true);
            }
            if (await Buff.Delirium())
            {
                return(true);
            }
            if (await Buff.BloodWeapon())
            {
                return(true);
            }

            if (Utilities.Routines.DarkKnight.OnGcd)
            {
                if (await Tank.Provoke(DarkKnightSettings.Instance))
                {
                    return(true);
                }
                if (await Defensive.Execute())
                {
                    return(true);
                }
                if (await SingleTarget.LowBlow())
                {
                    return(true);
                }
                if (await SingleTarget.Reprisal())
                {
                    return(true);
                }
                if (await Aoe.SaltedEarth())
                {
                    return(true);
                }
                if (await SingleTarget.CarveAndSpit())
                {
                    return(true);
                }
                if (await SingleTarget.Plunge())
                {
                    return(true);
                }
            }

            if (await Aoe.AbyssalDrain())
            {
                return(true);
            }
            if (await Aoe.Unleash())
            {
                return(true);
            }
            if (await SingleTarget.Unmend())
            {
                return(true);
            }
            if (await Aoe.Quietus())
            {
                return(true);
            }
            if (await SingleTarget.Bloodspiller())
            {
                return(true);
            }
            if (await SingleTarget.SoulEater())
            {
                return(true);
            }
            if (await SingleTarget.SyphonStrike())
            {
                return(true);
            }
            return(await SingleTarget.HardSlash());
        }