Example #1
0
    public void AdjustCol()
    {
        //if (this.name == "Flurry") Debug.Log(Movement);
        if (inProcess && !flag)
        {
            this.GetComponentInParent <EnemyMovement>().Stop(Delay);
        }
        Aoe.SetActive(InProcess);
        flag = inProcess;
        if (InProcess || Target == null)
        {
            return;
        }
        Movement = transform.position - lastPos;
        float r      = 4;
        float signZ  = -Mathf.Sign(User.transform.position.z - Target.transform.position.z);
        float signX  = -Mathf.Sign(User.transform.position.x - Target.transform.position.x);
        float deltax = Mathf.Abs(User.transform.position.x - Target.transform.position.x);
        float deltay = Mathf.Abs(User.transform.position.z - Target.transform.position.z);

        if (deltax > deltay)
        {
            Col.transform.localPosition = new Vector3(r * signX * Range / 10, Col.transform.localPosition.y, 0);
        }
        else
        {
            Col.transform.localPosition = new Vector3(0, Col.transform.localPosition.y, r * Range / 10 * signZ);
        }
    }
Example #2
0
 public override void Activate()
 {
     Invoke("DealDamage", Delay);
     Invoke("TurnWarningOn", (Delay - 1f));
     StartAnim();
     Aoe.SetActive(true);
 }
Example #3
0
 public static void Postfix(Aoe __instance, Collider collider)
 {
     if (__instance is PersistentAoe aoe)
     {
         aoe.OnHit(collider.gameObject);
     }
 }
Example #4
0
        public static async Task <bool> Combat()
        {
            await CombatBuff();

            if (Globals.InParty)
            {
                if (!AstrologianSettings.Instance.DoDamage)
                {
                    return(true);
                }

                if (Core.Me.CurrentManaPercent < AstrologianSettings.Instance.MinimumManaPercentToDoDamage && Core.Target.CombatTimeLeft() > AstrologianSettings.Instance.DoDamageIfTimeLeftLessThan)
                {
                    return(true);
                }
            }

            if (!GameSettingsManager.FaceTargetOnAction && !Core.Me.CurrentTarget.InView())
            {
                return(false);
            }

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (Globals.OnPvpMap)
            {
                if (await Pvp.Disable())
                {
                    return(true);            //Damage
                }
                return(await Pvp.Malefic()); //Damage
            }

            if (await Aoe.Gravity())
            {
                return(true);
            }
            if (await SingleTarget.Combust())
            {
                return(true);
            }
            if (await SingleTarget.CombustMultipleTargets())
            {
                return(true);
            }
            return(await SingleTarget.Malefic());
        }
Example #5
0
        /// <summary>
        /// Casts spell
        /// </summary>
        /// <param name="s">Spell to cast</param>
        /// <param name="t">Target for spell</param>
        /// <param name="hc">Minimum HitChance to cast</param>
        /// <param name="reactionIgnoreDelay">Delay to ignore target's reaction time</param>
        /// <param name="minHit">Minimum Hit Count to cast</param>
        /// <param name="rangeCheckFrom">Position where spell will be casted from</param>
        /// <param name="filterHPPercent">Minimum HP Percent to cast (for target)</param>
        /// <returns>true if spell has casted</returns>
        public static bool Cast(this Spell s, Obj_AI_Hero t, HitChance hc, int reactionIgnoreDelay = 0, byte minHit = 1, Vector3?rangeCheckFrom = null, float filterHPPercent = 100)
        {
            if (rangeCheckFrom == null)
            {
                rangeCheckFrom = ObjectManager.Player.ServerPosition;
            }

            if (minHit > 1)
            {
                return(Aoe.Cast(s, t, hc, reactionIgnoreDelay, minHit, rangeCheckFrom, filterHPPercent));
            }

            if (t.HealthPercent > filterHPPercent)
            {
                return(false);
            }

            if (Monitor.TryEnter(EnemyInfo[t.NetworkId].m_lock))
            {
                try
                {
                    HitChance predictedhc;
                    float     avgt = t.AvgMovChangeTime() + reactionIgnoreDelay;
                    float     movt = t.LastMovChangeTime();
                    Vector2   pos  = GetPrediction(t, s, t.GetWaypoints(), avgt, movt, out predictedhc, rangeCheckFrom.Value);

                    if (rangeCheckFrom.Value.To2D().Distance(pos) > s.Range + (s.Type == SkillshotType.SkillshotCircle ? s.Width / 2 : 0)) //out of range
                    {
                        Monitor.Pulse(EnemyInfo[t.NetworkId].m_lock);
                        return(false);
                    }

                    if (s.Collision && s.GetCollision(rangeCheckFrom.Value.To2D(), new List <Vector2> {
                        pos
                    }).Exists(q => q.IsEnemy))                                                                                        //needs update
                    {
                        Monitor.Pulse(EnemyInfo[t.NetworkId].m_lock);
                        return(false);
                    }


                    if (predictedhc >= hc)
                    {
                        s.Cast(pos);
                        return(true);
                    }

                    Monitor.Pulse(EnemyInfo[t.NetworkId].m_lock);
                    return(false);
                }
                finally
                {
                    Monitor.Exit(EnemyInfo[t.NetworkId].m_lock);
                }
            }

            return(false);
        }
Example #6
0
 new public void DealDamage()
 {
     this.GetComponentInParent <JailerMovement>().Current = MovementType.MoveToPlayer;
     foreach (GameObject enemy in enemies)
     {
         enemy.GetComponent <Stats>().damage(Damage, DmgType);
     }
     Invoke("MovePlayer", 2);
     Aoe.SetActive(false);
 }
Example #7
0
        public static async Task <bool> Combat()
        {
            //Only stop doing damage when in party
            if (Globals.InParty && Utilities.Combat.Enemies.Count > WhiteMageSettings.Instance.StopDamageWhenMoreThanEnemies)
            {
                return(false);
            }

            if (Globals.InParty)
            {
                if (!WhiteMageSettings.Instance.DoDamage)
                {
                    return(true);
                }

                if (Core.Me.CurrentManaPercent < WhiteMageSettings.Instance.MinimumManaPercentToDoDamage && !Core.Me.HasAura(Auras.ThinAir))
                {
                    return(false);
                }
            }

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

            if (await Aoe.Holy())
            {
                return(true);
            }
            if (await Aoe.AssizeDamage())
            {
                return(true);
            }

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (await SingleTarget.Dots())
            {
                return(true);
            }
            if (await SingleTarget.AfflatusMisery())
            {
                return(true);
            }
            return(await SingleTarget.Stone());
        }
Example #8
0
        public static async Task<bool> Combat()
        {
            if (BotManager.Current.IsAutonomous)
            {
                if (Core.Me.HasTarget)
                {
                    Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 20 + Core.Me.CurrentTarget.CombatReach);
                }
            }

            if (await Casting.TrackSpellCast()) return true;
            await Casting.CheckForSuccessfulCast();

            if (Core.Me.CurrentManaPercent <= ScholarSettings.Instance.MinimumManaPercent)
                return false;

            if (Utilities.Combat.Enemies.Count > ScholarSettings.Instance.StopDamageWhenMoreThanEnemies)
                return false;

            if (!ScholarSettings.Instance.DoDamage)
                return false;

            if (Globals.InParty)
            {
                if (Core.Me.CurrentManaPercent < ScholarSettings.Instance.MinimumManaPercent)
                    return false;

                if (Group.CastableAlliesWithin30.Any(c => c.IsAlive && c.CurrentHealthPercent < ScholarSettings.Instance.DamageOnlyIfAboveHealthPercent))
                    return false;
            }

            if (await Aoe.ArtOfWar()) return true;

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
                return false;

            if (await SingleTarget.Bio()) return true;
            if (await SingleTarget.BioMultipleTargets()) return true;
            if (await SingleTarget.Ruin2()) return true;
            if (await SingleTarget.EnergyDrain2()) return true;
            return await SingleTarget.Broil();
        }
Example #9
0
        private static async Task <bool> OffGlobalCooldownRotation()
        {
            if (await SingleTarget.WheelingThrust())
            {
                return(true);
            }
            if (await SingleTarget.FangAndClaw())
            {
                return(true);
            }

            if (DragoonSettings.Instance.Aoe && Utilities.Routines.Dragoon.EnemiesInView >= DragoonSettings.Instance.AoeEnemies)
            {
                if (await Aoe.CoethanTorment())
                {
                    return(true);
                }
                if (await Aoe.SonicThrust())
                {
                    return(true);
                }
                return(await Aoe.DoomSpike());
            }

            if (await SingleTarget.ChaosThrust())
            {
                return(true);
            }
            if (await SingleTarget.Disembowel())
            {
                return(true);
            }
            if (await SingleTarget.FullThrust())
            {
                return(true);
            }
            if (await SingleTarget.VorpalThrust())
            {
                return(true);
            }
            return(await SingleTarget.TrueThrust());
        }
