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