Пример #1
0
        private async Task <bool> UseSummoningBell()
        {
            GameObject bell = HelperFunctions.NearestSummoningBell();

            if (bell == null)
            {
                LogCritical("No summoning bell near by");
                return(false);
            }

            if (bell.Distance2D(Core.Me.Location) >= 3)
            {
                await MoveSummoningBell(bell.Location);

                if (bell.Distance2D(Core.Me.Location) >= 3)
                {
                    return(false);
                }
            }

            bell.Interact();
            // No need to wait on IsOpen when we already do it in the main task.
            await Coroutine.Wait(5000, () => RetainerList.IsOpen().Result);

            LogVerbose("Summoning Bell Used");

            return(true);
        }
Пример #2
0
        private float SortComplete(GameObject obj)
        {
            var weight = 150f;

            if (PartyManager.IsInParty && !PartyManager.IsPartyLeader && !DeepDungeonManager.BossFloor)
            {
                if (PartyManager.PartyLeader.IsInObjectManager && PartyManager.PartyLeader.CurrentHealth > 0)
                {
                    if (PartyManager.PartyLeader.BattleCharacter.HasTarget)
                    {
                        if (obj.ObjectId == PartyManager.PartyLeader.BattleCharacter.TargetGameObject.ObjectId)
                        {
                            weight += 600;
                        }
                    }
                    weight -= obj.Distance2D(PartyManager.PartyLeader.GameObject);
                }
                else
                {
                    if (FloorExit.location != Vector3.Zero)
                    {
                        weight -= Core.Me.Distance2D(Vector3.Lerp(obj.Location, FloorExit.location, 0.25f));
                    }
                }
            }
            else
            {
                if (FloorExit.location != Vector3.Zero)
                {
                    weight -= Core.Me.Distance2D(Vector3.Lerp(obj.Location, FloorExit.location, 0.25f));
                }
                else
                {
                    weight -= obj.Distance2D();
                }
            }

            switch (obj.Type)
            {
            case GameObjectType.BattleNpc when !PartyManager.IsInParty:
                return(weight / 2);

            case GameObjectType.BattleNpc:
                weight /= 2;
                break;

            case GameObjectType.Treasure:
                break;
            }

            if (DeepDungeonManager.PortalActive && Settings.Instance.GoForTheHoard && obj.NpcId == EntityNames.Hidden)
            {
                weight += 5;
            }

            return(weight);
        }
        public static float Sort(GameObject obj)
        {
            var weight = 150f;

            if (PartyManager.IsInParty && !PartyManager.IsPartyLeader && !DeepDungeonManager.BossFloor)
            {
                if (PartyManager.PartyLeader.IsInObjectManager && PartyManager.PartyLeader.CurrentHealth > 0)
                {
                    if (PartyManager.PartyLeader.BattleCharacter.HasTarget)
                    {
                        if (obj.ObjectId == PartyManager.PartyLeader.BattleCharacter.TargetGameObject.ObjectId)
                        {
                            weight += 600;
                        }
                    }
                    weight -= obj.Distance2D(PartyManager.PartyLeader.GameObject);
                }
                else
                {
                    weight -= obj.Distance2D();
                }
            }
            else
            {
                weight -= obj.Distance2D();
            }



            switch (obj.Type)
            {
            case GameObjectType.BattleNpc:
                weight /= 2;
                if ((obj as BattleCharacter).IsTargetingMyPartyMember())
                {
                    weight += 100;
                }
                break;

            case GameObjectType.Treasure:
                //weight += 10;
                break;
            }

            /*
             * if (obj.NpcId == EntityNames.BandedCoffer)
             *  weight += 500;
             *
             * if (obj.NpcId == EntityNames.BandedCoffer && !Blacklist.Contains(obj.ObjectId)) weight += 200;
             */

            return(weight);
        }
Пример #4
0
        private float Sort(GameObject obj)
        {
            var weight = 100f;

            weight -= obj.Distance2D();

            if (obj.Type == GameObjectType.BattleNpc)
            {
                return(weight / 2);
            }

            if (obj.NpcId == EntityNames.BandedCoffer)
            {
                weight += 500;
            }

            if (DeepDungeonManager.PortalActive && Settings.Instance.GoForTheHoard && (obj.NpcId == EntityNames.Hidden))
            {
                weight += 5;
            }
            else if (DeepDungeonManager.PortalActive && Settings.Instance.GoExit && obj.NpcId != EntityNames.OfPassage && PartyManager.IsInParty)
            {
                weight -= 10;
            }

            return(weight);
        }
Пример #5
0
        public static GameObject NearestSummoningBell()
        {
            List <GameObject> list = GameObjectManager.GameObjects
                                     .Where(r => r.Name ==
#if RB_CN
                                            "传唤铃"
#else
                                            "Summoning Bell"
#endif
                                            )
                                     .OrderBy(j => j.Distance())
                                     .ToList();

            if (list.Count <= 0)
            {
                LogCritical("No Summoning Bell Found");
                return(null);
            }

            GameObject bell = list[0];

            LogCritical("Found nearest bell: {0} Distance: {1}", bell, bell.Distance2D(Core.Me.Location));

            return(bell);
        }
