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)); }