public NBS(double epsilon = 1d)
{
_forwardHeuristic = null;
_backwardHeuristic = null;
_counts = new Dictionary <double, int>();
_queue = new NBSQueue <TState>(epsilon);
ResetNodeCount();
}
public int CompareTo(Node other)
{
_priorityCache = FCost.CompareTo(other.FCost); // A* first comparison F Cost
if (_priorityCache == 0)
{
_priorityCache = HCost.CompareTo(other.HCost);
}
return(-_priorityCache); // Negative since the 1 meaning that the cost has a higher integer value and we are trying to find the lower cost
}
public int CompareTo(PathNode nodeToCompare)
{
int compare = FCost.CompareTo(nodeToCompare.FCost);
if (compare == 0) // 2 fcost are equal.
{
compare = HCost.CompareTo(nodeToCompare.HCost);
}
return(-compare);
}
public int CompareTo(AstarNode other)
{
var compare = FCost.CompareTo(other.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost);
}
return(-compare);
}
public int CompareTo(Node nodeToCompare)
{
int compare = FCost.CompareTo(nodeToCompare.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(nodeToCompare.HCost);
}
return(-compare);
}
public override int CompareTo(Node other)
{
int compare = FCost.CompareTo(other.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost);
}
return(-compare);
}
public int CompareTo(GridTile other)
{
int compare = FCost.CompareTo(other.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost);
}
return(-compare);
}
public int CompareTo(AbstractAStarNode other)
{
int compare = FCost.CompareTo(other.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost);
}
return(compare);
}
//odradi ovo preko delegata
public int CompareTo(Field other)
{
int compare = FCost.CompareTo(other.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost);
}
//1 curent item is lower priority
return(-compare);
}
public int CompareTo(PathNode other)
{
int compare = FCost.CompareTo(other.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost); //remember, hCost is the tiebreaker
}
//CompareTo on integers treats higher as better. Because this is a pathing algorithm, our problem instead is minimization. So therefore, we return _negative_ compare.
return(-compare);
}
public int CompareTo(PathfindingNode other)
{
var compare = FCost.CompareTo(other.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost);
}
return(-compare);
}
public int CompareTo(Node other)
{
var comparison = FCost.CompareTo(other.FCost);
if (comparison == 0)
{
comparison = HCost.CompareTo(other.HCost);
}
return(-comparison);
}
public int CompareTo(GridNodeAStar other)
{
var compare = FCost.CompareTo(other.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost);
}
return(-compare);
}
public int CompareTo(INode other)
{
int fCostCompare = -FCost.CompareTo(other.FCost);
if (fCostCompare == 0)
{
return(-HCost.CompareTo(other.HCost));
}
return(fCostCompare);
}
public void GetPath(TState from, TState to, GetStateHash <TState> getHash, GetSuccessors <TState> getSuccessors,
GCost <TState> gCost, HCost <TState> forward, HCost <TState> backward, List <TState> thePath)
{
if (InitializeSearch(from, to, getHash, getSuccessors, gCost, forward, backward, thePath) == false)
{
return;
}
while (!ExpandAPair(thePath))
{
}
}
public int CompareTo(Node toCompare)
{
int compare = FCost.CompareTo(toCompare.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(toCompare.HCost);
}
//less fcost - higher priority (for heap class)
return(-compare);
}
public int CompareTo(PathfindingNode inNodeToCompare)
{
int compare = FCost.CompareTo(inNodeToCompare.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(inNodeToCompare.HCost);
}
// Flip the compare because we want to sort from lowest to highest.
return(-compare);
}
// --CURRENTLY UNUSED--
public int CompareTo(Node n)
{
int compare = FCost.CompareTo(n.FCost);
if (compare == 0)
{
compare = HCost.CompareTo(n.HCost);
}
// Need to flip the sign otherwise we get the wrong result!
return(compare * -1);
}
/// <summary>
/// The <c>CompareTo</c> method compares the <see cref="Node" />'s priority in a <see cref="Heap{T}" />.
/// This is based on the <see cref="Node.FCost" /> and <see cref="Node.HCost" />.
/// </summary>
/// <param name="other">The <see cref="Node" /> that it has to be compared to.</param>
/// <returns>
/// Returns <c>1</c> if it has a higher priority, <c>0</c> if the priority is the same and <c>-1</c> if it has a
/// lower priority.
/// </returns>
public int CompareTo(Node other)
{
// First compare the FCost between the nodes.
int compare = FCost.CompareTo(other.FCost);
// If both nodes have the same F-cost, take the H-cost in consideration.
if (compare == 0)
{
compare = HCost.CompareTo(other.HCost);
}
// Compare returns 1 if the value is higher, in this case we want to return 1 if the node has a higher priority and thus a lower compare value.
// So we need to invert the compare value and return it.
return(-compare);
}
public bool InitializeSearch(TState from, TState to, GetStateHash <TState> getHash, GetSuccessors <TState> getSuccessors,
GCost <TState> gCost, HCost <TState> forward, HCost <TState> backward, List <TState> thePath)
{
_getStateHash = getHash;
_gCost = gCost;
_getSuccessors = getSuccessors;
_forwardHeuristic = forward;
_backwardHeuristic = backward;
_currentCost = double.MaxValue;
_queue.Reset();
ResetNodeCount();
thePath.Clear();
_start = from;
_goal = to;
if (_start.Equals(_goal))
{
return(false);
}
_queue.ForwardQueue.AddOpenNode(_start, _getStateHash(_start), 0, _forwardHeuristic(_start, _goal));
_queue.BackwardQueue.AddOpenNode(_goal, _getStateHash(_goal), 0, _backwardHeuristic(_goal, _start));
return(true);
}
private void Expand(int nextID, BDOpenClosed <TState> current,
BDOpenClosed <TState> opposite, HCost <TState> heuristic, TState target)
{
current.Close();
//this can happen when we expand a single node instead of a pair
if (FPUtil.GreaterEq(current.Lookup(nextID).G + current.Lookup(nextID).H, _currentCost))
{
return;
}
_nodesExpanded++;
IEnumerable <TState> neighbors = _getSuccessors(current.Lookup(nextID).Data);
foreach (TState succ in neighbors)
{
_nodesTouched++;
StateLocation loc = current.Lookup(_getStateHash(succ), out int childID);
// screening
double edgeCost = _gCost(current.Lookup(nextID).Data, succ);
if (FPUtil.GreaterEq(current.Lookup(nextID).G + edgeCost, _currentCost))
{
continue;
}
switch (loc)
{
case StateLocation.Closed: // ignore
break;
case StateLocation.OpenReady: // update cost if needed
case StateLocation.OpenWaiting:
{
if (FPUtil.Less(current.Lookup(nextID).G + edgeCost, current.Lookup(childID).G))
{
double oldGCost = current.Lookup(childID).G;
current.Lookup(childID).ParentID = nextID;
current.Lookup(childID).G = current.Lookup(nextID).G + edgeCost;
current.KeyChanged(childID);
StateLocation loc2 = opposite.Lookup(_getStateHash(succ), out int reverseLoc);
if (loc2 == StateLocation.OpenReady || loc2 == StateLocation.OpenWaiting)
{
if (FPUtil.Less(current.Lookup(nextID).G + edgeCost + opposite.Lookup(reverseLoc).G, _currentCost))
{
_currentCost = current.Lookup(nextID).G + edgeCost + opposite.Lookup(reverseLoc).G;
_middleNode = succ;
}
}
else if (loc == StateLocation.Closed)
{
current.Remove(childID);
}
}
}
break;
case StateLocation.Unseen:
{
StateLocation locReverse = opposite.Lookup(_getStateHash(succ), out int reverseLoc);
if (locReverse != StateLocation.Closed)
{
double newNodeF = current.Lookup(nextID).G + edgeCost + heuristic(succ, target);
if (FPUtil.Less(newNodeF, _currentCost))
{
if (FPUtil.Less(newNodeF, _queue.GetLowerBound()))
{
current.AddOpenNode(succ,
_getStateHash(succ),
current.Lookup(nextID).G + edgeCost,
heuristic(succ, target),
nextID, StateLocation.OpenReady);
}
else
{
current.AddOpenNode(succ,
_getStateHash(succ),
current.Lookup(nextID).G + edgeCost,
heuristic(succ, target),
nextID, StateLocation.OpenWaiting);
}
if (locReverse == StateLocation.OpenReady || locReverse == StateLocation.OpenWaiting)
{
if (FPUtil.Less(current.Lookup(nextID).G + edgeCost + opposite.Lookup(reverseLoc).G, _currentCost))
{
_currentCost = current.Lookup(nextID).G + edgeCost + opposite.Lookup(reverseLoc).G;
_middleNode = succ;
}
}
}
}
}
break;
}
}
}
public void SetForwardHeuristic(HCost <TState> h)
{
_forwardHeuristic = h;
}
public void SetBackwardHeuristic(HCost <TState> h)
{
_backwardHeuristic = h;
}
public override int GetHashCode()
{
return((GCost.GetHashCode() + HCost.GetHashCode() + FCost.GetHashCode() + Position.GetHashCode()) * 26);
}
public int CompareTo(AStarNode other)
{
var dif = FCost.CompareTo(other.FCost);
return(dif == 0 ? HCost.CompareTo(other.HCost) : dif);
}
