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());
        }
Exemple #2
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 (await CustomOpenerLogic.Opener())
            {
                return(true);
            }

            if (MachinistSettings.Instance.UseFlamethrower && Core.Me.HasAura(Auras.Flamethrower))
            {
                // First check movement otherwise Flamethrower can be executed whereas you are moving
                if (MovementManager.IsMoving)
                {
                    return(false);
                }

                if (!MachinistSettings.Instance.UseFlamethrower)
                {
                    return(true);
                }

                if (Core.Me.EnemiesInCone(8) >= MachinistSettings.Instance.FlamethrowerEnemyCount)
                {
                    return(true);
                }
            }

            //oGCDs

            //Utility
            if (await Utility.Tactician())
            {
                return(true);
            }
            if (await PhysicalDps.ArmsLength(MachinistSettings.Instance))
            {
                return(true);
            }
            if (await PhysicalDps.SecondWind(MachinistSettings.Instance))
            {
                return(true);
            }
            if (await Utility.HeadGraze())
            {
                return(true);
            }

            if (Weaving.GetCurrentWeavingCounter() < 2)
            {
                //Pets
                if (await Pet.RookQueen())
                {
                    return(true);
                }
                if (await Pet.RookQueenOverdrive())
                {
                    return(true);
                }

                //Cooldowns
                if (await Cooldowns.Wildfire())
                {
                    return(true);
                }
                if (await Cooldowns.Hypercharge())
                {
                    return(true);
                }
                if (await Cooldowns.Reassemble())
                {
                    return(true);
                }
                if (await Cooldowns.BarrelStabilizer())
                {
                    return(true);
                }

                //oGCDs
                if (await SingleTarget.GaussRound())
                {
                    return(true);
                }
                if (await MultiTarget.Ricochet())
                {
                    return(true);
                }
            }

            //GCDs - Top Hypercharge Priority
            if (await MultiTarget.AutoCrossbow())
            {
                return(true);
            }
            if (await SingleTarget.HeatBlast())
            {
                return(true);
            }

            //Use On CD
            if (await MultiTarget.BioBlaster())
            {
                return(true);
            }
            if (await SingleTarget.Drill())
            {
                return(true);
            }
            if (await SingleTarget.HotAirAnchor())
            {
                return(true);
            }
            if (await MultiTarget.Flamethrower())
            {
                return(true);
            }
            if (await MultiTarget.SpreadShot())
            {
                return(true);
            }

            //Default Combo

            if (Core.Me.ClassLevel > 58)
            {
                if (Spells.Drill.Cooldown.TotalMilliseconds > 100)
                {
                    if (await SingleTarget.HeatedCleanShot())
                    {
                        return(true);
                    }
                    if (await SingleTarget.HeatedSlugShot())
                    {
                        return(true);
                    }
                }
            }
            else
            {
                if (await SingleTarget.HeatedCleanShot())
                {
                    return(true);
                }
                if (await SingleTarget.HeatedSlugShot())
                {
                    return(true);
                }
            }

            return(await SingleTarget.HeatedSplitShot());
        }
Exemple #3
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);
        }
Exemple #4
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());
        }
Exemple #5
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());
        }
Exemple #6
0
        public static async Task <bool> Execute()
        {
            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 (await CustomOpenerLogic.Opener())
            {
                return(true);
            }

            if (MachinistSettings.Instance.UseFlameThrower && Core.Me.HasAura(Auras.Flamethrower))
            {
                // Did someone use this manually? Make sure we don't cancel it...
                if (!MachinistSettings.Instance.UseFlameThrower)
                {
                    return(true);
                }

                if (MovementManager.IsMoving)
                {
                    return(false);
                }

                // Keep using it for the AOE benefit if we need to
                if (Core.Me.EnemiesInCone(8) >= MachinistSettings.Instance.FlamethrowerEnemies)
                {
                    return(true);
                }
            }

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

            if (Utilities.Routines.Machinist.OnGcd && Weaving.GetCurrentWeavingCounter() < 2)
            {
                if (await Buff.BarrelStabilizer())
                {
                    return(true);
                }
                if (await Buff.Wildfire())
                {
                    return(true);
                }
                if (await Buff.Hypercharge())
                {
                    return(true);
                }
                if (await Turret.AutomationQueen())
                {
                    return(true);
                }
                if (await Turret.Rook())
                {
                    return(true);
                }
                if (await Aoe.Flamethrower())
                {
                    return(true);
                }

                if (Core.Me.ClassLevel < Spells.Drill.LevelAcquired)
                {
                    if (await Buff.Reassemble())
                    {
                        return(true);
                    }
                }

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

                if (MachinistSettings.Instance.UseAoe)
                {
                    return(await Aoe.Ricochet());
                }

                return(await Buff.Tactician());
            }

            if (MachinistSettings.Instance.UseAoe)
            {
                if (await Aoe.Bioblaster())
                {
                    return(true);
                }
            }

            if (await SingleTarget.Drill())
            {
                return(true);
            }
            if (await SingleTarget.AirAnchor())
            {
                return(true);
            }

            if (MachinistSettings.Instance.UseAoe)
            {
                if (await Aoe.AutoCrossbow())
                {
                    return(true);
                }
                if (await Aoe.SpreadShot())
                {
                    return(true);
                }
            }

            if (await SingleTarget.HeatBlast())
            {
                return(true);
            }
            if (await SingleTarget.HotShot())
            {
                return(true);
            }
            if (await SingleTarget.CleanShot())
            {
                return(true);
            }
            if (await SingleTarget.SlugShot())
            {
                return(true);
            }
            return(await SingleTarget.SplitShot());
        }