/// <summary>
/// Reconstructs the path created from the A* algorithm. This aswell is copy pasted from wikipedia.
/// This is definitely not optimally implemented. This is O(3 * |cameFrom|) = (|cameFrom|) and
/// could probably be implemented with a factor of 1.
/// </summary>
/// <param name="cameFrom">A dictionary holding the record of the best preceding node for the given node</param>
/// <param name="current">The node from which to reconstruct the path</param>
/// <returns></returns>
private static IPath ReconstructPath(IReadOnlyDictionary <INode, INode> cameFrom, INode current)
{
var path = new List <INode>();
var currentNode = current;
path.Add(current);
while (cameFrom.ContainsKey(currentNode))
{
currentNode = cameFrom[currentNode];
path.Add(currentNode);
}
path.Reverse();
var sortedPath = new SortedPath();
foreach (var node in path)
{
sortedPath.AddNode(node);
}
return(sortedPath);
}
private IPath GetPathForGeneralUnits(GeneralUnit unit, INode destination, int graphIndex)
{
IPath path;
try
{
path = PathfindingFactory.GetPathfinding().AStar(mGraphs[graphIndex], unit.CurrentNode, destination);
}
catch (KeyNotFoundException)
{
path = new SortedPath();
}
return(path);
}
