示例#1
0
        public static void CheckRangeToggle(GameObject o)
        {
            //Core.Player.Distance2D(Core.Player.CurrentTarget.Location) > Core.Player.Distance2D(OldTargetLocation)) 
            if (!InternalSettings.Instance.General.Movement || !InternalSettings.Instance.General.StopInRange || o == null) return;
            if (!RangeToggle && IsInSafeRange(o) && o.InLineOfSight()) 
            {
                StopMove();
                RangeToggle = true;
            }//use last targObjId after i make universal
            if (RangeToggle && !IsInSafeRange(o)) RangeToggle = false;

        }
示例#2
0
        /// <summary>
        ///     Made by Zzi - Borrowed from DungeonMaster
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="interactRange"></param>
        /// <param name="canInteract">Return False if we should not interact with the object</param>
        /// <returns></returns>
        private static async Task <bool> ObjectInteraction(GameObject obj, float interactRange, Func <bool> canInteract)
        {
            if (!canInteract())
            {
                return(false);
            }

            if (!obj.IsValid || !obj.IsVisible)
            {
                return(false);
            }

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

            if (obj.Distance2D() > interactRange)
            {
                var mr = await CommonTasks.MoveTo(new MoveToParameters(obj.Location));

                if (mr == MoveResult.PathGenerationFailed && obj.InLineOfSight())
                {
                    Navigator.PlayerMover.MoveTowards(obj.Location);
                    return(true);
                }

                if (mr == MoveResult.PathGenerationFailed)
                {
                    Logger.Error($"Unable to move toward {obj.Name} [{obj.NpcId}] (It appears to be out of line of sight and off the mesh)");
                }

                return(mr.IsSuccessful());
            }

            if (MovementManager.IsMoving)
            {
                await CommonTasks.StopMoving();

                return(true);
            }

            if (Core.Target == null || Core.Target.ObjectId != obj.ObjectId)
            {
                obj.Target();
                return(true);
            }

            obj.Interact();
            await Coroutine.Sleep(500);

            return(true);
        }
示例#3
0
        public static void NavigateToUnitLos(GameObject unit, float distance)
        {
            if (RoutineManager.IsAnyDisallowed(CapabilityFlags.Movement))
            {
                return;
            }

            if (unit == null)
            {
                return;
            }

            if (!MovementManager.IsMoving && !unit.InView())
            {
                Core.Me.Face(Core.Me.CurrentTarget);
            }

            //        if (AvoidanceManager.Avoids.Any(r => r.IsPointInAvoid(unit.Location)))
            //            return;

            if (unit.Distance(Core.Me) > distance)
            {
                Navigator.MoveTo(new MoveToParameters(unit.Location));
            }

            if (Core.Me.Distance(Core.Me.CurrentTarget.Location) <= distance && unit.InView() && unit.InLineOfSight())
            {
                if (MovementManager.IsMoving)
                {
                    Navigator.PlayerMover.MoveStop();
                }
            }
            else
            {
                Navigator.MoveTo(new MoveToParameters(unit.Location));
            }
        }