Example #10
0
        private static async Task <bool> OffGlobalCooldownRotation()
        {
            if (await SingleTarget.WheelingThrust())
            {
                return(true);
            }
            if (await SingleTarget.FangAndClaw())
            {
                return(true);
            }

            if (DragoonSettings.Instance.Aoe && Core.Me.CurrentTarget.EnemiesNearby(8).Count() >= DragoonSettings.Instance.AoeEnemies && Core.Me.ClassLevel >= Spells.DoomSpike.LevelAcquired)
            {
                if (await Aoe.CoethanTorment())
                {
                    return(true);
                }
                if (await Aoe.SonicThrust())
                {
                    return(true);
                }
                return(await Aoe.DoomSpike());
            }

            if (await SingleTarget.ChaosThrust())
            {
                return(true);
            }
            if (await SingleTarget.Disembowel())
            {
                return(true);
            }
            if (await SingleTarget.FullThrust())
            {
                return(true);
            }
            if (await SingleTarget.VorpalThrust())
            {
                return(true);
            }
            return(await SingleTarget.TrueThrust());
        }
Example #11
0
    void Start()
    {
        velocidad     = velocidadInicial;
        spawnerObject = GameObject.Find("Spawner");
        zombieScript  = spawnerObject.GetComponent <Zombie>();
        bigScript     = spawnerObject.GetComponent <Big>();
        crispScript   = spawnerObject.GetComponent <Crisp>();
        bossScript    = spawnerObject.GetComponent <Boss>();
        throwScript   = spawnerObject.GetComponent <Throw>();
        aoeScript     = spawnerObject.GetComponent <Aoe>();

        mouse = GameObject.Find("cursor");

        audioSource  = gameObject.GetComponent <AudioSource>();
        audioScript  = GameObject.Find("Audios").GetComponent <Audios>();
        audioGeneral = GameObject.Find("Audios").GetComponent <AudioSource>();

        vidaSprite  = GameObject.Find("vida");
        bonusSprite = GameObject.Find("bonus");
    }
Example #12
0
    public override void CastSpell(Spellbook spellbook, int spellIndex, Vector3 direction)
    {
        ///<summary>
        ///
        ///                                 AOE SPELLS
        ///
        ///     • Aoe spells have aura like effects in default
        ///     • Aura like effects can be overritten by adding a Placable property that allows player to place them like turrets
        ///     • Auras have range modifier that determinates how far they reach, can be modified
        ///     • Aoe spells duration determinates how long the spell will last, can be modified
        ///     • Aoe spells work well with elements (burn, slow, etc.)
        ///         • Aoe effects can be added to projectiles   ??????
        ///
        /// </summary>

        // spawn instance in players current position
        Aoe aoe = Instantiate(this, spellbook.transform.position, spellbook.transform.rotation);

        aoe.transform.parent = spellbook.transform;

        foreach (AoeCard card in spellbook.spells[spellIndex].cards)
        {
            // apply all balances to spell
            foreach (SpellBalance balance in card.balances)
            {
                balance.Apply(aoe, spellbook);
            }

            // add all modifiers to spell
            foreach (AoeModifierSO mod in card.aoeModifiers)
            {
                mod.AddSpellComponent(aoe.gameObject);
            }
        }

        aoe.StartCoroutine(DestroyAoe(aoe.gameObject, spellbook, duration));
        spellbook.StopCasting();
        spellbook.SetCooldown();
    }
Example #13
0
        public static async Task <bool> Execute()
        {
            if (BotManager.Current.IsAutonomous)
            {
                Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3 + Core.Me.CurrentTarget.CombatReach);
            }

            if (await Buff.FistsOf())
            {
                return(true);
            }

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            var count = Utilities.Combat.Enemies.Count;

            if (2 >= count && count < 5)
            {
                //TODO: Add 2-4 target DPS rotation
            }
            else if (count >= 5)
            {
                //TODO: Add 5+ target DPS rotation
            }

            if (Utilities.Routines.Monk.OnGcd)
            {
                if (await SingleTarget.TheForbiddenChakra())
                {
                    return(true);
                }
                if (await SingleTarget.ShoulderTackle())
                {
                    return(true);
                }
                ///if (await Buff.PerfectBalance()) return true;
                if (await PhysicalDps.TrueNorth(MonkSettings.Instance))
                {
                    return(true);
                }
                if (await Buff.RiddleOfFire())
                {
                    return(true);
                }
                if (await Buff.RiddleOfEarth())
                {
                    return(true);
                }
                if (await Buff.Brotherhood())
                {
                    return(true);
                }
                if (await Aoe.ElixerField())
                {
                    return(true);
                }
            }
            if (await Aoe.Rockbreaker())
            {
                return(true);
            }
            if (await SingleTarget.Demolish())
            {
                return(true);
            }
            if (await SingleTarget.SnapPunch())
            {
                return(true);
            }
            if (await SingleTarget.TwinSnakes())
            {
                return(true);
            }
            if (await SingleTarget.TrueStrike())
            {
                return(true);
            }
            if (await SingleTarget.Bootshine())
            {
                return(true);
            }
            if (await SingleTarget.DragonKick())
            {
                return(true);
            }
            return(await Buff.FormShift());
        }
Example #14
0
        public static async Task <bool> Execute()
        {
            Group.UpdateAllies();

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

            if (await GambitLogic.Gambit())
            {
                return(true);
            }


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

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            if (await Buff.DancePartner())
            {
                return(true);
            }

            if (await Dances.StartTechnicalDance())
            {
                return(true);
            }
            if (Dances.TechnicalStep())
            {
                return(true);
            }

            if (await Dances.StartStandardDance())
            {
                return(true);
            }
            if (Dances.StandardStep())
            {
                return(true);
            }


            if (Utilities.Routines.Dancer.OnGcd)
            {
                //Only cast spells that are instant/off gcd
                if (await Buff.PreTechnicalDevilment())
                {
                    return(true);
                }
                if (await Aoe.FanDance3())
                {
                    return(true);
                }
                if (await Aoe.FanDance2())
                {
                    return(true);
                }
                if (await SingleTarget.FanDance())
                {
                    return(true);
                }
                if (await Buff.Flourish())
                {
                    return(true);
                }
                if (await Buff.Devilment())
                {
                    return(true);
                }
                if (await Buff.CuringWaltz())
                {
                    return(true);
                }
                if (await Buff.Improvisation())
                {
                    return(true);
                }
                if (await PhysicalDps.SecondWind(DancerSettings.Instance))
                {
                    return(true);
                }
            }

            if (await Aoe.SaberDance())
            {
                return(true);
            }

            if (await Aoe.Bloodshower())
            {
                return(true);
            }
            if (await Aoe.RisingWindmill())
            {
                return(true);
            }

            if (await SingleTarget.Fountainfall())
            {
                return(true);
            }
            if (await SingleTarget.ReverseCascade())
            {
                return(true);
            }

            if (await Aoe.Bladeshower())
            {
                return(true);
            }
            if (await Aoe.Windmill())
            {
                return(true);
            }

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

            return(await SingleTarget.Cascade());
        }
