When dealing with large graphs, computing paths can take a lot of time, even halting the game for a couple of seconds. This could ruins its overall experience, to say the least. Luckily enough there are methods to avoid this.
We'll learn how to implement path-finding techniques using coroutines by refactoring the A* algorithm learned previously, but we will handle its signature as a different function.
Even though this recipe is only defining a function, please take into consideration the comments in the code to understand the indentation and code flow more effectively:
- Modify the
Graphclass and add a couple of member variables. One for storing the path and the other to know whether the coroutine has finished:public List<Vertex> path; public bool isFinished;
- Declare the member function:
public IEnumerator GetPathInFrames(GameObject srcObj, GameObject dstObj, Heuristic h = null) { //next steps } - Include the following member variables at the beginning:
isFinished = false; path = new List<Vertex>(); if (srcObj == null || dstObj == null) { path = new List<Vertex>(); isFinished = true; yield break; } - Modify the loop to traverse the graph:
while (frontier.Count != 0) { // changes over A* yield return null; ////////////////////////////// node = frontier.Remove(); - Also, include the other path-retrieval validations:
if (ReferenceEquals(node.vertex, dst)) { // changes over A* path = BuildPath(src.id, node.vertex.id, ref previous); break; ////////////////////////////// } - Finally, reset the proper values and return control at the end of the function, after closing the main loop:
isFinished = true; yield break;
The yield return null statement inside the main loop works as a flag for delivering control to the higher-level functions, thus computing each new loop in each new frame using Unity's internal multi-tasking system.