void Insert(Heap* heap,int data){
if(heap->count==heap->capacity){
ResizeHeap(heap);
}
PercolateUp(heap,data);
heap->count++;
}
void AStar::FoundNode(Node *current_point, Node *new_point)
{
unsigned int g_value = CalculG(current_point, new_point->pos);
if (g_value < new_point->g)
{
new_point->g = g_value;
new_point->parent = current_point;
PercolateUp(GetIndex(new_point));
}
}
void PriorityQueue::InsertElement(int data)
{
if(count == 0)
{
A[0] = data;
count++;
return;
}
A[count] = data;
count++;
PercolateUp(count - 1);
}
void PriorityQueue::PercolateUp(int data)
{
if(data == 0) return;
int parent = Parent(data);
if(parent != -1)
{
if(heap_type == MAX_HEAP && A[parent] < A[data] ||
heap_type == MIN_HEAP && A[parent] > A[data])
{
int temp = A[parent];
A[parent] = A[data];
A[data] = temp;
PercolateUp(parent);
}
}
}
void HeapSort(double *pList, int cbLength )
{
int i;
double tmp;
for( i = 1; i < cbLength; i++ ) {
PercolateUp( i, pList );
}
for( i = cbLength - 1; i > 0; i-- ) {
tmp = pList[0];
pList[0] = pList[i];
pList[i] = tmp;
PercolateDown( i - 1, pList );
}
}
void AddOpen(PathFinder* pf, int x, int y, Node* parent)
{
if (x < 0 || x >= pf->map->width)
return;
if (y < 0 || y >= pf->map->height)
return;
// Ignore if the node isn't walkable
if (GetTile(pf->map, x, y) == Wall)
return;
// Ignore if the node has already been checked before.
if (pf->nodeMap[x][y].open == OnClosedList)
return;
if (pf->nodeMap[x][y].open == NoList)
{
pf->nodeMap[x][y].parent = parent;
pf->nodeMap[x][y].g = ComputeG(pf, x, y, parent);
pf->nodeMap[x][y].h = ComputeH(pf, x, y);
pf->nodeMap[x][y].f = ComputeF(pf, x, y);
pf->nodeMap[x][y].open = OnOpenList;
QueueAdd(pf->openList, &pf->nodeMap[x][y]);
}
else if (pf->nodeMap[x][y].open == OnOpenList)
{
int g = ComputeG(pf, x, y, parent);
// If this path we're currently searching is better, use it instead
if (pf->nodeMap[x][y].g > g)
{
pf->nodeMap[x][y].parent = parent;
pf->nodeMap[x][y].g = ComputeG(pf, x, y, parent);
pf->nodeMap[x][y].h = ComputeH(pf, x, y);
pf->nodeMap[x][y].f = ComputeF(pf, x, y);
int index = QueueSearch(pf->openList, &pf->nodeMap[x][y]);
PercolateUp(pf->openList, index, &pf->nodeMap[x][y]);
}
}
}
void AStar::HandleFoundNode(Node *current_node, Node *target_node)
{
unsigned int g_value = CalculGValue(current_node, target_node->pos);
if (g_value < target_node->g)
{
target_node->g = g_value;
target_node->parent = current_node;
size_t index = 0;
if (GetNodeIndex(target_node, index))
{
PercolateUp(index);
}
else
{
assert(false);
}
}
}