Example #15
0
        public static async Task <bool> Combat()
        {
            if (BotManager.Current.IsAutonomous)
            {
                if (Core.Me.HasTarget)
                {
                    Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 20 + Core.Me.CurrentTarget.CombatReach);
                }
            }

            if (await Casting.TrackSpellCast())
            {
                return(true);
            }

            await Casting.CheckForSuccessfulCast();

            BardRoutine.RefreshVars();

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            if (BardRoutine.GlobalCooldown.CanWeave())
            {
                // Utility
                if (await Utility.RepellingShot())
                {
                    return(true);
                }
                if (await Utility.WardensPaean())
                {
                    return(true);
                }
                if (await Utility.NaturesMinne())
                {
                    return(true);
                }
                if (await Utility.Troubadour())
                {
                    return(true);
                }
                if (await PhysicalDps.ArmsLength(BardSettings.Instance))
                {
                    return(true);
                }
                if (await PhysicalDps.SecondWind(BardSettings.Instance))
                {
                    return(true);
                }
                if (await PhysicalDps.Interrupt(BardSettings.Instance))
                {
                    return(true);
                }

                // Damage
                if (await SingleTarget.LastPossiblePitchPerfectDuringWM())
                {
                    return(true);
                }
                if (await Songs.LetMeSingYouTheSongOfMyPeople())
                {
                    return(true);
                }
                if (await Cooldowns.RagingStrikes())
                {
                    return(true);
                }
                if (await Cooldowns.BattleVoice())
                {
                    return(true);
                }
                if (await Cooldowns.RadiantFinale())
                {
                    return(true);
                }
                if (await Cooldowns.Barrage())
                {
                    return(true);
                }
                if (await SingleTarget.PitchPerfect())
                {
                    return(true);
                }
                if (await Aoe.RainOfDeathDuringMagesBallard())
                {
                    return(true);
                }
                if (await SingleTarget.BloodletterInMagesBallard())
                {
                    return(true);
                }
                if (await SingleTarget.EmpyrealArrow())
                {
                    return(true);
                }
                if (await SingleTarget.Sidewinder())
                {
                    return(true);
                }
                if (await Aoe.RainOfDeath())
                {
                    return(true);
                }
                if (await SingleTarget.Bloodletter())
                {
                    return(true);
                }
            }

            if (await DamageOverTime.IronJawsOnCurrentTarget())
            {
                return(true);
            }
            if (await DamageOverTime.SnapShotIronJawsOnCurrentTarget())
            {
                return(true);
            }
            if (await SingleTarget.StraightShotAfterBarrage())
            {
                return(true);
            }
            if (await DamageOverTime.WindbiteOnCurrentTarget())
            {
                return(true);
            }
            if (await DamageOverTime.VenomousBiteOnCurrentTarget())
            {
                return(true);
            }
            if (await Aoe.BlastArrow())
            {
                return(true);
            }
            if (await Aoe.ApexArrow())
            {
                return(true);
            }
            if (await Aoe.ShadowBite())
            {
                return(true);
            }
            if (await DamageOverTime.IronJawsOnOffTarget())
            {
                return(true);
            }
            if (await DamageOverTime.WindbiteOnOffTarget())
            {
                return(true);
            }
            if (await DamageOverTime.VenomousBiteOnOffTarget())
            {
                return(true);
            }
            if (await Aoe.LadonsBite())
            {
                return(true);
            }
            if (await SingleTarget.StraightShot())
            {
                return(true);
            }
            return(await SingleTarget.HeavyShot());
        }
Example #16
0
        public static async Task <bool> Combat()
        {
            if (BotManager.Current.IsAutonomous)
            {
                Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3 + Core.Me.CurrentTarget.CombatReach);
            }

            if (Core.Me.CurrentTarget == null)
            {
                return(false);
            }

            if (!Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            #region Positional Overlay
            if (BaseSettings.Instance.UsePositionalOverlay)
            {
                if (Core.Me.HasAura(Auras.SharperFangandClaw))
                {
                    if (!Core.Me.CurrentTarget.IsFlanking)
                    {
                        ViewModels.BaseSettings.Instance.PositionalStatus = "OutOfPosition";
                        ViewModels.BaseSettings.Instance.PositionalText   = "Move To Flank";
                    }
                    else
                    {
                        ViewModels.BaseSettings.Instance.PositionalStatus = "InPosition";
                        ViewModels.BaseSettings.Instance.PositionalText   = "You're In Position";
                    }
                }

                if (Core.Me.HasAura(Auras.EnhancedWheelingThrust))
                {
                    if (!Core.Me.CurrentTarget.IsBehind)
                    {
                        ViewModels.BaseSettings.Instance.PositionalStatus = "OutOfPosition";
                        ViewModels.BaseSettings.Instance.PositionalText   = "Move Behind";
                    }
                    else
                    {
                        ViewModels.BaseSettings.Instance.PositionalStatus = "InPosition";
                        ViewModels.BaseSettings.Instance.PositionalText   = "You're In Position";
                    }
                }

                if (ActionManager.LastSpell == Spells.Disembowel)
                {
                    if (!Core.Me.CurrentTarget.IsBehind)
                    {
                        ViewModels.BaseSettings.Instance.PositionalStatus = "OutOfPosition";
                        ViewModels.BaseSettings.Instance.PositionalText   = "Move Behind";
                    }
                    else
                    {
                        ViewModels.BaseSettings.Instance.PositionalStatus = "InPosition";
                        ViewModels.BaseSettings.Instance.PositionalText   = "You're In Position";
                    }
                }
            }
            #endregion

            #region Off GCD debugging
            if (Utilities.Routines.Dragoon.Jumps.Contains(Casting.LastSpell))
            {
                // Check to see if we're OFF GCD
                if (Spells.TrueThrust.Cooldown == TimeSpan.Zero)
                {
                    // Start the stopwatch if it isn't running
                    if (!JumpGcdTimer.IsRunning)
                    {
                        JumpGcdTimer.Restart();
                    }
                }
            }
            else
            {
                // We didn't use a Jump last, check to see if the stopwatch is running
                if (JumpGcdTimer.IsRunning)
                {
                    // We'll give a 50ms buffer for the time it takes to tick
                    if (JumpGcdTimer.ElapsedMilliseconds > 50)
                    {
                        Logger.WriteInfo($@"We wasted {JumpGcdTimer.ElapsedMilliseconds} ms off GCD");
                    }

                    // Stop the stopwatch
                    JumpGcdTimer.Stop();
                }
            }
            #endregion

            if (await PhysicalDps.Interrupt(DragoonSettings.Instance))
            {
                return(true);
            }
            if (await PhysicalDps.SecondWind(DragoonSettings.Instance))
            {
                return(true);
            }
            if (await PhysicalDps.Bloodbath(DragoonSettings.Instance))
            {
                return(true);
            }

            Utilities.Routines.Dragoon.EnemiesInView = Utilities.Combat.Enemies.Count(r => r.Distance(Core.Me) <= 10 + r.CombatReach && r.InView());

            if (Utilities.Routines.Dragoon.OnGcd && !_usedJumpDuringGcd)
            {
                if (await Jumps.MirageDive())
                {
                    _usedJumpDuringGcd = true;
                    return(true);
                }

                if (await Jumps.Execute())
                {
                    _usedJumpDuringGcd = true;
                    return(true);
                }

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

                if (await Buff.LanceCharge())
                {
                    return(true);
                }
                if (await Aoe.Nastrond())
                {
                    return(true);
                }
                if (await Buff.BloodOfTheDragon())
                {
                    return(true);
                }
                if (await Buff.DragonSight())
                {
                    return(true);
                }
                if (await Buff.BattleLitany())
                {
                    return(true);
                }
                return(await Buff.TrueNorth());
            }

            if (await OffGlobalCooldownRotation())
            {
                _usedJumpDuringGcd = false;
                return(true);
            }

            return(false);
        }
Example #17
0
        public static async Task <bool> Combat()
        {
            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            //if (await Defensive.ExecuteTankBusters()) return true;

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

            if (await Buff.Grit())
            {
                return(true);
            }
            if (await Tank.Interrupt(DarkKnightSettings.Instance))
            {
                return(true);
            }

            if (Weaving.GetCurrentWeavingCounter() < 2 && Spells.HardSlash.Cooldown.TotalMilliseconds > 650 + BaseSettings.Instance.UserLatencyOffset)
            {
                if (await Tank.Provoke(DarkKnightSettings.Instance))
                {
                    return(true);
                }
                if (await Defensive.Execute())
                {
                    return(true);
                }
                if (await Defensive.TheBlackestNight())
                {
                    return(true);
                }
                if (await SingleTarget.Reprisal())
                {
                    return(true);
                }
                if (await SingleTarget.CarveAndSpit())
                {
                    return(true);
                }
                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 Buff.Delirium())
                {
                    return(true);
                }
                if (await Buff.BloodWeapon())
                {
                    return(true);
                }
                if (await Buff.LivingShadow())
                {
                    return(true);
                }
            }

            if (await SingleTarget.Unmend())
            {
                return(true);
            }
            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());
        }
