/** Force recalculation of the current path. * If there is an ongoing path calculation, it will be canceled (so make sure you leave time for the paths to get calculated before calling this function again). */ public virtual void UpdatePath() { canSearchPath = true; waitingForPathCalc = false; Path p = seeker.GetCurrentPath(); //Cancel any eventual pending pathfinding request if (p != null && !seeker.IsDone()) { p.Error(); // Make sure it is recycled. We won't receive a callback for this one since we // replace the path directly after this p.Claim(this); p.Release(this); } waitingForPathCalc = true; lastRepath = Time.time; if (target != null) { seeker.StartPath(tr.position, target.position); } // seeker.StartPath(tr.position, targetPosition); }
static int Error(IntPtr L) { try { ToLua.CheckArgsCount(L, 1); Pathfinding.Path obj = (Pathfinding.Path)ToLua.CheckObject <Pathfinding.Path>(L, 1); obj.Error(); return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
public virtual void UpdatePath() { this.canSearchPath = true; this.waitingForPathCalc = false; Path currentPath = this.seeker.GetCurrentPath(); if (currentPath != null && !this.seeker.IsDone()) { currentPath.Error(); currentPath.Claim(this); currentPath.Release(this, false); } this.waitingForPathCalc = true; this.lastRepath = Time.time; this.seeker.StartPath(this.tr.position, this.target.position); }
public override void UpdatePath() { this.canSearchPath = true; this.waitingForPathCalc = false; Path currentPath = this.seeker.GetCurrentPath(); if (currentPath != null && !this.seeker.IsDone()) { currentPath.Error(); currentPath.Claim(this); currentPath.Release(this, false); } this.waitingForPathCalc = true; this.lastRepath = Time.time; Matrix4x4 matrix = this.graph.GetMatrix(); this.seeker.StartPath(matrix.MultiplyPoint3x4(this.tr.position), matrix.MultiplyPoint3x4(this.target.position)); }
public override void UpdatePath() { base.canSearchPath = true; base.waitingForPathCalc = false; Path currentPath = base.seeker.GetCurrentPath(); if ((currentPath != null) && !base.seeker.IsDone()) { currentPath.Error(); currentPath.Claim(this); currentPath.Release(this, false); } base.waitingForPathCalc = true; base.lastRepath = Time.time; Matrix4x4 matrix = this.graph.GetMatrix(); Vector3 start = matrix.MultiplyPoint3x4(base.tr.position); base.seeker.StartPath(start, matrix.MultiplyPoint3x4(base.target.position)); }
/** Puts the Path in queue for calculation. * The callback specified when constructing the path will be called when the path has been calculated. * Usually you should use the Seeker component instead of calling this function directly. * * \param p The path that should be put in queue for calculation * \param pushToFront If true, the path will be pushed to the front of the queue, bypassing all waiting paths and making it the next path to be calculated. * This can be useful if you have a path which you want to prioritize over all others. Be careful to not overuse it though. * If too many paths are put in the front of the queue often, this can lead to normal paths having to wait a very long time before being calculated. */ public static void StartPath (Path p, bool pushToFront = false) { if (active == null) { Debug.LogError ("There is no AstarPath object in the scene"); return; } if (p.GetState() != PathState.Created) { throw new System.Exception ("The path has an invalid state. Expected " + PathState.Created + " found " + p.GetState() + "\n" + "Make sure you are not requesting the same path twice"); } if (active.pathQueue.IsTerminating) { p.Error (); p.LogError ("No new paths are accepted"); return; } if (active.graphs == null || active.graphs.Length == 0) { Debug.LogError ("There are no graphs in the scene"); p.Error (); p.LogError ("There are no graphs in the scene"); Debug.LogError (p.errorLog); return; } p.Claim (active); //Will increment to PathQueue p.AdvanceState (PathState.PathQueue); if (pushToFront) { active.pathQueue.PushFront (p); } else { active.pathQueue.Push (p); } }
/** Puts the Path in queue for calculation. * The callback specified when constructing the path will be called when the path has been calculated. * Usually you should use the Seeker component instead of calling this function directly. */ public static void StartPath (Path p) { if (active == null) { Debug.LogError ("There is no AstarPath object in the scene"); return; } if (p.GetState() != PathState.Created) { throw new System.Exception ("The path has an invalid state. Expected " + PathState.Created + " found " + p.GetState() + "\n" + "Make sure you are not requesting the same path twice"); } if (!active.acceptNewPaths) { p.Error (); p.LogError ("No new paths are accepted"); //Debug.LogError (p.errorLog); //p.ReturnPath (); return; } if (active.graphs == null || active.graphs.Length == 0) { Debug.LogError ("There are no graphs in the scene"); p.Error (); p.LogError ("There are no graphs in the scene"); Debug.LogError (p.errorLog); //p.ReturnPath (); return; } /*MultithreadPath p2 = p as MultithreadPath; if (p2 == null) { Debug.LogError ("Path Not Set Up For Multithreading"); return; }*/ p.Claim (active); lock (pathQueue) { //Will increment to PathQueue p.AdvanceState (PathState.PathQueue); pathQueue.Enqueue (p); if (doSetQueueState) pathQueueFlag.Set (); } }
private IEnumerator CalculatePaths(PathThreadInfo threadInfo) { int numPaths = 0; PathHandler runData = threadInfo.runData; if (runData.nodes == null) { throw new NullReferenceException("NodeRuns must be assigned to the threadInfo.runData.nodes field before threads are started\nthreadInfo is an argument to the thread functions"); } long maxTicks = (long)(this.astar.maxFrameTime * 10000f); long targetTick = DateTime.UtcNow.Ticks + maxTicks; for (;;) { Path p = null; bool blockedBefore = false; while (p == null) { try { p = this.queue.PopNoBlock(blockedBefore); blockedBefore |= (p == null); } catch (ThreadControlQueue.QueueTerminationException) { yield break; } if (p == null) { yield return null; } } maxTicks = (long)(this.astar.maxFrameTime * 10000f); p.PrepareBase(runData); p.AdvanceState(PathState.Processing); Action<Path> tmpOnPathPreSearch = this.OnPathPreSearch; if (tmpOnPathPreSearch != null) { tmpOnPathPreSearch(p); } numPaths++; long startTicks = DateTime.UtcNow.Ticks; long totalTicks = 0L; p.Prepare(); if (!p.IsDone()) { this.astar.debugPath = p; p.Initialize(); while (!p.IsDone()) { p.CalculateStep(targetTick); p.searchIterations++; if (p.IsDone()) { break; } totalTicks += DateTime.UtcNow.Ticks - startTicks; yield return null; startTicks = DateTime.UtcNow.Ticks; if (this.queue.IsTerminating) { p.Error(); } targetTick = DateTime.UtcNow.Ticks + maxTicks; } totalTicks += DateTime.UtcNow.Ticks - startTicks; p.duration = (float)totalTicks * 0.0001f; } p.Cleanup(); OnPathDelegate tmpImmediateCallback = p.immediateCallback; if (tmpImmediateCallback != null) { tmpImmediateCallback(p); } Action<Path> tmpOnPathPostSearch = this.OnPathPostSearch; if (tmpOnPathPostSearch != null) { tmpOnPathPostSearch(p); } this.returnQueue.Enqueue(p); p.AdvanceState(PathState.ReturnQueue); if (DateTime.UtcNow.Ticks > targetTick) { yield return null; targetTick = DateTime.UtcNow.Ticks + maxTicks; numPaths = 0; } } yield break; }
private void CalculatePathsThreaded(PathThreadInfo threadInfo) { try { PathHandler runData = threadInfo.runData; if (runData.nodes == null) { throw new NullReferenceException("NodeRuns must be assigned to the threadInfo.runData.nodes field before threads are started\nthreadInfo is an argument to the thread functions"); } long num = (long)(this.astar.maxFrameTime * 10000f); long num2 = DateTime.UtcNow.Ticks + num; for (;;) { Path path = this.queue.Pop(); num = (long)(this.astar.maxFrameTime * 10000f); path.PrepareBase(runData); path.AdvanceState(PathState.Processing); if (this.OnPathPreSearch != null) { this.OnPathPreSearch(path); } long ticks = DateTime.UtcNow.Ticks; long num3 = 0L; path.Prepare(); if (!path.IsDone()) { this.astar.debugPath = path; path.Initialize(); while (!path.IsDone()) { path.CalculateStep(num2); path.searchIterations++; if (path.IsDone()) { break; } num3 += DateTime.UtcNow.Ticks - ticks; Thread.Sleep(0); ticks = DateTime.UtcNow.Ticks; num2 = ticks + num; if (this.queue.IsTerminating) { path.Error(); } } num3 += DateTime.UtcNow.Ticks - ticks; path.duration = (float)num3 * 0.0001f; } path.Cleanup(); if (path.immediateCallback != null) { path.immediateCallback(path); } if (this.OnPathPostSearch != null) { this.OnPathPostSearch(path); } this.returnQueue.Enqueue(path); path.AdvanceState(PathState.ReturnQueue); if (DateTime.UtcNow.Ticks > num2) { Thread.Sleep(1); num2 = DateTime.UtcNow.Ticks + num; } } } catch (Exception ex) { if (ex is ThreadAbortException || ex is ThreadControlQueue.QueueTerminationException) { if (this.astar.logPathResults == PathLog.Heavy) { Debug.LogWarning("Shutting down pathfinding thread #" + threadInfo.threadIndex); } return; } Debug.LogException(ex); Debug.LogError("Unhandled exception during pathfinding. Terminating."); this.queue.TerminateReceivers(); } Debug.LogError("Error : This part should never be reached."); this.queue.ReceiverTerminated(); }
/** Main pathfinding method. * This method will calculate the paths in the pathfinding queue. * * \see CalculatePathsThreaded * \see StartPath */ IEnumerator CalculatePaths(PathThreadInfo threadInfo) { int numPaths = 0; // Initialize memory for this thread PathHandler runData = threadInfo.runData; if (runData.nodes == null) { throw new System.NullReferenceException("NodeRuns must be assigned to the threadInfo.runData.nodes field before threads are started\n" + "threadInfo is an argument to the thread functions"); } // Max number of ticks before yielding/sleeping long maxTicks = (long)(astar.maxFrameTime * 10000); long targetTick = System.DateTime.UtcNow.Ticks + maxTicks; while (true) { //The path we are currently calculating Path p = null; AstarProfiler.StartProfile("Path Queue"); //Try to get the next path to be calculated bool blockedBefore = false; while (p == null) { try { p = queue.PopNoBlock(blockedBefore); blockedBefore |= p == null; } catch (ThreadControlQueue.QueueTerminationException) { yield break; } if (p == null) { AstarProfiler.EndProfile(); yield return(null); AstarProfiler.StartProfile("Path Queue"); } } AstarProfiler.EndProfile(); AstarProfiler.StartProfile("Path Calc"); //Max number of ticks we are allowed to continue working in one run //One tick is 1/10000 of a millisecond maxTicks = (long)(astar.maxFrameTime * 10000); p.PrepareBase(runData); //Now processing the path //Will advance to Processing p.AdvanceState(PathState.Processing); // Call some callbacks // It needs to be stored in a local variable to avoid race conditions var tmpOnPathPreSearch = OnPathPreSearch; if (tmpOnPathPreSearch != null) { tmpOnPathPreSearch(p); } numPaths++; //Tick for when the path started, used for calculating how long time the calculation took long startTicks = System.DateTime.UtcNow.Ticks; long totalTicks = 0; AstarProfiler.StartFastProfile(8); AstarProfiler.StartFastProfile(0); //Prepare the path AstarProfiler.StartProfile("Path Prepare"); p.Prepare(); AstarProfiler.EndProfile("Path Prepare"); AstarProfiler.EndFastProfile(0); // Check if the Prepare call caused the path to complete // If this happens the path usually failed if (!p.IsDone()) { //For debug uses, we set the last computed path to p, so we can view debug info on it in the editor (scene view). astar.debugPath = p; //Initialize the path, now ready to begin search AstarProfiler.StartProfile("Path Initialize"); p.Initialize(); AstarProfiler.EndProfile(); //The error can turn up in the Init function while (!p.IsDone()) { // Do some work on the path calculation. // The function will return when it has taken too much time // or when it has finished calculation AstarProfiler.StartFastProfile(2); AstarProfiler.StartProfile("Path Calc Step"); p.CalculateStep(targetTick); AstarProfiler.EndFastProfile(2); p.searchIterations++; AstarProfiler.EndProfile(); // If the path has finished calculation, we can break here directly instead of sleeping // Improves latency if (p.IsDone()) { break; } AstarProfiler.EndFastProfile(8); totalTicks += System.DateTime.UtcNow.Ticks - startTicks; // Yield/sleep so other threads can work AstarProfiler.EndProfile(); yield return(null); AstarProfiler.StartProfile("Path Calc"); startTicks = System.DateTime.UtcNow.Ticks; AstarProfiler.StartFastProfile(8); //Cancel function (and thus the thread) if no more paths should be accepted. //This is done when the A* object is about to be destroyed //The path is returned and then this function will be terminated (see similar IF statement higher up in the function) if (queue.IsTerminating) { p.Error(); } targetTick = System.DateTime.UtcNow.Ticks + maxTicks; } totalTicks += System.DateTime.UtcNow.Ticks - startTicks; p.duration = totalTicks * 0.0001F; #if ProfileAstar System.Threading.Interlocked.Increment(ref AstarPath.PathsCompleted); System.Threading.Interlocked.Add(ref AstarPath.TotalSearchedNodes, p.searchedNodes); #endif } // Cleans up node tagging and other things p.Cleanup(); AstarProfiler.EndFastProfile(8); // Call the immediate callback // It needs to be stored in a local variable to avoid race conditions var tmpImmediateCallback = p.immediateCallback; if (tmpImmediateCallback != null) { tmpImmediateCallback(p); } AstarProfiler.StartFastProfile(13); // It needs to be stored in a local variable to avoid race conditions var tmpOnPathPostSearch = OnPathPostSearch; if (tmpOnPathPostSearch != null) { tmpOnPathPostSearch(p); } AstarProfiler.EndFastProfile(13); //Push the path onto the return stack //It will be detected by the main Unity thread and returned as fast as possible (the next late update) returnQueue.Enqueue(p); p.AdvanceState(PathState.ReturnQueue); AstarProfiler.EndProfile(); //Wait a bit if we have calculated a lot of paths if (System.DateTime.UtcNow.Ticks > targetTick) { yield return(null); targetTick = System.DateTime.UtcNow.Ticks + maxTicks; numPaths = 0; } } }
/** Main pathfinding method (multithreaded). * This method will calculate the paths in the pathfinding queue when multithreading is enabled. * * \see CalculatePaths * \see StartPath * * \astarpro */ void CalculatePathsThreaded(PathThreadInfo threadInfo) { #if !ASTAR_FAST_BUT_NO_EXCEPTIONS try { #endif //Initialize memory for this thread PathHandler runData = threadInfo.runData; if (runData.nodes == null) { throw new System.NullReferenceException("NodeRuns must be assigned to the threadInfo.runData.nodes field before threads are started\nthreadInfo is an argument to the thread functions"); } //Max number of ticks before yielding/sleeping long maxTicks = (long)(astar.maxFrameTime * 10000); long targetTick = System.DateTime.UtcNow.Ticks + maxTicks; while (true) { //The path we are currently calculating Path p = queue.Pop(); //Max number of ticks we are allowed to continue working in one run //One tick is 1/10000 of a millisecond maxTicks = (long)(astar.maxFrameTime * 10000); AstarProfiler.StartFastProfile(0); p.PrepareBase(runData); //Now processing the path //Will advance to Processing p.AdvanceState(PathState.Processing); //Call some callbacks if (OnPathPreSearch != null) { OnPathPreSearch(p); } //Tick for when the path started, used for calculating how long time the calculation took long startTicks = System.DateTime.UtcNow.Ticks; long totalTicks = 0; //Prepare the path p.Prepare(); AstarProfiler.EndFastProfile(0); if (!p.IsDone()) { //For debug uses, we set the last computed path to p, so we can view debug info on it in the editor (scene view). astar.debugPath = p; AstarProfiler.StartFastProfile(1); //Initialize the path, now ready to begin search p.Initialize(); AstarProfiler.EndFastProfile(1); //The error can turn up in the Init function while (!p.IsDone()) { //Do some work on the path calculation. //The function will return when it has taken too much time //or when it has finished calculation AstarProfiler.StartFastProfile(2); p.CalculateStep(targetTick); p.searchIterations++; AstarProfiler.EndFastProfile(2); // If the path has finished calculation, we can break here directly instead of sleeping if (p.IsDone()) { break; } // Yield/sleep so other threads can work totalTicks += System.DateTime.UtcNow.Ticks - startTicks; Thread.Sleep(0); startTicks = System.DateTime.UtcNow.Ticks; targetTick = startTicks + maxTicks; // Cancel function (and thus the thread) if no more paths should be accepted. // This is done when the A* object is about to be destroyed // The path is returned and then this function will be terminated if (queue.IsTerminating) { p.Error(); } } totalTicks += System.DateTime.UtcNow.Ticks - startTicks; p.duration = totalTicks * 0.0001F; #if ProfileAstar System.Threading.Interlocked.Increment(ref AstarPath.PathsCompleted); System.Threading.Interlocked.Add(ref AstarPath.TotalSearchedNodes, p.searchedNodes); System.Threading.Interlocked.Add(ref AstarPath.TotalSearchTime, totalTicks); #endif } // Cleans up node tagging and other things p.Cleanup(); AstarProfiler.StartFastProfile(9); if (p.immediateCallback != null) { p.immediateCallback(p); } if (OnPathPostSearch != null) { OnPathPostSearch(p); } // Push the path onto the return stack // It will be detected by the main Unity thread and returned as fast as possible (the next late update hopefully) returnQueue.Enqueue(p); // Will advance to ReturnQueue p.AdvanceState(PathState.ReturnQueue); AstarProfiler.EndFastProfile(9); // Wait a bit if we have calculated a lot of paths if (System.DateTime.UtcNow.Ticks > targetTick) { Thread.Sleep(1); targetTick = System.DateTime.UtcNow.Ticks + maxTicks; } } #if !ASTAR_FAST_BUT_NO_EXCEPTIONS } catch (System.Exception e) { #if !NETFX_CORE if (e is ThreadAbortException || e is ThreadControlQueue.QueueTerminationException) #else if (e is ThreadControlQueue.QueueTerminationException) #endif { if (astar.logPathResults == PathLog.Heavy) { Debug.LogWarning("Shutting down pathfinding thread #" + threadInfo.threadIndex); } return; } Debug.LogException(e); Debug.LogError("Unhandled exception during pathfinding. Terminating."); //Unhandled exception, kill pathfinding queue.TerminateReceivers(); } #endif Debug.LogError("Error : This part should never be reached."); queue.ReceiverTerminated(); }