public override void Open(Path path, PathNode pathNode, PathHandler handler) { if (connections == null) { return; } for (int i = 0; i < connections.Length; i++) { GraphNode other = connections[i]; if (path.CanTraverse(other)) { PathNode pathOther = handler.GetPathNode(other); if (pathOther.pathID != handler.PathID) { pathOther.parent = pathNode; pathOther.pathID = handler.PathID; pathOther.cost = connectionCosts[i]; pathOther.H = path.CalculateHScore(other); other.UpdateG(path, pathOther); handler.PushNode(pathOther); } else { //If not we can test if the path from this node to the other one is a better one then the one already used uint tmpCost = connectionCosts[i]; #if ASTAR_NO_TRAVERSAL_COST if (pathNode.G + tmpCost < pathOther.G) #else if (pathNode.G + tmpCost + path.GetTraversalCost(other) < pathOther.G) #endif { pathOther.cost = tmpCost; pathOther.parent = pathNode; other.UpdateRecursiveG(path, pathOther, handler); } #if ASTAR_NO_TRAVERSAL_COST else if (pathOther.G + tmpCost < pathNode.G && other.ContainsConnection(this)) #else else if (pathOther.G + tmpCost + path.GetTraversalCost(this) < pathNode.G && other.ContainsConnection(this)) #endif { //Or if the path from the other node to this one is better pathNode.parent = pathOther; pathNode.cost = tmpCost; UpdateRecursiveG(path, pathNode, handler); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { if (this.connections == null) { return; } for (int i = 0; i < this.connections.Length; i++) { GraphNode graphNode = this.connections[i]; if (path.CanTraverse(graphNode)) { PathNode pathNode2 = handler.GetPathNode(graphNode); if (pathNode2.pathID != handler.PathID) { pathNode2.parent = pathNode; pathNode2.pathID = handler.PathID; pathNode2.cost = this.connectionCosts[i]; pathNode2.H = path.CalculateHScore(graphNode); graphNode.UpdateG(path, pathNode2); handler.PushNode(pathNode2); } else { uint num = this.connectionCosts[i]; if (pathNode.G + num + path.GetTraversalCost(graphNode) < pathNode2.G) { pathNode2.cost = num; pathNode2.parent = pathNode; graphNode.UpdateRecursiveG(path, pathNode2, handler); } else if (pathNode2.G + num + path.GetTraversalCost(this) < pathNode.G && graphNode.ContainsConnection(this)) { pathNode.parent = pathNode2; pathNode.cost = num; this.UpdateRecursiveG(path, pathNode, handler); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { if (connections == null) { return; } // Flag2 indicates if this node needs special treatment // with regard to connection costs bool flag2 = pathNode.flag2; // Loop through all connections for (int i = connections.Length - 1; i >= 0; i--) { GraphNode other = connections[i]; // Make sure we can traverse the neighbour if (path.CanTraverse(other)) { PathNode pathOther = handler.GetPathNode(other); // Fast path out, worth it for triangle mesh nodes since they usually have degree 2 or 3 if (pathOther == pathNode.parent) { continue; } uint cost = connectionCosts[i]; if (flag2 || pathOther.flag2) { // Get special connection cost from the path // This is used by the start and end nodes cost = path.GetConnectionSpecialCost(this, other, cost); } // Test if we have seen the other node before if (pathOther.pathID != handler.PathID) { // We have not seen the other node before // So the path from the start through this node to the other node // must be the shortest one so far // Might not be assigned pathOther.node = other; pathOther.parent = pathNode; pathOther.pathID = handler.PathID; pathOther.cost = cost; pathOther.H = path.CalculateHScore(other); other.UpdateG(path, pathOther); handler.PushNode(pathOther); } else { // If not we can test if the path from this node to the other one is a better one than the one already used if (pathNode.G + cost + path.GetTraversalCost(other) < pathOther.G) { pathOther.cost = cost; pathOther.parent = pathNode; other.UpdateRecursiveG(path, pathOther, handler); } else if (pathOther.G + cost + path.GetTraversalCost(this) < pathNode.G && other.ContainsConnection(this)) { // Or if the path from the other node to this one is better pathNode.parent = pathOther; pathNode.cost = cost; UpdateRecursiveG(path, pathNode, handler); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { if (connections == null) { return; } bool flag2 = pathNode.flag2; for (int i = connections.Length - 1; i >= 0; i--) { GraphNode other = connections[i]; if (path.CanTraverse(other)) { PathNode pathOther = handler.GetPathNode(other); //Fast path out, worth it for triangle mesh nodes since they usually have degree 2 or 3 if (pathOther == pathNode.parent) { continue; } uint cost = connectionCosts[i]; if (flag2 || pathOther.flag2) { cost = path.GetConnectionSpecialCost(this, other, cost); } if (pathOther.pathID != handler.PathID) { //Might not be assigned pathOther.node = other; pathOther.parent = pathNode; pathOther.pathID = handler.PathID; pathOther.cost = cost; pathOther.H = path.CalculateHScore(other); other.UpdateG(path, pathOther); handler.PushNode(pathOther); } else { //If not we can test if the path from this node to the other one is a better one than the one already used if (pathNode.G + cost + path.GetTraversalCost(other) < pathOther.G) { pathOther.cost = cost; pathOther.parent = pathNode; other.UpdateRecursiveG(path, pathOther, handler); //handler.PushNode (pathOther); } else if (pathOther.G + cost + path.GetTraversalCost(this) < pathNode.G && other.ContainsConnection(this)) { //Or if the path from the other node to this one is better pathNode.parent = pathOther; pathNode.cost = cost; UpdateRecursiveG(path, pathNode, handler); //handler.PushNode (pathNode); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { ushort pid = handler.PathID; if (connections != null) { for (int i = 0; i < connections.Length; i++) { GraphNode other = connections[i]; if (!path.CanTraverse(other)) { continue; } PathNode otherPN = handler.GetPathNode(other); uint tmpCost = connectionCosts[i]; if (otherPN.pathID != pid) { otherPN.parent = pathNode; otherPN.pathID = pid; otherPN.cost = tmpCost; otherPN.H = path.CalculateHScore(other); other.UpdateG(path, otherPN); //Debug.Log ("G " + otherPN.G + " F " + otherPN.F); handler.heap.Add(otherPN); //Debug.DrawRay ((Vector3)otherPN.node.Position, Vector3.up,Color.blue); } else { // Sorry for the huge number of #ifs //If not we can test if the path from the current node to this one is a better one then the one already used #if ASTAR_NO_TRAVERSAL_COST if (pathNode.G + tmpCost < otherPN.G) #else if (pathNode.G + tmpCost + path.GetTraversalCost(other) < otherPN.G) #endif { //Debug.Log ("Path better from " + NodeIndex + " to " + otherPN.node.NodeIndex + " " + (pathNode.G+tmpCost+path.GetTraversalCost(other)) + " < " + otherPN.G); otherPN.cost = tmpCost; otherPN.parent = pathNode; other.UpdateRecursiveG(path, otherPN, handler); //Or if the path from this node ("other") to the current ("current") is better } #if ASTAR_NO_TRAVERSAL_COST else if (otherPN.G + tmpCost < pathNode.G && other.ContainsConnection(this)) #else else if (otherPN.G + tmpCost + path.GetTraversalCost(this) < pathNode.G && other.ContainsConnection(this)) #endif { //Debug.Log ("Path better from " + otherPN.node.NodeIndex + " to " + NodeIndex + " " + (otherPN.G+tmpCost+path.GetTraversalCost (this)) + " < " + pathNode.G); pathNode.parent = otherPN; pathNode.cost = tmpCost; UpdateRecursiveG(path, pathNode, handler); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { GridGraph gg = GetGridGraph(GraphIndex); ushort pid = handler.PathID; { int[] neighbourOffsets = gg.neighbourOffsets; uint[] neighbourCosts = gg.neighbourCosts; GridNode[] nodes = gg.nodes; for (int i = 0; i < 8; i++) { if (GetConnectionInternal(i)) { GridNode other = nodes[nodeInGridIndex + neighbourOffsets[i]]; if (!path.CanTraverse(other)) { continue; } PathNode otherPN = handler.GetPathNode(other); // Multiply the connection cost with 1 + the average of the traversal costs for the two nodes uint tmpCost = (neighbourCosts[i] * (256 + path.GetTraversalCost(this) + path.GetTraversalCost(other))) / 128; if (otherPN.pathID != pid) { otherPN.parent = pathNode; otherPN.pathID = pid; otherPN.cost = tmpCost; otherPN.H = path.CalculateHScore(other); other.UpdateG(path, otherPN); //Debug.Log ("G " + otherPN.G + " F " + otherPN.F); handler.PushNode(otherPN); //Debug.DrawRay ((Vector3)otherPN.node.Position, Vector3.up,Color.blue); } else { // Sorry for the huge number of #ifs //If not we can test if the path from the current node to this one is a better one then the one already used if (pathNode.G + tmpCost < otherPN.G) { //Debug.Log ("Path better from " + NodeIndex + " to " + otherPN.node.NodeIndex + " " + (pathNode.G+tmpCost+path.GetTraversalCost(other)) + " < " + otherPN.G); otherPN.cost = tmpCost; otherPN.parent = pathNode; other.UpdateRecursiveG(path, otherPN, handler); //Or if the path from this node ("other") to the current ("current") is better } else if (otherPN.G + tmpCost < pathNode.G) { //Debug.Log ("Path better from " + otherPN.node.NodeIndex + " to " + NodeIndex + " " + (otherPN.G+tmpCost+path.GetTraversalCost (this)) + " < " + pathNode.G); pathNode.parent = otherPN; pathNode.cost = tmpCost; UpdateRecursiveG(path, pathNode, handler); } } } } } if (connections != null) { for (int i = 0; i < connections.Length; i++) { GraphNode other = connections[i]; if (!path.CanTraverse(other)) { continue; } PathNode otherPN = handler.GetPathNode(other); uint tmpCost = (connectionCosts[i] * (256 + path.GetTraversalCost(this) + path.GetTraversalCost(other))) / 128; if (otherPN.pathID != pid) { otherPN.parent = pathNode; otherPN.pathID = pid; otherPN.cost = tmpCost; otherPN.H = path.CalculateHScore(other); other.UpdateG(path, otherPN); //Debug.Log ("G " + otherPN.G + " F " + otherPN.F); handler.PushNode(otherPN); //Debug.DrawRay ((Vector3)otherPN.node.Position, Vector3.up,Color.blue); } else { // Sorry for the huge number of #ifs //If not we can test if the path from the current node to this one is a better one then the one already used if (pathNode.G + tmpCost < otherPN.G) { //Debug.Log ("Path better from " + NodeIndex + " to " + otherPN.node.NodeIndex + " " + (pathNode.G+tmpCost+path.GetTraversalCost(other)) + " < " + otherPN.G); otherPN.cost = tmpCost; otherPN.parent = pathNode; other.UpdateRecursiveG(path, otherPN, handler); //Or if the path from this node ("other") to the current ("current") is better } else if (otherPN.G + tmpCost < pathNode.G && other.ContainsConnection(this)) { //Debug.Log ("Path better from " + otherPN.node.NodeIndex + " to " + NodeIndex + " " + (otherPN.G+tmpCost+path.GetTraversalCost (this)) + " < " + pathNode.G); pathNode.parent = otherPN; pathNode.cost = tmpCost; UpdateRecursiveG(path, pathNode, handler); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { if (this.connections == null) { return; } for (int i = 0; i < this.connections.Length; i++) { GraphNode node = this.connections[i].node; if (path.CanTraverse(node)) { PathNode pathNode2 = handler.GetPathNode(node); if (pathNode2.pathID != handler.PathID) { pathNode2.parent = pathNode; pathNode2.pathID = handler.PathID; pathNode2.cost = this.connections[i].cost; pathNode2.H = path.CalculateHScore(node); node.UpdateG(path, pathNode2); handler.heap.Add(pathNode2); } else { uint cost = this.connections[i].cost; if (pathNode.G + cost + path.GetTraversalCost(node) < pathNode2.G) { pathNode2.cost = cost; pathNode2.parent = pathNode; node.UpdateRecursiveG(path, pathNode2, handler); } else if (pathNode2.G + cost + path.GetTraversalCost(this) < pathNode.G && node.ContainsConnection(this)) { pathNode.parent = pathNode2; pathNode.cost = cost; this.UpdateRecursiveG(path, pathNode, handler); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { GridGraph gg = GetGridGraph(GraphIndex); ushort pid = handler.PathID; #if ASTAR_JPS if (gg.useJumpPointSearch && !path.FloodingPath) { JPSOpen(path, pathNode, handler); } else #endif { int[] neighbourOffsets = gg.neighbourOffsets; uint[] neighbourCosts = gg.neighbourCosts; GridNode[] nodes = gg.nodes; for (int i = 0; i < 8; i++) { if (GetConnectionInternal(i)) { GridNode other = nodes[nodeInGridIndex + neighbourOffsets[i]]; if (!path.CanTraverse(other)) { continue; } PathNode otherPN = handler.GetPathNode(other); uint tmpCost = neighbourCosts[i]; if (otherPN.pathID != pid) { otherPN.parent = pathNode; otherPN.pathID = pid; otherPN.cost = tmpCost; otherPN.H = path.CalculateHScore(other); other.UpdateG(path, otherPN); //Debug.Log ("G " + otherPN.G + " F " + otherPN.F); handler.PushNode(otherPN); //Debug.DrawRay ((Vector3)otherPN.node.Position, Vector3.up,Color.blue); } else { // Sorry for the huge number of #ifs //If not we can test if the path from the current node to this one is a better one then the one already used #if ASTAR_NO_TRAVERSAL_COST if (pathNode.G + tmpCost < otherPN.G) #else if (pathNode.G + tmpCost + path.GetTraversalCost(other) < otherPN.G) #endif { //Debug.Log ("Path better from " + NodeIndex + " to " + otherPN.node.NodeIndex + " " + (pathNode.G+tmpCost+path.GetTraversalCost(other)) + " < " + otherPN.G); otherPN.cost = tmpCost; otherPN.parent = pathNode; other.UpdateRecursiveG(path, otherPN, handler); //Or if the path from this node ("other") to the current ("current") is better } #if ASTAR_NO_TRAVERSAL_COST else if (otherPN.G + tmpCost < pathNode.G) #else else if (otherPN.G + tmpCost + path.GetTraversalCost(this) < pathNode.G) #endif { //Debug.Log ("Path better from " + otherPN.node.NodeIndex + " to " + NodeIndex + " " + (otherPN.G+tmpCost+path.GetTraversalCost (this)) + " < " + pathNode.G); pathNode.parent = otherPN; pathNode.cost = tmpCost; UpdateRecursiveG(path, pathNode, handler); } } } } } #if !ASTAR_GRID_NO_CUSTOM_CONNECTIONS if (connections != null) { for (int i = 0; i < connections.Length; i++) { GraphNode other = connections[i]; if (!path.CanTraverse(other)) { continue; } PathNode otherPN = handler.GetPathNode(other); uint tmpCost = connectionCosts[i]; if (otherPN.pathID != pid) { otherPN.parent = pathNode; otherPN.pathID = pid; otherPN.cost = tmpCost; otherPN.H = path.CalculateHScore(other); other.UpdateG(path, otherPN); //Debug.Log ("G " + otherPN.G + " F " + otherPN.F); handler.PushNode(otherPN); //Debug.DrawRay ((Vector3)otherPN.node.Position, Vector3.up,Color.blue); } else { // Sorry for the huge number of #ifs //If not we can test if the path from the current node to this one is a better one then the one already used #if ASTAR_NO_TRAVERSAL_COST if (pathNode.G + tmpCost < otherPN.G) #else if (pathNode.G + tmpCost + path.GetTraversalCost(other) < otherPN.G) #endif { //Debug.Log ("Path better from " + NodeIndex + " to " + otherPN.node.NodeIndex + " " + (pathNode.G+tmpCost+path.GetTraversalCost(other)) + " < " + otherPN.G); otherPN.cost = tmpCost; otherPN.parent = pathNode; other.UpdateRecursiveG(path, otherPN, handler); //Or if the path from this node ("other") to the current ("current") is better } #if ASTAR_NO_TRAVERSAL_COST else if (otherPN.G + tmpCost < pathNode.G && other.ContainsConnection(this)) #else else if (otherPN.G + tmpCost + path.GetTraversalCost(this) < pathNode.G && other.ContainsConnection(this)) #endif { //Debug.Log ("Path better from " + otherPN.node.NodeIndex + " to " + NodeIndex + " " + (otherPN.G+tmpCost+path.GetTraversalCost (this)) + " < " + pathNode.G); pathNode.parent = otherPN; pathNode.cost = tmpCost; UpdateRecursiveG(path, pathNode, handler); } } } } #endif }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { if (base.connections != null) { bool flag = pathNode.flag2; for (int i = base.connections.Length - 1; i >= 0; i--) { GraphNode node = base.connections[i]; if (path.CanTraverse(node)) { PathNode node2 = handler.GetPathNode(node); if (node2 != pathNode.parent) { uint currentCost = base.connectionCosts[i]; if (flag || node2.flag2) { currentCost = path.GetConnectionSpecialCost(this, node, currentCost); } if (node2.pathID != handler.PathID) { node2.node = node; node2.parent = pathNode; node2.pathID = handler.PathID; node2.cost = currentCost; node2.H = path.CalculateHScore(node); node.UpdateG(path, node2); handler.PushNode(node2); } else if (((pathNode.G + currentCost) + path.GetTraversalCost(node)) < node2.G) { node2.cost = currentCost; node2.parent = pathNode; node.UpdateRecursiveG(path, node2, handler); } else if ((((node2.G + currentCost) + path.GetTraversalCost(this)) < pathNode.G) && node.ContainsConnection(this)) { pathNode.parent = node2; pathNode.cost = currentCost; this.UpdateRecursiveG(path, pathNode, handler); } } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { GridGraph gridGraph = GridNode.GetGridGraph(base.GraphIndex); ushort pathID = handler.PathID; int[] neighbourOffsets = gridGraph.neighbourOffsets; uint[] neighbourCosts = gridGraph.neighbourCosts; GridNode[] nodes = gridGraph.nodes; for (int i = 0; i < 8; i++) { if (this.GetConnectionInternal(i)) { GridNode gridNode = nodes[this.nodeInGridIndex + neighbourOffsets[i]]; if (path.CanTraverse(gridNode)) { PathNode pathNode2 = handler.GetPathNode(gridNode); uint num = neighbourCosts[i]; if (pathNode2.pathID != pathID) { pathNode2.parent = pathNode; pathNode2.pathID = pathID; pathNode2.cost = num; pathNode2.H = path.CalculateHScore(gridNode); gridNode.UpdateG(path, pathNode2); handler.PushNode(pathNode2); } else if (pathNode.G + num + path.GetTraversalCost(gridNode) < pathNode2.G) { pathNode2.cost = num; pathNode2.parent = pathNode; gridNode.UpdateRecursiveG(path, pathNode2, handler); } else if (pathNode2.G + num + path.GetTraversalCost(this) < pathNode.G) { pathNode.parent = pathNode2; pathNode.cost = num; this.UpdateRecursiveG(path, pathNode, handler); } } } } if (this.connections != null) { for (int j = 0; j < this.connections.Length; j++) { GraphNode graphNode = this.connections[j]; if (path.CanTraverse(graphNode)) { PathNode pathNode3 = handler.GetPathNode(graphNode); uint num2 = this.connectionCosts[j]; if (pathNode3.pathID != pathID) { pathNode3.parent = pathNode; pathNode3.pathID = pathID; pathNode3.cost = num2; pathNode3.H = path.CalculateHScore(graphNode); graphNode.UpdateG(path, pathNode3); handler.PushNode(pathNode3); } else if (pathNode.G + num2 + path.GetTraversalCost(graphNode) < pathNode3.G) { pathNode3.cost = num2; pathNode3.parent = pathNode; graphNode.UpdateRecursiveG(path, pathNode3, handler); } else if (pathNode3.G + num2 + path.GetTraversalCost(this) < pathNode.G && graphNode.ContainsConnection(this)) { pathNode.parent = pathNode3; pathNode.cost = num2; this.UpdateRecursiveG(path, pathNode, handler); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { if (this.connections == null) { return; } bool flag = pathNode.flag2; for (int i = this.connections.Length - 1; i >= 0; i--) { GraphNode graphNode = this.connections[i]; if (path.CanTraverse(graphNode)) { PathNode pathNode2 = handler.GetPathNode(graphNode); if (pathNode2 != pathNode.parent) { uint num = this.connectionCosts[i]; if (flag || pathNode2.flag2) { num = path.GetConnectionSpecialCost(this, graphNode, num); } if (pathNode2.pathID != handler.PathID) { pathNode2.node = graphNode; pathNode2.parent = pathNode; pathNode2.pathID = handler.PathID; pathNode2.cost = num; pathNode2.H = path.CalculateHScore(graphNode); graphNode.UpdateG(path, pathNode2); handler.PushNode(pathNode2); } else if (pathNode.G + num + path.GetTraversalCost(graphNode) < pathNode2.G) { pathNode2.cost = num; pathNode2.parent = pathNode; graphNode.UpdateRecursiveG(path, pathNode2, handler); } else if (pathNode2.G + num + path.GetTraversalCost(this) < pathNode.G && graphNode.ContainsConnection(this)) { pathNode.parent = pathNode2; pathNode.cost = num; this.UpdateRecursiveG(path, pathNode, handler); } } } } }
public override void Open(Path path, PathNode pathNode, PathHandler handler) { if (this.connections != null) { for (int i = 0; i < this.connections.Length; i++) { GraphNode node = this.connections[i]; if (path.CanTraverse(node)) { PathNode node2 = handler.GetPathNode(node); if (node2.pathID != handler.PathID) { node2.node = node; node2.parent = pathNode; node2.pathID = handler.PathID; node2.cost = this.connectionCosts[i]; node2.H = path.CalculateHScore(node); node.UpdateG(path, node2); handler.PushNode(node2); } else { uint num2 = this.connectionCosts[i]; if (((pathNode.G + num2) + path.GetTraversalCost(node)) < node2.G) { node2.cost = num2; node2.parent = pathNode; node.UpdateRecursiveG(path, node2, handler); } else if ((((node2.G + num2) + path.GetTraversalCost(this)) < pathNode.G) && node.ContainsConnection(this)) { pathNode.parent = node2; pathNode.cost = num2; this.UpdateRecursiveG(path, pathNode, handler); } } } } } }