Example #18
0
        public static async Task <bool> Combat()
        {
            Utilities.Routines.Samurai.RefreshVars();

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (await GambitLogic.Gambit())
            {
                return(true);
            }

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

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }
            if (Core.Me.CurrentTarget.HasAnyAura(Auras.Invincibility))
            {
                return(false);
            }

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

            if (SpellQueueLogic.SpellQueue.Any())
            {
                if (await SpellQueueLogic.SpellQueueMethod())
                {
                    return(true);
                }
            }
            // Shoha must come out before kaeshi or you overcap

            if (await SingleTarget.KaeshiSetsugekka())
            {
                return(true);
            }
            if (await Aoe.KaeshiGoken())
            {
                return(true);
            }

            if (Utilities.Routines.Samurai.OnGcd)
            {
                //Only cast spells that are instant/off gcd
                if (await PhysicalDps.Interrupt(SamuraiSettings.Instance))
                {
                    return(true);
                }
                if (await SingleTarget.MidareSetsugekka())
                {
                    return(true);
                }
                if (await Aoe.TenkaGoken())
                {
                    return(true);
                }
                if (await SingleTarget.Higanbana())
                {
                    return(true);
                }
                if (await Buff.BloodBath())
                {
                    return(true);
                }
                if (await Aoe.HissatsuKyuten())
                {
                    return(true);
                }
                if (await Aoe.HissatsuGuren())
                {
                    return(true);
                }
                if (await SingleTarget.HissatsuSenei())
                {
                    return(true);
                }
                if (await SingleTarget.HissatsuSeigan())
                {
                    return(true);
                }
                if (await SingleTarget.HissatsuShinten())
                {
                    return(true);
                }
                if (await SingleTarget.HissatsuGuren())
                {
                    return(true);
                }
                if (await Buff.Ikishoten())
                {
                    return(true);
                }
                if (await Buff.SecondWind())
                {
                    return(true);
                }
                if (await Buff.TrueNorth())
                {
                    return(true);
                }
                if (await Buff.MeikyoShisui())
                {
                    return(true);
                }
            }

            if (await SingleTarget.MidareSetsugekka())
            {
                return(true);
            }
            if (await SingleTarget.Shoha())
            {
                return(true);
            }
            if (await Aoe.TenkaGoken())
            {
                return(true);
            }
            if (await Aoe.Oka())
            {
                return(true);
            }
            if (await Aoe.Mangetsu())
            {
                return(true);
            }
            if (await Aoe.Fuga())
            {
                return(true);
            }

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



            if (await SingleTarget.Gekko())
            {
                return(true);
            }
            if (await SingleTarget.Kasha())
            {
                return(true);
            }
            if (await SingleTarget.Yukikaze())
            {
                return(true);
            }

            #region Last Spell Hakaze

            if (ActionManager.LastSpell == Spells.Hakaze)
            {
                if (Core.Me.ClassLevel < 18)
                {
                    if (await SingleTarget.Jinpu())
                    {
                        return(true);
                    }
                }

                var hasKa    = ActionResourceManager.Samurai.Sen.HasFlag(ActionResourceManager.Samurai.Iaijutsu.Ka);
                var hasGetsu = ActionResourceManager.Samurai.Sen.HasFlag(ActionResourceManager.Samurai.Iaijutsu.Getsu);
                var hasSetsu = ActionResourceManager.Samurai.Sen.HasFlag(ActionResourceManager.Samurai.Iaijutsu.Setsu);

                if (hasGetsu && !hasKa || !hasGetsu && hasKa)
                {
                    if (!Core.Me.HasAura(Auras.Shifu, true, 5000) || !ActionResourceManager.Samurai.Sen.HasFlag(ActionResourceManager.Samurai.Iaijutsu.Ka))
                    {
                        if (await SingleTarget.Shifu())
                        {
                            ViewModels.BaseSettings.Instance.PositionalText = "Flank Position Next";
                            return(true);
                        }
                    }
                    if (!Core.Me.HasAura(Auras.Jinpu, true, 5000) || !ActionResourceManager.Samurai.Sen.HasFlag(ActionResourceManager.Samurai.Iaijutsu.Getsu))
                    {
                        if (await SingleTarget.Jinpu())
                        {
                            ViewModels.BaseSettings.Instance.PositionalText = "Rear Position Next";
                            return(true);
                        }
                    }
                }

                var shifuAuraTimeleft = Core.Me.GetAuraById(Auras.Shifu)?.TimeLeft;
                var jinpuAuraTimeleft = Core.Me.GetAuraById(Auras.Jinpu)?.TimeLeft;

                if (!shifuAuraTimeleft.HasValue)
                {
                    if (await SingleTarget.Shifu())
                    {
                        ViewModels.BaseSettings.Instance.PositionalText = "Flank Position Next";
                        return(true);
                    }
                }
                else if (!jinpuAuraTimeleft.HasValue)
                {
                    if (await SingleTarget.Jinpu())
                    {
                        ViewModels.BaseSettings.Instance.PositionalText = "Rear Position Next";
                        return(true);
                    }
                }
                else if (shifuAuraTimeleft.Value > jinpuAuraTimeleft.Value)
                {
                    if (await SingleTarget.Jinpu())
                    {
                        ViewModels.BaseSettings.Instance.PositionalText = "Rear Position Next";
                        return(true);
                    }
                }
                else
                {
                    if (await SingleTarget.Shifu())
                    {
                        ViewModels.BaseSettings.Instance.PositionalText = "Flank Position Next";
                        return(true);
                    }
                }
            }

            #endregion

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

            return(await SingleTarget.Enpi());
        }
Example #19
0
        public static async Task <bool> Combat()
        {
            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

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

            if (await Tank.Interrupt(WarriorSettings.Instance))
            {
                return(true);
            }
            if (await Buff.Defiance())
            {
                return(true);
            }

            if (Weaving.GetCurrentWeavingCounter() < 2 && Spells.HeavySwing.Cooldown.TotalMilliseconds > 800 + BaseSettings.Instance.UserLatencyOffset)
            {
                //if (await Defensive.ExecuteTankBusters()) return true;
                if (await Defensive.Defensives())
                {
                    return(true);
                }
                if (await Buff.Beserk())
                {
                    return(true);
                }
                if (await Buff.InnerRelease())
                {
                    return(true);
                }
                if (await Buff.Infuriate())
                {
                    return(true);
                }
                if (await Buff.Equilibrium())
                {
                    return(true);
                }
                if (await SingleTarget.Onslaught())
                {
                    return(true);
                }
                if (await SingleTarget.Upheaval())
                {
                    return(true);
                }
            }

            if (WarriorSettings.Instance.UseDefiance)
            {
                if (await Tank.Provoke(WarriorSettings.Instance))
                {
                    return(true);
                }
                if (await SingleTarget.TomahawkOnLostAggro())
                {
                    return(true);
                }
            }

            if (await Aoe.SteelCyclone())
            {
                return(true);
            }
            if (await Aoe.Decimate())
            {
                return(true);
            }
            if (await Aoe.InnerReleaseDecimateSpam())
            {
                return(true);
            }
            if (await Aoe.Overpower())
            {
                return(true);
            }
            if (await SingleTarget.InnerBeast())
            {
                return(true);
            }
            if (await SingleTarget.FellCleave())
            {
                return(true);
            }
            if (await SingleTarget.InnerReleaseFellCleaveSpam())
            {
                return(true);
            }

            // Main Rotation Part

            if (await SingleTarget.StormsEye())
            {
                return(true);
            }
            if (await SingleTarget.StormsPath())
            {
                return(true);
            }
            if (await SingleTarget.Maim())
            {
                return(true);
            }
            if (await SingleTarget.HeavySwing())
            {
                return(true);
            }
            return(await SingleTarget.Tomahawk());
        }
Example #20
0
        public static async Task <bool> Combat()
        {
            if (BotManager.Current.IsAutonomous)
            {
                if (Core.Me.HasTarget)
                {
                    Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 20);
                }
            }

            if (await Casting.TrackSpellCast())
            {
                return(true);
            }
            await Casting.CheckForSuccessfulCast();

            if (Core.Me.CurrentManaPercent <= ScholarSettings.Instance.MinimumManaPercent)
            {
                return(false);
            }

            if (await Buff.SummonPet())
            {
                return(true);
            }

            if (Utilities.Combat.Enemies.Count > ScholarSettings.Instance.StopDamageWhenMoreThanEnemies)
            {
                return(true);
            }

            if (Globals.InParty)
            {
                if (!ScholarSettings.Instance.DoDamage)
                {
                    return(true);
                }

                if (Core.Me.CurrentManaPercent < ScholarSettings.Instance.MinimumManaPercent)
                {
                    return(true);
                }
            }

            if (await Aoe.ArtOfWar())
            {
                return(true);
            }

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (await SingleTarget.Bio())
            {
                return(true);
            }
            if (await SingleTarget.BioMultipleTargets())
            {
                return(true);
            }
            if (await SingleTarget.Ruin2())
            {
                return(true);
            }
            if (await SingleTarget.EnergyDrain2())
            {
                return(true);
            }
            return(await SingleTarget.Broil());
        }
