/** 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();
}