示例#4
0
        public async Task <bool> Cast(GameObject target = null, bool checkGCDType = true)
        {
            #region Target

            if (target == null)
            {
                switch (CastType)
                {
                case CastType.Target:
                case CastType.TargetLocation:
                    if (!Core.Player.HasTarget)
                    {
                        return(false);
                    }
                    target = Core.Player.CurrentTarget;
                    break;

                default:
                    target = Core.Player;
                    break;
                }
            }

            #endregion

            #region RecentSpell

            RecentSpell.RemoveAll(t => DateTime.UtcNow > t);
            if (RecentSpell.ContainsKey(target.ObjectId.ToString("X") + "-" + Name))
            {
                return(false);
            }

            #endregion

            #region CapabilityManager

            if (RoutineManager.IsAnyDisallowed(CapabilityFlags.Movement | CapabilityFlags.Facing))
            {
                return(false);
            }

            #endregion

            #region Cooldown

            if (ShinraEx.Settings.CooldownMode == CooldownModes.Disabled)
            {
                if ((SpellType == SpellType.Buff || SpellType == SpellType.Cooldown) && Cooldown(true) > 2500)
                {
                    return(false);
                }
            }

            #endregion

            #region AoE

            if (SpellType == SpellType.AoE && ShinraEx.Settings.RotationMode != Modes.Multi)
            {
                if (RoutineManager.IsAnyDisallowed(CapabilityFlags.Aoe))
                {
                    return(false);
                }

                var enemyCount =
                    Helpers.Enemies.Count(eu => eu.Distance2D(target) - eu.CombatReach - target.CombatReach <=
                                          DataManager.GetSpellData(ID).Radius);

                if (ShinraEx.Settings.CustomAoE)
                {
                    if (enemyCount < ShinraEx.Settings.CustomAoECount)
                    {
                        return(false);
                    }
                }
                else
                {
                    switch (Core.Player.CurrentJob)
                    {
                    case ClassJobType.Arcanist:
                    case ClassJobType.Summoner:
                        if (enemyCount < 2)
                        {
                            return(false);
                        }
                        break;

                    default:
                        if (enemyCount < 3)
                        {
                            return(false);
                        }
                        break;
                    }
                }
            }

            #endregion

            #region Directional

            switch (ID)
            {
            // Cone
            case 41:
            case 70:
            case 106:
            case 7483:
            case 7488:
            {
                if (!Helpers.InView(Core.Player.Location, Core.Player.Heading, target.Location))
                {
                    return(false);
                }
                break;
            }

            // Line
            case 86:
            case 7496:
            {
                if (!Core.Player.IsFacing(target))
                {
                    return(false);
                }
                break;
            }
            }

            #endregion

            #region Pet

            switch (SpellType)
            {
            case SpellType.Pet when Core.Player.Pet == null:
            case SpellType.Pet when PetManager.PetMode != PetMode.Obey:
            case SpellType.Pet when Core.Player.IsMounted:
            case SpellType.Pet when !PetManager.CanCast(Name, target):
            case SpellType.Pet when !await Coroutine.Wait(5000, () => PetManager.DoAction(Name, target)):
                return(false);

            case SpellType.Pet:
            {
                ShinraEx.LastSpell = this;

                #region AddRecent

                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + TimeSpan.FromSeconds(3);
                RecentSpell.Add(key, val);

                #endregion

                Logging.Write(Colors.GreenYellow, $@"[ShinraEx] Casting >>> {Name}");
                return(true);
            }

            case SpellType.Card when Core.Player.IsMounted:
            case SpellType.Card when !ActionManager.CanCast(ID, target) || RecentSpell.ContainsKey("Card"):
            case SpellType.Card when !await Coroutine.Wait(1000, () => ActionManager.DoAction(ID, target)):
                return(false);

            case SpellType.Card:
            {
                ShinraEx.LastSpell = this;

                #region AddRecent

                var val = DateTime.UtcNow + TimeSpan.FromSeconds(.5);

                if (ID == 3593)
                {
                    val += TimeSpan.FromSeconds(2);
                }
                RecentSpell.Add("Card", val);

                #endregion

                Logging.Write(Colors.GreenYellow, $@"[ShinraEx] Casting >>> {Name}");
                return(true);
            }
            }

            #endregion

            #region Card

            if (ShinraEx.Settings.AstrologianCardOnly && Core.Player.CurrentJob == ClassJobType.Astrologian)
            {
                return(false);
            }

            #endregion

            #region Ninjutsu

            if (SpellType == SpellType.Ninjutsu || SpellType == SpellType.Mudra)
            {
                #region Movement

                if (BotManager.Current.IsAutonomous)
                {
                    switch (ActionManager.InSpellInRangeLOS(2247, target))
                    {
                    case SpellRangeCheck.ErrorNotInLineOfSight:
                        await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                        return(false);

                    case SpellRangeCheck.ErrorNotInRange:
                        await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                        return(false);

                    case SpellRangeCheck.ErrorNotInFront:
                        if (!target.InLineOfSight())
                        {
                            await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                            return(false);
                        }

                        target.Face();
                        return(false);

                    case SpellRangeCheck.Success:
                        if (MovementManager.IsMoving)
                        {
                            Navigator.PlayerMover.MoveStop();
                        }
                        break;
                    }
                }

                #endregion

                #region IsMounted

                if (Core.Player.IsMounted)
                {
                    return(false);
                }

                #endregion

                #region CanCast

                if (ShinraEx.Settings.QueueSpells &&
                    !ActionManager.CanCastOrQueue(DataManager.GetSpellData(ID), target) ||
                    !ActionManager.CanCast(ID, target))
                {
                    return(false);
                }

                #endregion

                #region DoAction

                if (!await Coroutine.Wait(1000, () => ActionManager.DoAction(ID, target)))
                {
                    return(false);
                }

                #endregion

                #region Wait

                await Coroutine.Wait(2000, () => !ActionManager.CanCast(ID, target));

                #endregion

                ShinraEx.LastSpell = this;

                #region AddRecent

                if (SpellType == SpellType.Mudra)
                {
                    var key = target.ObjectId.ToString("X") + "-" + Name;
                    var val = DateTime.UtcNow + TimeSpan.FromSeconds(1);
                    RecentSpell.Add(key, val);
                }

                #endregion

                Logging.Write(Colors.GreenYellow, $@"[ShinraEx] Casting >>> {Name}");
                return(true);
            }

            #endregion

            #region CanAttack

            var bc = target as BattleCharacter;

            if (!target.CanAttack && CastType != CastType.Self && CastType != CastType.SelfLocation &&
                (bc == null || !bc.IsFate))
            {
                switch (SpellType)
                {
                case SpellType.Damage:
                case SpellType.DoT:
                case SpellType.Cooldown:
                    return(false);
                }
            }

            #endregion

            #region HasSpell

            if (!ActionManager.HasSpell(ID))
            {
                return(false);
            }

            #endregion

            #region Movement

            if (BotManager.Current.IsAutonomous)
            {
                switch (ActionManager.InSpellInRangeLOS(ID, target))
                {
                case SpellRangeCheck.ErrorNotInLineOfSight:
                    await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                    Helpers.Debug($"LineOfSight >>> {Name}");
                    return(false);

                case SpellRangeCheck.ErrorNotInRange:
                    await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                    Helpers.Debug($"Range >>> {Name}");
                    return(false);

                case SpellRangeCheck.ErrorNotInFront:
                    if (!target.InLineOfSight())
                    {
                        await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                        Helpers.Debug($"Facing >>> {Name}");
                        return(false);
                    }

                    target.Face();
                    return(false);

                case SpellRangeCheck.Success:
                    if (CastType == CastType.TargetLocation && Core.Player.Distance2D(target) +
                        Core.Player.CombatReach +
                        target.CombatReach > 25)
                    {
                        await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                        await Coroutine.Wait(1000,
                                             () => Core.Player.Distance2D(target) + Core.Player.CombatReach + target.CombatReach <=
                                             25);

                        return(false);
                    }

                    Navigator.PlayerMover.MoveStop();
                    break;
                }

                if (Core.Player.HasTarget && !MovementManager.IsMoving && Core.Player.IsMounted)
                {
                    Logging.Write(Colors.Yellow, @"[ShinraEx] Dismounting...");
                    ActionManager.Dismount();
                    await Coroutine.Sleep(1000);
                }
            }

            #endregion

            #region IsMounted

            if (Core.Player.IsMounted)
            {
                return(false);
            }

            #endregion

            #region StopCasting

            if (SpellType == SpellType.Heal)
            {
                if (Core.Player.IsCasting && !Helpers.HealingSpells.Contains(Core.Player.SpellCastInfo.Name))
                {
                    var stopCasting = false;
                    switch (Core.Player.CurrentJob)
                    {
                    case ClassJobType.Astrologian:
                        stopCasting = ShinraEx.Settings.AstrologianInterruptDamage;
                        break;

                    case ClassJobType.Scholar:
                        stopCasting = ShinraEx.Settings.ScholarInterruptDamage;
                        break;

                    case ClassJobType.WhiteMage:
                        stopCasting = ShinraEx.Settings.WhiteMageInterruptDamage;
                        break;
                    }

                    if (stopCasting)
                    {
                        Helpers.Debug($@"Trying to cast {Name}");
                        Logging.Write(Colors.Yellow, $@"[ShinraEx] Interrupting >>> {Core.Player.SpellCastInfo.Name}");
                        ActionManager.StopCasting();
                        await Coroutine.Wait(500, () => !Core.Player.IsCasting);
                    }
                }
            }

            #endregion

            #region CanCast

            switch (CastType)
            {
            case CastType.TargetLocation:
            case CastType.SelfLocation:
                if (!ActionManager.CanCastLocation(ID, target.Location) || Core.Player.IsCasting)
                {
                    return(false);
                }
                break;

            default:
                if (ShinraEx.Settings.QueueSpells && GCDType == GCDType.On)
                {
                    if (!ActionManager.CanCastOrQueue(DataManager.GetSpellData(ID), target))
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!ActionManager.CanCast(ID, target))
                    {
                        return(false);
                    }
                }

                break;
            }

            if (MovementManager.IsMoving && DataManager.GetSpellData(ID).AdjustedCastTime.TotalMilliseconds > 0)
            {
                if (!BotManager.Current.IsAutonomous)
                {
                    return(false);
                }
                Navigator.PlayerMover.MoveStop();
            }

            #endregion

            #region InView

            if (GameSettingsManager.FaceTargetOnAction == false && CastType == CastType.Target &&
                SpellType != SpellType.Heal &&
                SpellType != SpellType.Buff &&
                !Helpers.InView(Core.Player.Location, Core.Player.Heading, target.Location))
            {
                return(false);
            }

            #endregion

            #region GCD

            if (GCDType == GCDType.Off && checkGCDType)
            {
                switch (Core.Player.CurrentJob)
                {
                case ClassJobType.Arcanist:
                case ClassJobType.Scholar:
                case ClassJobType.Summoner:
                    if (DataManager.GetSpellData(163).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Archer:
                case ClassJobType.Bard:
                    if (DataManager.GetSpellData(97).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Astrologian:
                    if (DataManager.GetSpellData(3594).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Conjurer:
                case ClassJobType.WhiteMage:
                    if (DataManager.GetSpellData(119).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.DarkKnight:
                    if (DataManager.GetSpellData(3617).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Gladiator:
                case ClassJobType.Paladin:
                    if (DataManager.GetSpellData(9).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Lancer:
                case ClassJobType.Dragoon:
                    if (ID == 8801 || ID == 8802)
                    {
                        if (DataManager.GetSpellData(75).Cooldown.TotalMilliseconds < 1500)
                        {
                            return(false);
                        }
                        else if (DataManager.GetSpellData(75).Cooldown.TotalMilliseconds < 1000)
                        {
                            return(false);
                        }
                    }

                    break;

                case ClassJobType.Machinist:
                    if (DataManager.GetSpellData(2866).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Marauder:
                case ClassJobType.Warrior:
                    if (DataManager.GetSpellData(31).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Pugilist:
                case ClassJobType.Monk:
                    if (DataManager.GetSpellData(53).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.RedMage:
                    if (DataManager.GetSpellData(7504).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Rogue:
                case ClassJobType.Ninja:
                    if (DataManager.GetSpellData(2240).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Samurai:
                    if (DataManager.GetSpellData(7477).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Thaumaturge:
                case ClassJobType.BlackMage:
                    if (DataManager.GetSpellData(142).Cooldown.TotalMilliseconds < 1000)
                    {
                        return(false);
                    }
                    break;
                }
            }

            #endregion

            #region DoAction

            switch (CastType)
            {
            case CastType.TargetLocation:
                if (ShinraEx.Settings.RandomCastLocations)
                {
                    var randX       = target.CombatReach * _rand.NextDouble() * GetMultiplier();
                    var randZ       = target.CombatReach * _rand.NextDouble() * GetMultiplier();
                    var randXYZ     = new Vector3((float)randX, 0f, (float)randZ);
                    var newLocation = target.Location + randXYZ;

                    if (!await Coroutine.Wait(1000, () => ActionManager.DoActionLocation(ID, newLocation)))
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!await Coroutine.Wait(1000, () => ActionManager.DoActionLocation(ID, target.Location)))
                    {
                        return(false);
                    }
                }

                break;

            case CastType.SelfLocation:
                if (ShinraEx.Settings.RandomCastLocations)
                {
                    var randX       = (1f * _rand.NextDouble() + 1f) * GetMultiplier();
                    var randZ       = (1f * _rand.NextDouble() + 1f) * GetMultiplier();
                    var randXYZ     = new Vector3((float)randX, 0f, (float)randZ);
                    var newLocation = target.Location + randXYZ;

                    if (!await Coroutine.Wait(1000, () => ActionManager.DoActionLocation(ID, newLocation)))
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!await Coroutine.Wait(1000, () => ActionManager.DoActionLocation(ID, target.Location)))
                    {
                        return(false);
                    }
                }

                break;

            default:
                if (SpellType == SpellType.PVP)
                {
                    if (!await Coroutine.Wait(1000, () => ActionManager.DoPvPCombo(Combo, target)))
                    {
                        return(false);
                    }
                    Logging.Write(Colors.Orange, $@"DoAction Combo {Combo} 0x{target.ObjectId:X}");
                }
                else
                {
                    if (!await Coroutine.Wait(1000, () => ActionManager.DoAction(ID, target)))
                    {
                        return(false);
                    }
                }

                break;
            }

            #endregion

            #region Wait

            switch (CastType)
            {
            case CastType.SelfLocation:
            case CastType.TargetLocation:
                await Coroutine.Wait(3000, () => !ActionManager.CanCastLocation(ID, target.Location));

                break;

            default:
                await Coroutine.Wait(3000, () => !ActionManager.CanCast(ID, target));

                break;
            }

            #endregion

            ShinraEx.LastSpell = this;
            Logging.Write(Colors.GreenYellow,
                          $@"[ShinraEx] Casting >>> {Name}{(SpellType == SpellType.PVP ? " Combo" : "")}");

            #region AddRecent

            if (SpellType != SpellType.Damage && SpellType != SpellType.AoE && SpellType != SpellType.Heal &&
                SpellType != SpellType.PVP &&
                await CastComplete(this))
            {
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(3);
                RecentSpell.Add(key, val);
            }

            if (SpellType == SpellType.Damage || SpellType == SpellType.DoT)
            {
                if (!Helpers.OpenerFinished && !RecentSpell.ContainsKey("Opener") && await CastComplete(this, true))
                {
                    var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(3);
                    RecentSpell.Add("Opener", val);
                }
            }

            #endregion

            return(true);
        }
示例#5
0
 private static bool IsHealable(this GameObject c)
 {
     return(c.IsTargetable && c.InLineOfSight() && Core.Player.UnitDistance(c, 25, false));
 }
示例#6
0
        public async Task <bool> Cast(GameObject target = null)
        {
            #region Target
            if (target == null)
            {
                switch (CastType)
                {
                case CastType.TargetLocation:
                    if (!Core.Player.HasTarget)
                    {
                        return(false);
                    }
                    target = Core.Player.CurrentTarget;
                    break;

                case CastType.Target:
                    if (!Core.Player.HasTarget)
                    {
                        return(false);
                    }
                    target = Core.Player.CurrentTarget;
                    break;

                default:
                    target = Core.Player;
                    break;
                }
            }
            #endregion

            #region Recent Spell Check
            RecentSpell.RemoveAll(t => DateTime.UtcNow > t);

            if (RecentSpell.ContainsKey(target.ObjectId.ToString("X") + "-" + Name))
            {
                return(false);
            }
            #endregion

            #region Bard Song Check

            if (Core.Player.CurrentJob == ClassJobType.Bard &&
                SpellType == SpellType.Buff)
            {
                if (Core.Player.HasAura(135, true) ||
                    Core.Player.HasAura(137, true))
                {
                    return(false);
                }
            }

            #endregion

            #region AoE Check

            if (SpellType == SpellType.AoE &&
                Ultima.UltSettings.SmartTarget)
            {
                var EnemyCount = Helpers.EnemyUnit.Count(eu => eu.Distance2D(target) - eu.CombatReach - target.CombatReach <= DataManager.GetSpellData(ID).Radius);

                switch (Core.Player.CurrentJob)
                {
                case ClassJobType.Arcanist:
                case ClassJobType.Scholar:
                case ClassJobType.Summoner:
                    if (EnemyCount < 2)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Archer:
                case ClassJobType.Bard:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Astrologian:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Conjurer:
                case ClassJobType.WhiteMage:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.DarkKnight:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Gladiator:
                case ClassJobType.Paladin:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Lancer:
                case ClassJobType.Dragoon:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Machinist:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Marauder:
                case ClassJobType.Warrior:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Pugilist:
                case ClassJobType.Monk:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Rogue:
                case ClassJobType.Ninja:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Thaumaturge:
                case ClassJobType.BlackMage:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Samurai:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.RedMage:
                    if (EnemyCount < 3)
                    {
                        return(false);
                    }
                    break;
                }
            }

            #region Cone Check

            if (ID == 106 || ID == 41 || ID == 70)
            {
                if (!Helpers.InView(Core.Player.Location, Core.Player.Heading, target.Location))
                {
                    return(false);
                }
            }

            #endregion

            #region Rectangle Check

            if (ID == 86)
            {
                if (!Core.Player.IsFacing(target))
                {
                    return(false);
                }
            }

            #endregion

            #endregion

            #region Pet Exception
            if (SpellType == SpellType.Pet)
            {
                if (Core.Player.Pet == null)
                {
                    return(false);
                }

                if (PetManager.PetMode != PetMode.Obey)
                {
                    if (!await Coroutine.Wait(1000, () => PetManager.DoAction("Obey", Core.Player)))
                    {
                        return(false);
                    }
                    Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: Pet Obey");
                }

                #region IsMounted Check

                if (Core.Player.IsMounted)
                {
                    return(false);
                }

                #endregion

                #region CanCast

                if (!PetManager.CanCast(Name, target))
                {
                    return(false);
                }

                #endregion

                #region DoAction

                if (!await Coroutine.Wait(5000, () => PetManager.DoAction(Name, target)))
                {
                    return(false);
                }

                #endregion

                Ultima.LastSpell = this;

                #region Recent Spell Add
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(Name).AdjustedCastTime + TimeSpan.FromSeconds(5);
                RecentSpell.Add(key, val);
                #endregion

                Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);

                return(true);
            }
            #endregion

            #region Card Exception

            if (SpellType == SpellType.Card)
            {
                if (!await Coroutine.Wait(1000, () => ActionManager.DoAction(ID, target)))
                {
                    return(false);
                }
                Ultima.LastSpell = this;
                #region Recent Spell Add
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(3590).AdjustedCastTime + TimeSpan.FromSeconds(5);
                RecentSpell.Add(key, val);
                #endregion
                Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);
                return(true);
            }

            #endregion

            #region CanAttack Check

            if (!target.CanAttack &&
                CastType != CastType.Self)
            {
                switch (SpellType)
                {
                case SpellType.Damage:
                case SpellType.DoT:
                case SpellType.Movement:
                case SpellType.Cooldown:
                case SpellType.Interrupt:
                case SpellType.Execute:
                case SpellType.Knockback:
                case SpellType.Debuff:
                case SpellType.Flank:
                case SpellType.Behind:
                    return(false);
                }
            }

            #endregion

            #region Ninjutsu Exception

            if (SpellType == SpellType.Ninjutsu ||
                SpellType == SpellType.Mudra)
            {
                #region Player Movement

                if (BotManager.Current.IsAutonomous)
                {
                    switch (ActionManager.InSpellInRangeLOS(2247, target))
                    {
                    case SpellRangeCheck.ErrorNotInLineOfSight:
                        await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                        return(false);

                    case SpellRangeCheck.ErrorNotInRange:
                        await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                        return(false);

                    case SpellRangeCheck.ErrorNotInFront:
                        if (!target.InLineOfSight())
                        {
                            await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                            return(false);
                        }
                        target.Face();
                        return(false);

                    case SpellRangeCheck.Success:
                        if (MovementManager.IsMoving)
                        {
                            Navigator.PlayerMover.MoveStop();
                        }
                        break;
                    }
                }

                #endregion

                #region IsMounted Check

                if (Core.Player.IsMounted)
                {
                    return(false);
                }

                #endregion

                #region CanCast

                if (Ultima.UltSettings.QueueSpells)
                {
                    if (!ActionManager.CanCastOrQueue(DataManager.GetSpellData(ID), target))
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!ActionManager.CanCast(ID, target))
                    {
                        return(false);
                    }
                }

                #endregion

                #region Wait For Animation

                if (Ultima.LastSpell.ID != 0 &&
                    Ultima.LastSpell.SpellType != SpellType.Ninjutsu &&
                    Ultima.LastSpell.SpellType != SpellType.Mudra)
                {
                    await Coroutine.Wait(1000, () => DataManager.GetSpellData(Ultima.LastSpell.ID).Cooldown.TotalMilliseconds <= DataManager.GetSpellData(Ultima.LastSpell.ID).AdjustedCooldown.TotalMilliseconds - 1000);
                }

                #endregion

                #region DoAction

                if (!await Coroutine.Wait(1000, () => ActionManager.DoAction(ID, target)))
                {
                    return(false);
                }

                #endregion

                #region Wait For Cast Completion

                await Coroutine.Wait(2000, () => !ActionManager.CanCast(ID, target));

                #endregion

                Ultima.LastSpell = this;

                #region Recent Spell Add

                if (SpellType == SpellType.Mudra)
                {
                    var key = target.ObjectId.ToString("X") + "-" + Name;
                    var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(1);
                    RecentSpell.Add(key, val);
                }

                #endregion

                Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);

                return(true);
            }

            #endregion

            #region HasSpell Check

            if (!ActionManager.HasSpell(ID))
            {
                return(false);
            }

            #endregion

            #region Player Movement

            if (BotManager.Current.IsAutonomous)
            {
                switch (ActionManager.InSpellInRangeLOS(ID, target))
                {
                case SpellRangeCheck.ErrorNotInLineOfSight:
                    await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                    return(false);

                case SpellRangeCheck.ErrorNotInRange:
                    await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                    return(false);

                case SpellRangeCheck.ErrorNotInFront:
                    if (!target.InLineOfSight())
                    {
                        await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                        return(false);
                    }
                    target.Face();
                    return(false);

                case SpellRangeCheck.Success:
                    if (CastType == CastType.TargetLocation &&
                        Core.Player.Distance2D(target) + Core.Player.CombatReach + target.CombatReach > 25)
                    {
                        await CommonTasks.MoveAndStop(new MoveToParameters(target.Location), 0f);

                        await Coroutine.Wait(1000, () => Core.Player.Distance2D(target) + Core.Player.CombatReach + target.CombatReach <= 25);

                        return(false);
                    }
                    Navigator.PlayerMover.MoveStop();
                    break;
                }

                if (Core.Player.HasTarget &&
                    !MovementManager.IsMoving &&
                    Core.Player.IsMounted)
                {
                    Logging.Write(Colors.Yellow, @"[Ultima] Dismounting...");
                    ActionManager.Dismount();
                    await Coroutine.Sleep(1000);
                }
            }

            #endregion

            #region IsMounted Check

            if (Core.Player.IsMounted)
            {
                return(false);
            }

            #endregion

            #region CanCast Check

            switch (CastType)
            {
            case CastType.TargetLocation:
            case CastType.SelfLocation:
                if (!ActionManager.CanCastLocation(ID, target.Location))
                {
                    return(false);
                }
                break;

            default:
                if (Ultima.UltSettings.QueueSpells)
                {
                    if (!ActionManager.CanCastOrQueue(DataManager.GetSpellData(ID), target))
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!ActionManager.CanCast(ID, target))
                    {
                        return(false);
                    }
                }
                break;
            }

            if (MovementManager.IsMoving &&
                DataManager.GetSpellData(ID).AdjustedCastTime.TotalMilliseconds > 0)
            {
                if (!BotManager.Current.IsAutonomous)
                {
                    return(false);
                }
                Navigator.PlayerMover.MoveStop();
            }

            #endregion

            #region InView Check

            if (GameSettingsManager.FaceTargetOnAction == false &&
                CastType == CastType.Target &&
                SpellType != SpellType.Heal &&
                SpellType != SpellType.Defensive &&
                !Helpers.InView(Core.Player.Location, Core.Player.Heading, target.Location))
            {
                return(false);
            }

            #endregion

            #region Off-GCD Check
            if (GCDType == GCDType.Off)
            {
                switch (Core.Player.CurrentJob)
                {
                case ClassJobType.Arcanist:
                case ClassJobType.Scholar:
                case ClassJobType.Summoner:
                    if (Core.Player.ClassLevel >= 38 &&
                        Core.Player.CurrentManaPercent > 40 &&
                        DataManager.GetSpellData(163).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Archer:
                case ClassJobType.Bard:
                    if (DataManager.GetSpellData(97).Cooldown.TotalMilliseconds <= 700)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Astrologian:
                    if (DataManager.GetSpellData(3596).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Conjurer:
                case ClassJobType.WhiteMage:
                    if (DataManager.GetSpellData(119).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.DarkKnight:
                    if (DataManager.GetSpellData(3617).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Gladiator:
                case ClassJobType.Paladin:
                    if (DataManager.GetSpellData(9).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Lancer:
                case ClassJobType.Dragoon:
                    if (DataManager.GetSpellData(75).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Machinist:
                    if (DataManager.GetSpellData(2866).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Marauder:
                case ClassJobType.Warrior:
                    if (DataManager.GetSpellData(31).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Pugilist:
                case ClassJobType.Monk:
                    if (DataManager.GetSpellData(53).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Rogue:
                case ClassJobType.Ninja:
                    if (DataManager.GetSpellData(2240).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Thaumaturge:
                case ClassJobType.BlackMage:
                    if (DataManager.GetSpellData(142).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.Samurai:
                    if (DataManager.GetSpellData(8821).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;

                case ClassJobType.RedMage:
                    if (DataManager.GetSpellData(7503).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                    break;
                }
            }
            #endregion

            #region DoAction
            switch (CastType)
            {
            case CastType.TargetLocation:
                if (Ultima.UltSettings.RandomCastLocation)
                {
                    var rndx   = (target.CombatReach * _rnd.NextDouble() * GetMultiplier());
                    var rndz   = (target.CombatReach * _rnd.NextDouble() * GetMultiplier());
                    var rndxz  = new Vector3((float)rndx, 0f, (float)rndz);
                    var tarloc = target.Location;
                    var rndloc = tarloc + rndxz;

                    if (!await Coroutine.Wait(1000, () => ActionManager.DoActionLocation(ID, rndloc)))
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!await Coroutine.Wait(1000, () => ActionManager.DoActionLocation(ID, target.Location)))
                    {
                        return(false);
                    }
                }
                break;

            case CastType.SelfLocation:
                if (Ultima.UltSettings.RandomCastLocation)
                {
                    var rndx   = ((1f * _rnd.NextDouble() + 1f) * GetMultiplier());
                    var rndz   = ((1f * _rnd.NextDouble() + 1f) * GetMultiplier());
                    var rndxz  = new Vector3((float)rndx, 0f, (float)rndz);
                    var tarloc = target.Location;
                    var rndloc = tarloc + rndxz;

                    if (!await Coroutine.Wait(1000, () => ActionManager.DoActionLocation(ID, rndloc)))
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!await Coroutine.Wait(1000, () => ActionManager.DoActionLocation(ID, target.Location)))
                    {
                        return(false);
                    }
                }
                break;

            default:
                if (!await Coroutine.Wait(1000, () => ActionManager.DoAction(ID, target)))
                {
                    return(false);
                }
                break;
            }
            #endregion

            #region Wait For Cast Completion

            switch (CastType)
            {
            case CastType.SelfLocation:
            case CastType.TargetLocation:
                await Coroutine.Wait(3000, () => !ActionManager.CanCastLocation(ID, target.Location));

                break;

            default:
                await Coroutine.Wait(3000, () => !ActionManager.CanCast(ID, target));

                break;
            }

            #endregion

            Ultima.LastSpell = this;

            #region Recent Spell Add
            if (SpellType != SpellType.Damage &&
                SpellType != SpellType.Heal &&
                SpellType != SpellType.AoE &&
                SpellType != SpellType.Behind &&
                SpellType != SpellType.Flank)
            {
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(5);
                RecentSpell.Add(key, val);
            }
            if (SpellType == SpellType.Heal)
            {
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(3);
                RecentSpell.Add(key, val);
            }
            #endregion

            Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);

            return(true);
        }
示例#7
0
        public async Task <bool> Cast(GameObject target = null)
        {
            #region Target
            if (target == null)
            {
                switch (CastType)
                {
                case CastType.Location:
                    if (!Core.Player.HasTarget)
                    {
                        return(false);
                    }
                    target = Core.Player.CurrentTarget;
                    break;

                case CastType.Target:
                    if (!Core.Player.HasTarget)
                    {
                        return(false);
                    }
                    target = Core.Player.CurrentTarget;
                    break;

                default:
                    target = Core.Player;
                    break;
                }
            }
            #endregion

            #region Recent Spell Check
            RecentSpell.RemoveAll(t => DateTime.UtcNow > t);

            if (RecentSpell.ContainsKey(target.ObjectId.ToString("X") + "-" + Name))
            {
                return(false);
            }
            #endregion

            #region Pet Exception
            if (SpellType == SpellType.Pet)
            {
                if (Core.Player.Pet == null)
                {
                    return(false);
                }
                if (Pet.PetMode != PetMode.Obey)
                {
                    await Coroutine.Wait(1000, () => Pet.DoAction("Obey", Core.Player));
                }
                if (!Pet.CanCast(Name, target))
                {
                    return(false);
                }
                if (!await Coroutine.Wait(5000, () => Pet.DoAction(Name, target)))
                {
                    return(false);
                }
                Ultima.LastSpell = this;
                #region Recent Spell Add
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(Name).AdjustedCastTime + TimeSpan.FromSeconds(5);
                RecentSpell.Add(key, val);
                #endregion
                Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);
                return(true);
            }
            #endregion

            #region Ninjutsu Exception
            if (SpellType == SpellType.Ninjutsu)
            {
                if (BotManager.Current.IsAutonomous &&
                    Core.Player.HasTarget)
                {
                    switch (Actionmanager.InSpellInRangeLOS(2247, target))
                    {
                    case SpellRangeCheck.ErrorNotInLineOfSight:
                        Navigator.MoveTo(target.Location);
                        return(true);

                    case SpellRangeCheck.ErrorNotInRange:
                        Navigator.MoveTo(target.Location);
                        return(true);

                    case SpellRangeCheck.ErrorNotInFront:
                        if (!target.InLineOfSight())
                        {
                            Navigator.MoveTo(target.Location);
                            return(true);
                        }
                        target.Face();
                        return(true);
                    }
                    if (MovementManager.IsMoving &&
                        target.InLineOfSight() &&
                        Core.Player.Distance(target) <= 15 &&
                        Core.Player.IsFacing(target))
                    {
                        Navigator.PlayerMover.MoveStop();
                    }
                }
                if (!await Coroutine.Wait(1000, () => Actionmanager.DoAction(ID, target)))
                {
                    return(false);
                }
                Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);
                return(true);
            }
            #endregion

            #region Player Movement
            if (BotManager.Current.IsAutonomous &&
                Core.Player.HasTarget)
            {
                switch (Actionmanager.InSpellInRangeLOS(ID, target))
                {
                case SpellRangeCheck.ErrorNotInLineOfSight:
                    Navigator.MoveTo(target.Location);
                    return(false);

                case SpellRangeCheck.ErrorNotInRange:
                    Navigator.MoveTo(target.Location);
                    return(false);

                case SpellRangeCheck.ErrorNotInFront:
                    if (!target.InLineOfSight())
                    {
                        Navigator.MoveTo(target.Location);
                        return(false);
                    }
                    target.Face();
                    return(false);
                }
                if (MovementManager.IsMoving &&
                    target.InLineOfSight() &&
                    Core.Player.Distance(target) <= (DataManager.GetSpellData(ID).Range + Core.Player.CombatReach + target.CombatReach) &&
                    Core.Player.IsFacing(target))
                {
                    Navigator.PlayerMover.MoveStop();
                }
            }
            #endregion

            #region CanCast Check
            if (!Actionmanager.CanCast(ID, target))
            {
                return(false);
            }

            if (MovementManager.IsMoving &&
                DataManager.GetSpellData(ID).AdjustedCastTime.TotalMilliseconds > 0)
            {
                if (!BotManager.Current.IsAutonomous)
                {
                    return(false);
                }
                Navigator.PlayerMover.MoveStop();
            }
            #endregion

            #region Off-GCD Check
            if (GCDType == GCDType.Off)
            {
                if (Core.Player.CurrentJob == ClassJobType.Arcanist ||
                    Core.Player.CurrentJob == ClassJobType.Scholar ||
                    Core.Player.CurrentJob == ClassJobType.Summoner)
                {
                    if (Core.Player.ClassLevel >= 38 &&
                        Core.Player.CurrentManaPercent > 40 &&
                        DataManager.GetSpellData(163).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
                if (Core.Player.CurrentJob == ClassJobType.Archer ||
                    Core.Player.CurrentJob == ClassJobType.Bard)
                {
                    if (DataManager.GetSpellData(97).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
                if (Core.Player.CurrentJob == ClassJobType.Conjurer ||
                    Core.Player.CurrentJob == ClassJobType.WhiteMage)
                {
                    if (DataManager.GetSpellData(119).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
                if (Core.Player.CurrentJob == ClassJobType.Gladiator ||
                    Core.Player.CurrentJob == ClassJobType.Paladin)
                {
                    if (DataManager.GetSpellData(9).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
                if (Core.Player.CurrentJob == ClassJobType.Lancer ||
                    Core.Player.CurrentJob == ClassJobType.Dragoon)
                {
                    if (DataManager.GetSpellData(75).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
                if (Core.Player.CurrentJob == ClassJobType.Marauder ||
                    Core.Player.CurrentJob == ClassJobType.Warrior)
                {
                    if (DataManager.GetSpellData(31).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
                if (Core.Player.CurrentJob == ClassJobType.Pugilist ||
                    Core.Player.CurrentJob == ClassJobType.Monk)
                {
                    if (DataManager.GetSpellData(53).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
                if (Core.Player.CurrentJob == ClassJobType.Rogue ||
                    Core.Player.CurrentJob == ClassJobType.Ninja)
                {
                    if (DataManager.GetSpellData(2240).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
                if (Core.Player.CurrentJob == ClassJobType.Thaumaturge ||
                    Core.Player.CurrentJob == ClassJobType.BlackMage)
                {
                    if (DataManager.GetSpellData(142).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return(false);
                    }
                }
            }
            #endregion

            #region DoAction
            if (CastType == CastType.Location)
            {
                if (!await Coroutine.Wait(1000, () => Actionmanager.DoActionLocation(ID, target.Location)))
                {
                    return(false);
                }
            }
            else
            {
                if (!await Coroutine.Wait(1000, () => Actionmanager.DoAction(ID, target)))
                {
                    return(false);
                }
            }
            #endregion
            Ultima.LastSpell = this;
            #region Recent Spell Add
            if (SpellType != SpellType.Damage &&
                SpellType != SpellType.Behind &&
                SpellType != SpellType.Flank)
            {
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(5);
                RecentSpell.Add(key, val);
            }
            #endregion
            Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);
            await Coroutine.Wait(3000, () => !Actionmanager.CanCast(ID, target));

            return(true);
        }
        public async Task<bool> Cast(GameObject target = null)
        {
            #region Target
            if (target == null)
            {
                switch (CastType)
                {
                    case CastType.TargetLocation:
                        if (!Core.Player.HasTarget)
                        {
                            return false;
                        }
                        target = Core.Player.CurrentTarget;
                        break;
                    case CastType.Target:
                        if (!Core.Player.HasTarget)
                        {
                            return false;
                        }
                        target = Core.Player.CurrentTarget;
                        break;
                    default:
                        target = Core.Player;
                        break;
                }
            }
            #endregion

            #region Recent Spell Check
            RecentSpell.RemoveAll(t => DateTime.UtcNow > t);

            if (RecentSpell.ContainsKey(target.ObjectId.ToString("X") + "-" + Name))
            {
                return false;
            }
            #endregion

            #region Bard Song Check

            if (Core.Player.CurrentJob == ClassJobType.Bard &&
                SpellType == SpellType.Buff)
            {
                if (Core.Player.HasAura(135, true) ||
                    Core.Player.HasAura(137, true))
                {
                    return false;
                }
            }

            #endregion

            #region AoE Check

            if (SpellType == SpellType.AoE &&
                Ultima.UltSettings.SmartTarget)
            {
                var EnemyCount = Helpers.EnemyUnit.Count(eu => eu.Distance2D(target) - eu.CombatReach - target.CombatReach <= DataManager.GetSpellData(ID).Radius);

                switch (Core.Player.CurrentJob)
                {
                    case ClassJobType.Arcanist:
                    case ClassJobType.Scholar:
                    case ClassJobType.Summoner:
                        if (EnemyCount < 2)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Archer:
                    case ClassJobType.Bard:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Astrologian:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Conjurer:
                    case ClassJobType.WhiteMage:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.DarkKnight:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Gladiator:
                    case ClassJobType.Paladin:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Lancer:
                    case ClassJobType.Dragoon:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Machinist:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Marauder:
                    case ClassJobType.Warrior:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Pugilist:
                    case ClassJobType.Monk:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Rogue:
                    case ClassJobType.Ninja:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                    case ClassJobType.Thaumaturge:
                    case ClassJobType.BlackMage:
                        if (EnemyCount < 3)
                        {
                            return false;
                        }
                        break;
                }
            }

            #region Cone Check

            if (ID == 106 || ID == 41 || ID == 70)
            {
                if (!Helpers.InView(Core.Player.Location, Core.Player.Heading, target.Location))
                {
                    return false;
                }
            }

            #endregion

            #region Rectangle Check

            if (ID == 86)
            {
                if (!Core.Player.IsFacing(target))
                {
                    return false;
                }
            }

            #endregion

            #endregion

            #region Pet Exception
            if (SpellType == SpellType.Pet)
            {
                if (Core.Player.Pet == null)
                {
                    return false;
                }

                if (Pet.PetMode != PetMode.Obey)
                {
                    if (!await Coroutine.Wait(1000, () => Pet.DoAction("Obey", Core.Player)))
                    {
                        return false;
                    }
                    Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: Pet Obey");
                }

                #region IsMounted Check

                if (Core.Player.IsMounted)
                {
                    return false;
                }

                #endregion

                #region CanCast

                if (!Pet.CanCast(Name, target))
                {
                    return false;
                }

                #endregion

                #region DoAction

                if (!await Coroutine.Wait(5000, () => Pet.DoAction(Name, target)))
                {
                    return false;
                }

                #endregion

                Ultima.LastSpell = this;

                #region Recent Spell Add
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(Name).AdjustedCastTime + TimeSpan.FromSeconds(5);
                RecentSpell.Add(key, val);
                #endregion

                Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);

                return true;
            }
            #endregion

            #region Card Exception

            if (SpellType == SpellType.Card)
            {
                if (!await Coroutine.Wait(1000, () => Actionmanager.DoAction(ID, target)))
                {
                    return false;
                }
                Ultima.LastSpell = this;
                #region Recent Spell Add
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(3590).AdjustedCastTime + TimeSpan.FromSeconds(5);
                RecentSpell.Add(key, val);
                #endregion
                Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);
                return true;
            }

            #endregion

            #region CanAttack Check

            if (!target.CanAttack &&
                CastType != CastType.Self)
            {
                switch (SpellType)
                {
                    case SpellType.Damage:
                    case SpellType.DoT:
                    case SpellType.Movement:
                    case SpellType.Cooldown:
                    case SpellType.Interrupt:
                    case SpellType.Execute:
                    case SpellType.Knockback:
                    case SpellType.Debuff:
                    case SpellType.Flank:
                    case SpellType.Behind:
                        return false;
                }
            }

            #endregion

            #region Ninjutsu Exception

            if (SpellType == SpellType.Ninjutsu ||
                SpellType == SpellType.Mudra)
            {
                #region Player Movement

                if (BotManager.Current.IsAutonomous)
                {
                    switch (Actionmanager.InSpellInRangeLOS(2247, target))
                    {
                        case SpellRangeCheck.ErrorNotInLineOfSight:
                            Navigator.MoveTo(target.Location);
                            return false;
                        case SpellRangeCheck.ErrorNotInRange:
                            Navigator.MoveTo(target.Location);
                            return false;
                        case SpellRangeCheck.ErrorNotInFront:
                            if (!target.InLineOfSight())
                            {
                                Navigator.MoveTo(target.Location);
                                return false;
                            }
                            target.Face();
                            return false;
                        case SpellRangeCheck.Success:
                            if (MovementManager.IsMoving)
                            {
                                Navigator.PlayerMover.MoveStop();
                            }
                            break;
                    }
                }

                #endregion

                #region IsMounted Check

                if (Core.Player.IsMounted)
                {
                    return false;
                }

                #endregion

                #region CanCast

                if (Ultima.UltSettings.QueueSpells)
                {
                    if (!Actionmanager.CanCastOrQueue(DataManager.GetSpellData(ID), target))
                    {
                        return false;
                    }
                }
                else
                {
                    if (!Actionmanager.CanCast(ID, target))
                    {
                        return false;
                    }
                }

                #endregion

                #region Wait For Animation

                if (Ultima.LastSpell.ID != null &&
                    Ultima.LastSpell.SpellType != SpellType.Ninjutsu &&
                    Ultima.LastSpell.SpellType != SpellType.Mudra)
                {
                    await Coroutine.Wait(1000, () => DataManager.GetSpellData(Ultima.LastSpell.ID).Cooldown.TotalMilliseconds <= DataManager.GetSpellData(Ultima.LastSpell.ID).AdjustedCooldown.TotalMilliseconds - 1000);
                }

                #endregion

                #region DoAction

                if (!await Coroutine.Wait(1000, () => Actionmanager.DoAction(ID, target)))
                {
                    return false;
                }

                #endregion

                #region Wait For Cast Completion

                await Coroutine.Wait(2000, () => !Actionmanager.CanCast(ID, target));

                #endregion

                Ultima.LastSpell = this;

                #region Recent Spell Add

                if (SpellType == SpellType.Mudra)
                {
                    var key = target.ObjectId.ToString("X") + "-" + Name;
                    var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(1);
                    RecentSpell.Add(key, val);
                }

                #endregion

                Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);

                return true;
            }

            #endregion

            #region HasSpell Check

            if (!Actionmanager.HasSpell(ID))
            {
                return false;
            }

            #endregion

            #region Player Movement

            if (BotManager.Current.IsAutonomous)
            {
                switch (Actionmanager.InSpellInRangeLOS(ID, target))
                {
                    case SpellRangeCheck.ErrorNotInLineOfSight:
                        Navigator.MoveTo(target.Location);
                        return false;
                    case SpellRangeCheck.ErrorNotInRange:
                        Navigator.MoveTo(target.Location);
                        return false;
                    case SpellRangeCheck.ErrorNotInFront:
                        if (!target.InLineOfSight())
                        {
                            Navigator.MoveTo(target.Location);
                            return false;
                        }
                        target.Face();
                        return false;
                    case SpellRangeCheck.Success:
                        if (CastType == CastType.TargetLocation &&
                            Core.Player.Distance2D(target) + Core.Player.CombatReach + target.CombatReach > 25)
                        {
                            Navigator.MoveTo(target.Location);
                            await Coroutine.Wait(1000, () => Core.Player.Distance2D(target) + Core.Player.CombatReach + target.CombatReach <= 25);
                            return false;
                        }
                        Navigator.PlayerMover.MoveStop();
                        break;
                }

                if (Core.Player.HasTarget &&
                    !MovementManager.IsMoving &&
                    Core.Player.IsMounted)
                {
                    Logging.Write(Colors.Yellow, @"[Ultima] Dismounting...");
                    Actionmanager.Dismount();
                    await Coroutine.Sleep(1000);
                }
            }

            #endregion

            #region IsMounted Check

            if (Core.Player.IsMounted)
            {
                return false;
            }

            #endregion

            #region CanCast Check

            switch (CastType)
            {
                case CastType.TargetLocation:
                case CastType.SelfLocation:
                    if (!Actionmanager.CanCastLocation(ID, target.Location))
                    {
                        return false;
                    }
                    break;
                default:
                    if (Ultima.UltSettings.QueueSpells)
                    {
                        if (!Actionmanager.CanCastOrQueue(DataManager.GetSpellData(ID), target))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (!Actionmanager.CanCast(ID, target))
                        {
                            return false;
                        }
                    }
                break;
            }

            if (MovementManager.IsMoving &&
                DataManager.GetSpellData(ID).AdjustedCastTime.TotalMilliseconds > 0)
            {
                if (!BotManager.Current.IsAutonomous)
                {
                    return false;
                }
                Navigator.PlayerMover.MoveStop();
            }

            #endregion

            #region InView Check

            if (GameSettingsManager.FaceTargetOnAction == false &&
                CastType == CastType.Target &&
                SpellType != SpellType.Heal &&
                SpellType != SpellType.Defensive &&
                !Helpers.InView(Core.Player.Location, Core.Player.Heading, target.Location))
            {
                return false;
            }

            #endregion

            #region Off-GCD Check
            if (GCDType == GCDType.Off)
            {
                switch (Core.Player.CurrentJob)
                {
                    case ClassJobType.Arcanist:
                    case ClassJobType.Scholar:
                    case ClassJobType.Summoner:
                    if (Core.Player.ClassLevel >= 38 &&
                        Core.Player.CurrentManaPercent > 40 &&
                        DataManager.GetSpellData(163).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Archer:
                    case ClassJobType.Bard:
                    if (DataManager.GetSpellData(97).Cooldown.TotalMilliseconds <= 700)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Astrologian:
                    if (DataManager.GetSpellData(3596).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Conjurer:
                    case ClassJobType.WhiteMage:
                    if (DataManager.GetSpellData(119).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.DarkKnight:
                    if (DataManager.GetSpellData(3617).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Gladiator:
                    case ClassJobType.Paladin:
                    if (DataManager.GetSpellData(9).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Lancer:
                    case ClassJobType.Dragoon:
                    if (DataManager.GetSpellData(75).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Machinist:
                    if (DataManager.GetSpellData(2866).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Marauder:
                    case ClassJobType.Warrior:
                    if (DataManager.GetSpellData(31).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Pugilist:
                    case ClassJobType.Monk:
                    if (DataManager.GetSpellData(53).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Rogue:
                    case ClassJobType.Ninja:
                    if (DataManager.GetSpellData(2240).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                    case ClassJobType.Thaumaturge:
                    case ClassJobType.BlackMage:
                    if (DataManager.GetSpellData(142).Cooldown.TotalMilliseconds <= 1000)
                    {
                        return false;
                    }
                    break;
                }
            }
            #endregion

            #region Cleric Stance Check

            if (Actionmanager.HasSpell(122))
            {
                switch (Core.Player.HasAura("Cleric Stance"))
                {
                    case true:
                        if (SpellType == SpellType.Heal)
                        {
                            await Coroutine.Wait(1000, () => Actionmanager.DoAction(122, Core.Player));
                            Logging.Write(Colors.OrangeRed, @"[Ultima] Removing Cleric Stance");
                            await Coroutine.Wait(3000, () => !Core.Player.HasAura(145));
                        }
                        break;
                    case false:
                        if (SpellType == SpellType.Damage ||
                            SpellType == SpellType.DoT)
                        {
                            await Coroutine.Wait(1000, () => Actionmanager.DoAction(122, Core.Player));
                            Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: Cleric Stance");
                            await Coroutine.Wait(3000, () => Core.Player.HasAura(145));
                        }
                        break;
                }
            }

            #endregion

            #region DoAction
            switch (CastType)
            {
                case CastType.TargetLocation:
                    if (Ultima.UltSettings.RandomCastLocation)
                    {
                        var rndx = (target.CombatReach * _rnd.NextDouble() * GetMultiplier());
                        var rndz = (target.CombatReach * _rnd.NextDouble() * GetMultiplier());
                        var rndxz = new Vector3((float)rndx, 0f, (float)rndz);
                        var tarloc = target.Location;
                        var rndloc = tarloc + rndxz;

                        if (!await Coroutine.Wait(1000, () => Actionmanager.DoActionLocation(ID, rndloc)))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (!await Coroutine.Wait(1000, () => Actionmanager.DoActionLocation(ID, target.Location)))
                        {
                            return false;
                        }
                    }
                    break;
                case CastType.SelfLocation:
                    if (Ultima.UltSettings.RandomCastLocation)
                    {
                        var rndx = ((1f * _rnd.NextDouble() + 1f) * GetMultiplier());
                        var rndz = ((1f * _rnd.NextDouble() + 1f) * GetMultiplier());
                        var rndxz = new Vector3((float)rndx, 0f, (float)rndz);
                        var tarloc = target.Location;
                        var rndloc = tarloc + rndxz;

                        if (!await Coroutine.Wait(1000, () => Actionmanager.DoActionLocation(ID, rndloc)))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (!await Coroutine.Wait(1000, () => Actionmanager.DoActionLocation(ID, target.Location)))
                        {
                            return false;
                        }
                    }
                    break;
                default:
                    if (!await Coroutine.Wait(1000, () => Actionmanager.DoAction(ID, target)))
                    {
                        return false;
                    }
                    break;
            }
            #endregion

            #region Wait For Cast Completion

            switch (CastType)
            {
                case CastType.SelfLocation:
                case CastType.TargetLocation:
                    await Coroutine.Wait(3000, () => !Actionmanager.CanCastLocation(ID, target.Location));
                    break;
                default:
                    await Coroutine.Wait(3000, () => !Actionmanager.CanCast(ID, target));
                    break;
            }

            #endregion

            Ultima.LastSpell = this;

            #region Recent Spell Add
            if (SpellType != SpellType.Damage &&
                SpellType != SpellType.Heal &&
                SpellType != SpellType.AoE &&
                SpellType != SpellType.Behind &&
                SpellType != SpellType.Flank)
            {
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(5);
                RecentSpell.Add(key, val);
            }
            if (SpellType == SpellType.Heal)
            {
                var key = target.ObjectId.ToString("X") + "-" + Name;
                var val = DateTime.UtcNow + DataManager.GetSpellData(ID).AdjustedCastTime + TimeSpan.FromSeconds(3);
                RecentSpell.Add(key, val);
            }
            #endregion

            Logging.Write(Colors.OrangeRed, @"[Ultima] Ability: " + Name);

            return true;
        }
示例#9
0
#pragma warning disable 1998
        public static async Task CheckFace(GameObject o)
#pragma warning restore 1998
        {//&& !Helpers.Rogue.me.MovementInfo.IsStrafing
            if (InternalSettings.Instance.General.Movement && o != null && MovementManager.IsMoving 
                && !TooClose(o) && o.InLineOfSight() && !IsFacingMovement(Core.Player, o)
                ) Face(o);
        }
示例#10
0
#pragma warning disable 1998
        public static async Task<bool> PullMove(GameObject o)
#pragma warning restore 1998
        {
            if (!InternalSettings.Instance.General.Movement || o == null) return false;
            CheckRangeToggle(o);
            OldTargetLocation = Core.Player.CurrentTarget.Location;
            if (o.InLineOfSight() && IsInSafeRange(o))
            {
                StopMove();
                return false;
            }
            if (!(MovementManager.IsMoving && IsFacingMovement(Core.Player, o))) MoveTo(o);
            return true;
        }
示例#11
0
        public static MoveResult MoveTo(GameObject o)
        {//Math.Abs(o.Z - Core.Player.Z) > 1 ?
            //MovementManager.IsMoving && Movement.IsFacingMovement(Core.Player, o)
            if (o == null) return MoveResult.Failed;
            if (MovementManager.IsMoving && IsFacingMovement(Core.Player, o)) return MoveResult.Moving;
            if (!o.InLineOfSight() || Running || !InternalSettings.Instance.General.MeshFreeMovement
                || (Core.Player.Location.Z + 2) < o.Location.Z 
                || InternalSettings.Instance.General.MeshOnStillTargets && Core.Player.CurrentTarget.Distance2D(OldTargetLocation) < 0.05)
            {
                MoveResult mr = Navigator.MoveTo(o.Location);
                if (mr == MoveResult.ReachedDestination)
                {
                    StopMove();
                    Logging.Write(Colors.OrangeRed, "[YourRaidingBuddy] Location Reached?");
                    return mr;
                }//add timer for generating/ed
                if (mr != MoveResult.Moving)
                    Logging.Write(Colors.OrangeRed, "[YourRaidingBuddy] Movement Result: " + mr);
                if (mr == MoveResult.Done || mr == MoveResult.Moved || mr == MoveResult.Moving 
                    || mr == MoveResult.GeneratingPath || mr == MoveResult.PathGenerated) 
                    return mr;

            }
            if (InternalSettings.Instance.General.MeshFreeMovement)
            {
                Navigator.Clear();
                Logging.Write(Colors.OrangeRed, "[YourRaidingBuddy] Moving Mesh Free");
                MyMover.MoveTowards(o.Location); 
            }
            //MathEx.GetPointAt(o.Location, CombatMovementRange(o), MathEx.NormalizeRadian(MathHelper.CalculateHeading(Core.Player.Location, o.Location))));
            return MoveResult.Moving;
            //return !o.InLineOfSight() ? Navigator.MoveTo(o.Location) : Navigator.NavigationProvider.MoveToRandomSpotWithin(MathEx.GetPointAt(o.Location, CombatMovementRange(o), MathEx.NormalizeRadian(MathHelper.CalculateHeading(Core.Player.Location, Core.Player.CurrentTarget.Location))), 1f);
        }