Example #21
0
        public static async Task <bool> Combat()
        {
            Utilities.Routines.Ninja.RefreshVars();
            //Logger.Write("Ninki:" + Utilities.Routines.Ninja.ninki);
            if (BotManager.Current.IsAutonomous)
            {
                Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3 + Core.Me.CurrentTarget.CombatReach);
            }

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

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (await PhysicalDps.Interrupt(NinjaSettings.Instance))
            {
                return(true);
            }

            //if (Core.Me.HasAura(Auras.TenChiJin))
            //{
            //    Logger.Error("Capturd TCJ");
            //    //Let's check which TCJ we will do. 1=Suiton/2-Doton
            //    if (Utilities.Routines.Ninja.AoeEnemies5Yards > 1 && Utilities.Routines.Ninja.TCJState == 0 && !Core.Me.HasAura(Auras.Doton))
            //    {
            //        Utilities.Routines.Ninja.TCJState = 2;
            //    }
            //    if (Utilities.Routines.Ninja.AoeEnemies5Yards < 2 && Utilities.Routines.Ninja.TCJState == 0)
            //    {
            //        Utilities.Routines.Ninja.TCJState = 1;
            //    }

            //    if (Utilities.Routines.Ninja.TCJState == 1)
            //    {
            //        if (Casting.LastSpell == Spells.Chi)
            //        {
            //            Utilities.Routines.Ninja.TCJState = 0;
            //            return await Spells.Jin.Cast(Core.Me.CurrentTarget);
            //        }

            //        if (Casting.LastSpell == Spells.Ten)
            //        {
            //            return await Spells.Chi.Cast(Core.Me.CurrentTarget);
            //        }

            //        return await Spells.Ten.Cast(Core.Me.CurrentTarget);
            //    }

            //    if (Utilities.Routines.Ninja.TCJState == 2)
            //    {
            //        if (Casting.LastSpell == Spells.Jin)
            //        {
            //            Utilities.Routines.Ninja.TCJState = 0;
            //            return await Spells.Chi.Cast(Core.Me);
            //        }

            //        if (Casting.LastSpell == Spells.Ten)
            //        {
            //            return await Spells.Jin.Cast(Core.Me.CurrentTarget);
            //        }

            //        return await Spells.Ten.Cast(Core.Me.CurrentTarget);
            //    }
            //}
            if (Ninjutsu.ForceRaiton())
            {
                return(true);
            }
            if (Spells.SpinningEdge.Cooldown.TotalMilliseconds > 650)
            {
                //Utility Force Toggle
                if (await PhysicalDps.ArmsLength(NinjaSettings.Instance))
                {
                    return(true);
                }
                if (await Utility.SecondWindForce())
                {
                    return(true);
                }
                if (await Utility.ShadeShift())
                {
                    return(true);
                }
                if (await Utility.TrueNorth())
                {
                    return(true);
                }
                if (await Utility.Feint())
                {
                    return(true);
                }
                if (await Utility.BloodBath())
                {
                    return(true);
                }

                if (await PhysicalDps.SecondWind(NinjaSettings.Instance))
                {
                    return(true);
                }

                //if (await PhysicalDps.SecondWind(NinjaSettings.Instance)) return true;
                if (await SingleTarget.TrickAttack())
                {
                    return(true);
                }
                if (await Ninjutsu.TenChiJin())
                {
                    return(true);
                }
                if (await Buff.Meisui())
                {
                    return(true);
                }
                //if (await Buff.TrueNorth()) return true;
                //if (await Buff.ShadeShift()) return true;
                if (await Buff.Bunshin())
                {
                    return(true);
                }
                if (await SingleTarget.Assassinate())
                {
                    return(true);
                }
                if (await Aoe.HellfrogMedium())
                {
                    return(true);
                }
                if (await SingleTarget.Bhavacakra())
                {
                    return(true);
                }
                if (await SingleTarget.Mug())
                {
                    return(true);
                }
                if (await Buff.Kassatsu())
                {
                    return(true);
                }
                if (await SingleTarget.DreamWithinADream())
                {
                    return(true);
                }
            }
            if (await SingleTarget.ShadowFang())
            {
                return(true);
            }

            //Ninjutsu
            if (NinjutsuCheck())
            {
                if (Ninjutsu.Huton())
                {
                    return(true);
                }
                if (Ninjutsu.GokaMekkyaku())
                {
                    return(true);
                }
                if (Ninjutsu.Doton())
                {
                    return(true);
                }
                if (Ninjutsu.Katon())
                {
                    return(true);
                }
                if (Ninjutsu.Suiton())
                {
                    return(true);
                }
                if (Ninjutsu.HyoshoRanryu())
                {
                    return(true);
                }
                if (Ninjutsu.Raiton())
                {
                    return(true);
                }
                //if (Ninjutsu.FumaShuriken()) return true;
            }

            if (await Aoe.HakkeMujinsatsu())
            {
                return(true);
            }
            if (await Aoe.DeathBlossom())
            {
                return(true);
            }
            if (await SingleTarget.ArmorCrush())
            {
                return(true);
            }
            if (await SingleTarget.AeolianEdge())
            {
                return(true);
            }
            if (await SingleTarget.GustSlash())
            {
                return(true);
            }
            return(await SingleTarget.SpinningEdge());
        }
Example #22
0
        public static async Task <bool> Combat()
        {
            if (BotManager.Current.IsAutonomous)
            {
                if (Core.Me.HasTarget)
                {
                    Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3 + Core.Me.CurrentTarget.CombatReach);
                }
            }

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

            if (await Buff.Grit())
            {
                return(true);
            }

            if (await Tank.Interrupt(DarkKnightSettings.Instance))
            {
                return(true);
            }

            if (DarkKnightRoutine.GlobalCooldown.CountOGCDs() < 2 &&
                Spells.HardSlash.Cooldown.TotalMilliseconds > 650 + BaseSettings.Instance.UserLatencyOffset)
            {
                if (await Tank.Provoke(DarkKnightSettings.Instance))
                {
                    return(true);
                }
                if (await Defensive.Execute())
                {
                    return(true);
                }
                if (await Defensive.Oblation(true))
                {
                    return(true);
                }
                if (await Defensive.Reprisal())
                {
                    return(true);
                }
                if (await SingleTarget.CarveAndSpit())
                {
                    return(true);
                }
                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 Buff.Delirium())
                {
                    return(true);
                }
                if (await Buff.BloodWeapon())
                {
                    return(true);
                }
                if (await Buff.LivingShadow())
                {
                    return(true);
                }
                if (await SingleTarget.Shadowbringer())
                {
                    return(true);
                }
            }

            if (await SingleTarget.UnmendForAggro())
            {
                return(true);
            }
            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);
            }
            if (await SingleTarget.HardSlash())
            {
                return(true);
            }
            if (await SingleTarget.Unmend())
            {
                return(true);
            }

            return(false);
        }
