Exemple #1
0
 private async Task <bool> TakingWaypoint()
 {
     if (!await WaypointCoroutine.UseWaypoint(BountyData.WaypointNumber))
     {
         return(false);
     }
     State = States.InZone;
     return(false);
 }
Exemple #2
0
 private async Task <bool> Coroutine()
 {
     if (await WaypointCoroutine.UseWaypoint(WaypointNumber))
     {
         _isDone = true;
         return(true);
     }
     return(false);
 }
 private async Task <bool> TakingWaypoint()
 {
     DisablePulse();
     if (!await WaypointCoroutine.UseWaypoint(_keywardenData.WaypointNumber))
     {
         return(false);
     }
     State = States.Searching;
     return(false);
 }
Exemple #4
0
 public static async Task <CoroutineResult> EnsureIsInTown()
 {
     if (!(ZetaDia.IsInTown &&
           ZetaDia.Globals.WorldSnoId == SNOWorld.X1_Tristram_Adventure_Mode_Hub) &&
         await WaypointCoroutine.UseWaypoint(WaypointFactory.ActHubs[Act.A1]))
     {
         return(CoroutineResult.Running);
     }
     return(await Coroutine.Wait(TimeSpan.FromSeconds(2), () => ZetaDia.IsInTown) ? CoroutineResult.Done : CoroutineResult.Running);
 }
        private async Task <bool> TakingWaypoint()
        {
            DisablePulse();
            Waypoint wp = ZetaDia.Storage.ActManager.GetWaypointByLevelAreaSnoId(_keywardenData.WaypointLevelAreaId);

            if (!await WaypointCoroutine.UseWaypoint(wp.Number))
            {
                return(false);
            }
            State = States.Searching;
            return(false);
        }
        public virtual async Task <bool> InGameTask()
        {
            if (!AutoFollow.Enabled)
            {
                return(false);
            }

            if (!Core.GameIsReady || Party.IsLocked)
            {
                await Coroutine.Sleep(1000);

                Log.Verbose("Waiting (Invalid State)");
                return(true);
            }

            if (!Core.TrinityIsReady)
            {
                Log.Verbose("Waiting for Trinity to be ready");
                return(true);
            }

            if (Player.IsInTown && AdvDia.CurrentWorldId != ExplorationData.ActHubWorldIds[Act.A1] && PluginEvents.CurrentProfileType != ProfileType.Bounty)
            {
                return(!await WaypointCoroutine.UseWaypoint(WaypointFactory.ActHubs[Act.A1]));
            }

            AcceptRiftDialog();

            if (DateTime.UtcNow < Coordination.WaitUntil)
            {
                Log.Debug("Waiting... (Generic IC) Remaining={0}s", Coordination.WaitUntil.Subtract(DateTime.UtcNow).TotalSeconds);
                await Coroutine.Sleep(500);

                return(true);
            }

            if (!AutoFollow.CurrentLeader.IsValid)
            {
                if (!AutoFollow.CurrentParty.Any(m => m.IsLeader))
                {
                    Log.Info("There is currently no leader");
                }
                else
                {
                    Log.Debug("Leader message was invalid");
                }
                return(true);
            }

            GameUI.SafeCheckClickButtons();
            return(false);
        }
Exemple #7
0
        private async Task <bool> ReturningToTown()
        {
            if (IsInZone)
            {
                State = States.TownRun;
                return(false);
            }
            if (!await WaypointCoroutine.UseWaypoint(WaypointFactory.ActHubs[_act]))
            {
                return(false);
            }

            return(false);
        }
        public override async Task <bool> InGameTask()
        {
            // Returning True => go to next tick immediately, execution starts again from top of the tree.
            // Returning False => allow execution to continue to lower hooks. Such as profiles, Adventurer.

            if (!AutoFollow.CurrentLeader.IsValid)
            {
                return(false);
            }

            //if (!Service.IsConnected || AutoFollow.NumberOfConnectedBots == 0)
            //    return false;

            if (Player.IsInTown && AdvDia.CurrentWorldId != ExplorationData.ActHubWorldIds[Act.A1])
            {
                return(!await WaypointCoroutine.UseWaypoint(WaypointFactory.ActHubs[Act.A1]));
            }

            if (Player.IsFollower)
            {
                if (await Party.LeaveWhenInWrongGame())
                {
                    return(true);
                }
            }

            if (await Coordination.WaitForGameStartDelay())
            {
                return(true);
            }

            if (await Coordination.WaitBeforeStartingRift())
            {
                return(true);
            }

            if (await Coordination.WaitAfterChangingWorlds())
            {
                return(true);
            }

            if (await WaitForGemUpgraded())
            {
                return(true);
            }
            return(false);
        }
Exemple #9
0
        public override async Task <bool> MainTask()
        {
            if (WaypointNumber == -1 && DestinationLevelAreaSnoId != 0)
            {
                WaypointNumber = WaypointCoroutine.GetWaypointNumber(DestinationLevelAreaSnoId);
            }

            if (!await WaypointCoroutine.UseWaypoint(WaypointNumber))
            {
                return(false);
            }

            Done();
            await Coroutine.Sleep(1000);

            return(true);
        }
Exemple #10
0
 private async Task <bool> GoingToAct1Hub()
 {
     DisablePulse();
     if (_goingToAct1HubWaitTimer == null)
     {
         _goingToAct1HubWaitTimer = new WaitTimer(TimeSpan.FromSeconds(5));
         _goingToAct1HubWaitTimer.Reset();
     }
     if (!_goingToAct1HubWaitTimer.IsFinished)
     {
         return(false);
     }
     if (!await WaypointCoroutine.UseWaypoint(WaypointFactory.ActHubs[Act.A1]))
     {
         return(false);
     }
     _goingToAct1HubWaitTimer = null;
     State = States.InTown;
     return(false);
 }