// This looks in the Hash if a node exists in ClosedList

//  If so, it returns the PathNode, else NULL

{

	return (PathNode*)Hash_Get(&aystar->ClosedListHash, node->tile, node->direction);

}

// This adds a node to the ClosedList

//  It makes a copy of the data

{

	// Add a node to the ClosedList

	*new_node = *node;

	Hash_Set(&aystar->ClosedListHash, node->node.tile, node->node.direction, new_node);

}

// Checks if a node is in the OpenList

//   If so, it returns the OpenListNode, else NULL

{

	return (OpenListNode*)Hash_Get(&aystar->OpenListHash, node->tile, node->direction);

}

{

	// Return the item the Queue returns.. the best next OpenList item.

	OpenListNode* res = (OpenListNode*)aystar->OpenListQueue.pop(&aystar->OpenListQueue);

		Hash_Delete(&aystar->OpenListHash, res->path.node.tile, res->path.node.direction);

	return res;

}

// Adds a node to the OpenList

//  It makes a copy of node, and puts the pointer of parent in the struct

{

	// Add a new Node to the OpenList

	new_node->g = g;

	new_node->path.parent = parent;

	new_node->path.node = *node;

 *  return values:

 *	AYSTAR_DONE : indicates we are done

 */

	int new_f, new_g, new_h;

	PathNode *closedlist_parent;

	OpenListNode *check;

	closedlist_parent = AyStarMain_ClosedList_IsInList(aystar, &parent->path.node);

	// Check if this item is already in the OpenList

		uint i;

		// Yes, check if this g value is lower..

		if (new_g > check->g) return AYSTAR_DONE;

		check->g = new_g;

		check->path.parent = closedlist_parent;

		/* Copy user data, will probably have changed */

			check->path.node.user_data[i] = current->user_data[i];

		// Readd him in the OpenListQueue

		aystar->OpenListQueue.push(&aystar->OpenListQueue, check, new_f);

	} else {

 *	AYSTAR_FOUND_END_NODE : indicates we found the end. Path_found now is true, and in path is the path found.

 *	AYSTAR_STILL_BUSY : indicates we have done this tile, did not found the path yet, and have items left to try.

 */

	int i, r;

	// Get the best node from OpenList

	OpenListNode *current = AyStarMain_OpenList_Pop(aystar);

	// If empty, drop an error

	// Check for end node and if found, return that code

	if (aystar->EndNodeCheck(aystar, current) == AYSTAR_FOUND_END_NODE) {

	aystar->GetNeighbours(aystar, current);

	// Go through all neighbours

		// Check and add them to the OpenList if needed

		r = aystar->checktile(aystar, &aystar->neighbours[i], current);

	}

/*

 * This function frees the memory it allocated

 */

	aystar->OpenListQueue.free(&aystar->OpenListQueue, false);

	/* 2nd argument above is false, below is true, to free the values only

	 * once */

 * This function make the memory go back to zero

 *  This function should be called when you are using the same instance again.

 */

	// Clean the Queue, but not the elements within. That will be done by

	// the hash.

	aystar->OpenListQueue.clear(&aystar->OpenListQueue, false);

	//  Quit if result is no AYSTAR_STILL_BUSY or is more than loops_per_tick

	while ((r = aystar->loop(aystar)) == AYSTAR_STILL_BUSY && (aystar->loops_per_tick == 0 || ++i < aystar->loops_per_tick)) { }

#ifdef AYSTAR_DEBUG

#endif

	if (r != AYSTAR_STILL_BUSY) {

		/* We're done, clean up */

		aystar->clear(aystar);

	}

}

/*

 * clear() automatically when the algorithm finishes

 * g is the cost for starting with this node.

 */

#ifdef AYSTAR_DEBUG

	printf("[AyStar] Starting A* Algorithm from node (%d, %d, %d)\n",

		TileX(start_node->tile), TileY(start_node->tile), start_node->direction);

	AyStarMain_OpenList_Add(aystar, NULL, start_node, 0, g);

}

	// Allocated the Hash for the OpenList and ClosedList

	init_Hash(&aystar->OpenListHash, hash, num_buckets);

	init_Hash(&aystar->ClosedListHash, hash, num_buckets);