Example #23
0
        public static async Task <bool> Combat()
        {
            if (BotManager.Current.IsAutonomous)
            {
                Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3 + Core.Me.CurrentTarget.CombatReach);
            }

            Utilities.Routines.Monk.RefreshVars();

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

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            if (await Buff.FistsOf())
            {
                return(true);
            }

            if (await Buff.Meditate())
            {
                return(true);
            }

            //var count = Utilities.Combat.Enemies.Count;
            //if (2 >= count && count < 5)
            //{
            //    //TODO: Add 2-4 target DPS rotation
            //}
            //else if (count >= 5)
            //{
            //    //TODO: Add 5+ target DPS rotation
            //}
            if (!Core.Me.HasAura(Auras.Anatman) || MonkSettings.Instance.UseManualPB && Core.Me.HasAura(Auras.PerfectBalance))
            {
                if (Weaving.GetCurrentWeavingCounter() < 2 && Spells.Bootshine.Cooldown.TotalMilliseconds > 750 + BaseSettings.Instance.UserLatencyOffset)
                {
                    if (await PhysicalDps.Interrupt(MonkSettings.Instance))
                    {
                        return(true);
                    }
                    if (await PhysicalDps.SecondWind(MonkSettings.Instance))
                    {
                        return(true);
                    }
                    if (await PhysicalDps.Bloodbath(MonkSettings.Instance))
                    {
                        return(true);
                    }
                    if (await PhysicalDps.Feint(MonkSettings.Instance))
                    {
                        return(true);
                    }
                    if (await Buff.RiddleOfFire())
                    {
                        return(true);
                    }
                    if (await Buff.Brotherhood())
                    {
                        return(true);
                    }
                    if (await SingleTarget.TornadoKick())
                    {
                        return(true);
                    }
                    if (await Aoe.Enlightenment())
                    {
                        return(true);
                    }
                    if (await SingleTarget.TheForbiddenChakra())
                    {
                        return(true);
                    }
                    if (await SingleTarget.ShoulderTackle())
                    {
                        return(true);
                    }
                    if (await Buff.PerfectBalance())
                    {
                        return(true);
                    }
                    if (await Buff.TrueNorthRiddleOfEarth())
                    {
                        return(true);
                    }
                    //if (await Buff.RiddleOfFire()) return true;
                    //if (await Buff.Brotherhood()) return true;
                    if (await SingleTarget.ElixirField())
                    {
                        return(true);
                    }
                }
                if (await Aoe.Rockbreaker())
                {
                    return(true);
                }
                if (await Aoe.FourPointStrike())
                {
                    return(true);
                }
                if (await Aoe.ArmOfDestroyer())
                {
                    return(true);
                }
                if (await SingleTarget.PerfectBalanceRoT())
                {
                    return(true);
                }
                //if (await Aoe.Rockbreaker()) return true;
                //if (await Aoe.FourPointStrike()) return true;
                //if (await Aoe.ArmOfDestroyer()) return true;
                if (await SingleTarget.Demolish())
                {
                    return(true);
                }
                if (await SingleTarget.SnapPunch())
                {
                    return(true);
                }
                if (await SingleTarget.TwinSnakes())
                {
                    return(true);
                }
                if (await SingleTarget.TrueStrike())
                {
                    return(true);
                }
                if (await SingleTarget.Bootshine())
                {
                    return(true);
                }
                if (await SingleTarget.DragonKick())
                {
                    return(true);
                }
                return(await Buff.FormShiftIC());
            }

            return(false);
        }
Example #24
0
        public static async Task <bool> Execute()
        {
            if (await Defensive.TankBusters())
            {
                return(true);
            }

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            if (await Buff.Oath())
            {
                return(true);
            }


            if (Utilities.Routines.Paladin.OnGcd)
            {
                if (await Buff.Cover())
                {
                    return(true);
                }
                if (await Tank.Provoke(PaladinSettings.Instance))
                {
                    return(true);
                }
                if (await Defensive.Defensives())
                {
                    return(true);
                }
                if (await Buff.Intervention())
                {
                    return(true);
                }
                if (await Buff.DivineVeil())
                {
                    return(true);
                }
                if (await SingleTarget.Requiescat())
                {
                    return(true);
                }
                if (await Buff.FightOrFlight())
                {
                    return(true);
                }
                if (await SingleTarget.Interject())
                {
                    return(true);
                }
                if (!Utilities.Routines.Paladin.OGCDHold)
                {
                    if (await SingleTarget.SpiritsWithin())
                    {
                        return(true);
                    }
                    if (await Aoe.CircleofScorn())
                    {
                        return(true);
                    }
                    if (await SingleTarget.Intervene())
                    {
                        return(true);
                    }
                }
                if (await Buff.Sheltron())
                {
                    return(true);
                }
            }

            if (await SingleTarget.ShieldBash())
            {
                return(true);
            }
            if (await SingleTarget.ShieldLobLostAggro())
            {
                return(true);
            }
            if (await Aoe.Confiteor())
            {
                return(true);
            }
            if (await Aoe.HolyCircle())
            {
                return(true);
            }
            if (await Aoe.TotalEclipse())
            {
                return(true);
            }
            if (await SingleTarget.HolySpirit())
            {
                return(true);
            }
            if (await SingleTarget.Atonement())
            {
                return(true);
            }


            if (ActionManager.LastSpell == Spells.RiotBlade && Core.Me.ClassLevel > 25 && Core.Me.ClassLevel < 60)
            {
                return(await Spells.RageofHalone.Cast(Core.Me.CurrentTarget));
            }

            #region Last Spell RiotBlade
            if (ActionManager.LastSpell == Spells.RiotBlade)
            {
                if (Core.Me.ClassLevel >= 54 && !Core.Me.CurrentTarget.HasAura(Auras.GoringBlade, true, (PaladinSettings.Instance.RefreshGoringBlade) * 1000) && Core.Me.CurrentTarget.HealthCheck(PaladinSettings.Instance.HealthSetting, PaladinSettings.Instance.HealthSettingPercent))
                {
                    if (await Spells.GoringBlade.Cast(Core.Me.CurrentTarget))
                    {
                        return(true);
                    }
                }

                if (Core.Me.ClassLevel > 59)
                {
                    return(await Spells.RoyalAuthority.Cast(Core.Me.CurrentTarget));
                }

                return(await Spells.FastBlade.Cast(Core.Me.CurrentTarget));
            }
            #endregion

            #region Last Spell FastBlade
            if (ActionManager.LastSpell == Spells.FastBlade)
            {
                // Low level just fast blade
                if (Core.Me.ClassLevel < 4)
                {
                    return(await Spells.FastBlade.Cast(Core.Me.CurrentTarget));
                }

                //// if we have RA and RA in shield oath is enabled riot blade
                //if (ActionManager.HasSpell(Spells.RoyalAuthority.Id))
                //{
                //    if (PaladinSettings.Instance.RoyalAuthorityComboInShieldOath)
                //    {
                //        return await Spells.RiotBlade.Cast(Core.Me.CurrentTarget);
                //    }
                //}

                //if (!Core.Me.CurrentTarget.HasAura(Auras.GoringBlade, true, PaladinSettings.Instance.RefreshGoringBlade * 1000))
                //{
                //    return await Spells.RiotBlade.Cast(Core.Me.CurrentTarget);
                //}

                if (Core.Me.ClassLevel >= 4)
                {
                    return(await Spells.RiotBlade.Cast(Core.Me.CurrentTarget));
                }

                return(false);
            }
            #endregion

            if (await Spells.FastBlade.Cast(Core.Me.CurrentTarget))
            {
                return(true);
            }

            if (PaladinSettings.Instance.ShieldLobToPull && !Core.Me.InCombat)
            {
                return(await Spells.ShieldLob.Cast(Core.Me.CurrentTarget));
            }
            if (PaladinSettings.Instance.HolySpiritWhenOutOfMeleeRange && Core.Me.ClassLevel >= 64 && await Spells.HolySpirit.Cast(Core.Me.CurrentTarget))
            {
                return(true);
            }
            return(await SingleTarget.ShieldLob());
        }
Example #25
0
        public static async Task <bool> Execute()
        {
            if (BotManager.Current.IsAutonomous)
            {
                Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3 + Core.Me.CurrentTarget.CombatReach);
            }

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

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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


            if (await PhysicalDps.Interrupt(NinjaSettings.Instance))
            {
                return(true);
            }

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (Utilities.Routines.Ninja.OnGcd)
            {
                if (await PhysicalDps.SecondWind(NinjaSettings.Instance))
                {
                    return(true);
                }
                if (await PhysicalDps.Bloodbath(NinjaSettings.Instance))
                {
                    return(true);
                }
                if (await PhysicalDps.Feint(NinjaSettings.Instance))
                {
                    return(true);
                }

                if (Core.Me.HasAura(Auras.Suiton))
                {
                    if (await PhysicalDps.TrueNorth(NinjaSettings.Instance))
                    {
                        return(true);
                    }
                }

                if (await Buff.ShadeShift())
                {
                    return(true);
                }
                if (await Buff.Bunshin())
                {
                    return(true);
                }
                if (await SingleTarget.Assassinate())
                {
                    return(true);
                }
                if (await SingleTarget.Mug())
                {
                    return(true);
                }
                if (await Buff.Kassatsu())
                {
                    return(true);
                }
                if (await SingleTarget.TrickAttack())
                {
                    return(true);
                }
                if (await SingleTarget.DreamWithinADream())
                {
                    return(true);
                }
                if (await Aoe.HellfrogMedium())
                {
                    return(true);
                }
                if (await SingleTarget.Bhavacakra())
                {
                    return(true);
                }
                if (await Ninjutsu.TenChiJin())
                {
                    return(true);
                }
            }

            if (Ninjutsu.Huton())
            {
                return(true);
            }
            if (Ninjutsu.GokaMekkyaku())
            {
                return(true);
            }
            if (Ninjutsu.Doton())
            {
                return(true);
            }
            if (Ninjutsu.Katon())
            {
                return(true);
            }
            if (Ninjutsu.Suiton())
            {
                return(true);
            }
            if (Ninjutsu.HyoshoRanryu())
            {
                return(true);
            }
            if (Ninjutsu.Raiton())
            {
                return(true);
            }
            if (Ninjutsu.FumaShuriken())
            {
                return(true);
            }

            if (await Aoe.HakkeMujinsatsu())
            {
                return(true);
            }
            if (await Aoe.DeathBlossom())
            {
                return(true);
            }
            if (await SingleTarget.ShadowFang())
            {
                return(true);
            }
            if (await SingleTarget.ArmorCrush())
            {
                return(true);
            }
            if (await SingleTarget.AeolianEdge())
            {
                return(true);
            }
            if (await SingleTarget.GustSlash())
            {
                return(true);
            }
            return(await SingleTarget.SpinningEdge());
        }
