// Token: 0x06002745 RID: 10053 RVA: 0x001AD344 File Offset: 0x001AB544 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; PathProcessor.GraphUpdateLock graphUpdateLock = AstarPath.active.PausePathfinding(); bool flag; try { AstarPath.active.UpdateGraphs(guo); AstarPath.active.FlushGraphUpdates(); flag = PathUtilities.IsPathPossible(nodes); if (!flag || alwaysRevert) { guo.RevertFromBackup(); AstarPath.active.FloodFill(); } } finally { graphUpdateLock.Release(); } guo.trackChangedNodes = false; return(flag); }
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.QueueGraphUpdates(); AstarPath.active.FlushGraphUpdates(); worked = (worked && PathUtilities.IsPathPossible(nodes)); if (!worked || alwaysRevert) { guo.RevertFromBackup(); AstarPath.active.FloodFill(); } }); AstarPath.active.FlushThreadSafeCallbacks(); guo.trackChangedNodes = false; return(worked); }
public static bool IsPathPossible(List <GraphNode> nodes, int tagMask) { if (nodes.Count == 0) { return(true); } if ((tagMask >> (int)nodes[0].Tag & 1) == 0) { return(false); } if (!PathUtilities.IsPathPossible(nodes)) { return(false); } List <GraphNode> reachableNodes = PathUtilities.GetReachableNodes(nodes[0], tagMask); bool result = true; for (int i = 1; i < nodes.Count; i++) { if (!reachableNodes.Contains(nodes[i])) { result = false; break; } } ListPool <GraphNode> .Release(reachableNodes); return(result); }
/// <summary> /// 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 false is returned. /// This is slower than a normal graph update. /// All queued graph updates will be flushed during this function. /// /// Returns: True if the given nodes are still reachable from each other after the guo has been applied. False otherwise. /// </summary> /// <param name="guo">The GraphUpdateObject to update the graphs with</param> /// <param name="nodes">Nodes which should have valid paths between them. All nodes should be walkable or false will be returned.</param> /// <param name="alwaysRevert">If true, reverts the graphs to the old state even if no blocking occurred</param> public static bool UpdateGraphsNoBlock(GraphUpdateObject guo, List <GraphNode> nodes, bool alwaysRevert = false) { bool worked; // Pause pathfinding while modifying the graphs var graphLock = AstarPath.active.PausePathfinding(); try { // Make sure any pending graph updates have been done before we start AstarPath.active.FlushGraphUpdates(); // 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; AstarPath.active.UpdateGraphs(guo); // Update the graphs immediately 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 = PathUtilities.IsPathPossible(nodes); // If it did not work, revert the GUO if (!worked || alwaysRevert) { guo.RevertFromBackup(); // Recalculate connected components AstarPath.active.hierarchicalGraph.RecalculateIfNecessary(); } } finally { graphLock.Release(); } // Disable tracking nodes, not strictly necessary, but will slightly reduce the cance that some user causes errors guo.trackChangedNodes = false; return(worked); }
/** 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); }
/** 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 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 occurred * * \returns True if the given nodes are still reachable from each other after the \a guo has been applied. False otherwise. */ 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; // Pause pathfinding while modifying the graphs var graphLock = AstarPath.active.PausePathfinding(); try { AstarPath.active.UpdateGraphs(guo); // Update the graphs immediately 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 = 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(); } } finally { graphLock.Release(); } // Disable tracking nodes, not strictly necessary, but will slightly reduce the cance that some user causes errors guo.trackChangedNodes = false; return(worked); }