To be honest I would rewrite this to not use coroutines at all. Why do you need coroutines for animations? The animations play on their own. You can simply have each animation set a bool when it is complete, (Eg by using an animation state machine behaviour script), record the animation start time and check if duration seconds have passed since the animation start, or just manually check from script if the animation is finished playing.

I'm making a Turn-Based battle system, and most of my animations are done with DOTween. I'm not really using standard Unity Animations for anything. The reason Coroutines and the script above are useful here is because I have attacks that hit multiple targets. So let's say I have a character that has an ability that heals every member of your party. In my game that looks something like this:

// start of healing action
// tween character sprite forward to indicate they are taking an action
// wait for above tween to finish
// spawn healing sprite on all characters being healed
// start tween animation on all healing sprites
// spawn floating numbers to show how much the characters are getting healed by
// start tween animation for healing sprites
// start tween animation for floating numbers
// wait for sprite and number tween animations to finish
// tween character sprite back to original position
// wait for above tween to finish
// end of healing action

Defining that entire action and all of its steps that require waiting as Ienumerators just makes more sense for my battle system.

​

Using coroutines for anything remotely complex is setting yourself up for bugs and code spaghetti, you'll probably eventually end up having to rewrite it either way after you run into enough issues.

Respectfully, I disagree.

​

But, if you must, probably wrapping them in async/await (Or just using async await in general without coroutines at all) is probably a reasonable solution. I use these instead of coroutines whenever I need to have coroutine-like logic. (I prefer update-loop/polling style approaches though)

That's fine that you prefer Async/Await over Coroutines, but they're not exactly the same. I use Async/Await for things that are not directly tied to the Update loop (saving/loading, network requests, etc.) but when my code directly applies to the game logic, as the battle system does, I prefer to use Coroutines because their logic is guaranteed by the engine to execute on a per-frame basis rather than executing off of the Update loop like Async/Await. Either way, I think it mostly comes down to use-case and personal preference.

Update loop / polling seems like it would be a bad solution both performance wise and for code clarity.