Unity wait for all coroutines

I'm going to wait for several coroutines in another coroutine. Example code

private IEnumerator WaitForAllAnimations(List<ShiftedGem> shiftedGems)
{
    float duration = 3f;
    isDuringAnimation = true;

    List<Coroutine> animationCoroutines = new List<Coroutine>();

    for (int i = 0; i < shiftedGems.Count(); i++)
    {
        ShiftedGem shiftedGem = shiftedGems[i];
        Debug.Log("Add animation");
        ShiftAnimation shiftAnimation = shiftedGem.GameObject.AddComponent<ShiftAnimation>();
        yield return StartCoroutine(shiftAnimation.AnimateShift(shiftedGem.GameObject, shiftedGem.ShiftAmount, duration));

        animationCoroutines.Add(animationCoroutine);
    }

    foreach (Coroutine coroutine in animationCoroutines)
    {
        Debug.Log("Wait for coroutine");
        yield return coroutine;
    }

    Debug.Log("Animation end");
    isDuringAnimation = false;
}

However, it does not work as expected - the Debug.Log("Animation end") is called before AnimateShift is finished.

I've tried a simpler example:

IEnumerator CoroutineA(List<ShiftedGem> shiftedGems)
{
    Debug.Log("Start Coroutine A");

    yield return StartCoroutine(CoroutineB());
    Debug.Log("End Coroutine A");
}

IEnumerator CoroutineB()
{
    Debug.Log("Start Coroutine B");
    yield return new WaitForSeconds(1f);
    Debug.Log("End Coroutine B");
}

Which works fine ("End Coroutine A" is logged after "End Coroutine B").

But if I move StartCoroutine(CoroutineB()) into a loop:

IEnumerator CoroutineA(List<ShiftedGem> shiftedGems)
{
    Debug.Log("Start Coroutine A");
    foreach (ShiftedGem shiftedGem in shiftedGems)
    {
        yield return StartCoroutine(CoroutineB());
    }
    Debug.Log("End Coroutine A");
}

IEnumerator CoroutineB()
{
    Debug.Log("Start Coroutine B");
    yield return new WaitForSeconds(10f);
    Debug.Log("End Coroutine B");
}

Then once again - Debug.Log("End Coroutine A") is called before Debug.Log("End Coroutine B").

How should I organize my code, to be able to wait for all animationCoroutines inside the WaitForAllAnimations Coroutine?

First of all, it seems strange a bit that you are adding an object to the list of coroutines that I don't see being assigned anywhere. Anyway, about the options:

You can use some kind of counter to count the current amount of coroutines run. Based on your last piece of code:

int _someCounter = 0;

IEnumerator CoroutineA(List<ShiftedGem> shiftedGems)
{
    Debug.Log("Start Coroutine A");
    _someCounter = 0;
    foreach (ShiftedGem shiftedGem in shiftedGems)
    {
        StartCoroutine(CoroutineB());
    }
    while(_someCounter > 0)
    {
        yield return null;
    }
    Debug.Log("End Coroutine A");
}

IEnumerator CoroutineB()
{
    Debug.Log("Start Coroutine B");
    _someCounter++;
    yield return new WaitForSeconds(10f);
    _someCounter--;
    Debug.Log("End Coroutine B");
}

However, be careful that the code above will not be stable in case running the second time until the previous call is not finished yet.

I think the best option with minimum changes to your existing variant will be to add a flag to your ShiftAnimation component to check if animation is still in progress. Based on your initial example:

private IEnumerator WaitForAllAnimations(List<ShiftedGem> shiftedGems)
{
    float duration = 3f;
    isDuringAnimation = true;

    List<ShiftAnimations> animations = new List<ShiftAnimations>();

    for (int i = 0; i < shiftedGems.Count(); i++)
    {
        ShiftedGem shiftedGem = shiftedGems[i];
        Debug.Log("Add animation");
        ShiftAnimation shiftAnimation = shiftedGem.GameObject.AddComponent<ShiftAnimation>();
        animations.Add(shiftAnimation);
        shiftAnimation.AnimateShift(shiftedGem.GameObject, shiftedGem.ShiftAmount, duration);

    }
    
    bool isAnyAnimationActive;
    do
    {
        isAnyAnimationActive = false;
        foreach (var animationIt in animations)
        {
            if(animationIt.IsAnimationActive == true)
            {
                isAnyAnimationActive = true;
                break;
            }
        }        
        
        yield return null;
    }
    while(isAnyAnimationActive == true);

    Debug.Log("Animation end");
    isDuringAnimation = false;
}

And in your ShiftAnimation component something like this:

...
bool _isAnimationActive = false;

public IsAnimationActive => _isAnimationActive;

public void AnimateShift(your parameters here)
{
    StartCoroutine(CoAnimateShift(your parameters here));
}

IEnumerator CoAnimateShift(your parameters here)
{
    _isAnimationActive = true;

    // your code here

    _isAnimationActive = false;
}
...

If you're looking for a better way to handle asynchronous tasks in Unity, I recommend checking out the UniTask plugin. This plugin offers an easy-to-use alternative to traditional C# async/await, as well as Unity's coroutines which can be difficult to work with.

With UniTask, you can use the WhenAll() method to wait for multiple tasks to complete. This approach only requires that you refactor your existing coroutines as async methods, which can simplify your code and improve its readability.