void RefreshGlobalCardUINow()
    {
        if (pokerGamePlayData.globalCards.Count == 0)
        {
            return;
        }
        ICardInfo _cardInfo             = null;
        PanelCardDetailController _card = null;
        Vector3 _pos = Vector3.zero;

        for (int i = 0; i < pokerGamePlayData.globalCards.Count; i++)
        {
            _cardInfo = Poker_GamePlay_Manager.instance.GetCardInfo(pokerGamePlayData.globalCards[i]);
            if (_cardInfo == null)
            {
                                #if TEST
                Debug.LogError("_cardInfo is NULL : " + pokerGamePlayData.globalCards[i]);
                                #endif
                continue;
            }

            _pos = placeHolder_GlobalCards_Catched[globalCardsPoolManager.listObjects.Count].position;

            _card = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, Poker_GamePlay_Manager.instance.panelCardContainer).GetComponent <PanelCardDetailController>();
            _card.transform.position = _pos;
            _card.ResizeAgain(Poker_GamePlay_Manager.instance.sizeCard.x, Poker_GamePlay_Manager.instance.sizeCard.y);
            _card.ShowNow(_cardInfo);
            globalCardsPoolManager.AddObject(_card);
        }
    }
    IEnumerator DoActionDealGlobalCard(List <sbyte> _valueCards)
    {
        List <ICardInfo> _tmpListCardInfo             = new List <ICardInfo>();
        ICardInfo        _cardInfo                    = null;
        List <PanelCardDetailController> _tmpListCard = new List <PanelCardDetailController>();
        PanelCardDetailController        _card        = null;

        for (int i = 0; i < _valueCards.Count; i++)
        {
            _cardInfo = Poker_GamePlay_Manager.instance.GetCardInfo(_valueCards[i]);
            if (_cardInfo == null)
            {
                                #if TEST
                Debug.LogError("_cardInfo is NULL : " + _valueCards[i]);
                                #endif
                continue;
            }
            _tmpListCardInfo.Add(_cardInfo);

            _card = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, Poker_GamePlay_Manager.instance.panelCardContainer).GetComponent <PanelCardDetailController>();
            _card.transform.position = placeHolder_SpawnCard_Catched.position;
            _card.ResizeAgain(Poker_GamePlay_Manager.instance.sizeCard.x, Poker_GamePlay_Manager.instance.sizeCard.y);
            _tmpListCard.Add(_card);
        }
        yield return(Yielders.Get(0.1f));

        for (int i = 0; i < _tmpListCard.Count; i++)
        {
            CoroutineChain.Start
            .Sequential(_tmpListCard[i].Move(placeHolder_GlobalCards_Catched[globalCardsPoolManager.listObjects.Count].position, 0.1f, LeanTweenType.easeOutSine, Poker_GamePlay_Manager.instance.CanPlayMusicAndSfx() ? Poker_GamePlay_Manager.instance.myAudioInfo.sfx_DealCard : null)
                        , _tmpListCard[i].Show(_tmpListCardInfo[i]));
            globalCardsPoolManager.AddObject((MySimplePoolObjectController)_tmpListCard[i]);
            yield return(Yielders.Get(0.1f));
        }
    }
    IEnumerator DoActionDealPlayerCard(Poker_PlayerGroup _playerGroup)
    {
        List <PanelCardDetailController> _tmpListCard = new List <PanelCardDetailController>();
        PanelCardDetailController        _card        = null;

        for (int i = 0; i < 2; i++)
        {
            _card = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, Poker_GamePlay_Manager.instance.panelCardContainer).GetComponent <PanelCardDetailController>();
            _card.transform.position = placeHolder_SpawnCard_Catched.position;
            _card.ResizeAgain(Poker_GamePlay_Manager.instance.sizeCard.x, Poker_GamePlay_Manager.instance.sizeCard.y);
            _tmpListCard.Add(_card);
        }

        yield return(Yielders.Get(0.1f));

        for (int i = 0; i < _tmpListCard.Count; i++)
        {
            if (!_playerGroup.isMe)
            {
                if (Poker_GamePlay_Manager.instance.CanPlayMusicAndSfx())
                {
                    MyAudioManager.instance.PlaySfx(Poker_GamePlay_Manager.instance.myAudioInfo.sfx_DealCard);
                }
                CoroutineChain.Start
                .Parallel(_tmpListCard[i].Move(_playerGroup.cardCoverHoldersCatched[i].position, 0.1f, LeanTweenType.easeOutSine)
                          , _tmpListCard[i].Rotate(_playerGroup.cardCoverHoldersCatched[i].rotation.eulerAngles, 0.1f)
                          , _tmpListCard[i].ScaleTo(_playerGroup.cardCoverHoldersCatched[i].localScale, 0.1f, LeanTweenType.notUsed));
            }
            else
            {
                ICardInfo _cardInfo = null;

                for (int j = 0; j < pokerGamePlayData.listPlayerPlayingData.Count; j++)
                {
                    if (pokerGamePlayData.listPlayerPlayingData[j].isMe &&
                        pokerGamePlayData.listPlayerPlayingData[j].userData.IsEqual(_playerGroup.userData))
                    {
                        _cardInfo = Poker_GamePlay_Manager.instance.GetCardInfo(pokerGamePlayData.listPlayerPlayingData[j].ownCards[i]);
                        if (_cardInfo == null)
                        {
                                                        #if TEST
                            Debug.LogError("_cardInfo is NULL : " + pokerGamePlayData.listPlayerPlayingData[j].ownCards[i]);
                                                        #endif
                            continue;
                        }
                        break;
                    }
                }

                CoroutineChain.Start
                .Parallel(_tmpListCard[i].Move(_playerGroup.ownCardHoldersCatched[i].position, 0.1f, LeanTweenType.easeOutSine
                                               , Poker_GamePlay_Manager.instance.CanPlayMusicAndSfx() ? Poker_GamePlay_Manager.instance.myAudioInfo.sfx_DealCard : null)
                          , _tmpListCard[i].Rotate(_playerGroup.ownCardHoldersCatched[i].rotation.eulerAngles, 0.1f)
                          , _tmpListCard[i].ScaleTo(_playerGroup.ownCardHoldersCatched[i].localScale, 0.1f, LeanTweenType.notUsed))
                .Sequential(_tmpListCard[i].Show(_cardInfo));
            }
            _playerGroup.ownCardPoolManager.AddObject(_tmpListCard[i]);
            yield return(Yielders.Get(0.1f));
        }
    }
    IEnumerator DoActionDealCards(float _timeDelay)
    {
        System.TimeSpan _tmpDeltaTime = dragonTigerCasinoData.nextTimeToShowResult - System.DateTime.Now;
        if (_tmpDeltaTime.TotalSeconds <= 5)
        {
            cardDragon = LeanPool.Spawn(cardPrefab, cardDragonDealPlaceHolder.position, Quaternion.identity, panelCardContainer).GetComponent <PanelCardDetailController>();
            cardDragon.transform.position = cardDragonDealPlaceHolder.position;
            cardDragon.ResizeAgain(100, 150f);
            cardTiger = LeanPool.Spawn(cardPrefab, cardTigerDealPlaceHolder.position, Quaternion.identity, panelCardContainer).GetComponent <PanelCardDetailController>();
            cardTiger.transform.position = cardTigerDealPlaceHolder.position;
            cardTiger.ResizeAgain(100, 150f);
        }
        else
        {
            cardDragon = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, panelCardContainer).GetComponent <PanelCardDetailController>();
            cardDragon.transform.position = posistionSpawnCard;
            cardDragon.ResizeAgain(100, 150f);
            cardTiger = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, panelCardContainer).GetComponent <PanelCardDetailController>();
            cardTiger.transform.position = posistionSpawnCard;
            cardTiger.ResizeAgain(100, 150f);
            yield return(Yielders.Get(_timeDelay));

            yield return(CoroutineChain.Start
                         .Sequential(
                             cardDragon.Move(cardDragonDealPlaceHolder.position, 0.3f, LeanTweenType.easeOutSine, myAudioInfo.sfx_DealCard),
                             cardTiger.Move(cardTigerDealPlaceHolder.position, 0.3f, LeanTweenType.easeOutSine, myAudioInfo.sfx_DealCard)));
        }
    }
    void RefreshAllPlayerGroupUINow()
    {
        if (pokerGamePlayData.currentGameState == PokerGamePlayData.GameState.STATUS_WAIT_FOR_PLAYER)
        {
            for (int i = 0; i < pokerGamePlayData.listSessionIdOnChair.Count; i++)
            {
                if (pokerGamePlayData.listSessionIdOnChair[i] < 0)                 // ghế trống
                {
                    continue;
                }
                for (int j = 0; j < pokerGamePlayData.listGlobalPlayerData.Count; j++)
                {
                    if (pokerGamePlayData.listSessionIdOnChair[i] == pokerGamePlayData.listGlobalPlayerData[j].sessionId)
                    {
                        Poker_GamePlay_Manager.instance.listPlayerGroup[i].InitData(pokerGamePlayData.listGlobalPlayerData[j]);
                        break;
                    }
                }
            }
        }
        else           // đang chơi thì hiện thông tin người chơi và chia bài cho họ
        {
            List <int> _listIndexChairPlaying = new List <int>();
            Vector3    _pos = Vector3.zero;
            Quaternion _rot = Quaternion.identity;
            PanelCardDetailController _card = null;
            for (int i = 0; i < pokerGamePlayData.listPlayerPlayingData.Count; i++)
            {
                _listIndexChairPlaying.Add(pokerGamePlayData.listPlayerPlayingData[i].indexChair);
                int _indexChair = pokerGamePlayData.listPlayerPlayingData[i].indexChair;

                Poker_PlayerGroup _playerGroup = Poker_GamePlay_Manager.instance.listPlayerGroup[_indexChair];
                _playerGroup.InitData(pokerGamePlayData.listPlayerPlayingData[i].userData);
                _playerGroup.ShowPlayerState(pokerGamePlayData.listPlayerPlayingData[i].currentState, true);
                if (pokerGamePlayData.listPlayerPlayingData[i].turnBet > 0)
                {
                    _playerGroup.myPanelBet.SetBet(pokerGamePlayData.listPlayerPlayingData[i].turnBet, true);
                    _playerGroup.myPanelBet.Show();
                }

                if (pokerGamePlayData.listPlayerPlayingData[i].currentState != PokerGamePlayData.Poker_PlayerPlayingData.State.STATEPOKER_FOLD)
                {
                    for (int j = 0; j < _playerGroup.cardCoverHoldersCatched.Count; j++)
                    {
                        _pos = _playerGroup.cardCoverHoldersCatched[j].position;
                        _rot = _playerGroup.cardCoverHoldersCatched[j].rotation;

                        _card = LeanPool.Spawn(cardPrefab, Vector3.zero, Quaternion.identity, Poker_GamePlay_Manager.instance.panelCardContainer).GetComponent <PanelCardDetailController>();
                        _card.transform.position = _pos;
                        _card.transform.rotation = _rot;
                        _card.ResizeAgain(Poker_GamePlay_Manager.instance.sizeCard.x, Poker_GamePlay_Manager.instance.sizeCard.y);
                        _playerGroup.ownCardPoolManager.AddObject(_card);
                    }
                }

                if (i == 0)
                {
                    panelRoleSmallBlind.gameObject.SetActive(true);
                    panelRoleSmallBlind.position = _playerGroup.myPanelBet.imgIconChip.transform.position;
                }
                else if (i == 1)
                {
                    panelRoleBigBlind.gameObject.SetActive(true);
                    panelRoleBigBlind.position = _playerGroup.myPanelBet.imgIconChip.transform.position;
                }
            }
            // --- hiện các thông tin người chơi đang chờ --- //
            List <int> _listIndexChairWaiting = new List <int>();
            for (int i = 0; i < pokerGamePlayData.numberChairs; i++)
            {
                if (!_listIndexChairPlaying.Contains(i))
                {
                    _listIndexChairWaiting.Add(i);
                }
            }
            for (int i = 0; i < _listIndexChairWaiting.Count; i++)
            {
                int            _indexChair = _listIndexChairWaiting[i];
                short          _sessionId  = pokerGamePlayData.listSessionIdOnChair[_indexChair];
                UserDataInGame _userData   = pokerGamePlayData.GetUserDataInGameFromListGlobal(_sessionId);
                if (_userData == null)
                {
                    continue;
                }

                Poker_PlayerGroup _playerGroup = Poker_GamePlay_Manager.instance.listPlayerGroup[_indexChair];
                _playerGroup.InitAsIncognito(_userData);
            }
        }
    }