Example #26
0
        public static async Task <bool> Combat()
        {
            if (await GambitLogic.Gambit())
            {
                return(true);
            }

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

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

            // Can't attack, so just exit
            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            // Can't attack, so just exit
            if (Core.Me.CurrentTarget.HasAnyAura(Auras.Invincibility))
            {
                return(false);
            }

            // Can't attack, so just exit
            if (Core.Me.HasAura(Auras.WaningNocturne, true, 1000))
            {
                return(false);
            }

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

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

            //Interrupt
            if (await MagicDps.Interrupt(BlueMageSettings.Instance))
            {
                return(true);
            }

            //Manage PhantomFlury
            ff14bot.Objects.Aura waxingNocturne = Core.Me.Auras.FirstOrDefault(x => x.Id == Auras.WaxingNocturne && x.CasterId == Core.Player.ObjectId);
            ff14bot.Objects.Aura phantomFlurry  = Core.Me.Auras.FirstOrDefault(x => x.Id == Auras.PhantomFlurry && x.CasterId == Core.Player.ObjectId);

            if (Core.Me.InCombat && BlueMageSettings.Instance.UsePhantomFlurry && Casting.LastSpell == Spells.PhantomFlurry)
            {
                if (Core.Me.HasAura(Auras.WaxingNocturne) && waxingNocturne.TimespanLeft.TotalMilliseconds <= 1000)
                {
                    return(await Aoe.PhantomFlurryEnd());
                }

                if (Core.Me.HasAura(Auras.PhantomFlurry) && phantomFlurry.TimespanLeft.TotalMilliseconds <= 1000)
                {
                    return(await Aoe.PhantomFlurryEnd());
                }

                return(true);
            }

            //Buff should always be active
            if (await Buff.OffGuard())
            {
                return(true);
            }

            //Buff
            if (await Buff.Whistle())
            {
                return(true);
            }
            if (await Aoe.Tingle())
            {
                return(true);
            }
            if (await Buff.Bristle())
            {
                return(true);
            }
            if (await Buff.MoonFlute())
            {
                return(true);
            }

            //Jump
            if (await Aoe.JKick())
            {
                return(true);
            }

            //DOT should always be active
            if (await SingleTarget.SongOfTorment())
            {
                return(true);
            }

            if (Casting.LastSpell != Spells.Surpanakha || (Casting.LastSpell == Spells.Surpanakha && Spells.Surpanakha.Charges < 1))
            {
                //GCD
                if (await Buff.Swiftcast())
                {
                    return(true);
                }
                if (await SingleTarget.TripleTrident())
                {
                    return(true);
                }
                if (await SingleTarget.MatraMagic())
                {
                    return(true);
                }
                if (await SingleTarget.TheRoseOfDestruction())
                {
                    return(true);
                }
                if (await Aoe.Surpanakha())
                {
                    return(true);
                }

                if (BlueMageRoutine.OnGcd && Casting.LastSpell != Spells.Surpanakha)
                {
                    if (BlueMageRoutine.GlobalCooldown.CountOGCDs() < 2)
                    {
                        //put oGCD here
                        if (await Aoe.NightBloom())
                        {
                            return(true);
                        }
                        if (await Aoe.PhantomFlurry())
                        {
                            return(true);
                        }
                        if (await Aoe.ShockStrike())
                        {
                            return(true);
                        }
                        if (await Aoe.GlassDance())
                        {
                            return(true);
                        }
                        if (await Aoe.Quasar())
                        {
                            return(true);
                        }
                        if (await Aoe.FeatherRain())
                        {
                            return(true);
                        }
                        if (await Buff.LucidDreaming())
                        {
                            return(true);
                        }

                        if (await Aoe.Eruption())
                        {
                            return(true);                      //FeatherRain if possible, otherwise Eruption
                        }
                        if (await Aoe.MountainBuster())
                        {
                            return(true);                            //ShockStrike if possible, otherwise MountainBuster
                        }
                    }
                }

                if (await SingleTarget.SharpKnife())
                {
                    return(true);                                 //if melee
                }
                if (await SingleTarget.AbyssalTransfixion())
                {
                    return(true);                                         //if SonicBoom deactivated
                }
                return(await SingleTarget.SonicBoom());
            }
            else
            {
                //Logger.WriteInfo($@"[Surpanakha] Charges = {Spells.Surpanakha.Charges}");
                return(await Aoe.Surpanakha());
            }
        }
Example #27
0
        public static async Task <bool> Combat()
        {
            if (BotManager.Current.IsAutonomous)
            {
                if (Core.Me.HasTarget)
                {
                    Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 3 + Core.Me.CurrentTarget.CombatReach);
                }
            }

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

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

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

            if (await Buff.DancePartner())
            {
                return(true);
            }

            if (await Aoe.StarfallDance())
            {
                return(true);
            }
            if (await Dances.Tillana())
            {
                return(true);
            }
            if (await Dances.StandardStep())
            {
                return(true);
            }
            if (await Dances.TechnicalStep())
            {
                return(true);
            }
            if (await Dances.DanceStep())
            {
                return(true);
            }

            if (Core.Me.HasAura(Auras.StandardStep) || Core.Me.HasAura(Auras.TechnicalStep))
            {
                return(false);
            }

            if (DancerRoutine.GlobalCooldown.CanWeave())
            {
                if (await PhysicalDps.Interrupt(DancerSettings.Instance))
                {
                    return(true);
                }
                if (await PhysicalDps.SecondWind(DancerSettings.Instance))
                {
                    return(true);
                }
                if (await Buff.CuringWaltz())
                {
                    return(true);
                }
                if (await Buff.PreTechnicalDevilment())
                {
                    return(true);
                }
                if (await Aoe.FanDance3())
                {
                    return(true);
                }
                if (await Aoe.FanDance2())
                {
                    return(true);
                }
                if (await SingleTarget.FanDance())
                {
                    return(true);
                }
                if (await Aoe.FanDance4())
                {
                    return(true);
                }
                if (await Buff.Flourish())
                {
                    return(true);
                }
                if (await Buff.Devilment())
                {
                    return(true);
                }
                if (await Buff.Improvisation())
                {
                    return(true);
                }
            }

            if (await Aoe.SaberDance())
            {
                return(true);
            }
            if (await Aoe.Bloodshower())
            {
                return(true);
            }
            if (await Aoe.RisingWindmill())
            {
                return(true);
            }
            if (await SingleTarget.Fountainfall())
            {
                return(true);
            }
            if (await SingleTarget.ReverseCascade())
            {
                return(true);
            }
            if (await Aoe.Bladeshower())
            {
                return(true);
            }
            if (await Aoe.Windmill())
            {
                return(true);
            }
            if (await SingleTarget.Fountain())
            {
                return(true);
            }
            return(await SingleTarget.Cascade());
        }
