/** Initializes the path. Sets up the open list and adds the first node to it */ public virtual void Initialize() { System.DateTime startTime = System.DateTime.Now; //Resets the binary heap, don't clear it because that takes an awful lot of time, instead we can just change the numberOfItems in it (which is just an int) //Binary heaps are just like a standard array but are always sorted so the node with the lowest F value can be retrieved faster open = AstarPath.active.binaryHeap; open.numberOfItems = 1; if (hasEndPoint && startNode == endNode) { endNode.parent = null; endNode.h = 0; endNode.g = 0; Trace(endNode); foundEnd = true; return; } //Adjust the costs for the end node if (hasEndPoint && recalcStartEndCosts) { endNodeCosts = endNode.InitialOpen(open, hTarget, (Int3)endPoint, this, false); callback += ResetCosts; /** \todo Might interfere with other paths since other paths might be calculated before #callback is called */ } Node.activePath = this; startNode.pathID = pathID; startNode.parent = null; startNode.cost = 0; startNode.g = startNode.penalty; startNode.UpdateH(hTarget, heuristic, heuristicScale); if (recalcStartEndCosts) { startNode.InitialOpen(open, hTarget, startIntPoint, this, true); } else { startNode.Open(open, hTarget, this); } searchedNodes++; //any nodes left to search? if (open.numberOfItems <= 1) { LogError("No open points, the start node didn't open any nodes"); duration += (System.DateTime.Now.Ticks - startTime.Ticks) * 0.0001F; return; } current = open.Remove(); duration += (System.DateTime.Now.Ticks - startTime.Ticks) * 0.0001F; }
public override void Initialize() { if (hasEndPoint && startNode == endNode) { NodeRun endNodeR = endNode.GetNodeRun(runData); endNodeR.parent = null; endNodeR.h = 0; endNodeR.g = 0; Trace(endNodeR); CompleteState = PathCompleteState.Complete; return; } //Adjust the costs for the end node /*if (hasEndPoint && recalcStartEndCosts) { * endNodeCosts = endNode.InitialOpen (open,hTarget,(Int3)endPoint,this,false); * callback += ResetCosts; /* \todo Might interfere with other paths since other paths might be calculated before #callback is called * * }*/ NodeRun startRNode = startNode.GetNodeRun(runData); startRNode.pathID = pathID; startRNode.parent = null; startRNode.cost = 0; startRNode.g = startNode.penalty; startNode.UpdateH(hTarget, heuristic, heuristicScale, startRNode); /*if (recalcStartEndCosts) { * startNode.InitialOpen (open,hTarget,startIntPoint,this,true); * } else {*/ startNode.Open(runData, startRNode, hTarget, this); //} searchedNodes++; partialBestTarget = startRNode; //any nodes left to search? if (runData.open.numberOfItems <= 1) { if (calculatePartial) { CompleteState = PathCompleteState.Partial; Trace(partialBestTarget); } else { Error(); LogError("No open points, the start node didn't open any nodes"); return; } } currentR = runData.open.Remove(); }
/** Initializes the path. Sets up the open list and adds the first node to it */ public virtual void Initialize() { runData.pathID = pathID; //Resets the binary heap, don't clear everything because that takes an awful lot of time, instead we can just change the numberOfItems in it (which is just an int) //Binary heaps are just like a standard array but are always sorted so the node with the lowest F value can be retrieved faster runData.open.Clear(); if (hasEndPoint && startNode == endNode) { NodeRun endNodeR = endNode.GetNodeRun(runData); endNodeR.parent = null; endNodeR.h = 0; endNodeR.g = 0; Trace(endNodeR); foundEnd = true; return; } //Adjust the costs for the end node /*if (hasEndPoint && recalcStartEndCosts) { * endNodeCosts = endNode.InitialOpen (open,hTarget,(Int3)endPoint,this,false); * callback += ResetCosts; /* \todo Might interfere with other paths since other paths might be calculated before #callback is called * * }*/ //Node.activePath = this; NodeRun startRNode = startNode.GetNodeRun(runData); startRNode.pathID = pathID; startRNode.parent = null; startRNode.cost = 0; startRNode.g = startNode.penalty; startNode.UpdateH(hTarget, heuristic, heuristicScale, startRNode); /*if (recalcStartEndCosts) { * startNode.InitialOpen (open,hTarget,startIntPoint,this,true); * } else {*/ startNode.Open(runData, startRNode, hTarget, this); //} searchedNodes++; //any nodes left to search? if (runData.open.numberOfItems <= 1) { LogError("No open points, the start node didn't open any nodes"); return; } currentR = runData.open.Remove(); }
/** Initializes the path. * Sets up the open list and adds the first node to it */ public override void Initialize () { NodeRun startRNode = startNode.GetNodeRun (runData); startRNode.pathID = pathID; startRNode.parent = null; startRNode.cost = 0; startRNode.g = startNode.penalty; startNode.UpdateH (Int3.zero,heuristic,heuristicScale, startRNode); startNode.Open (runData,startRNode,Int3.zero,this); searchedNodes++; allNodes.Add (startNode); //any nodes left to search? if (runData.open.numberOfItems <= 1) { CompleteState = PathCompleteState.Complete; return; } currentR = runData.open.Remove (); }
/** Opens the nodes connected to this node. This is a base call and can be called by node classes overriding the Open function to open all connections in the #connections array. * \see #connections * \see Open */ public void BaseOpen(NodeRunData nodeRunData, NodeRun nodeR, Int3 targetPosition, Path path) { if (connections == null) { return; } for (int i = 0; i < connections.Length; i++) { Node node = connections[i]; if (!path.CanTraverse(node)) { continue; } NodeRun nodeR2 = node.GetNodeRun(nodeRunData); if (nodeR2.pathID != nodeRunData.pathID) { nodeR2.parent = nodeR; nodeR2.pathID = nodeRunData.pathID; nodeR2.cost = (uint)connectionCosts[i]; node.UpdateH(targetPosition, path.heuristic, path.heuristicScale, nodeR2); node.UpdateG(nodeR2, nodeRunData); nodeRunData.open.Add(nodeR2); //Debug.DrawLine (position,node.position,Color.cyan); //Debug.Log ("Opening Node "+node.position.ToString ()+" "+g+" "+node.cost+" "+node.g+" "+node.f); } else { //If not we can test if the path from the current node to this one is a better one then the one already used uint tmpCost = (uint)connectionCosts[i]; if (nodeR.g + tmpCost + node.penalty #if !NoTagPenalty + path.GetTagPenalty(node.tags) #endif < nodeR2.g) { nodeR2.cost = tmpCost; nodeR2.parent = nodeR; //TODO!!!!! ?? node.UpdateAllG(nodeR2, nodeRunData); nodeRunData.open.Add(nodeR2); } else if (nodeR2.g + tmpCost + penalty #if !NoTagPenalty + path.GetTagPenalty(tags) #endif < nodeR.g) //Or if the path from this node ("node") to the current ("current") is better { bool contains = node.ContainsConnection(this); //Make sure we don't travel along the wrong direction of a one way link now, make sure the Current node can be moved to from the other Node. /*if (node.connections != null) { * for (int y=0;y<node.connections.Length;y++) { * if (node.connections[y] == this) { * contains = true; * break; * } * } * }*/ if (!contains) { continue; } nodeR.parent = nodeR2; nodeR.cost = tmpCost; //TODO!!!!!!! ?? UpdateAllG(nodeR, nodeRunData); nodeRunData.open.Add(nodeR); } } } }