void PathFinder::update(double aDelta)
{
//Make sure we are in the seaching path state.
while(isSearchingPath() == true)
{
//Next make sure there is at least 1 path node in the open list.
//If there isn't it's possible that the destination can not be reached.
if(m_OpenList.size() == 0)
{
m_State = StateError;
return;
}
//Get the first path node from the Open List, because Open List is sorted,
//we know this is the Path Node with the lowest F score.
PathNode* currentNode = m_OpenList.front();
//Next add it to the closed list.
m_ClosedList.push_back(currentNode);
//Lastly remove it from the Open List
m_OpenList.erase(m_OpenList.begin());
//Next get the current node's tile's index from the level.
int currentNodeTileIndex = m_Level->getTileIndexForTile(currentNode->getTile());
if(currentNodeTileIndex == m_DestinationTileIndex)
{
//If the current node's tile index is the same as the destination tile, the we
//have reached out destination tile and now know the shortest path.
do
{
//If the parent node doesn't equal NULL, and the current node to the final path list.
if(currentNode->getParentNode() != NULL)
{
m_FinalPath.insert(m_FinalPath.begin(), currentNode);
}
//Set the node's tile isPath flag to true
currentNode->getTile()->setIsPath(true);
//Set the current node to the parent node.
currentNode = currentNode->getParentNode();
}
while(currentNode != NULL);
//Set the state to the PathFound
m_State = StatePathFound;
return;
}
//Now, if we got here, it means we haven't reached the destination, we need to
// get the current node's adjacent tiles and calculate their path scores.
std::vector<Tile*> adjacentTiles;
addAdjacentTile(adjacentTiles, currentNode->getTile(), -1, 0); //Left
addAdjacentTile(adjacentTiles, currentNode->getTile(), 1, 0); //Right
addAdjacentTile(adjacentTiles, currentNode->getTile(), 0, -1); //Up
addAdjacentTile(adjacentTiles, currentNode->getTile(), 0, 1); //Down
//Cycle through the adjacent tiles
for(int i = 0; i < adjacentTiles.size(); i++)
{
Tile* adjacentTile = adjacentTiles.at(i);
//Next we need to check if the adjacent tile is already in the close list,
//if it is, then we can ignore this tile.
if(isTileInClosedList(adjacentTile) == true)
{
continue;
}
//Then we need to check if the adjacent tile is already in the Open List
if(isTileInOpenList(adjacentTile) == true)
{
//If we got here, then the tile is in the Open list alreadu and we have to determine
//if the existing tile's score is lower or the adjacent tile.
PathNode* existingNode = getPathNodeFromOpenList(adjacentTile);
//Check to see if the adjacent node has a higher G Score
//(since the h scores will be identical)
//than the existing node's G score.
if(existingNode->getScoreG() > currentNode->getScoreG() +1)
{
//Update the existing node's parent.
existingNode->setParentNode(currentNode);
//Set the lower G score
existingNode->setScoreG(currentNode->getScoreG() +1);
//Sort the OpenList
sortOpenList();
}
}
else
{
//If we got here then the tile doesn't exist in the Open or Closed list.
//Let's make a new PathNode object and calculate it's tile score.
PathNode* adjacentNode = new PathNode(adjacentTile);
//Set the pathNode's parent.
adjacentNode->setParentNode(currentNode);
//Calculate the G score, it's a Parent node's G score plus 1.
adjacentNode->setScoreG(currentNode->getScoreG() +1);
//Calculate the H score, remember we use the manhattan distance method.
adjacentNode->setScoreH(getManhattanDistanceCost(adjacentTile, m_Level->getTileForIndex(m_DestinationTileIndex)));
//Lastly add is to the Open list, calling this method will sort the open list.
addNodeToOpenList(adjacentNode);
}
}
}
}
