Implementing A* pathfinding algorithm

Question

I'm having trouble implementing the last part of the A* pathfinding algorithm in a 2D array. I'm using the tutorial on https://www.raywenderlich.com/4946/introduction-to-a-pathfinding All the way at the end, there is the pseudocode for the alhorithm. I have been able to follow this code almost all the way to the end. The difference with my code and the pseudocode is that I precalculate all G, H and F values for all nodes. This is why have trouble implementing the last step. Here is the pseudocode:

[openList add:originalSquare]; // start by adding the original position to the open list
do {
currentSquare = [openList squareWithLowestFScore]; // Get the square with the lowest F score

[closedList add:currentSquare]; // add the current square to the closed list
[openList remove:currentSquare]; // remove it to the open list

if ([closedList contains:destinationSquare]) { // if we added the destination to the closed list, we've found a path
    // PATH FOUND
    break; // break the loop
}

adjacentSquares = [currentSquare walkableAdjacentSquares]; // Retrieve all its walkable adjacent squares

foreach (aSquare in adjacentSquares) {

    if ([closedList contains:aSquare]) { // if this adjacent square is already in the closed list ignore it
        continue; // Go to the next adjacent square
    }

    if (![openList contains:aSquare]) { // if its not in the open list

        // compute its score, set the parent
        [openList add:aSquare]; // and add it to the open list

    } else { // if its already in the open list

        // test if using the current G score make the aSquare F score lower, if yes update the parent because it means its a better path

    }
}

} while(![openList isEmpty]); // Continue until there is no more available square in the open list (which means there is no path)

The tutorial states it is written in Objective-C, but my implementation is in C++. Here is my calculatePath function:

AStarPath AStarSearch::calculatePath()
{
    if (!wasInit)
    {
        throw "AStarSearch::calculatePath():  A* Search was not initialized!\n";
    }
    /*Create open and closed lists*/
    std::vector<AStarNode*> openList;
    std::vector<AStarNode*> closedList;

    /*Add the start node to the open list*/
    openList.push_back(startNode);

    do
    {
        /*Get square with lowest F score in the open list*/
        AStarNode* currentNode = openList[0];
        for (int index = 0; index < openList.size(); ++index)
        {
            if (openList[index]->getF() < currentNode->getF())
                currentNode = openList[index];
        }

        /*Remove the current node from the open list, add it to the closed list*/
        std::remove(openList.begin(), openList.end(), currentNode);
        closedList.push_back(currentNode);

        /*Check if the destination is in the closed list*/
        if (std::find(closedList.begin(), closedList.end(), endNode) != closedList.end());
        {
            /*Found a path, break the loop*/
            break;
        }

        /*Find walkable and adjacent nodes*/
        std::vector<AStarNode*> walkableAdjacent = getWalkableAdjacentNodes(currentNode->getX(), currentNode->getY());
        for (std::vector<AStarNode*>::iterator it = walkableAdjacent.begin(); it != walkableAdjacent.end(); ++it)
        {
            /*Skip the node if it is in the closed list*/
            if (std::find(closedList.begin(), closedList.end(), *it) != closedList.end())
            {
                /*Skip to next node*/
                continue;
            }
            /*If the node is not in the open list, set it's parent and add it to the open list*/
            if (std::find(openList.begin(), openList.end(), *it) != closedList.end())
            {
                /*Set the parent to the current node*/
                (*it)->setParent(currentNode);
                /*Add the node to the open list*/
                openList.push_back(*it);
            }
            /*If the node is in the open list*/
            else
            {
                //This is the part I'm having trouble with
            }
        }

    } while (!openList.empty());
}

Pseudo code for what should come within the else statement would already help alot.

EDIT: Am I correct when I write this within the else statement:

/*Check if the node has a better G value than the current node*/
if ((*it)->getG() < currentNode->getG())
{
    /*Do I have to set a parent here?*/
}

Edit 2: I see my question is getting downvotes. Can someone tell me what I am doing wrong, so I can correct myself and give more information if needed, or learn from it from my next question?

Answer 1

As I have precalculated all G and F values, there is no point in updating them in the else statement, so I can just leave it empty.