Wait until continuing inside a function with a coroutine in Unity

Question

I have a base class called Ability and then children classes for each ability like BasicMeleeStrike. I have a turn based game so the Do() method of each ability does it's logic sequentially. I'm trying to make coding a little nicer looking in each child ability class and I want to not have to yield out from in them but call base class functions that will do the operations over time but I want them to wait until they come back to the child class Do() function but what I have doesn't work. Is this possible?

class Ability{
   public virtual IEnumerator Do(Actor target){}
   protected IEnumerator JumpToTarget(Actor target){
      yield return StartCoroutine(_JumpToTarget(target);
   }
   private IEnumerator _JumpToTarget(Actor target){
      // inside here I tween to a location so it's yielding return null until it's done
   }
}

class BasicMeleeAttack : Ability{
   public override IEnumerator Do(Actor target){
      JumpToTarget(target);
      anim.Play("attack");
   }
}

No jumping happens but the attack animation plays. When I put a breakpoint on anim.Play() it's hit right away. Is there a way to make it stay inside JumpToTarget(target) until it's finished without having to do a yield inside BasicMeleeAttack's Do() function? I just think it's much friendlier to not have to code that for all my actions.

Answer 1

Is there a way to do this without StartCoroutine()?

Sure, you can step the IEnumerator manually.

var nestedRoutine = JumpToTarget(target);
while(nestedRoutine.MoveNext())
    yield return null; // Wait a frame and check again next time.
                       // Note that this ignores what nestedRoutine yielded!
                       // If it's waiting on a WWW to download, and we don't
                       // handle that case ourselves, we'll pump it too early.

// Execution resumes here once JumpToTarget finishes all its work.

But this seems like substantially more work than just

yield return StartCoroutine(JumpToTarget(target));
// Execution resumes here once JumpToTarget finishes all its work.
// This correctly handles all yield return types that Unity accepts,
// since we're letting the Unity engine handle the yielding logic.