Пример #6
0
        public override float Sort(GameObject obj)
        {
            var weight = 150f;

            if (PartyManager.IsInParty && !PartyManager.IsPartyLeader && !DeepDungeonManager.BossFloor)
            {
                if (PartyManager.PartyLeader.IsInObjectManager && PartyManager.PartyLeader.CurrentHealth > 0)
                {
                    if (PartyManager.PartyLeader.BattleCharacter.HasTarget)
                    {
                        if (obj.ObjectId == PartyManager.PartyLeader.BattleCharacter.TargetGameObject.ObjectId)
                        {
                            weight += 600;
                        }
                    }
                    weight -= obj.Distance2D(PartyManager.PartyLeader.GameObject);
                }
                else
                {
                    weight -= obj.Distance2D();
                }
            }
            else
            {
                weight -= obj.Distance2D();
            }

            switch (obj.Type)
            {
            case GameObjectType.BattleNpc:
                weight /= 2;
                if ((obj as BattleCharacter).IsTargetingMyPartyMember())
                {
                    weight += 100;
                }
                break;

            case GameObjectType.Treasure:
                //weight += 10;
                break;
            }

            return(weight);
        }
Пример #7
0
 public static bool IsInSafeRange(GameObject o)
 {
     if (o == null) return false;
     switch (Core.Player.CurrentJob)
     {
         case ClassJobType.Ninja:
         case ClassJobType.Rogue:
         case ClassJobType.Dragoon:
         case ClassJobType.Lancer:
         case ClassJobType.Monk:
         case ClassJobType.Pugilist:
         case ClassJobType.Marauder:
         case ClassJobType.Warrior:
         case ClassJobType.Gladiator:
         case ClassJobType.Paladin:
             return o.Distance2D() < CombatMovementRange(o);
         default:
             return o.Distance2D() < ObjectSpellRange(o);
     }
 }
Пример #8
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);
        }
Пример #9
0
        public static float CombatDistance(this GameObject target)
        {
            if (target == null)
            {
                return(0);
            }
            var increment = BotBase.Instance.EnableCombatReachIncrement ? BotBase.Instance.CombatReachIncrement : 0;
            var targetCR  = target.CombatReach;

            if (WorldManager.InPvP && target is BattleCharacter b && !b.HasAura(1420))
            {
                targetCR = 0.5f;
            }

            //return Core.Me.Distance2D(target) - Core.Me.CombatReach - targetCR - increment;
            return(target.Distance2D() - 0.5f - targetCR - increment);
        }
Пример #10
0
        private float Sort(GameObject obj)
        {
            float weight = 100f;


            //weight -= obj.Distance2D();

            if (PartyManager.IsInParty && !PartyManager.IsPartyLeader && !DeepDungeonManager.BossFloor)
            {
                if (PartyManager.PartyLeader.IsInObjectManager && PartyManager.PartyLeader.CurrentHealth > 0)
                {
                    if (PartyManager.PartyLeader.BattleCharacter.HasTarget)
                    {
                        if (obj.ObjectId == PartyManager.PartyLeader.BattleCharacter.TargetGameObject.ObjectId)
                        {
                            weight += 600;
                        }
                    }
                    weight -= obj.Distance2D(PartyManager.PartyLeader.GameObject);
                }
                else
                {
                    weight -= obj.Distance2D();
                }
            }
            else
            {
                weight -= obj.Distance2D();
            }

            switch (obj.Type)
            {
            case GameObjectType.BattleNpc when !DeepDungeonManager.PortalActive && !PartyManager.IsInParty:
                return(weight / 2);

            case GameObjectType.BattleNpc:
                weight /= 2;
                break;
            }


            if (obj.NpcId == EntityNames.BandedCoffer && !Blacklist.Contains(obj.ObjectId))
            {
                weight += 200;
            }

            if (DeepDungeonManager.PortalActive && obj.NpcId == EntityNames.FloorExit &&
                (Core.Me.HasAura(Auras.NoAutoHeal) || Core.Me.HasAura(Auras.Amnesia)))
            {
                weight += 500;
            }

            if (DeepDungeonManager.PortalActive && Settings.Instance.GoExit)
            {
                weight += 500;
            }

            if (DeepDungeonManager.PortalActive && Settings.Instance.GoForTheHoard && obj.NpcId == EntityNames.Hidden)
            {
                weight += 5;
            }
            else if (DeepDungeonManager.PortalActive && Settings.Instance.GoExit &&
                     obj.NpcId != EntityNames.FloorExit && PartyManager.IsInParty)
            {
                weight -= 10;
            }

            return(weight);
        }
Пример #11
0
 /// <summary>
 /// Checks whether a given gameobject is in pull range.
 /// </summary>
 /// <param name="obj"></param>
 /// <returns></returns>
 internal static bool IsInPullRange(this GameObject obj)
 {
     return(obj.Distance2D() <= RoutineManager.Current.PullRange);
 }
