Adding a time-delay without changing the function signature

Question

I have written a simple generic implementation of the BFS algorithm, which I intend to use in several places in my Unity game. A simplified version of the class is:

class BFS {
     public abstract void OnNewNodeDiscovered(Node node);

     public void FindPath(Node start, Node end) { 
         // Implementation of the algorithm.
         // Calls OnNewNodeDiscovered whenever a new node is discovered.
     }
}

I added the method OnNewNodeDiscovered so that users of this class can do custom actions, such as logging, changing the colors of things in the scene, etc., during the algorithm.

This works fine, but now I want to create a sub-class which also, in the function OnNewNodeDiscovered, adds a time-delay, so that the progress of the algorithm can be displayed to the player. The problem is that, the only way I know for adding a time delay in Unity is to convert the function to a coroutine, which returns IEnumerator, and then "yield return new WaitForSecods(delay)". But this breaks my design of having a generic OnNewNodeDiscovered function.

My quesion is: is there an alternative way to add a time-delay inside a function that will be called from Unity? Can't I just say something like "sleep(duration)" to sleep for the specified duration and return later to the next statement point, without having to change the return type to IEnumerator?

Answer 1

Based on your comments, I think you are actually looking for the thing you said you were not looking for. Below an example of how you could implement something you want, the idea is that FindPath is run like a CoRoutine, and it yields OnNewNodeDiscovered (which is an IENumerator)

Now I used an example that draws a line that alternates colors every 0.1 seconds to test whether it works as intended, but I think you should be able to convert this to your own needs.

public class Example : MonoBehaviour
{
    public void Start()
    {
        StartCoroutine(FindPath(Vector3.zero, new Vector3(100, 0, 0), 100));
    }

    public virtual IEnumerator FoundNode(Vector3 from, Vector3 to)
    {
        Debug.DrawLine(from, to, Color.red, 0.1f);
        yield return new WaitForSeconds(0.1f);
        Debug.DrawLine(from, to, Color.green, 0.1f);
        yield return new WaitForSeconds(0.1f);
    }

    public IEnumerator FindPath(Vector3 start, Vector3 end, int steps)
    {
        Vector3 step = (end - start) / steps;

        Vector3 pos = start;

        for (int i = 0; i < steps; i++)
        {
            Vector3 next = pos + step;
            yield return FoundNode(pos, next);
            pos = next;
        }
    }
}

And if you in some cases don't want a delay in OnNewNodeDiscovered, calling yield break; instead of yield return something; makes it yield immediatly (so without a delay)

Answer 2

My method would be to add a separate function in your subclass to achieve this.

class BFS {
     public abstract void OnNewNodeDiscovered(Node node);

     public void FindPath(Node start, Node end) { 
         // Implementation of the algorithm.
         // Calls OnNewNodeDiscovered whenever a new node is discovered.
     }
}

class BFS_SubClass {
    public void OnNewNodeDiscovered(Node node) {
        ...
        // Implementation
        ...
        TimeDelay(time);
        ...
        // More implementation
    }

    private IEnumerator TimeDelay(float time) {
        yield return new waitforseconds(time);
    }
}

Calling the IEnumerator as a function should allow you to retain single thread-ness and achieve a time delay.

Disclaimer, it's been a while since I did unity c#