Unity IEnumerator, waiting but no longer executing called function fully anymore

Question

I am writing a game with some logic that records player actions and then replays them in the same sequence at the same timing but with other influences involved at a later date.

So far I have the code sort of working, it records perfectly as I require it, and then plays back the sequence perfectly, but the issue has been timing.

As an simple example. If the character is to walk from A -> B -> C but to wait for x time at B, then the code easily traverses the path, but will not stop at B for the given time.

So I wrote a couple of functions that I thought might handle this as you can see here.

private IEnumerator followSequence()
{
    // Loop through each action steps in sequence.
    foreach (Action step in sequence)
    {
        //Check if the action time is less than the current clock time.
        Debug.Log("Step.tick: " + step.tick + " || Clock.tick: " + clock.getTick());
        if (clock.getTick() < step.tick)
        {
            //If so wait out the difference to resync the action.
            yield return new WaitForSeconds(step.tick - clock.getTick());                
        }

        // Carry out the step.
        play(step);
    }
    yield break;
}

private void play(Action step)
{
    Debug.Log(step.type);

    // Set up a followpath script
    FollowPath follow = (player.GetComponent<FollowPath>() ? player.GetComponent<FollowPath>() : player.AddComponent<FollowPath>());

    // Tell the follow path script that object is not a guard.
    follow.isGuard = false;

    // Create a new point object on the map
    Transform aPoint = (Transform)Instantiate(PathPoint, step.point, Quaternion.identity);
    path.points.Add(aPoint);

    // Initiate movement.
    follow.Path = path;
    follow.TravelPath();

    // Check if action is an objective.
    if (step.type == Action.Type.Action)
    {
        step.actions.OnClick();
    }        
}

Now if I comment out the *yield return new WaitForSeconds()* part in the first function, the code works as expected and completes the step in the sequence just not to the given timing.

When the same code is not commented out, then the timings work perfectly and the 2nd *Debug.log("step.type")* is called at the exact right time, however the character no longer moves, I.E. the *follow.TravelPath()* never seems to be executed.

I have tried making the 2nd function an IEnmerator and yielding to it. I have tried a custom wait() function. I have tried yielding to the TravelPath() function.

Has anyone any more ideas I have follow up or where I could look to try and resolve this?

Edit:

Code that calls followSequence() as requested:

    private void playActions()
{
    // Reset player immediately to the starting position
    player.transform.position = sequence[0].point;

    // Stop the character and freeze the scene when alarm sounds!.
    player.GetComponent<IncrementController>().freeze();
    player.GetComponent<IncrementController>().enabled = false;

    // Restart the clock and scene.
    clock.Restart();
    sceneManager.restart();

    // Activate guard and remove sphere.
    guard.SetActive(true);
    guardShere.SetActive(false);

    // Stop recording;
    recording = false;
    line.SetActive(false);

    // Start playback sequence.
    StartCoroutine(followSequence());
}

Answer 1

The behavior is as expected, on the line there you do yield return the execution of the context is paused until you do MoveNext() (which does apparently never happen) on the enumerator, which is returned by followSequence.

But as far as I can see from the comments, you just want to wait for some seconds for resync so you don't need to return at all. In your case I don't see any reason why you might need an Enumerable of WaitForSeconds if you just want to skip some time. Without to know how you you call the function and the implementation of WaitForSeconds I would suggest you to change it's return type to void.

private void followSequence()
{
    // Loop through each action steps in sequence.
    foreach (Action step in sequence)
    {
        //Check if the action time is less than the current clock time.
        Debug.Log("Step.tick: " + step.tick + " || Clock.tick: " + clock.getTick());
        if (clock.getTick() < step.tick)
        {
            //If so wait out the difference to resync the action.
            new WaitForSeconds(step.tick - clock.getTick());                
        }

        // Carry out the step.
        play(step);
    }
}