Не понимаю Coroutine

метод FindAllMatches изменяет MatchedType =MatchedType.Normal если ее значение None

почему в IEnumerator DestroyMatchAndRefillBoard() yield return не обеспечивает полное завершение DestroyMatches щас код работает но то что здесь написано выглгядит нелепо

 private IEnumerator CheckBoardCo()
     {
         _boardSetup.findMatches.FindAllMatches();
         foreach (var piece in _boardSetup.AllPieces)  
         {
             if (piece != null && piece.IsClearable())
             {
                 if (piece.GamePieceData.MatchedType == MatchedType.Special)
                 {
                     piece.GamePieceData.MatchedType = MatchedType.None;
                 }
             }
         }

вместо этого я бы хотел цикл foreach который ресетит piece.GamePieceData.MatchedType = MatchedType.None; иметь прямо внутри IENUMERATOR DestroyMatches

основной код

private IEnumerator DestroyMatchAndRefillBoard()
    {
        yield return  StartCoroutine(DestroyMatchesCo());
        yield return new WaitForSeconds(_refillDelay);
        yield return StartCoroutine(DecreaseRowCo());
        yield return new WaitForSeconds(_refillDelay);
        yield return StartCoroutine(FillBoardCo());
        yield return StartCoroutine(CheckBoardCo());
    }
    
    private IEnumerator DestroyMatchesCo()
    {
        //make bomb if matches more than 3
        if (_boardSetup.findMatches.currentMatches.Count >= 4)
        {
            _boardSetup.BoardCheck.CheckToMakeBombs();
        }
        //make matchType Normal
        foreach (var piece in _boardSetup.AllPieces)  
        {
            if (piece != null && piece.IsClearable())
            {
                if (piece.GamePieceData.MatchedType == MatchedType.Normal)
                {
                    piece.ClearableComponent.ActivatePieces();
                }
            }
        }
        //find nearest pieces and destroy
        foreach (var piece in _boardSetup.AllPieces)  
        {
            if (piece != null && piece.IsClearable())
            {
                  if (piece.GamePieceData.MatchedType == MatchedType.Normal &&
                          piece==_boardSetup.CurrentGamePiece)
                 {
                     int column = piece.GamePieceData.Column;
                     int row = piece.GamePieceData.Row;
                     piece.ClearableComponent.ClearPiece();
                     yield return new WaitForSeconds(fillTime);
                     yield return StartCoroutine(FindAndDestroyNearestPieces(column, row, MatchedType.Normal));
                     break;
                 }
               
            }
        }
        if (_boardSetup.CurrentGamePiece==null)
        {
            foreach (var piece in _boardSetup.AllPieces)
            {
                if (piece != null && piece.IsClearable())
                {
                    if (piece.GamePieceData.MatchedType==MatchedType.Normal)
                    {
                        piece.ClearableComponent.ClearPiece();
                        yield return new WaitForSeconds(fillTime);
                    }
                }
            }
        }
        _boardSetup.HintManager.HintDelaySeconds = _boardSetup.HintManager.hintDelay;
        _boardSetup.findMatches.currentMatches.Clear();
        _boardSetup.CurrentGamePiece = null;
    }
     
     private IEnumerator DecreaseRowCo()
     {
         for (int i = 0; i < _boardSetup.Width; i++)
         {
             for (int j = 0; j < _boardSetup.Height; j++)
             {
                 if (!_boardSetup.BlankSpaces[i, j] && _boardSetup.AllPieces[i, j] == null)
                 {
                     for (int k = j + 1; k < _boardSetup.Height; k++)
                     {
                         if (_boardSetup.AllPieces[i, k] != null)
                         {
                             _boardSetup.AllPieces[i, k].GamePieceData.Row = j;
                             _boardSetup.AllPieces[i, k] = null;
                             yield return new WaitForSeconds(fillTime/2);
                             break;
                         }
                     }
                 }
             }
         }
     }
     
     private IEnumerator CheckBoardCo()
     {
         _boardSetup.findMatches.FindAllMatches();
         foreach (var piece in _boardSetup.AllPieces)  
         {
             if (piece != null && piece.IsClearable())
             {
                 if (piece.GamePieceData.MatchedType == MatchedType.Special)
                 {
                     piece.GamePieceData.MatchedType = MatchedType.None;
                 }
             }
         }
 // Continue looping until there are no more matches on the board
         if (_boardSetup.BoardCheck.MatchesOnBoard())
         {
             _boardSetup.streak++;
             GameController.CurrentState = GameState.Move;
             StartCoroutine(DestroyMatchAndRefillBoard());
             yield break;
         }
         _boardSetup.streak=1;
         _boardSetup.findMatches.currentMatches.Clear();
         _boardSetup.CurrentGamePiece = null;
         if (_boardSetup.DeadLock.IsDeadLocked())
         {
             _boardSetup.DeadLock.ShuffleBoard();
             GameController.CurrentState=GameState.Move;
             yield break;
         }
         // Set the game state to Move
         GameController.CurrentState=GameState.Move;
     }

то что ниже отвечает за спавн и инициализацию обьекта

 internal GamePiece SpawnNewPiece(int column, int row, PieceType type, ColorType colorType = ColorType.Empty,MatchedType matchedType=MatchedType.None, int yOffset = 0)
    {
        _boardSetup.AllPieces[column, row]= Instantiate(_boardSetup.PiecePrefabDict[type], new Vector3(column, row + yOffset, 0), Quaternion.identity, this.transform.Find("Piece Container"));
        _boardSetup.AllPieces[column, row].Init(column, row, type,matchedType);
      
        if (colorType != ColorType.Empty) 
            _boardSetup.AllPieces[column, row].ColorableComponent.Color=colorType;
        else
        {
            if (type == PieceType.ColorClear)
                _boardSetup.AllPieces[column, row].ColorableComponent.Color=ColorType.Any;
            else
                _boardSetup.AllPieces[column, row].ColorableComponent.Color=((ColorType)Random.Range(0,_boardSetup.AllPieces[column, row].ColorableComponent.NumColors));
        }
        return _boardSetup.AllPieces[column, row];
    }
    
    public void MakeBomb(int column, int row, PieceType pieceType, ColorType colorType)
    {
        foreach (PieceType type in new[] { PieceType.AdjacentClear, PieceType.ColorClear, PieceType.RowClear, PieceType.ColumnClear })
        {
            if (pieceType == type)
            {
                SpawnNewPiece(column, row, type, colorType,MatchedType.Special);
                break;
            }
        }
    }