Cancel coroutine by parameter?

Unity Engine
1

Hey all!

I’m working on a rhythm game and I made a function that invokes after a specified number of “beats” in the music.

Here it is…

public static void InvokeAfterBeats(this MonoBehaviour me, Action theDelegate, int beats, BeatMaster beatHandler)
    {
        if (beats > 0)
        {
            me.StartCoroutine(ExecuteAfterBeats(theDelegate, beats, beatHandler));
        }
        else
        {
            theDelegate();
        }
    }

private static IEnumerator ExecuteAfterBeats(Action theDelegate, int beats, BeatMaster beatHandler)
{
    int currentBeat = 0;

    bool canBeat = false;

    while (currentBeat < beats)
    {
        if (!beatHandler.fixedEnemyBeat)
        {
            canBeat = true;
        }

        if (beatHandler.fixedEnemyBeat && canBeat)
        {
            currentBeat++;
            canBeat = false;
        }
        yield return new WaitForSeconds(0.0166666f);
    }

    theDelegate();
}

How exactly would I go about canceling this? I don’t want to cancel it based on the IEnumerator name cause I might have more than one going at once and I only want to cancel one or two of them.

Preferably I would cancel it based on the Action that was given to it when it was called. Kinda like CancelInvoke.

Any ideas?

2

When you call StartCoroutine(), it returns an object of type Coroutine. You can pass that object to a StopCoroutine() call to tell it which coroutine to stop.

Coroutine firstcoroutine = StartCoroutine(MyFunction(1));
Coroutine secondCoroutine = StartCoroutine(MyFunction(2));

// Stop just the first one
StopCoroutine(firstCoroutine);
3

Thanks! That was just enough to nudge me in the right direction!

The solution I ended up with…

static Dictionary<Action, Coroutine> startedRoutines;

public static void InvokeAfterBeats(this MonoBehaviour me, Action theDelegate, int beats, BeatMaster beatHandler, BeatType type = BeatType.EnemyBeat)
    {
        if (beats > 0)
        {
            startedRoutines.Add(theDelegate, (me.StartCoroutine(ExecuteAfterBeats(theDelegate, beats, beatHandler, type))));
        }
        else
        {
            theDelegate();
        }
    }

public static void CancelInvokeAfterBeats (this MonoBehaviour me, Action theDelegate)
    {
        me.StopCoroutine(startedRoutines[theDelegate]);
        startedRoutines.Remove(theDelegate);
    }

Basically every time it we call the function it stores it in a dictionary with the Action as the key!

Then we can cancel them by the Action that they call!

4

Using delegates as keys in a Dictionary is probably a bad idea, because two delegates that do the same thing or call the same function will not necessarily compare as equal.

I don’t know where your Actions are coming from. If they are explicitly saved somewhere as Actions and you are reusing the same references, then it might be OK. But that would be an unusual thing to do.

You probably want to figure out some higher-level organizational structure you can impose on your data.

1 Like
5

Yeah that didn’t work as planned. I switched to using a string as the key so I can then stop them by their key value.

Thanks for the help!

6

Note, technically speaking… you can just start and stop coroutines by their string name in the first place:

Though personally I find this a bit smelly.

But having to look up in a dictionary by string is also a bit smelly as well for the same reason.

7

But that string has to be the method name, not an arbitrary string you’ve made up. As the OP points out, migueltuliompg is running multiple concurrent coroutines that all use the same method, so stopping by method name isn’t specific enough.

Also, the documentation you linked says that you shouldn’t stop a coroutine via string unless you also started it via string (though it doesn’t specify what will happen if you try).

1 Like
8

Aw, didn’t catch that.

Yes, that’s why I said “start and stop by their string name” and included the documentation in a link**.**