Пример #12
0
        public async Task <bool> Run()
        {
            if (Target.Type != (PoiType)PoiTypes.UseBeaconOfReturn)
            {
                return(false);
            }

            //let the navigation task handle moving toward the object if we are too far away.
            if (Target.Location.Distance2D(Core.Me.Location) > 3)
            {
                return(false);
            }

            GameObject unit = GameObjectManager.GetObjectByNPCId(EntityNames.BeaconOfReturn);

            if (unit == null)
            {
                Logger.Warn("Beacon of return could not be found at this location");
                location = Vector3.Zero;
                Poi.Clear("Beacon of Return could not be found");
                return(true);
            }

            if (unit.Distance2D(Core.Me.Location) >= 3)
            {
                await CommonTasks.MoveAndStop(new MoveToParameters(unit.Location, "Beacon of Return"), 2.5f, true);

                return(true);
            }

            //if we are a frog / lust we can't open a chest
            if (Constants.AuraTransformed)
            {
                Logger.Warn("Unable to open chest. Waiting for aura to end...");
                await CommonTasks.StopMoving("Waiting on aura to end");

                await Coroutine.Wait(TimeSpan.FromSeconds(30),
                                     () => !(Constants.AuraTransformed) || Core.Me.InCombat || DeepDungeonHoH.StopPlz);

                //incase we entered combat
                return(true);
            }

            await Coroutine.Yield();

            if (Core.Me.HasAura(Auras.Lust))
            {
                await Tasks.Coroutines.Common.CancelAura(Auras.Lust);
            }
            Logger.Verbose("Attempting to interact with: {0}", unit.Name);
            unit.Target();
            unit.Interact();

            await Coroutine.Wait(1000, () => SelectYesno.IsOpen);

            if (SelectYesno.IsOpen)
            {
                SelectYesno.ClickYes();
                await Coroutine.Wait(1000, () => Core.Me.IsCasting);
            }

            await Coroutine.Wait(10000, () => !Core.Me.IsCasting);

            await Coroutine.Sleep(500);

            Poi.Clear("Used Beacon Of Return");
            return(true);
        }
        public static float SortComplete(GameObject obj)
        {
            var weight = 150f;

            if (PartyManager.IsInParty && !PartyManager.IsPartyLeader && !DeepDungeonManager.BossFloor)
            {
                if (PartyManager.PartyLeader.IsInObjectManager && PartyManager.PartyLeader.CurrentHealth > 0)
                {
                    if (PartyManager.PartyLeader.BattleCharacter.HasTarget)
                    {
                        if (obj.ObjectId == PartyManager.PartyLeader.BattleCharacter.TargetGameObject.ObjectId)
                        {
                            weight += 600;
                        }
                    }
                    weight -= obj.Distance2D(PartyManager.PartyLeader.GameObject);
                }
                else
                {
                    weight -= obj.Distance2D();
                }
            }
            else
            {
                if (FloorExit.location != Vector3.Zero)
                {
                    weight -= Core.Me.Distance2D(Vector3.Lerp(obj.Location, FloorExit.location, 0.25f));
                }
                else
                {
                    weight -= obj.Distance2D();
                }
            }

            switch (obj.Type)
            {
            case GameObjectType.BattleNpc when !PartyManager.IsInParty:
                return(weight / 2);

            case GameObjectType.BattleNpc:
                weight /= 2;
                break;

            case GameObjectType.Treasure:
                break;
            }

/*
 *          if (obj.NpcId == EntityNames.BandedCoffer)
 *              weight += 500;
 *
 *          if (DeepDungeonManager.PortalActive && Settings.Instance.GoForTheHoard && obj.NpcId == EntityNames.Hidden)
 *              weight += 5;
 */
            //else if (DeepDungeonManager.PortalActive && Settings.Instance.GoExit &&
            //         obj.NpcId != EntityNames.FloorExit && PartyManager.IsInParty)
            //    weight -= 10;

            //if (obj.NpcId == EntityNames.BandedCoffer && !Blacklist.Contains(obj.ObjectId)) weight += 200;

            //if (DeepDungeonManager.PortalActive && obj.NpcId == EntityNames.FloorExit &&
            // (Core.Me.HasAura(Auras.NoAutoHeal) || Core.Me.HasAura(Auras.Amnesia))) weight += 500;

            //if (DeepDungeonManager.PortalActive && Settings.Instance.GoExit) weight -= 10;

            if (DeepDungeonManager.PortalActive && Settings.Instance.GoForTheHoard && obj.NpcId == EntityNames.Hidden)
            {
                weight += 5;
            }
            //else if (DeepDungeonManager.PortalActive && Settings.Instance.GoExit &&
            //         obj.NpcId != EntityNames.FloorExit && PartyManager.IsInParty)
            //    weight -= 10;

            return(weight);
        }
Пример #14
0
 public static bool TooClose(GameObject o)
 {
     if (o == null) return false;
     return o.Distance2D() < 1f;
 }
Пример #15
0
 public static bool IsInSafeMeleeRange(GameObject o)
 {
     if (o == null) return false;
     return o.Distance2D() < CombatMovementRange(o);
 }