Example #28
0
        public static async Task <bool> Combat()
        {
            if (BotManager.Current.IsAutonomous)
            {
                if (Core.Me.HasTarget)
                {
                    Movement.NavigateToUnitLos(Core.Me.CurrentTarget, 23);
                }
            }

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }
            if (Core.Me.CurrentTarget.HasAnyAura(Auras.Invincibility))
            {
                return(false);
            }
            if (await CustomOpenerLogic.Opener())
            {
                return(true);
            }

            //DON'T CHANGE THE ORDER OF THESE
            if (await Buff.Enochian())
            {
                return(true);
            }
            if (await Buff.Triplecast())
            {
                return(true);
            }
            if (await Buff.Sharpcast())
            {
                return(true);
            }
            if (await Buff.ManaFont())
            {
                return(true);
            }
            if (await Buff.LeyLines())
            {
                return(true);
            }
            if (await Buff.UmbralSoul())
            {
                return(true);
            }


            if (BlackMageSettings.Instance.UseAoe && Core.Me.CurrentTarget.EnemiesNearby(10).Count() >= BlackMageSettings.Instance.AoeEnemies)

            {
                if (await Aoe.Flare())
                {
                    return(true);
                }
                if (await Aoe.Blizzard2())
                {
                    return(true);
                }
                if (await Aoe.Freeze())
                {
                    return(true);
                }
                if (await Aoe.Foul())
                {
                    return(true);
                }
                if (await Aoe.Fire2())
                {
                    return(true);
                }
                if (await Aoe.Thunder4())
                {
                    return(true);
                }
                if (await Aoe.Fire3())
                {
                    return(true);
                }
                if (await Aoe.Fire4())
                {
                    return(true);
                }
            }

            if (await SingleTarget.Blizzard4())
            {
                return(true);
            }
            if (await SingleTarget.Fire())
            {
                return(true);
            }
            if (await SingleTarget.Thunder3())
            {
                return(true);
            }
            if (await SingleTarget.Xenoglossy())
            {
                return(true);
            }
            if (await SingleTarget.Fire4())
            {
                return(true);
            }
            if (await SingleTarget.Despair())
            {
                return(true);
            }

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


            if (await SingleTarget.Blizzard())
            {
                return(true);
            }
            if (await SingleTarget.Blizzard3())
            {
                return(true);
            }

            if (Core.Me.ClassLevel < 80)
            {
                return(await Spells.Fire3.Cast(Core.Me.CurrentTarget));
            }

            return(false);
        }
Example #29
0
        public static async Task <bool> Combat()
        {
            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

            if (Core.Me.CurrentTarget.HasAnyAura(Auras.Invincibility))
            {
                return(false);
            }

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

            //if (await Defensive.ExecuteTankBusters()) return true;

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

            if (await Tank.Interrupt(GunbreakerSettings.Instance))
            {
                return(true);
            }
            if (await SingleTarget.RoughDivide())
            {
                return(true);
            }

            if (Utilities.Routines.Gunbreaker.OnGcd)
            {
                if (await Defensive.Execute())
                {
                    return(true);
                }
                if (await Buff.RoyalGuard())
                {
                    return(true);
                }
                if (await Buff.Bloodfest())
                {
                    return(true);
                }
                if (await Buff.NoMercy())
                {
                    return(true);
                }
                if (await SingleTarget.EyeGouge())
                {
                    return(true);
                }
                if (await SingleTarget.AbdomenTear())
                {
                    return(true);
                }
                if (await SingleTarget.JugularRip())
                {
                    return(true);
                }
                if (await SingleTarget.DangerZone())
                {
                    return(true);
                }
                if (await SingleTarget.BlastingZone())
                {
                    return(true);
                }

                if (GunbreakerSettings.Instance.UseAoe)
                {
                    if (await Aoe.BowShock())
                    {
                        return(true);
                    }
                }
            }



            if (GunbreakerSettings.Instance.UseAoe)
            {
                if (await Aoe.FatedCircle())
                {
                    return(true);
                }
                if (await Aoe.DemonSlaughter())
                {
                    return(true);
                }
                if (await Aoe.DemonSlice())
                {
                    return(true);
                }
            }

            if (await SingleTarget.GnashingFang())
            {
                return(true);
            }
            if (await SingleTarget.SonicBreak())
            {
                return(true);
            }
            if (await SingleTarget.LightningShot())
            {
                return(true);
            }
            if (await SingleTarget.WickedTalon())
            {
                return(true);
            }
            if (await SingleTarget.SavageClaw())
            {
                return(true);
            }
            if (await SingleTarget.SolidBarrel())
            {
                return(true);
            }
            if (await SingleTarget.BrutalShell())
            {
                return(true);
            }
            if (await SingleTarget.BurstStrike())
            {
                return(true);
            }

            if (Core.Me.HasAura(Auras.ReadytoRip))
            {
                return(await Spells.JugularRip.Cast(Core.Me.CurrentTarget));
            }
            if (Core.Me.HasAura(Auras.ReadytoTear))
            {
                return(await Spells.AbdomenTear.Cast(Core.Me.CurrentTarget));
            }
            if (Core.Me.HasAura(Auras.ReadytoGouge))
            {
                return(await Spells.EyeGouge.Cast(Core.Me.CurrentTarget));
            }


            return(await SingleTarget.KeenEdge());
        }
Example #30
0
        public static async Task <bool> Execute()
        {
            Group.UpdateAllies();

            if (Core.Me.IsCasting)
            {
                return(true);
            }

            if (await Casting.TrackSpellCast())
            {
                return(true);
            }

            await Casting.CheckForSuccessfulCast();

            Globals.InParty       = PartyManager.IsInParty;
            Globals.PartyInCombat = Globals.InParty && Utilities.Combat.Enemies.Any(r => r.TaggerType == 2) || Core.Me.InCombat;
            Utilities.Routines.Bard.RefreshVars();

            if (!Core.Me.HasTarget || !Core.Me.CurrentTarget.ThoroughCanAttack())
            {
                return(false);
            }

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

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

            if (Weaving.GetCurrentWeavingCounter() < 2 && Spells.HeavyShot.Cooldown.TotalMilliseconds > 650 + BaseSettings.Instance.UserLatencyOffset)
            {
                // Utility
                if (await Utility.RepellingShot())
                {
                    return(true);
                }
                if (await Utility.WardensPaean())
                {
                    return(true);
                }
                if (await Utility.NaturesMinne())
                {
                    return(true);
                }
                if (await Utility.Troubadour())
                {
                    return(true);
                }
                if (await PhysicalDps.ArmsLength(BardSettings.Instance))
                {
                    return(true);
                }
                if (await PhysicalDps.SecondWind(BardSettings.Instance))
                {
                    return(true);
                }
                if (await Utility.HeadGraze())
                {
                    return(true);
                }

                // Damage
                if (await SingleTarget.LastPossiblePitchPerfectDuringWM())
                {
                    return(true);
                }
                if (await Songs.LetMeSingYouTheSongOfMyPeople())
                {
                    return(true);
                }
                if (await Cooldowns.BattleVoice())
                {
                    return(true);
                }
                if (await Cooldowns.RagingStrikes())
                {
                    return(true);
                }
                if (await Cooldowns.Barrage())
                {
                    return(true);
                }
                if (await SingleTarget.PitchPerfect())
                {
                    return(true);
                }
                if (await Aoe.RainOfDeathDuringMagesBallard())
                {
                    return(true);
                }
                if (await SingleTarget.BloodletterInMagesBallard())
                {
                    return(true);
                }
                if (await SingleTarget.EmpyrealArrow())
                {
                    return(true);
                }
                if (await Aoe.ShadowBite())
                {
                    return(true);
                }
                if (await SingleTarget.Sidewinder())
                {
                    return(true);
                }
                if (await Aoe.RainOfDeath())
                {
                    return(true);
                }
                if (await SingleTarget.Bloodletter())
                {
                    return(true);
                }
            }

            if (await SingleTarget.StraightShotAfterBarrage())
            {
                return(true);
            }
            if (await DamageOverTime.IronJawsOnCurrentTarget())
            {
                return(true);
            }
            if (await DamageOverTime.SnapShotIronJawsOnCurrentTarget())
            {
                return(true);
            }
            if (await DamageOverTime.WindbiteOnCurrentTarget())
            {
                return(true);
            }
            if (await DamageOverTime.VenomousBiteOnCurrentTarget())
            {
                return(true);
            }
            if (await Aoe.ApexArrow())
            {
                return(true);
            }
            if (await DamageOverTime.IronJawsOnOffTarget())
            {
                return(true);
            }
            if (await DamageOverTime.WindbiteOnOffTarget())
            {
                return(true);
            }
            if (await DamageOverTime.VenomousBiteOnOffTarget())
            {
                return(true);
            }
            if (await Aoe.QuickNock())
            {
                return(true);
            }
            if (await SingleTarget.StraightShot())
            {
                return(true);
            }
            return(await SingleTarget.HeavyShot());
        }