public static bool UpdateGraphsNoBlock(GraphUpdateObject guo, List <GraphNode> nodes, bool alwaysRevert = false)
{
for (int i = 0; i < nodes.Count; i++)
{
if (!nodes[i].Walkable)
{
return(false);
}
}
guo.trackChangedNodes = true;
bool worked = true;
AstarPath.RegisterSafeUpdate(delegate
{
AstarPath.active.UpdateGraphs(guo);
AstarPath.active.FlushGraphUpdates();
worked = (worked && PathUtilities.IsPathPossible(nodes));
if (!worked || alwaysRevert)
{
guo.RevertFromBackup();
AstarPath.active.FloodFill();
}
});
AstarPath.active.FlushThreadSafeCallbacks();
guo.trackChangedNodes = false;
return(worked);
}
protected override void OnEnable()
{
base.OnEnable();
if (Application.isPlaying && AstarPath.active != null && AstarPath.active.astarData != null && AstarPath.active.astarData.pointGraph != null && !AstarPath.active.isScanning)
{
AstarPath.RegisterSafeUpdate(new Action(this.OnGraphsPostUpdate));
}
}
protected override void OnEnable()
{
base.OnEnable();
if (Application.isPlaying && AstarPath.active != null && AstarPath.active.astarData != null && AstarPath.active.astarData.pointGraph != null && !AstarPath.active.isScanning)
{
// Call OnGraphsPostUpdate as soon as possible when it is safe to update the graphs
AstarPath.RegisterSafeUpdate(OnGraphsPostUpdate);
}
}
/** Updates graphs and checks if all nodes are still reachable from each other.
* Graphs are updated, then a check is made to see if the nodes are still reachable from each other.
* If they are not, the graphs are reverted to before the update and \a false is returned.
* This is slower than a normal graph update.
* All queued graph updates and thread safe callbacks will be flushed during this function.
*
* \note This might return true for small areas even if there is no possible path if AstarPath.minAreaSize is greater than zero (0).
* So when using this, it is recommended to set AstarPath.minAreaSize to 0. (A* Inspector -> Settings -> Pathfinding)
*
* \param guo The GraphUpdateObject to update the graphs with
* \param nodes Nodes which should have valid paths between them. All nodes should be walkable or \a false will be returned.
* \param alwaysRevert If true, reverts the graphs to the old state even if no blocking ocurred
*/
public static bool UpdateGraphsNoBlock(GraphUpdateObject guo, List <GraphNode> nodes, bool alwaysRevert = false)
{
//Make sure all nodes are walkable
for (int i = 0; i < nodes.Count; i++)
{
if (!nodes[i].Walkable)
{
return(false);
}
}
//Track changed nodes to enable reversion of the guo
guo.trackChangedNodes = true;
bool worked = true;
AstarPath.RegisterSafeUpdate(delegate() {
AstarPath.active.UpdateGraphs(guo);
//Make sure graph updates are registered for update and not delayed for performance
AstarPath.active.QueueGraphUpdates();
//Call thread safe callbacks, includes graph updates
AstarPath.active.FlushGraphUpdates();
//Check if all nodes are in the same area and that they are walkable, i.e that there are paths between all of them
worked = worked && PathUtilities.IsPathPossible(nodes);
//If it did not work, revert the GUO
if (!worked || alwaysRevert)
{
guo.RevertFromBackup();
//The revert operation does not revert ALL nodes' area values, so we must flood fill again
AstarPath.active.FloodFill();
}
}, true);
//Force the thread safe callback to be called
AstarPath.active.FlushThreadSafeCallbacks();
//Disable tracking nodes, not strictly necessary, but will slightly reduce the cance that some user causes errors
guo.trackChangedNodes = false;
return(worked);
}
/**
* SafeOnDestroy should be used when there is a risk that the pathfinding is searching through this graph when called
*/
public void SafeOnDestroy()
{
AstarPath.RegisterSafeUpdate(OnDestroy);
}
// Token: 0x06000423 RID: 1059 RVA: 0x00021572 File Offset: 0x0001F972
public void SafeOnDestroy()
{
AstarPath.RegisterSafeUpdate(new OnVoidDelegate(this.OnDestroy));
}
