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));
}
}
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 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)));
}
}
public override void InitData(bool _isFullScreen, bool _connectFirst, System.Action _onFinished = null)
{
currentGameState = GameState.Bet;
panelUserInGame.InitData();
iconNotificationChat.SetActive(false);
effectPoolManager = new MySimplePoolManager();
listProcessPlaying = new List <IEnumerator>();
listProcessNonPlaying = new List <IEnumerator>();
screenChat = ((GameObject)Instantiate(screenChatPrefab, transform)).GetComponent <ScreenChatController>();
isFullScreen = _isFullScreen;
if (isFullScreen)
{
ratioScale = 1f;
myContainer.localScale = Vector3.one * ratioScale;
btnClose.gameObject.SetActive(false);
btnMiniGame.SetActive(true);
btnShop.SetActive(true);
btnSetting.SetActive(true);
btnChat.SetActive(true);
}
else
{
ratioScale = 0.8f;
myContainer.localScale = Vector3.one * ratioScale;
btnClose.gameObject.SetActive(true);
btnClose.transform.position = btnClose_PlaceHolder.position;
Vector3 _tmpPosUserInfo = panelUserInGame.transform.position;
_tmpPosUserInfo.x -= 0.4f;
panelUserInGame.transform.position = _tmpPosUserInfo;
btnMiniGame.SetActive(false);
btnShop.SetActive(false);
btnSetting.SetActive(true);
btnChat.SetActive(true);
}
posistionSpawnCard = CoreGameManager.instance.currentSceneManager.mainCamera.transform.position;
posistionSpawnCard.y += CoreGameManager.instance.currentSceneManager.mainCamera.sizeOfCamera.y / 2 + 3f;
posistionSpawnCard.z = 0f;
cardDragon = null;
cardTiger = null;
dragonTigerCasinoData = new DragonTigerCasinoData();
panelListChip.InitData();
StartCoroutine(DoActionRun(_connectFirst, _onFinished));
}
void InitAllCallback()
{
callbackManager = new DragonTiger_CallbackManager();
callbackManager.onDestructAllObject = () => {
effectPoolManager.ClearAllObjectsNow();
panelListChip.SelfDestruction();
if (cardDragon != null)
{
cardDragon.SelfDestruction();
cardDragon = null;
}
if (cardTiger != null)
{
cardTiger.SelfDestruction();
cardTiger = null;
}
screenChat.SelfDestruction();
if (onPressBack != null)
{
CoreGameManager.instance.RemoveCurrentCallbackPressBackKey(onPressBack);
onPressBack = null;
}
};
callbackManager.onStartShowBet += () => {
panelUserInGame.RefreshGoldInfo();
panelListChip.SetFocusChipAgain();
RefreshUITableBet();
StartCountDown();
DealCards(0.5f);
};
callbackManager.onStartShowResult += () => {
panelHistory.Hide();
};
screenChat.onSendMessage = (_mess) =>
{
DragonTiger_RealTimeAPI.instance.SendMessageChat(_mess);
};
screenChat.onStartShow += HideIconNotificationChat;
screenChat.onHasNewMessage += ShowIconNotificationChat;
}
IEnumerator DoActionClearAllPlayerCards()
{
for (int i = 0; i < Poker_GamePlay_Manager.instance.listPlayerGroup.Count; i++)
{
if (!Poker_GamePlay_Manager.instance.listPlayerGroup[i].isInitialized)
{
continue;
}
for (int j = 0; j < Poker_GamePlay_Manager.instance.listPlayerGroup[i].ownCardPoolManager.listObjects.Count; j++)
{
PanelCardDetailController _cardDetail = (PanelCardDetailController)Poker_GamePlay_Manager.instance.listPlayerGroup[i].ownCardPoolManager.listObjects[j];
CoroutineChain.Start
.Parallel(_cardDetail.Move(placeHolder_SpawnCard_Catched.position, 0.1f, LeanTweenType.easeOutSine, Poker_GamePlay_Manager.instance.CanPlayMusicAndSfx() ? Poker_GamePlay_Manager.instance.myAudioInfo.sfx_Card : null)
, _cardDetail.Rotate(placeHolder_SpawnCard_Catched.rotation.eulerAngles, 0.1f));
yield return(null);
}
}
yield return(Yielders.Get(0.5f));
}
IEnumerator DoActionShowCard(List <sbyte> _valueCards, Poker_PlayerGroup _playerGroup)
{
ICardInfo _cardInfo = 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;
}
PanelCardDetailController _panelCardDetail = (PanelCardDetailController)_playerGroup.ownCardPoolManager.listObjects[i];
CoroutineChain.Start
.Parallel(_panelCardDetail.Move(_playerGroup.cardOpenHoldersCatched[i].position, 0.1f, LeanTweenType.easeOutSine)
, _panelCardDetail.Rotate(_playerGroup.cardOpenHoldersCatched[i].rotation.eulerAngles, 0.1f)
, _panelCardDetail.ScaleTo(_playerGroup.cardOpenHoldersCatched[i].localScale, 0.1f, LeanTweenType.notUsed))
.Sequential(_panelCardDetail.Show(_cardInfo));
}
yield return(1f);
}
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);
}
}
}
IEnumerator DoActionShowResult()
{
if (currentGameState == GameState.ShowResult)
{
Debug.LogError("Đang show result rồi");
yield break;
}
DragonTigerCasinoData.DragonTiger_Result_Data _resultData = dragonTigerCasinoData.processResultData[0];
currentGameState = GameState.ShowResult;
// ---- Merge dữ liệu ---- //
int _cardDragon = ((int)_resultData.cardDragon) % 13;
int _cardTiger = ((int)_resultData.cardTiger) % 13;
if (_cardDragon > _cardTiger)
{
dragonTigerCasinoData.listHistory.Add((int)IndexBet.Dragon);
}
else if (_cardDragon < _cardTiger)
{
dragonTigerCasinoData.listHistory.Add((int)IndexBet.Tiger);
}
else
{
dragonTigerCasinoData.listHistory.Add((int)IndexBet.Tie);
}
dragonTigerCasinoData.CheckListHistoryAgain();
dragonTigerCasinoData.ResetTableBet();
dragonTigerCasinoData.nextTimeToShowResult = _resultData.nextTimeToShowResult;
DataManager.instance.userData.gold = _resultData.GOLD;
DataManager.instance.userData.SetTotalBetInGameInfo(IMiniGameInfo.Type.DragonTigerCasino, 0);
if (_resultData.caseCheck == 1)
{
AchievementDetail _achievementDetail = DataManager.instance.achievementData.GetAchievementDetail(IMiniGameInfo.Type.DragonTigerCasino);
if (_achievementDetail != null)
{
if (_resultData.goldProcess > 0)
{
_achievementDetail.countWin = _resultData.achievement;
}
else if (_resultData.goldProcess < 0)
{
_achievementDetail.countLose = _resultData.achievement;
}
else
{
_achievementDetail.countDraw = _resultData.achievement;
}
}
else
{
Debug.LogError(">>> _achievementDetail is null");
}
}
else if (_resultData.caseCheck == -88)
{
PopupManager.Instance.CreatePopupMessage(MyLocalize.GetString(MyLocalize.kError)
, MyLocalize.GetString("Error/GamePlay_BetError_0")
, _resultData.caseCheck.ToString()
, MyLocalize.GetString(MyLocalize.kOk));
}
// ----------------------- //
if (callbackManager != null && callbackManager.onStartShowResult != null)
{
callbackManager.onStartShowResult();
}
ICardInfo _cardDragonInfo = GetCardInfo(_resultData.cardDragon);
if (_cardDragonInfo == null)
{
Debug.LogError("_cardDragonInfo is null");
}
ICardInfo _cardTigerInfo = GetCardInfo(_resultData.cardTiger);
if (_cardTigerInfo == null)
{
Debug.LogError("_cardTigerInfo is null");
}
float _timeShow = 0.2f;
yield return(CoroutineChain.Start
.Sequential(cardDragon.Move(cardDragonShowPlaceHolder.position, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card)
, cardTiger.Move(cardTigerShowPlaceHolder.position, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card))
.Sequential(cardDragon.ScaleTo(Vector2.one * 2f, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card)
, cardTiger.ScaleTo(Vector2.one * 2f, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card))
.Parallel(cardDragon.Show(_cardDragonInfo, myAudioInfo.sfx_Card)
, cardTiger.Show(_cardTigerInfo, myAudioInfo.sfx_Card)));
yield return(Yielders.Get(1f));
Vector2 _start = Vector2.zero;
bool _isFinished = false;
if (_cardDragon > _cardTiger)
{
_start = showEffWinGold_Dragon_PlaceHolder.position;
yield return(cardTiger.ScaleTo(Vector2.one, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card));
cardTiger.SetUpShadow(true);
panelTableBetTiger.SetShadow(true);
panelTableBetTie.SetShadow(true);
MyAudioManager.instance.PlaySfx(myAudioInfo.sfx_ShowResult);
cardDragon.SetUpLoopHighlight(() => {
_isFinished = true;
});
yield return(new WaitUntil(() => _isFinished));
yield return(cardDragon.ScaleTo(Vector2.one, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card));
// panelTableBetDragon.SetUpHighlight();
}
else if (_cardDragon < _cardTiger)
{
_start = showEffWinGold_Tiger_PlaceHolder.position;
yield return(cardDragon.ScaleTo(Vector2.one, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card));
cardDragon.SetUpShadow(true);
panelTableBetDragon.SetShadow(true);
panelTableBetTie.SetShadow(true);
MyAudioManager.instance.PlaySfx(myAudioInfo.sfx_ShowResult);
cardTiger.SetUpLoopHighlight(() => {
_isFinished = true;
});
yield return(new WaitUntil(() => _isFinished));
yield return(cardTiger.ScaleTo(Vector2.one, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card));
// panelTableBetTiger.SetUpHighlight();
}
else
{
_start = showEffWinGold_Tie_PlaceHolder.position;
yield return(CoroutineChain.Start
.Parallel(cardDragon.ScaleTo(Vector2.one, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card)
, cardTiger.ScaleTo(Vector2.one, _timeShow, LeanTweenType.easeInSine, myAudioInfo.sfx_Card)));
panelTableBetDragon.SetShadow(true);
panelTableBetTiger.SetShadow(true);
MyAudioManager.instance.PlaySfx(myAudioInfo.sfx_ShowResult);
panelTableBetTie.SetUpHighlight(() => {
_isFinished = true;
});
yield return(new WaitUntil(() => _isFinished));
}
if (_resultData.betUnit > 0)
{
Vector2 _end = iconGoldHolder.position;
StartCoroutine(MyConstant.DoActionShowPopupWinGold(panelBonusGoldPrefab, effectPoolManager, myCanvas.transform
, showEffPanelGoldBonusEffPlaceHolder.position, 1.1f, _resultData.betUnit
, () => {
panelUserInGame.RefreshGoldInfo();
}));
yield return(StartCoroutine(MyConstant.DoActionShowEffectGoldFly(goldPrefab, effectPoolManager, sortingLayerManager.sortingLayerInfo_GoldObject
, _start, _end, 10, ratioScale, 0.8f
, () => {
MyAudioManager.instance.PlaySfx(GameInformation.instance.globalAudioInfo.sfx_Gold);
})));
}
panelTableBetDragon.SetShadow(false);
panelTableBetTie.SetShadow(false);
panelTableBetTiger.SetShadow(false);
cardDragon.SetUpShadow(false);
cardTiger.SetUpShadow(false);
yield return(CoroutineChain.Start
.Parallel(cardDragon.Move(posistionSpawnCard, 0.3f, LeanTweenType.easeInSine, myAudioInfo.sfx_Card),
cardTiger.Move(posistionSpawnCard, 0.3f, LeanTweenType.easeInSine, myAudioInfo.sfx_Card)));
cardDragon.SelfDestruction();
cardDragon = null;
cardTiger.SelfDestruction();
cardTiger = null;
if (callbackManager != null && callbackManager.onEndShowResult != null)
{
callbackManager.onEndShowResult();
}
_resultData = null;
dragonTigerCasinoData.processResultData.RemoveAt(0);
SetBetAgain();
}
