private static void PrintTopK(Stream ip, int k, int magicNumber)
{
MinHeap <int> heap = new MinHeap <int>();
int val;
while ((val = ip.Next()) != -1)
{
if (val == magicNumber)
{
// print the heap
continue;
}
if (heap.Count == k)
{
if (heap.Peek() < val)
{
heap.Delete();
heap.Add(val);
}
}
else
{
heap.Add(val);
}
}
}
public void TestComparer()
{
MinHeap <int> minHeap = new MinHeap <int>(new ReverseIntComparer());
int items = 10;
minHeap.Add(10);
minHeap.Add(1);
minHeap.Add(9);
minHeap.Add(2);
minHeap.Add(8);
minHeap.Add(3);
minHeap.Add(7);
minHeap.Add(4);
minHeap.Add(6);
minHeap.Add(5);
StringBuilder actual = new StringBuilder();
for (int i = 0; i < items; i++)
{
actual.Append(minHeap.Remove());
}
string expected = "10987654321";
Assert.AreEqual(expected, actual.ToString());
}
//SOLUTION FOR LEETCODE QUESTION:
//253 - MEETING ROOMS II - Given an array of meeting time intervals intervals where intervals[i] = [starti, endi],
//return the minimum number of conference rooms required.
//*****DIFFICULTY - MEDIUM*****
/// <summary>
/// Method the returns minimum number of meeting rooms needed given an array of meeting intervals
/// </summary>
/// <param name="intervals"></param>
/// <returns>Number of meeting rooms</returns>
public int MinMeetingRooms(int[][] intervals)
{
//Sort intervals by starting time
Array.Sort(intervals, (item1, item2) => { return(item1[0].CompareTo(item2[0])); });
//Invoking MiniHeap class
var minHeap = new MinHeap(intervals.Length);
//Add the end time of the first interval to the MinHeap
minHeap.Add(intervals[0][1]);
//For each other interval, check if the start time is less than the current min on heap
for (int i = 1; i < intervals.Length; i++)
{
//If true add the end of current interval to MinHeap
if (intervals[i][0] >= minHeap.Peek())
{
minHeap.Pop();
}
//If false, pop the min and add the current end time to heap
minHeap.Add(intervals[i][1]);
}
//The number of elements left in the MinHeap will tell us the number of rooms needed
return(minHeap.Count());
}
public int KthSmallest(int[][] matrix, int k)
{
int n = matrix.Length;
int size = Math.Min(n, k);
int currentRank = 1;
MinHeap minHeap = new MinHeap(size);
for (int row = 0; row < size; row++)
{
minHeap.Add(new MatrixInfo(matrix[row][0], row, 0));
}
while (minHeap.Size() > 0)
{
if (currentRank == k)
{
return(minHeap.ExtractMin().Value);
}
MatrixInfo min = minHeap.ExtractMin();
if (min.Col + 1 < n)
{
var m = new MatrixInfo(matrix[min.Row][min.Col + 1], min.Row, min.Col + 1);
minHeap.Add(m);
}
currentRank++;
}
return(0);
}
public void AddSameKeyThrowException()
{
var heap = new MinHeap <string, double, Dictionary <string, int> >();
heap.Add("item1", 3.0);
Assert.Throws <ArgumentException>(() => heap.Add("item1", 4.0));
}
public static int Run(int[] input)
{
if (input == null || input.Length == 0)
{
throw new InvalidOperationException();
}
var root = input[0];
var left = new MaxHeap <int>();
var right = new MinHeap <int>();
for (var i = 1; i < input.Length; i++)
{
var current = input[i];
if (current <= root)
{
if (left.Count > right.Count)
{
if (left.GetRoot() > current)
{
right.Add(root);
root = left.Pop();
left.Add(current);
}
else
{
right.Add(root);
root = current;
}
}
else
{
left.Add(current);
}
}
else
{
if (right.Count + 1 > left.Count)
{
if (right.GetRoot() < current)
{
left.Add(root);
root = right.Pop();
right.Add(current);
}
else
{
left.Add(root);
root = current;
}
}
else
{
right.Add(current);
}
}
}
return(root);
}
private void CalculateIntegrateField()
{
InitGrid();
MinHeap <Node> open_set = new MinHeap <Node>(size_x * size_y);
open_set.Add(World2Node(player_pos));
while (open_set.Count > 0)
{
Node cur_node = open_set.RemoveFirst();
cur_node.mem_closed_set = true;
foreach (Node neighbour in GetNeighbours(cur_node))
{
if (neighbour.IsWalkable() && !neighbour.mem_closed_set)
{
float cost = cur_node.cost_val + CalculateCost(cur_node.grid_x, cur_node.grid_y, neighbour.grid_x, neighbour.grid_y);
if (cost < neighbour.cost_val)
{
neighbour.cost_val = cost;
neighbour.parent = cur_node;
}
if (!open_set.Contains(neighbour))
{
open_set.Add(neighbour);
}
else
{
open_set.UpdateItem(neighbour);
}
}
}
}
//Debug.Log()
}
public void AddNum(int num)
{
if (maxH.GetSize() > 0 && num >= maxH.Peek()) // If num is bigger than the 1st half it goes to the 2nd half
{
minH.Add(num);
}
else
{
maxH.Add(num);
}
if (Math.Abs(maxH.GetSize() - minH.GetSize()) > 1) // If there are more than one number of difference
{
if (maxH.GetSize() > minH.GetSize())
{
int number = maxH.Pull();
minH.Add(number);
}
else
{
int number = minH.Pull();
maxH.Add(number);
}
}
}
/// <summary>
///
/// </summary>
void ProcessEdge(Edge edge, Operand o)
{
int owningPolygon = (int)o;
if (edge.From == edge.To)
{
return;
}
SweepEvent from = new SweepEvent(edge.From, true, owningPolygon, null);
SweepEvent to = new SweepEvent(edge.To, true, owningPolygon, from);
from.Other = to;
if (from.Point.x < to.Point.x)
{
to.Left = false;
}
else if (from.Point.x > to.Point.x)
{
from.Left = false;
}
else if (from.Point.y < to.Point.y)
{
to.Left = false; // the line segment is vertical. The bottom endpoint is the left endpoint
}
else
{
from.Left = false;
}
futureSweepLineEvents.Add(from);
futureSweepLineEvents.Add(to);
}
IEnumerator FindAIPath(Vector3 startPos, Vector3 targetPos)
{
Vector3[] waypoints = new Vector3[0];
bool pathSuccess = false;
Node startNode = grid.NodeFromWorldPoint(startPos);
Node targetNode = grid.NodeFromWorldPoint(targetPos);
if ((startNode.walkable && startNode.aiWalkable) && (targetNode.walkable && targetNode.aiWalkable))
{
MinHeap <Node> openSet = new MinHeap <Node>(grid.MaxSize);
HashSet <Node> closedSet = new HashSet <Node>();
openSet.Add(startNode);
while (openSet.Count > 0)
{
Node currentNode = openSet.RemoveFirst();
closedSet.Add(currentNode);
if (currentNode == targetNode)
{
pathSuccess = true;
break;
}
foreach (Node neighbour in grid.GetNeighbours(currentNode))
{
if (!(neighbour.walkable && neighbour.aiWalkable) || closedSet.Contains(neighbour))
{
continue;
}
int newMovementCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour);
if (newMovementCostToNeighbour < neighbour.gCost || !openSet.Contains(neighbour))
{
neighbour.gCost = newMovementCostToNeighbour;
neighbour.hCost = GetDistance(neighbour, targetNode);
neighbour.parent = currentNode;
if (!openSet.Contains(neighbour))
{
openSet.Add(neighbour);
}
else
{
openSet.UpdateItem(neighbour);
}
}
}
}
}
yield return(null);
if (pathSuccess)
{
waypoints = RetracePath(startNode, targetNode);
}
requestManager.FinishedProcessingPath(waypoints, pathSuccess);
}
public ListNode MergeKLists1(ListNode[] lists)
{
ListNode result = new ListNode(0);
ListNode pointer = result;
MinHeap mh = new MinHeap();
foreach (ListNode node in lists)
{
if (node != null)
{
mh.Add(node);
}
}
while (mh.Count > 0)
{
ListNode node = mh.PopMin();
if (node.next != null)
{
mh.Add(node.next);
}
pointer.next = node;
pointer = pointer.next;
}
return result.next;
}
public int LargestSumAfterKNegations(int[] A, int K)
{
var minheap = new MinHeap <int>();
int sum = 0;
foreach (var num in A)
{
sum += num;
minheap.Add(num);
}
int counter = 0;
while (counter < K)
{
if (minheap.Peek() <= 0)
{
var newVal = Math.Abs(minheap.Poll());
sum += newVal * 2;
minheap.Add(newVal);
}
else
{
var newVal = minheap.Poll();
sum -= newVal * 2;
minheap.Add(-newVal);
}
++counter;
}
return(sum);
}
public static void FindMinPath(Node source, Dictionary <Node, List <Connection> > graph)
{
MinHeap <Node> minHeap = new MinHeap <Node>();
foreach (var node in graph)
{
node.Key.DijkstraDistance = long.MaxValue;
}
source.DijkstraDistance = 0L;
minHeap.Add(source);
while (minHeap.Count > 0)
{
Node currentNode = minHeap.Remove();
foreach (var connection in graph[currentNode])
{
long distance = currentNode.DijkstraDistance + connection.Distance;
if (distance < connection.Node.DijkstraDistance)
{
connection.Node.DijkstraDistance = distance;
minHeap.Add(connection.Node);
}
}
}
}
void UpdatePossibleBridges(SimpleClosedPath exterior, SimpleClosedPath mainHole)
{
possibleBridges.Clear();
foreach (Vector2 from in mainHole.Points())
{
foreach (SimpleClosedPath hole in exterior.Holes())
{
if (hole == mainHole)
{
continue;
}
foreach (Vector2 to in hole.Points())
{
possibleBridges.Add(new ExtendedEdge(from, to));
}
}
foreach (Vector2 to in exterior.Points())
{
possibleBridges.Add(new ExtendedEdge(from, to));
}
}
// possibleBridges.Sort(bridgeComparer);
}
static long OperationCount(long minAllowedNumber, long[] initialNumbers)
{
var minHeap = new MinHeap();
for (var i = 0; i < initialNumbers.Length; i++)
{
minHeap.Add(initialNumbers[i]);
}
long operationCount = 0;
var currentMin = minHeap.PeekMin();
while (minHeap.Count >= 2 && minHeap.PeekMin() < minAllowedNumber)
{
operationCount++;
var minElement = minHeap.RemoveMin();
var secondMinElement = minHeap.RemoveMin();
var newElement = minElement + (2 * secondMinElement);
minHeap.Add(newElement);
currentMin = minHeap.PeekMin();
}
if (currentMin < minAllowedNumber)
{
return(-1);
}
return(operationCount);
}
private bool Finding(LinkE s, LinkE e)
{
bool bo = false;
MinHeap <LinkE> heap = new MinHeap <LinkE>();
heap.Add(s);
LinkE current;
while (heap.Count > 0)
{
current = heap.ExtractMin();
Debug.Log(current);
Map[current.R, current.C] = false; //设为已走过
if (current.EqualTo(end))
{
end.Pre = current.Pre;
return(true);
}
List <LinkE> nextElements = GetNextElements(current);
if (nextElements.Count > 0)
{
for (int i = 0; i < nextElements.Count; i++)
{
nextElements[i].Pre = current;
heap.Add(nextElements[i]);
}
}
}
return(bo);
}
public void TestRemove_TenItems()
{
MinHeap <int> minHeap = new MinHeap <int>();
int items = 10;
minHeap.Add(10);
minHeap.Add(1);
minHeap.Add(9);
minHeap.Add(2);
minHeap.Add(8);
minHeap.Add(3);
minHeap.Add(7);
minHeap.Add(4);
minHeap.Add(6);
minHeap.Add(5);
StringBuilder actual = new StringBuilder();
for (int i = 0; i < items; i++)
{
actual.Append(minHeap.Remove());
}
string expected = "12345678910";
Assert.AreEqual(expected, actual.ToString());
}
public void AddFailsWhenReachedCapacity()
{
MinHeap heap = new MinHeap(2);
heap.Add(new Node(5));
heap.Add(new Node(3));
Assert.False(heap.Add(new Node(2)));
}
public void MinHeap_Test1()
{
var heap = new MinHeap <int>();
heap.Add(42);
heap.Add(48);
heap.Add(6);
Assert.Equal(6, heap.GetMin());
}
public void TestPeek_NonEmptyHeap()
{
MinHeap <int> minHeap = new MinHeap <int>();
minHeap.Add(90);
minHeap.Add(5);
minHeap.Add(15);
minHeap.Add(89);
Assert.AreEqual(5, minHeap.Peek());
}
public void GetMinTest()
{
var heap = new MinHeap <int, int>();
heap.Add(42, -1);
heap.Add(5, 6);
var Min = heap.Min;
Assert.AreEqual(42, Min.Key);
Assert.AreEqual(-1, Min.Value);
}
private MinHeap <int> getExampleHeap()
{
MinHeap <int> h = new MinHeap <int>();
h.Add(4);
h.Add(5);
h.Add(3);
h.Add(1);
h.Add(2);
return(h);
}
static void GetMedian(Stream ip)
{
int val;
MinHeap <int> rHeap = new MinHeap <int>();
MaxHeap <int> lHeap = new MaxHeap <int>();
double runningMedian = 0.0;
while ((val = ip.Next()) != -1)
{
if (rHeap.Count == lHeap.Count)
{
if (val < runningMedian)
{
lHeap.Add(val);
runningMedian = lHeap.Peek();
}
else
{
rHeap.Add(val);
runningMedian = rHeap.Peek();
}
}
else if (lHeap.Count > rHeap.Count)
{
if (val < runningMedian)
{
rHeap.Add(lHeap.Delete());
lHeap.Add(val);
}
else
{
rHeap.Add(val);
}
runningMedian = (lHeap.Peek() + rHeap.Peek()) / 2.0;
}
else
{
if (val < runningMedian)
{
lHeap.Add(val);
}
else
{
lHeap.Add(rHeap.Delete());
rHeap.Add(val);
}
runningMedian = (lHeap.Peek() + rHeap.Peek()) / 2.0;
}
}
}
//Astar implementation
public static LinkedList <Road> CreateJourney(Road start, Road destination)
{
HashSet <Road> closedList = new HashSet <Road>();
RoadComparer comp = new RoadComparer();
comp.destination = destination;
Heap <Road> openList = new MinHeap <Road>(comp);
Dictionary <Road, Road> cameFrom = new Dictionary <Road, Road>();
Dictionary <Road, float> nodeScore = new Dictionary <Road, float>();
openList.Add(start);
nodeScore[start] = 0f;
while (openList.Count != 0)
{
Road currentBest = openList.ExtractDominating();
//goal
if (Mathf.Approximately(0f, RoadDistance(destination, currentBest)))
{
return(CreatePath(start, cameFrom, destination));
}
closedList.Add(currentBest);
//expand nodes going from current best
List <Road> successors = currentBest.neighbourRoads;
foreach (Road successor in successors)
{
if (closedList.Contains(successor))
{
continue;
}
float tentative = nodeScore[currentBest] + RoadDistance(currentBest, successor);
float oldBestScore;
if (!nodeScore.TryGetValue(successor, out oldBestScore))
{
oldBestScore = float.MaxValue;
}
if (!openList.SlowContains(successor) || tentative < oldBestScore)
{
cameFrom[successor] = currentBest;
nodeScore[successor] = tentative;
if (!openList.SlowContains(successor))
{
openList.Add(successor);
}
}
}
}
return(null);
}
/// <summary>Find the closest path towards the exit.
/// <para>Returns null if no path was found.</para>
/// <para>NOTE: It can return null if <paramref name="start"/> is inside a closed door's position.</para>
/// </summary>
private Breadcrumb PathfindGenerateCrumbs(IMyCubeGrid grid, ref Vector3I start) // used in a background thread
{
scanned.Clear();
openList.Clear();
var startBreadcrumb = new Breadcrumb(start);
openList.Add(startBreadcrumb);
var directions = Base6Directions.IntDirections;
while (openList.HasNext())
{
var crumb = openList.GetFirst();
if (DistanceToBox(crumb.Position, grid.Min, grid.Max) < 0)
{
return(crumb); // found outside of grid, terminate.
}
for (int i = 0; i < directions.Length; ++i)
{
if (ShouldCancelTask)
{
return(null);
}
var dir = directions[i];
var moveId = new MoveId(ref crumb.Position, ref dir);
if (!scanned.Contains(moveId)) // ensure we didn't already check this position+direction
{
scanned.Add(moveId);
var target = crumb.Position + dir;
var distToOutside = DistanceToBox(target, grid.Min, grid.Max) + 1; // adding 1 to offset edges
if (distToOutside < 0) // gone outside of edge already, exit
{
return(crumb);
}
if (IsInInflatedBounds(grid, target) && !IsPressurized(grid, crumb.Position, target))
{
int pathCost = crumb.PathCost + 1; // direction movement cost, always 1 in our case
int cost = pathCost + distToOutside; // using distance to box edge instead of a predefined end
openList.Add(new Breadcrumb(target, cost, pathCost, crumb));
}
}
}
}
return(null);
}
public void MinReturnsHeapRoot()
{
MinHeap heap = new MinHeap(4);
heap.Add(new Node(5));
heap.Add(new Node(3));
heap.Add(new Node(2));
heap.Add(new Node(7));
Assert.Equal(2, heap.Min().Distance);
}
public void TestClear()
{
MinHeap <int> minHeap = new MinHeap <int>();
minHeap.Add(1);
minHeap.Add(2);
minHeap.Add(3);
minHeap.Clear();
Assert.AreEqual(0, minHeap.Count);
minHeap.Peek();
}
public void ContainsKeyTest()
{
var heap = new MinHeap <string, int, Dictionary <string, int> >();
heap.Add("item1", 3);
heap.Add("item2", 4);
heap.Add("item3", 8);
Assert.IsTrue(heap.ContainsKey("item2"));
Assert.IsFalse(heap.ContainsKey("item4"));
Assert.Throws <ArgumentNullException>(() => heap.ContainsKey(null));
}
public void AssertThat_Remove_UpdatesMinimum()
{
IMinHeap <int> heap = new MinHeap <int>();
heap.Add(5);
heap.Add(3);
heap.Add(7);
Assert.AreEqual(3, heap.RemoveMin());
Assert.AreEqual(5, heap.RemoveMin());
Assert.AreEqual(7, heap.RemoveMin());
}
public void IndexerTest()
{
var heap = new MinHeap <string, int, Dictionary <string, int> >();
heap.Add("item1", 3);
heap.Add("item2", 4);
heap.Add("item3", 8);
Assert.AreEqual(8, heap["item3"]);
Assert.Throws <KeyNotFoundException>(() => heap["item5"].ToString());
}
public MinHeap <Point> ExtractPoints(SortedSet <Segment> path)
{
MinHeap <Point> points = new MinHeap <Point>();
foreach (Segment item in path)
{
points.Add(item.Minimum);
points.Add(item.Maximum);
}
return(points);
}
public void RemoveItemsFromMinHeapCorrectlyUpdatesMinimum()
{
MinHeap<int> heap = new MinHeap<int>();
heap.Add(5);
heap.Add(3);
heap.Add(7);
Assert.AreEqual(3, heap.RemoveMin());
Assert.AreEqual(5, heap.Minimum);
}
public void AddItemToMinHeapCorrectlyUpdatesMinimum()
{
MinHeap<int> heap = new MinHeap<int>();
heap.Add(5);
Assert.AreEqual(5, heap.Minimum);
heap.Add(3);
Assert.AreEqual(3, heap.Minimum);
heap.Add(7);
Assert.AreEqual(3, heap.Minimum);
}
/// <summary>
/// call this to plan a path between points
/// </summary>
/// <param name="begin"></param>
/// <param name="end"></param>
/// <returns></returns>
public Route FindRoute(Location begin, Location end)
{
HashSet<MapTile> tilesToReset = new HashSet<MapTile>();//all tiles that need to be reset
MapTile mapEnd = Map[end.Row, end.Col];
MapTile mapBegin = Map[begin.Row, begin.Col];
tilesToReset.Add(mapBegin);
mapBegin.CostKnown = 0;
mapBegin.Heuristic = Globals.state.GetDistance(begin, end);
mapBegin.CostEstimate = mapBegin.CostKnown + mapBegin.Heuristic;
MinHeap<MapTile> OpenSet = new MinHeap<MapTile>();
OpenSet.Add(mapBegin);
while (!OpenSet.IsEmpty)
{
MapTile current = OpenSet.ExtractMin();
if (current == mapEnd)
return BuildRoute(mapEnd, tilesToReset);//reset after the oath is build, we need those pi pointers
foreach (Direction d in (Direction[])Enum.GetValues(typeof(Direction)))
{
Location tile = Globals.state.GetDestination(current.GetLocation, d);
MapTile neighbour = Map[tile.Row, tile.Col];
bool succesful = Relax(current, neighbour, mapEnd);
tilesToReset.Add(neighbour);//hashset will not contain duplicates
if (!neighbour.InOpenSet && succesful)
{
OpenSet.Add(neighbour);
neighbour.InOpenSet = true;//openset is a min heap, no O(1) lookup so store this in the tile
}
else
{
if (neighbour.InOpenSet && succesful)
{
OpenSet.ChangeKey(neighbour, neighbour.CostEstimate);
}
}
}
}
foreach (MapTile t in tilesToReset)//no route found, still need to reset
t.Reset();
return null;
}
public static IEnumerable<int> GetMedians(IEnumerable<int> sequence)
{
var enumerator = sequence.GetEnumerator();
var smallestNumbers = new MaxHeap<int>();
var largestNumbers = new MinHeap<int>();
if (enumerator.MoveNext())
{
var number = enumerator.Current;
smallestNumbers.Add(number);
yield return smallestNumbers.Max;
}
while (enumerator.MoveNext())
{
var number = enumerator.Current;
if (smallestNumbers.Count <= largestNumbers.Count)
{
if (number > largestNumbers.Min)
{
var min = largestNumbers.ExtractMin();
smallestNumbers.Add(min);
largestNumbers.Add(number);
}
else
{
smallestNumbers.Add(number);
}
}
else
{
if (number < smallestNumbers.Max)
{
var max = smallestNumbers.ExtractMax();
largestNumbers.Add(max);
smallestNumbers.Add(number);
}
else
{
largestNumbers.Add(number);
}
}
yield return smallestNumbers.Max;
}
}
public void TestInsert()
{
var list = new List<int> { 1, 9, 3, 6, 5, 2, 7, 11, 9 };
var minHeap = new MinHeap();
list.ForEach(elem => minHeap.Add(elem));
Assert.AreEqual(1, minHeap.peekMin());
}
public void InsertLotsOfNumbersToMinHeap()
{
var numbers = new int[] {
12,12,12,12,12,12,13,12,13,11,12,12,13,12,12,12,13,13,12,13,13,13,12,12,13,12,13,12,13,13,12,14,12,12,13,12,12,13,13,12,14,13,12,12,13,13,13,13,13,13,13,12,13,13,14,13,13,13,13,13,
};
MinHeap<int> heap = new MinHeap<int>(100, Comparer<int>.Default);
foreach (var number in numbers)
heap.Add(number);
while (heap.Count > 0)
heap.RemoveMin();
}
public void BulkInsertToMinHeap()
{
var values = new[] {
1, 2, 5, 213, 25, 3, 2, 5, 3, 2, 45, 2, 5, 2, 2, 4, 6, 32, 75, 5, 47, 7, 4, 3, 5, 34, 4
};
var heap = new MinHeap<int>(100, Comparer<int>.Default);
heap.Add(values);
//Sort values and test that the heap returns them in the same order
Array.Sort(values);
foreach (var value in values)
Assert.AreEqual(value, heap.RemoveMin());
}
public void testBunchOfInsertionsAndDeletions()
{
var list = new List<double> { 74, 101, 11, 1000, 4, -101, -1000 };
var minHeap = new MinHeap();
list.ForEach(elem => minHeap.Add(elem));
list.Sort();
var mins = new List<double>();
for (int i = 0; i < list.Count; i++)
{
mins.Add(minHeap.removeMin());
}
List<Tuple<double, double>> expectedVsActual = list.Zip(mins, Tuple.Create).ToList();
foreach(var tuple in expectedVsActual)
{
Assert.AreEqual(tuple.Item1, tuple.Item2);
}
}
/// <summary>
/// Finds the path reversed.
/// </summary>
/// <param name="roomUserable">The user.</param>
/// <param name="whatIsDiag">if set to <c>true</c> [diag].</param>
/// <param name="gameLocalMap">The map.</param>
/// <param name="startMap">The start.</param>
/// <param name="endMap">The end.</param>
/// <returns>PathFinderNode.</returns>
public static PathFinderNode FindPathReversed(RoomUser roomUserable, bool whatIsDiag, Gamemap gameLocalMap, Vector2D startMap, Vector2D endMap)
{
MinHeap<PathFinderNode> minSpanTreeCost = new MinHeap<PathFinderNode>(256);
PathFinderNode[,] pathFinderMap = new PathFinderNode[gameLocalMap.Model.MapSizeX, gameLocalMap.Model.MapSizeY];
PathFinderNode pathFinderStart = new PathFinderNode(startMap) {Cost = 0};
PathFinderNode pathFinderEnd = new PathFinderNode(endMap);
pathFinderMap[pathFinderStart.Position.X, pathFinderStart.Position.Y] = pathFinderStart;
minSpanTreeCost.Add(pathFinderStart);
while (minSpanTreeCost.Count > 0)
{
pathFinderStart = minSpanTreeCost.ExtractFirst();
pathFinderStart.InClosed = true;
for (int index = 0; (whatIsDiag ? (index < DiagMovePoints.Length ? 1 : 0) : (index < NoDiagMovePoints.Length ? 1 : 0)) != 0; index++)
{
Vector2D realEndPosition = pathFinderStart.Position + (whatIsDiag ? DiagMovePoints[index] : NoDiagMovePoints[index]);
bool isEndOfPath = (realEndPosition.X == endMap.X) && (realEndPosition.Y == endMap.Y);
if (gameLocalMap.IsValidStep(roomUserable, new Vector2D(pathFinderStart.Position.X, pathFinderStart.Position.Y), realEndPosition, isEndOfPath, roomUserable.AllowOverride))
{
PathFinderNode pathFinderSecondNodeCalculation;
if (pathFinderMap[realEndPosition.X, realEndPosition.Y] == null)
{
pathFinderSecondNodeCalculation = new PathFinderNode(realEndPosition);
pathFinderMap[realEndPosition.X, realEndPosition.Y] = pathFinderSecondNodeCalculation;
}
else
pathFinderSecondNodeCalculation = pathFinderMap[realEndPosition.X, realEndPosition.Y];
if (!pathFinderSecondNodeCalculation.InClosed)
{
int internalSpanTreeCost = 0;
if (pathFinderStart.Position.X != pathFinderSecondNodeCalculation.Position.X)
internalSpanTreeCost++;
if (pathFinderStart.Position.Y != pathFinderSecondNodeCalculation.Position.Y)
internalSpanTreeCost++;
int loopTotalCost = pathFinderStart.Cost + internalSpanTreeCost + pathFinderSecondNodeCalculation.Position.GetDistanceSquared(endMap);
if (loopTotalCost < pathFinderSecondNodeCalculation.Cost)
{
pathFinderSecondNodeCalculation.Cost = loopTotalCost;
pathFinderSecondNodeCalculation.Next = pathFinderStart;
}
if (!pathFinderSecondNodeCalculation.InOpen)
{
if (pathFinderSecondNodeCalculation.Equals(pathFinderEnd))
{
pathFinderSecondNodeCalculation.Next = pathFinderStart;
return pathFinderSecondNodeCalculation;
}
pathFinderSecondNodeCalculation.InOpen = true;
minSpanTreeCost.Add(pathFinderSecondNodeCalculation);
}
}
}
}
}
return null;
}
public static PathFinderNode FindPathReversed(RoomUser User, bool Diag, Gamemap Map, Vector2D Start, Vector2D End)
{
MinHeap<PathFinderNode> minHeap = new MinHeap<PathFinderNode>(256);
PathFinderNode[,] array = new PathFinderNode[Map.Model.MapSizeX, Map.Model.MapSizeY];
PathFinderNode pathFinderNode = new PathFinderNode(Start);
pathFinderNode.Cost = 0;
PathFinderNode breadcrumb = new PathFinderNode(End);
array[pathFinderNode.Position.X, pathFinderNode.Position.Y] = pathFinderNode;
minHeap.Add(pathFinderNode);
checked
{
while (minHeap.Count > 0)
{
pathFinderNode = minHeap.ExtractFirst();
pathFinderNode.InClosed = true;
int num = 0;
while (Diag ? (num < PathFinder.DiagMovePoints.Length) : (num < PathFinder.NoDiagMovePoints.Length))
{
Vector2D vector2D = pathFinderNode.Position + (Diag ? PathFinder.DiagMovePoints[num] : PathFinder.NoDiagMovePoints[num]);
bool endOfPath = vector2D.X == End.X && vector2D.Y == End.Y;
if (Map.IsValidStep(User, new Vector2D(pathFinderNode.Position.X, pathFinderNode.Position.Y), vector2D, endOfPath, User.AllowOverride))
{
PathFinderNode pathFinderNode2;
if (array[vector2D.X, vector2D.Y] == null)
{
pathFinderNode2 = new PathFinderNode(vector2D);
array[vector2D.X, vector2D.Y] = pathFinderNode2;
}
else
{
pathFinderNode2 = array[vector2D.X, vector2D.Y];
}
if (!pathFinderNode2.InClosed)
{
int num2 = 0;
if (pathFinderNode.Position.X != pathFinderNode2.Position.X)
{
num2++;
}
if (pathFinderNode.Position.Y != pathFinderNode2.Position.Y)
{
num2++;
}
int num3 = pathFinderNode.Cost + num2 + pathFinderNode2.Position.GetDistanceSquared(End);
if (num3 < pathFinderNode2.Cost)
{
pathFinderNode2.Cost = num3;
pathFinderNode2.Next = pathFinderNode;
}
if (!pathFinderNode2.InOpen)
{
if (pathFinderNode2.Equals(breadcrumb))
{
pathFinderNode2.Next = pathFinderNode;
return pathFinderNode2;
}
pathFinderNode2.InOpen = true;
minHeap.Add(pathFinderNode2);
}
}
}
num++;
}
}
return null;
}
}
public static PathFinderNode FindPathReversed(RoomUser User, bool Diag, Gamemap Map, Vector2D Start,
Vector2D End)
{
var OpenList = new MinHeap<PathFinderNode>(256);
var PfMap = new PathFinderNode[Map.Model.MapSizeX, Map.Model.MapSizeY];
PathFinderNode Node;
Vector2D Tmp;
int Cost;
int Diff;
var Current = new PathFinderNode(Start);
Current.Cost = 0;
var Finish = new PathFinderNode(End);
PfMap[Current.Position.X, Current.Position.Y] = Current;
OpenList.Add(Current);
while (OpenList.Count > 0)
{
Current = OpenList.ExtractFirst();
Current.InClosed = true;
for (int i = 0; Diag ? i < DiagMovePoints.Length : i < NoDiagMovePoints.Length; i++)
{
Tmp = Current.Position + (Diag ? DiagMovePoints[i] : NoDiagMovePoints[i]);
bool IsFinalMove = (Tmp.X == End.X && Tmp.Y == End.Y);
if (Map.IsValidStep(new Vector2D(Current.Position.X, Current.Position.Y), Tmp, IsFinalMove, User.AllowOverride))
{
if (PfMap[Tmp.X, Tmp.Y] == null)
{
Node = new PathFinderNode(Tmp);
PfMap[Tmp.X, Tmp.Y] = Node;
}
else
{
Node = PfMap[Tmp.X, Tmp.Y];
}
if (!Node.InClosed)
{
Diff = 0;
if (Current.Position.X != Node.Position.X)
{
Diff += 1;
}
if (Current.Position.Y != Node.Position.Y)
{
Diff += 1;
}
Cost = Current.Cost + Diff + Node.Position.GetDistanceSquared(End);
if (Cost < Node.Cost)
{
Node.Cost = Cost;
Node.Next = Current;
}
if (!Node.InOpen)
{
if (Node.Equals(Finish))
{
Node.Next = Current;
return Node;
}
Node.InOpen = true;
OpenList.Add(Node);
}
}
}
}
}
return null;
}
/// <summary>
/// Method that switfly finds the best path from start to end. Doesn't reverse outcome
/// </summary>
/// <returns>The end SearchNode where each .next is a step back</returns>
private SearchNode FindPathReversed(Point2 start, Point2 end)
{
SearchNode startNode = new SearchNode(start, 0, 0, null);
MinHeap openList = new MinHeap();
openList.Add(startNode);
int sx = myBoard.boardWidth;
int sy = myBoard.boardHeight;
bool[] brWorld = new bool[sx * sy];
brWorld[start.x + (start.y) * sx] = true;
Point2[] tilesAround;
while (openList.HasNext()) {
SearchNode current = openList.ExtractFirst();
tilesAround = (current.position.y % 2 == 0)? aroundEven : aroundOdd;
for (int i = 0; i < tilesAround.Length; i++) {
Point2 tmpy = tilesAround[i];
Point2 tmp = current.position + tmpy;
if (tmp == end) {
//int cst = tileList[tmp.y][tmp.x].GetComponent<HexTile>().stepCost;
return new SearchNode(end, current.pathCost, current.cost, current);
}
int brWorldIdx = tmp.x + (tmp.y) * sx;
if (hex_accessible(tmp) && brWorld[brWorldIdx] == false) {
brWorld[brWorldIdx] = true;
//int pathCost = current.pathCost + surr.Cost;
int pathCost = current.pathCost + 1;
int cost = pathCost + tmp.GetDistanceSquared(end);
SearchNode node = new SearchNode(tmp, cost, pathCost, current);
openList.Add(node);
}
}
}
return null; //no path found
}
public void TestAddAndCount()
{
var minHeap = new MinHeap<long>();
minHeap.Add(9999999999);
Assert.AreEqual(1, minHeap.Count);
}
public static VoronoiGraph ComputeVoronoiGraph(IEnumerable<Vector2> points)
{
var pq = new MinHeap<VEvent>();
var currentCircles = new Dictionary<VDataNode, VCircleEvent>();
var vg = new VoronoiGraph();
VNode rootNode = null;
foreach (var v in points)
{
pq.Add(new VDataEvent(v));
}
while (pq.Count > 0)
{
var ve = pq.RemoveMin();
VDataNode[] circleCheckList;
if (ve is VDataEvent)
{
rootNode = VNode.ProcessDataEvent(ve as VDataEvent, rootNode, vg, ve.Y, out circleCheckList);
}
else if (ve is VCircleEvent)
{
currentCircles.Remove(((VCircleEvent)ve).NodeN);
if (!((VCircleEvent)ve).Valid)
continue;
rootNode = VNode.ProcessCircleEvent(ve as VCircleEvent, rootNode, vg, out circleCheckList);
}
else
throw new Exception("Got event of type " + ve.GetType() + "!");
foreach (var vd in circleCheckList)
{
if (currentCircles.ContainsKey(vd))
{
currentCircles[vd].Valid = false;
currentCircles.Remove(vd);
}
var vce = VNode.CircleCheckDataNode(vd, ve.Y);
if (vce != null)
{
pq.Add(vce);
currentCircles[vd] = vce;
}
}
var evt = ve as VDataEvent;
if (evt != null)
{
var dp = evt.DataPoint;
foreach (var vce in currentCircles.Values)
{
if (Vector2.Distance(dp, vce.Center) < vce.Y - vce.Center.Y && Math.Abs(Vector2.Distance(dp, vce.Center) - (vce.Y - vce.Center.Y)) > 1e-10)
vce.Valid = false;
}
}
}
VNode.CleanUpTree(rootNode as VEdgeNode);
foreach (var ve in vg.Edges)
{
if (ve.Done)
continue;
if (!ve.VVertexB.HasValue)
{
ve.AddVertex(VvInfinite);
if (Math.Abs(ve.LeftData.Y - ve.RightData.Y) < 1e-10 && ve.LeftData.X < ve.RightData.X)
{
var t = ve.LeftData;
ve.LeftData = ve.RightData;
ve.RightData = t;
}
}
}
var minuteEdges = new List<Edge>();
foreach (var ve in vg.Edges)
{
if (!ve.IsPartlyInfinite && ve.VVertexA.Equals(ve.VVertexB))
{
minuteEdges.Add(ve);
// prevent rounding errors from expanding to holes
foreach (var ve2 in vg.Edges)
{
if (ve2.VVertexA.Equals(ve.VVertexA))
ve2.VVertexA = ve.VVertexA;
if (ve2.VVertexB.Equals(ve.VVertexA))
ve2.VVertexB = ve.VVertexA;
}
}
}
foreach (var ve in minuteEdges)
vg.MutableEdges.Remove(ve);
return vg;
}
private static void MinTest()
{
Console.WriteLine("\nThis section is to test the MIN HEAP class.\n");
string sort_error = "The current value is not grater than the next value on the array.";
string pop_error = "The current value is not less than the next value on the array";
string invariant_error = "The invariants have been broken.";
MinHeap<int> myHeap = new MinHeap<int>();
int[] numberList = new int[] { 2, 5, 9, 2, 8, 1, 4, 7, 3, 6 };
Console.WriteLine("Adding the following numbers to the heap: [{0}]\n",
string.Join(", ", numberList));
foreach (int number in numberList)
myHeap.Add(number);
Console.WriteLine("New Heap: [{0}]\n", string.Join(", ", myHeap));
Console.WriteLine("Performing Heap Sort...\n");
myHeap.Sort();
TestMinSort(myHeap, sort_error);
Console.WriteLine("New Heap: [{0}]\n", string.Join(", ", myHeap));
Console.WriteLine("Rebuilding Heap...\n");
myHeap.BuildHeap();
Console.WriteLine("New Heap: [{0}]\n", string.Join(", ", myHeap));
Console.WriteLine("Poping the top value until heap is empty...\n");
TestMinPop(myHeap, pop_error);
int elements = 20000;
myHeap = new MinHeap<int>(elements);
int[] random_list = RandomIntArray(elements);
Console.WriteLine("Adding {0} values to a new heap and verifying the invariants...\n", elements);
Console.WriteLine("This part will take a while...\n");
foreach (int number in random_list)
{
myHeap.Add(number);
TestMinInvariant(myHeap, invariant_error);
}
Console.WriteLine("Heap too big to print on console, current elements in heap: {0}\n", myHeap.Count);
Console.WriteLine("Going to pop half of the values out of the heap and verifying the invariants...\n");
Console.WriteLine("Again... This part will take a while...\n");
for (int i = 0; i < elements / 2; i++)
{
myHeap.PopMin();
TestMinInvariant(myHeap, invariant_error);
}
Console.WriteLine("Heap too big to print on console, current elements in heap: {0}\n", myHeap.Count);
}
/// <summary>
/// Method that switfly finds the best path from start to end. Doesn't reverse outcome
/// </summary>
/// <returns>The end breadcrump where each next is a step back)</returns>
private static BreadCrumb FindPathReversed(Level world, BotMap level, Point3D start, Point3D end)
{
MinHeap<BreadCrumb> openList = new MinHeap<BreadCrumb>(256);
BreadCrumb[, ,] brWorld = new BreadCrumb[world.Size.x, world.Size.y, world.Size.z];
BreadCrumb node;
Point3D tmp;
int cost;
int diff;
BreadCrumb current = new BreadCrumb(start);
current.cost = 0;
BreadCrumb finish = new BreadCrumb(end);
try
{
brWorld[current.position.X, current.position.Y, current.position.Z] = current;
}
catch { return current; }
openList.Add(current);
while (openList.Count > 0)
{
//Find best item and switch it to the 'closedList'
current = openList.ExtractFirst();
current.onClosedList = true;
//Find neighbours
for (int i = 0; i < surrounding.Length; i++)
{
tmp = current.position + surrounding[i];
if ((tmp.X <= -1 || tmp.Y <= -1 || tmp.Z <= -1) || (tmp.X >= level.Size.x || tmp.Y >= level.Size.y || tmp.Z >= level.Size.z))
break;
TriBool block = false;
try
{
block = level.AirMap[tmp.X, tmp.Z, tmp.Y]; //Check if block is air
}
catch { }
if (block != TriBool.Unknown)
{
//Check if we've already examined a neighbour, if not create a new node for it.
if (brWorld[tmp.X, tmp.Y, tmp.Z] == null)
{
node = new BreadCrumb(tmp);
brWorld[tmp.X, tmp.Y, tmp.Z] = node;
}
else
{
node = brWorld[tmp.X, tmp.Y, tmp.Z];
}
//If the node is not on the 'closedList' check it's new score, keep the best
if (!node.onClosedList)
{
diff = 0;
if (current.position.X != node.position.X)
{
diff += 1;
}
if (current.position.Y != node.position.Y)
{
diff += 1;
}
if (current.position.Z != node.position.Z)
{
diff += 1;
}
if (block == false) //Solid but breakable, allows bot to go through solid areas
{
diff += 50;
}
cost = current.cost + diff + node.position.GetDistanceSquared(end);
if (cost < node.cost)
{
node.cost = cost;
node.next = current;
}
//If the node wasn't on the openList yet, add it
if (!node.onOpenList)
{
//Check to see if we're done
if (node.Equals(finish))
{
node.next = current;
return node;
}
node.onOpenList = true;
openList.Add(node);
}
}
}
}
}
return null; //no path found
}
public List<Node> Astar(Node start, Node goal)
{
if (start == null || goal == null){
return null;
}
if (start == goal)
{
return new List<Node> {start};
}
foreach(Node node in objectManager.NodeManager.nodes)
{
node.Reset();
}
MinHeap openSet = new MinHeap(start);
start.IsInOpenSet = true;
start.gScore = 0;
start.fScore = start.gScore + Heuristic_cost_estimate (goal, start);
Node current = null;
while (openSet.Count() > 0) {
current = openSet.GetRoot ();
current.IsInOpenSet = false;
current.IsInClosedSet = true;
if (current == goal)
{
return Reconstruct_path (start, goal);
}
foreach (Node neighbor in current.BorderTiles) {
if(neighbor == null || !neighbor.IsWalkable || neighbor.IsInClosedSet)
continue;
// if the new gscore is lower replace it
int tentativeGscore = current.gScore + Heuristic_cost_estimate (current, neighbor);
if (!neighbor.IsInOpenSet || tentativeGscore < neighbor.gScore) {
neighbor.parent = current;
neighbor.gScore = tentativeGscore;
neighbor.fScore = neighbor.gScore + Heuristic_cost_estimate (goal, neighbor);
if (!neighbor.IsInOpenSet){
openSet.Add (neighbor);
neighbor.IsInOpenSet = true;
}
else
{
openSet.Reevaluate(neighbor);
}
}
}
}
// Fail
return null;
}
/// <summary>
/// Neighbour handling of our AStar algorithm.
/// </summary>
private void HandleNeighbours(AStarNode current, List<MeshNode> neighbours, MinHeap<AStarNode> workingQueue, PointSet<float> workingCoords, PointSet<float> exploredCoords, Vector2 end)
{
foreach (MeshNode neighbour in neighbours)
{
// neighbour will be added if neither in workingQueue(workingCoords) nor exploredCoords
if (!exploredCoords.Contains(neighbour.mVector.X, neighbour.mVector.Y) && !workingCoords.Contains(neighbour.mVector.X, neighbour.mVector.Y))
{
double neighbourCostsToEnd = HelperMethods.EuklidDistance(neighbour.mVector, end);
double neighbourLatestCosts =
current.mLatestCosts + HelperMethods.EuklidDistance(current.mNode.mVector, neighbour.mVector);
AStarNode neighbour2 = new AStarNode(neighbourLatestCosts, neighbourCostsToEnd, neighbour, current);
// add neighbour with its heuristic value to workingQueue:
workingQueue.Add(HeuristicValue(neighbour2), neighbour2);
workingCoords.Add(neighbour.mVector.X, neighbour.mVector.Y);
}
}
}
/// <summary>
/// Method that switfly finds the best path from start to end. Doesn't reverse outcome
/// </summary>
/// <returns>The end breadcrump where each .next is a step back)</returns>
private static BreadCrumb FindPathReversed(World world, Point3D start, Point3D end)
{
MinHeap<BreadCrumb> openList = new MinHeap<BreadCrumb>(256);
BreadCrumb[, ,] brWorld = new BreadCrumb[world.Right, world.Top, world.Back];
BreadCrumb node;
Point3D tmp;
int cost;
int diff;
int count;
BreadCrumb current = new BreadCrumb(start);
current.cost = 0;
BreadCrumb finish = new BreadCrumb(end);
if (current.position.X < 0 || current.position.X > brWorld.GetUpperBound(0) || current.position.Y < 0 || current.position.Y > brWorld.GetUpperBound(0)) return null;
brWorld[current.position.X, current.position.Y, current.position.Z] = current;
openList.Add(current);
count = 0;
while (openList.Count > 0)
{
//Find best item and switch it to the 'closedList'
current = openList.ExtractFirst();
current.onClosedList = true;
//Find neighbours
for (int i = 0; i < surrounding.Length; i++)
{
tmp = current.position + surrounding[i];
if (world.PositionIsFree(tmp) || (tmp.X==end.X && tmp.Y==end.Y && tmp.Z==end.Z))
{
//Check if we've already examined a neighbour, if not create a new node for it.
if (brWorld[tmp.X, tmp.Y, tmp.Z] == null)
{
node = new BreadCrumb(tmp);
brWorld[tmp.X, tmp.Y, tmp.Z] = node;
}
else
{
node = brWorld[tmp.X, tmp.Y, tmp.Z];
}
//If the node is not on the 'closedList' check it's new score, keep the best
if (!node.onClosedList)
{
diff = 0;
if (current.position.X != node.position.X)
{
diff += 1;
}
if (current.position.Y != node.position.Y)
{
diff += 1;
}
if (current.position.Z != node.position.Z)
{
diff += 1;
}
cost = current.cost + diff + node.position.GetDistanceSquared(end);
if (cost < node.cost)
{
node.cost = cost;
node.next = current;
}
//If the node wasn't on the openList yet, add it
if (!node.onOpenList)
{
//Check to see if we're done
if (node.Equals(finish))
{
node.next = current;
return node;
}
node.onOpenList = true;
openList.Add(node);
}
}
}
}
count++;
if (count > 1000) return null;
}
return null; //no path found
}
/// <summary>
/// Finds the path reversed.
/// </summary>
/// <param name="RoomUserable">The user.</param>
/// <param name="WhatIsDiag">if set to <c>true</c> [diag].</param>
/// <param name="GameLocalMap">The map.</param>
/// <param name="StartMap">The start.</param>
/// <param name="EndMap">The end.</param>
/// <returns>PathFinderNode.</returns>
public static PathFinderNode FindPathReversed(RoomUser RoomUserable, bool WhatIsDiag, Gamemap GameLocalMap, Vector2D StartMap, Vector2D EndMap)
{
MinHeap<PathFinderNode> MinSpanTreeCost = new MinHeap<PathFinderNode>(256);
PathFinderNode[,] PathFinderMap = new PathFinderNode[GameLocalMap.Model.MapSizeX, GameLocalMap.Model.MapSizeY];
PathFinderNode PathFinderStart = new PathFinderNode(StartMap) { Cost = 0 };
PathFinderNode PathFinderEnd = new PathFinderNode(EndMap);
PathFinderMap[PathFinderStart.Position.X, PathFinderStart.Position.Y] = PathFinderStart;
MinSpanTreeCost.Add(PathFinderStart);
int loop_variable_one, InternalSpanTreeCost, loop_total_cost;
while (MinSpanTreeCost.Count > 0)
{
PathFinderStart = MinSpanTreeCost.ExtractFirst();
PathFinderStart.InClosed = true;
loop_variable_one = 0;
while ((WhatIsDiag ? (loop_variable_one < DiagMovePoints.Length) : (loop_variable_one < NoDiagMovePoints.Length)))
{
Vector2D RealEndPosition = PathFinderStart.Position + (WhatIsDiag ? DiagMovePoints[loop_variable_one] : NoDiagMovePoints[loop_variable_one]);
bool IsEndOfPath = ((RealEndPosition.X == EndMap.X) && (RealEndPosition.Y == EndMap.Y));
if (GameLocalMap.IsValidStep(RoomUserable, new Vector2D(PathFinderStart.Position.X, PathFinderStart.Position.Y), RealEndPosition, IsEndOfPath, RoomUserable.AllowOverride))
{
PathFinderNode PathFinderSecondNodeCalculation;
if (PathFinderMap[RealEndPosition.X, RealEndPosition.Y] == null)
{
PathFinderSecondNodeCalculation = new PathFinderNode(RealEndPosition);
PathFinderMap[RealEndPosition.X, RealEndPosition.Y] = PathFinderSecondNodeCalculation;
}
else
{
PathFinderSecondNodeCalculation = PathFinderMap[RealEndPosition.X, RealEndPosition.Y];
}
if (!PathFinderSecondNodeCalculation.InClosed)
{
InternalSpanTreeCost = 0;
if (PathFinderStart.Position.X != PathFinderSecondNodeCalculation.Position.X)
InternalSpanTreeCost++;
if (PathFinderStart.Position.Y != PathFinderSecondNodeCalculation.Position.Y)
InternalSpanTreeCost++;
loop_total_cost = PathFinderStart.Cost + InternalSpanTreeCost + PathFinderSecondNodeCalculation.Position.GetDistanceSquared(EndMap);
if (loop_total_cost < PathFinderSecondNodeCalculation.Cost)
{
PathFinderSecondNodeCalculation.Cost = loop_total_cost;
PathFinderSecondNodeCalculation.Next = PathFinderStart;
}
if (!PathFinderSecondNodeCalculation.InOpen)
{
if (PathFinderSecondNodeCalculation.Equals(PathFinderEnd))
{
PathFinderSecondNodeCalculation.Next = PathFinderStart;
return PathFinderSecondNodeCalculation;
}
PathFinderSecondNodeCalculation.InOpen = true;
MinSpanTreeCost.Add(PathFinderSecondNodeCalculation);
}
}
}
loop_variable_one++;
}
}
return null;
}
