#include "13S_GameScene.h"

#include "13S_GamePlayer.h"
#include "13S_GameLogic.h"
#include "UserInfo.h"
#include "MainScene.h"
#include "MissionWeiXin.h"
#include "DismissScene.h"
#include "13S_BigCardSprite.h"

#include "PopScene.h"
#include "ActionEx.h"
#include "JniFun.h"
#include "SetScene.h"
#include "ChatScene.h"
#include "PlayerScene.h"
#include "IpTipScene.h"

#include "SimpleAudioEngine.h"

using namespace SSS_SPACE;

bool SSSGameScene::init()
{
	if (!GameFrameBase::init())
	{
		return false;
	}

	m_strGameRuleInfo = "";
	m_bClassicRule = false;
	_cbGameStatus = SSS_GS_WK_FREE;
	_wBuildCardTime = 40;
	_wRobBankerTime = 20;
	_wUserChipTime = 20;

	zeromemory(&m_PrivateRoomInfo, sizeof(CMD_GF_Private_Room_Info));

	initNet();
	initScene();

	return true;
}

//进场动画完成回调;
void SSSGameScene::onEnterTransitionDidFinish()
{
	GameFrameBase::onEnterTransitionDidFinish();

	if (true == GAME_MUISCBG)
	{
		CocosDenshion::SimpleAudioEngine::getInstance()->playBackgroundMusic("Games/13S/Sound/background1.mp3", true);
	}

	// 暂时停了测试;
#if CC_PLATFORM_WIN32 == CC_TARGET_PLATFORM
	CocosDenshion::SimpleAudioEngine* pAudio = CocosDenshion::SimpleAudioEngine::getInstance();
	pAudio->stopBackgroundMusic(true);
#endif

	// 录像模式;
	if (m_IsGameRecord)
	{
		StartRecord(SSS_GAME_PLAYER);

		// 隐藏功能按钮;
		m_sprRepBg->setVisible(false);
	}
	else
	{
		// 增加游戏内事件处理;
		auto dispatcher = Director::getInstance()->getEventDispatcher();
		dispatcher->addCustomEventListener(SHOW_PRIVATE_END, CC_CALLBACK_1(SSSGameScene::onEventShowPrivate, this));

		CGameServerItem* pGameServerItem = GameMission::g_pGameServerItem;
		CC_ASSERT(pGameServerItem != nullptr);
		if (pGameServerItem != nullptr)
		{
			m_kGameMission.SetServerItem(pGameServerItem);
			m_kGameMission.start();
		}
	}

}

//场景退出;
void SSSGameScene::onExit()
{
	GameFrameBase::onExit();

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		SafeDelete(m_aryPlayer[i]);
	}

	auto dispatcher = Director::getInstance()->getEventDispatcher();
	dispatcher->removeCustomEventListeners(SHOW_PRIVATE_END);
}

//场景初始化;
void SSSGameScene::initScene()
{
	//根节点;
	m_rootNode = CSLoader::createNodeWithVisibleSize("Games/13S/GameTableScene.csb");
	CC_ASSERT(m_rootNode != nullptr);
	this->addChild(m_rootNode, ZO_DEFAULT);

	// 公告;
	auto ImageSytem = (ImageView*)m_rootNode->getChildByName("ImgRoll");
	CC_ASSERT(ImageSytem!=nullptr);
	SetSystemNode(ImageSytem);

	// 绑定界面元素;
	_MainPanel = static_cast<Layout*>(m_rootNode->getChildByName("MainPanel"));
	CC_ASSERT(_MainPanel != nullptr);

	// 房间信息;
	_imgRoomInfo = static_cast<ImageView*>(_MainPanel->getChildByName("imgRoomInfo"));
	CC_ASSERT(_imgRoomInfo != nullptr);

	// 房间ID;
	_txtRoomID = static_cast<Text*>(_imgRoomInfo->getChildByName("txtRoomID"));
	CC_ASSERT(_txtRoomID != nullptr);

	// 房间规则;
	_txtRoomRule = static_cast<Text*>(_imgRoomInfo->getChildByName("txtRule"));
	CC_ASSERT(_txtRoomRule != nullptr);
	_txtRoomRule->setString("");

	// 局数;
	_txtJushu = static_cast<Text*>(_imgRoomInfo->getChildByName("txtRoundNum"));
	CC_ASSERT(_txtJushu != nullptr);
	_txtJushu->setVisible(false);

	// 结束面板;
	_ResultPanel = static_cast<Layout*>(m_rootNode->getChildByName("resultPanel"));
	CC_ASSERT(_ResultPanel != nullptr);
	_ResultPanel->setVisible(false);

	// 胜负动画;
	_pArmatureResult = (Armature*)_ResultPanel->getChildByName("armaGameResult");
	CC_ASSERT(_pArmatureResult != nullptr);
	_pArmatureResult->setVisible(false);

	// 准备按钮;
	_btnReady = static_cast<Button*>(_ResultPanel->getChildByName("btnReady"));
	CC_ASSERT(_btnReady != nullptr);

	// 准备开始;
	_btnReady->addClickEventListener([=](Ref* pSender) {
		playBtnClickEffect();
		SendUserReady();

		ArmatureAnimation* pAniResult = _pArmatureResult->getAnimation();
		if (pAniResult != nullptr)
		{
			pAniResult->stop();
		}
		_pArmatureResult->setVisible(false);

		_ResultPanel->setVisible(false);
	});

	// 查看总成绩按钮;
	_btnPrivateEnd = static_cast<Button*>(_ResultPanel->getChildByName("btnPrivateEnd"));
	CC_ASSERT(_btnPrivateEnd != nullptr);
	_btnPrivateEnd->setVisible(false);
	_btnPrivateEnd->addClickEventListener([this](Ref*){
		playBtnClickEffect();

		//BJOpenResultScene* pOpenResultScene = BJOpenResultScene::create();
		_OpenResultScene->updateUIData(m_dwRoomID, &_aryResultItem, true);
		_OpenResultScene->setVisible(true);
	});

	for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		string strName = StringUtils::format("txtScoreChair_%d", i);
		_pTxtResultScore[i] = static_cast<TextAtlas*>(_ResultPanel->getChildByName(strName));
		CC_ASSERT(_pTxtResultScore[i]!=nullptr);
		_pTxtResultScore[i]->setString("");

		//string strXin = StringUtils::format("txtXinScore_%d", i);
		//_pTxtXinScore[i] = static_cast<TextAtlas*>(_ResultPanel->getChildByName(strXin));
		//CC_ASSERT(_pTxtXinScore[i] != nullptr);
		//_pTxtXinScore[i]->setString("");
	}

	// 按钮面板;
	_ButtonPanel = static_cast<Layout*>(_MainPanel->getChildByName("ButtonPanel"));
	CC_ASSERT(_ButtonPanel != nullptr);

	// 发牌面板;
	_SendCardPanel = static_cast<Layout*>(_MainPanel->getChildByName("panelSendCard"));
	CC_ASSERT(_SendCardPanel != nullptr);
	_SendCardPanel->setVisible(false);

	// 微信邀请按钮;
	_btnInvite = static_cast<Button*>(_ButtonPanel->getChildByName("btnInvite"));
	CC_ASSERT(_btnInvite != nullptr);
	_btnInvite->setVisible(false);

	// 解散房间按钮;
	_btnDismiss = static_cast<Button*>(_ButtonPanel->getChildByName("btnDismiss"));
	CC_ASSERT(_btnDismiss != nullptr);
	_btnDismiss->setVisible(false);

	//设置按钮;
	auto btnSetting = static_cast<Button*>(_ButtonPanel->getChildByName("btnSetting"));
	CC_ASSERT(btnSetting != nullptr);
	btnSetting->addClickEventListener([this](Ref*){
		YSAudioEngine::Instance().playBtnClickEffect();

		TipNode* pNode = SetScene::create();
		CC_ASSERT(pNode != nullptr);
		this->addChild(pNode, ZO_ANI);
		pNode->pushScene();
	});

	// 离开按钮;
	_btnLeave = static_cast<Button*>(_ButtonPanel->getChildByName("btnLeave"));
	CC_ASSERT(_btnLeave != nullptr);
	//_btnLeave->setVisible(false);

	_btnLeave->addClickEventListener([=](Ref* pSender){
		YSAudioEngine::Instance().playBtnClickEffect();

		GamePlayer* pGamePlayer = getSelfGamePlayer();

		auto callback_ok = [=](){

			if (pGamePlayer != nullptr)
			{
				CMD_GR_UserStandUp request;
				memset(&request, 0, sizeof(request));

				request.wTableID = pGamePlayer->GetTableID();
				request.wChairID = pGamePlayer->GetChairID();
				request.cbForceLeave = true;

				m_kGameMission.SendSocketData(MDM_GR_USER, SUB_GR_USER_STANDUP, &request, sizeof(request));
			}

			this->runAction(Sequence::createWithTwoActions(DelayTime::create(0.2f), CallFunc::create([=]{
				Director::getInstance()->getEventDispatcher()->dispatchCustomEvent(LEAVE_GAME);
			})));
		};

		std::string strPop = "您确定要离开房间吗？";
		if (_cbGameStatus != SSS_GS_WK_FREE)
		{
			strPop = "您正在游戏中,强行退出会被扣分,确定要强退吗?";
		}

		PopScene::Instance().show(utility::a_u8(strPop), callback_ok, nullptr);
	});

	// 语音按钮;
	_btnVoice = static_cast<Button*>(_ButtonPanel->getChildByName("btnVoice"));
	CC_ASSERT(_btnVoice != nullptr);
	_btnVoice->addTouchEventListener(CC_CALLBACK_2(SSSGameScene::OnButtonVoiceTouched, this));


	// 聊天按钮;
	_btnChat = static_cast<Button*>(_ButtonPanel->getChildByName("btnChat"));
	CC_ASSERT(_btnChat != nullptr);
	_btnChat->addClickEventListener([this](Ref*){
		YSAudioEngine::Instance().playBtnClickEffect();

		auto chatLayer = ChatLayer::create(m_vecShortChatList);
		CC_ASSERT(chatLayer != nullptr);
		this->addChild(chatLayer, ZO_ANI);
		chatLayer->pushScene();
	});


	// 开始按钮;
	_btnStartGame = static_cast<Button*>(_ButtonPanel->getChildByName("btnStartGame"));
	CC_ASSERT(_btnStartGame != nullptr);
	_btnStartGame->setVisible(false);

	// 开始游戏;
	_btnStartGame->addClickEventListener([=](Ref* pSender) {
		playBtnClickEffect();

		SendUserReady();

		_btnStartGame->setEnabled(false);

	});

	// 开始动画;
	_pArmatureStart = (Armature*)_MainPanel->getChildByName("armaStartGame");
	CC_ASSERT(_pArmatureStart != nullptr);
	_pArmatureStart->setVisible(false);

	ArmatureAnimation* pAniStart = _pArmatureStart->getAnimation();
	if (pAniStart != nullptr)
	{
		pAniStart->setMovementEventCallFunc(CC_CALLBACK_3(SSSGameScene::movementEventCallFunc, this));
	}

	// 全垒打动画;
	_pArmaAllKillEffect = (Armature*)_MainPanel->getChildByName("armaAllKillEffect");
	CC_ASSERT(_pArmaAllKillEffect != nullptr);
	_pArmaAllKillEffect->setVisible(false);

	ArmatureAnimation* pAniAllKill = _pArmaAllKillEffect->getAnimation();
	if (pAniAllKill != nullptr)
	{
		pAniAllKill->setMovementEventCallFunc(CC_CALLBACK_3(SSSGameScene::movementEventCallFunc, this));
	}

	// 抢庄面板;
	_RobPanel = static_cast<Layout*>(_MainPanel->getChildByName("RobPanel"));
	CC_ASSERT(_RobPanel != nullptr);
	_RobPanel->setVisible(false);

	// 抢庄;
	_btnRobYes = static_cast<Button*>(_RobPanel->getChildByName("btnRobYes"));
	CC_ASSERT(_btnRobYes != nullptr);
	_btnRobYes->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onRobYesButtonClick, this));

	// 不抢庄;
	_btnRobNo = static_cast<Button*>(_RobPanel->getChildByName("btnRobNo"));
	CC_ASSERT(_btnRobNo != nullptr);
	_btnRobNo->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onRobNoButtonClick, this));

	// 压注面板;
	_YaZhuPanel = static_cast<Layout*>(_MainPanel->getChildByName("YaZhuPanel"));
	CC_ASSERT(_YaZhuPanel != nullptr);
	_YaZhuPanel->setVisible(false);

	// 压注按钮;
	for (uint8 i = 0; i < 3; i++)
	{
		Button* pTmpButton = static_cast<Button*>(_YaZhuPanel->getChildByName(StringUtils::format("btnScore%d", 3+i)));
		CC_ASSERT(pTmpButton != nullptr);
		pTmpButton->setTag(3 + i);
		pTmpButton->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onYaZhuButtonClick, this));
		_aryButtonScore[i] = pTmpButton;
	}

	// 特殊面板;
	_SpecialPanel = static_cast<Layout*>(_MainPanel->getChildByName("SpecialPanel"));
	CC_ASSERT(_SpecialPanel != nullptr);
	_SpecialPanel->setVisible(false);

	// 特殊牌类型;
	_sprSpecialType = static_cast<Sprite*>(_SpecialPanel->getChildByName("txtCardType"));
	CC_ASSERT(_sprSpecialType != nullptr);

	_sprOtherCallBanker = static_cast<Sprite*>(_MainPanel->getChildByName("watting_callbanker"));
	CC_ASSERT(_sprOtherCallBanker != nullptr);

	_sprOtherAddScore = static_cast<Sprite*>(_MainPanel->getChildByName("watting_addscore"));
	CC_ASSERT(_sprOtherAddScore != nullptr);

	_sprSelfAddScore = static_cast<Sprite*>(_MainPanel->getChildByName("owner_addscore"));
	CC_ASSERT(_sprSelfAddScore != nullptr);

	setOperateStatus(SSS_OS_NULL);

	// 不摆特殊牌按钮;
	_btnRefuseCards = static_cast<Button*>(_SpecialPanel->getChildByName("btnRefuseCards"));
	CC_ASSERT(_btnRefuseCards != nullptr);
	_btnRefuseCards->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onRefuseCardsButtonClick, this));

	// 确定特殊牌按钮;
	_btnCommitSpecial = static_cast<Button*>(_SpecialPanel->getChildByName("btnCommit"));
	CC_ASSERT(_btnCommitSpecial != nullptr);
	_btnCommitSpecial->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onCommitSpecialButtonClick, this));

	// 操作面板;
	_OperatePanel = static_cast<Layout*>(_MainPanel->getChildByName("OperatePanel"));
	CC_ASSERT(_OperatePanel != nullptr);
	_OperatePanel->setVisible(false);

	auto OperCardPanelParent = static_cast<Layout*>(_OperatePanel->getChildByName("OperateCardPanel"));
	CC_ASSERT(OperCardPanelParent != nullptr);

	// 创建扑克操作面板;
	Size operSize = OperCardPanelParent->getContentSize();
	auto func = CC_CALLBACK_2(SSSGameScene::selectCardCallback, this);
	_OperateCardPanel = SSSOperateCardPanel::create(operSize, func);
	OperCardPanelParent->addChild(_OperateCardPanel);

	// 桌面上的时钟精灵;
	_imgGameClock = static_cast<Sprite*>(_MainPanel->getChildByName("imgGameClock"));
	CC_ASSERT(_imgGameClock != nullptr);
	_imgGameClock->setVisible(false);

	// 操作面板上的时钟精灵;
	_imgOperClock = static_cast<Sprite*>(_OperatePanel->getChildByName("imgGameClock"));
	CC_ASSERT(_imgOperClock != nullptr);
	_imgOperClock->setVisible(false);

	// 比较按钮;
	_btnCompare = static_cast<Button*>(_OperatePanel->getChildByName("btnCompare"));
	CC_ASSERT(_btnCompare != nullptr);
	_btnCompare->setVisible(false);

	// 重置按钮;
	_btnReset = static_cast<Button*>(_OperatePanel->getChildByName("btnReset"));
	CC_ASSERT(_btnReset != nullptr);
	_btnReset->setVisible(false);

	// 随机组牌按钮;
	_btnRandomCard = static_cast<Button*>(_OperatePanel->getChildByName("btnRandomCard"));
	CC_ASSERT(_btnRandomCard != nullptr);
	_btnRandomCard->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onRandomButtonClick, this));

	auto tricksPanel = static_cast<ImageView*>(_OperatePanel->getChildByName("imgTricksPanel"));
	CC_ASSERT(tricksPanel != nullptr);

	for (int i = 0; i < SSS_GROUP_COUNT; i++)
	{
		auto imgCardBlock = static_cast<ImageView*>(tricksPanel->getChildByName(StringUtils::format("imgCardBlock%d", i)));
		CC_ASSERT(imgCardBlock!=nullptr);

		_aryTricksCardPanel[i] = static_cast<Layout*>(imgCardBlock->getChildByName("panelCard"));
		CC_ASSERT(_aryTricksCardPanel[i]!=nullptr);

		_aryButtonRechoose[i] = static_cast<Button*>(tricksPanel->getChildByName(StringUtils::format("btnRechoose%d", i)));
		CC_ASSERT(_aryButtonRechoose[i]!=nullptr);
		_aryButtonRechoose[i]->setEnabled(false);

		_arySprCardType[i] = static_cast<Sprite*>(tricksPanel->getChildByName(StringUtils::format("sprCardType%d", i)));
		CC_ASSERT(_arySprCardType[i] != nullptr);
		_arySprCardType[i]->setVisible(false);

		_arySprCardShadow[i] = static_cast<Sprite*>(imgCardBlock->getChildByName("imgCardShadow"));
		CC_ASSERT(_arySprCardShadow[i] != nullptr);
		_arySprCardShadow[i]->setVisible(false);
	}

	//对子按钮;
	_btnDuiZi = static_cast<Button*>(_OperatePanel->getChildByName("btnDuiZi"));
	CC_ASSERT(_btnDuiZi != nullptr);
	_btnDuiZi->setEnabled(false);
	_btnDuiZi->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onDuiZiButtonClick, this));

	//两对按钮;
	_btnLiangDui = static_cast<Button*>(_OperatePanel->getChildByName("btnLiangDui"));
	CC_ASSERT(_btnLiangDui != nullptr);
	_btnLiangDui->setEnabled(false);
	_btnLiangDui->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onLiangDuiButtonClick, this));

	//三条按钮;
	_btnSanTiao = static_cast<Button*>(_OperatePanel->getChildByName("btnSanTiao"));
	CC_ASSERT(_btnSanTiao != nullptr);
	_btnSanTiao->setEnabled(false);
	_btnSanTiao->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onSanTiaoButtonClick, this));

	//顺子按钮;
	_btnShunZi = static_cast<Button*>(_OperatePanel->getChildByName("btnShunZi"));
	CC_ASSERT(_btnShunZi != nullptr);
	_btnShunZi->setEnabled(false);
	_btnShunZi->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onShunZiButtonClick, this));

	//同花按钮;
	_btnTongHua = static_cast<Button*>(_OperatePanel->getChildByName("btnTongHua"));
	CC_ASSERT(_btnTongHua != nullptr);
	_btnTongHua->setEnabled(false);
	_btnTongHua->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onTongHuaButtonClick, this));

	//葫芦按钮;
	_btnHuLu = static_cast<Button*>(_OperatePanel->getChildByName("btnHuLu"));
	CC_ASSERT(_btnHuLu != nullptr);
	_btnHuLu->setEnabled(false);
	_btnHuLu->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onHuLuButtonClick, this));

	//铁支按钮;
	_btnTieZhi = static_cast<Button*>(_OperatePanel->getChildByName("btnTieZhi"));
	CC_ASSERT(_btnTieZhi != nullptr);
	_btnTieZhi->setEnabled(false);
	_btnTieZhi->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onTieZhiButtonClick, this));

	//同花顺按钮;
	_btnTongHuaShun = static_cast<Button*>(_OperatePanel->getChildByName("btnTongHuaShun"));
	CC_ASSERT(_btnTongHuaShun != nullptr);
	_btnTongHuaShun->setEnabled(false);
	_btnTongHuaShun->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onTongHuaShunButtonClick, this));
	
	// 头道小于中道提示;
	_imgQualifiedTips = static_cast<Sprite*>(_OperatePanel->getChildByName("imgQualifiedTips"));
	CC_ASSERT(_imgQualifiedTips != nullptr);
	_imgQualifiedTips->setVisible(false);

	// 摊牌;
	_txtTip = static_cast<Text*>(_MainPanel->getChildByName("txtTip"));
	CC_ASSERT(_txtTip != nullptr);
	_txtTip->setVisible(true);
	_txtTip->setString("");

	// 发牌位置;
	_ptSendCardPos = _MainPanel->getChildByName("imgCard")->getPosition();

	// 语音标志;
	m_pVoiceNode = (Node*)m_rootNode->getChildByName("VoiceNode");
	CC_ASSERT(m_pVoiceNode != nullptr);
	m_pVoiceNode->setVisible(false);

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		std::string strName = StringUtils::format("panelChair_%d", i);
		Layout* layout = static_cast<Layout*>(_MainPanel->getChildByName(strName));
		CC_ASSERT(layout!=nullptr);

		m_aryPlayer[i] = new SSS_GamePlayer(i, layout);
	
		layout->addClickEventListener([i, this](Ref* pSender){
			CC_ASSERT(pSender != nullptr);
			if (nullptr == pSender) return;

			if ((m_aryPlayer[i] != nullptr) && m_aryPlayer[i]->getUserItem(false) != nullptr)
			{
				PlayerScene* playerScene = PlayerScene::create();
				playerScene->showPlayerInfo(m_aryPlayer[i]);
				this->addChild(playerScene, ZO_TRUSTEE);
			}
		});
	}

	m_pLocalPlayer = m_aryPlayer[SSS_VIEW_SELF_ID];

	auto exitCallFunc = [=](Ref*){
		auto callback = [=](){
			onClickExitGameButton(nullptr);

			this->runAction(Sequence::createWithTwoActions(DelayTime::create(0.2f), CallFunc::create([=]{
				Director::getInstance()->getEventDispatcher()->dispatchCustomEvent(LEAVE_GAME);
			})));
		};

		PopScene::Instance().show(utility::a_u8("您确定要退出游戏吗？"), callback, nullptr);
	};

	// 比牌;
	_btnCompare->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onCompareButtonClick, this));

    // 重置手牌;
	_btnReset->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onResetButtonClick, this));

	for (int i = 0; i < SSS_GROUP_COUNT; i++)
	{
		_aryButtonRechoose[i]->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onRechooseButtonClick, this));
		_aryButtonRechoose[i]->setTag(i);

		//string strName = StringUtils::format("btnPanel%d", i);
		//auto btnPanel = static_cast<Layout*>(tricksPanel->getChildByName(strName));
		//CC_ASSERT(btnPanel!=nullptr);

		_aryTricksCardPanel[i]->addTouchEventListener(CC_CALLBACK_2(SSSGameScene::onPanelTouchEvent, this));
		_aryTricksCardPanel[i]->setTag(i);
	}

	// 邀请;
	_btnInvite->addClickEventListener(CC_CALLBACK_1(SSSGameScene::onInviteButtonClick, this));

	// 解散房间函数;
	auto callback = [this](){
		onEventAgreeDismissRoom(true);
	};

	_btnDismiss->addClickEventListener([=](Ref* pSender) {
        // 解散;
		playBtnClickEffect();
		std::string strTip;
		if (0 == m_PrivateRoomInfo.dwPlayCout && false == m_PrivateRoomInfo.bStartGame)
		{
			strTip = "牌局开始前解散房间不扣房卡，是否解散？";
		}
		else
		{
			strTip = "您确定要解散房间吗？";
		}

		PopScene::Instance().show(utility::a_u8(strTip.c_str()), callback, nullptr);
	});

	// 私人场结束面板;
	_OpenResultScene = SSSOpenResultScene::create();
	addChild(_OpenResultScene);
	_OpenResultScene->setVisible(false);

	//// 解散房间函数;
	//auto callback = [this](){
	//	onEventAgreeDismissRoom(true);
	//};

	//对手机返回键的监听 ;
	auto keyListener = EventListenerKeyboard::create();
	//和回调函数绑定 ;
	keyListener->onKeyReleased = [=](EventKeyboard::KeyCode keyCode, Event * pEvent){
		//返回值处理;
		if (keyCode == EventKeyboard::KeyCode::KEY_ESCAPE)
		{
			//uint8 cbWinChairID = 3;
			//uint8 cbLoseChairID = 2;

			//uint16 wWinViewID = SwitchViewChairID(cbWinChairID);
			//tagSSSGunInfo* pWinInfo = new tagSSSGunInfo;
			//pWinInfo->wViewID = wWinViewID;
			//pWinInfo->ptPos = m_aryPlayer[wWinViewID]->getHandCardPos(1, 2);
			//pWinInfo->cbGender = m_aryPlayer[wWinViewID]->GetGender();
			//pWinInfo->nScore = std::abs(10);

			//uint16 wLoseViewID = SwitchViewChairID(cbLoseChairID);
			//tagSSSGunInfo* pLoseInfo = new tagSSSGunInfo;
			//pLoseInfo->wViewID = wLoseViewID;
			//pLoseInfo->ptPos = m_aryPlayer[wLoseViewID]->getHandCardPos(1, 2);
			//pLoseInfo->cbGender = m_aryPlayer[wLoseViewID]->GetGender();
			//pLoseInfo->nScore = -10;

			//tagSSSTwoGunInfos* pInfo = new tagSSSTwoGunInfos;
			//pInfo->pWinnerInfo = pWinInfo;
			//pInfo->pLoserInfo = pLoseInfo;
			//m_GameOverAni->addGunPlay(pInfo);

			//m_GameOverAni->showAnimation(nullptr);
			exitCallFunc(nullptr);
		}
	};
	//添加到事件分发器中 ;
	_eventDispatcher->addEventListenerWithSceneGraphPriority(keyListener, this);

	SpriteFrameCache* pSpriteFrameCache = SpriteFrameCache::getInstance();
	pSpriteFrameCache->addSpriteFramesWithFile("Games/13S/Cards/PinLargeCard1.plist");
	pSpriteFrameCache->addSpriteFramesWithFile("Games/13S/Cards/PinLargeCard2.plist");
	pSpriteFrameCache->addSpriteFramesWithFile("Games/13S/Cards/PinSmallCard.plist");

	m_GameOverAni = CGameOverAni::create();
	_MainPanel->addChild(m_GameOverAni);

	loadShortChat("Games/13S/ShortChat/ChatInfo.json");

	//重置场景;
	resetScene();

	//重置数据;
	ResetAllData();
}

//重置场景;
void SSSGameScene::resetScene(bool bAll/* = false*/)
{
	//重置玩家UI;
	for (uint8 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		m_aryPlayer[i]->resetUI(bAll);
		m_aryPlayer[i]->setBankerVisible(false);
		m_aryPlayer[i]->updateUserChip(0);
	}

	for (int i = 0; i < SSS_GROUP_COUNT; i++)
	{
		_aryTricksCardPanel[i]->removeAllChildren();

		_aryButtonRechoose[i]->setEnabled(false);
		_arySprCardType[i]->setVisible(false);
	}

	setOperateStatus(SSS_OS_NULL);

	_RobPanel->setVisible(false);
	_YaZhuPanel->setVisible(false);
	_SpecialPanel->setVisible(false);
	_OperatePanel->setVisible(false);
	_ResultPanel->setVisible(false);
}

//重置数据;
void SSSGameScene::resetData()
{
	_cbGameStatus = SSS_GS_WK_FREE;

	_iBaseScore = 0;
	_wBankerUser = INVALID_CHAIR;
	_cbCurOpenCardAniIndex = 0;
	_wSelfSpecialType = SSS_CT_INVALID;

	_wKillAllUserChairID = INVALID_CHAIR;

	for (uint8 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		_aryActiveStatus[i] = SSS_HAND_STATUS_NULL;
	}

	zeromemory(_aryHandCardData, sizeof(_aryHandCardData));
	zeromemory(_aryTricksFrontCard, sizeof(_aryTricksFrontCard));
	zeromemory(_aryTricksMidCard, sizeof(_aryTricksMidCard));
	zeromemory(_aryTricksBackCard, sizeof(_aryTricksBackCard));
	zeromemory(_arySpecialType, sizeof(_arySpecialType));

	zeromemory(_arySpecialCompareResult, sizeof(_arySpecialCompareResult));
	zeromemory(_aryThreeKillResult, sizeof(_aryThreeKillResult));

	zeromemory(_aryFrontCard, sizeof(_aryFrontCard));
	zeromemory(_aryMidCard, sizeof(_aryMidCard));
	zeromemory(_aryBackCard, sizeof(_aryBackCard));
}

//重置数据(相当于玩家离开);
void SSSGameScene::ResetAllData()
{
	resetScene();

	resetData();
}

//重置桌子;
void SSSGameScene::ResetTable()
{
	resetScene(true);

	resetData();
}

//获取快捷语音文件路径;
const std::string SSSGameScene::getShortChatSoundPath(uint8 cbGender, int nIndex)
{
	// 短语;
	std::string strFilePath = "Games/13S/ShortChat/";
	if (cbGender == enMan)
	{
		strFilePath += StringUtils::format("man/%d.mp3", nIndex);
	}
	else
	{
		strFilePath += StringUtils::format("woman/%d.mp3", nIndex);
	}

	return strFilePath;
}

//绑定网络消息;
void SSSGameScene::initNet()
{
	addNetCBDefine(SSS_SUB_S_GAME_START, this, SSSGameScene::onSubGameStart);

	addNetCBDefine(SSS_SUB_S_START_ROB, this, SSSGameScene::onSubStartRob);
	addNetCBDefine(SSS_SUB_S_USER_ROB, this, SSSGameScene::onSubUserRob);
	addNetCBDefine(SSS_SUB_S_START_CHIP, this, SSSGameScene::onSubStartChip);
	addNetCBDefine(SSS_SUB_S_USER_CHIP, this, SSSGameScene::onSubUserChip);

	addNetCBDefine(SSS_SUB_S_SEND_LEFT_CARD, this, SSSGameScene::onSubSendLeftCard);
	addNetCBDefine(SSS_SUB_S_START_OPEN, this, SSSGameScene::onSubStartOpen);
	addNetCBDefine(SSS_SUB_S_OPEN_CARD, this, SSSGameScene::onSubOpenCard);
	addNetCBDefine(SSS_SUB_S_CLASSIC_CMP_CARD, this, SSSGameScene::onSubClassicCompareCard);
	addNetCBDefine(SSS_SUB_S_BANKER_CMP_CARD, this, SSSGameScene::onSubBankerCompareCard);

	addNetCBDefine(SSS_SUB_S_GAME_END, this, SSSGameScene::onSubGameEnd);
}

bool SSSGameScene::OnEventSceneMessage(uint8 cbGameStatus, bool bLookonUser, void* pData, int nDataSize)
{
	_cbGameStatus = cbGameStatus;

	switch (cbGameStatus)
	{
	case SSS_GS_WK_FREE:
	{
		return onGameSceneFree(pData, nDataSize);
	}
	case SSS_GS_WK_ROB_BANKER:
	{
		return onGameSceneRobBanker(pData, nDataSize);
	}
	case SSS_GS_WK_USER_CHIP:
	{
		return onGameSceneUserChip(pData, nDataSize);
	}
	case SSS_GS_WK_SEND_CARD:
	{
		return onGameSceneSendCard(pData, nDataSize);
	}
	case SSS_GS_WK_OPEN_CARD:
	{
		return onGameSceneOpenCard(pData, nDataSize);
	}
	case SSS_GS_WK_COMPARE_CARD:
	{
		return onGameSceneCompareCard(pData, nDataSize);
	}
	default:
		break;
	}

	return true;
}

//恢复空闭场景;
bool SSSGameScene::onGameSceneFree(void* pData, int nDataSize)
{
	//校验数据;
	CC_ASSERT(nDataSize == sizeof(SSS_CMD_S_StatusFree));
	SSS_CMD_S_StatusFree* pStatusFree = (SSS_CMD_S_StatusFree*)pData;

	_wBuildCardTime = pStatusFree->wBuildCardTime;
	_wRobBankerTime = pStatusFree->wRobBankerTime;
	_wUserChipTime = pStatusFree->wUserChipTime;

	return true;
}

//抢庄场景;
bool SSSGameScene::onGameSceneRobBanker(void* pData, int nDataSize)
{
	//校验数据;
	CC_ASSERT(nDataSize == sizeof(SSS_CMD_S_StatusRob));
	SSS_CMD_S_StatusRob* pStatusRob = (SSS_CMD_S_StatusRob*)pData;

	_wBuildCardTime = pStatusRob->BaseStatus.wBuildCardTime;
	_wRobBankerTime = pStatusRob->BaseStatus.wRobBankerTime;
	_wUserChipTime = pStatusRob->BaseStatus.wUserChipTime;

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		_aryActiveStatus[i] = pStatusRob->BaseStatus.cbHandStatus[i];
	}

	_cbSendCardCount = pStatusRob->cbCardCount;
	memcpy(_aryHandCardData, pStatusRob->cbHandCardData, sizeof(_aryHandCardData));

	showCurHandCard(_cbSendCardCount);

	uint16 wSelfChairID = getSelfChairID();
	CC_ASSERT(wSelfChairID<SSS_GAME_PLAYER);
	//抢庄状态 0:没操作，1:不抢，2:抢;
	if (0==pStatusRob->cbRobStatus[wSelfChairID])
	{
		_RobPanel->setVisible(true);
	}
	else
	{
		setOperateStatus(SSS_OS_CALLBANK);
	}

	return true;
}

//下注场景;
bool SSSGameScene::onGameSceneUserChip(void* pData, int nDataSize)
{
	//校验数据;
	CC_ASSERT(nDataSize == sizeof(SSS_CMD_S_StatusChip));
	SSS_CMD_S_StatusChip* pStatusChip = (SSS_CMD_S_StatusChip*)pData;

	_wBuildCardTime = pStatusChip->BaseStatus.wBuildCardTime;
	_wRobBankerTime = pStatusChip->BaseStatus.wRobBankerTime;
	_wUserChipTime = pStatusChip->BaseStatus.wUserChipTime;
	_wBankerUser = pStatusChip->wBankerUser;

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		_aryActiveStatus[i] = pStatusChip->BaseStatus.cbHandStatus[i];
	}

	_cbSendCardCount = pStatusChip->cbCardCount;
	memcpy(_aryHandCardData, pStatusChip->cbHandCardData, sizeof(_aryHandCardData));

	showCurHandCard(_cbSendCardCount);

	uint16 wSelfChairID = getSelfChairID();
	CC_ASSERT(wSelfChairID < SSS_GAME_PLAYER);
	//抢庄状态 0:没操作，1:已操作;
	if ((pStatusChip->wBankerUser != wSelfChairID) && (0 == pStatusChip->cbChipStatus[wSelfChairID]))
	{
		_YaZhuPanel->setVisible(true);
		setOperateStatus(SSS_OS_ADDSCORE1);
	}
	else
	{
		setOperateStatus(SSS_OS_ADDSCORE0);
	}

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		int nChipScore = pStatusChip->lUserChipScore[i];
		if (nChipScore>0)
		{
			uint16 wViewID = SwitchViewChairID(i);
			m_aryPlayer[wViewID]->updateUserChip(nChipScore);
		}
	}

	showBankerIcon();

	return true;
}

//发牌场景;
bool SSSGameScene::onGameSceneSendCard(void* pData, int nDataSize)
{
	//校验数据;
	CC_ASSERT(nDataSize == sizeof(SSS_CMD_S_StatusSendCard));
	SSS_CMD_S_StatusSendCard* pStatusSend = (SSS_CMD_S_StatusSendCard*)pData;

	_wBuildCardTime = pStatusSend->BaseStatus.wBuildCardTime;
	_wRobBankerTime = pStatusSend->BaseStatus.wRobBankerTime;
	_wUserChipTime = pStatusSend->BaseStatus.wUserChipTime;

	_wSelfSpecialType = pStatusSend->wSpecialType;
	_cbSendCardCount = pStatusSend->cbCardCount;
	_wBankerUser = pStatusSend->wBankerUser;

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		_aryActiveStatus[i] = pStatusSend->BaseStatus.cbHandStatus[i];
	}

	memcpy(_aryHandCardData, pStatusSend->cbHandCardData, sizeof(_aryHandCardData));
	uint16 wMyChairID = getSelfChairID();
	CC_ASSERT(wMyChairID < SSS_GAME_PLAYER);

	if (wMyChairID < SSS_GAME_PLAYER)
	{
		memcpy(_aryFrontCard[wMyChairID], pStatusSend->cbHandCardData, SSS_MIN_ITEM_COUNT);
		memcpy(_aryMidCard[wMyChairID], &pStatusSend->cbHandCardData[3], SSS_MAX_ITEM_COUNT);
		memcpy(_aryBackCard[wMyChairID], &pStatusSend->cbHandCardData[8], SSS_MAX_ITEM_COUNT);
	}

	showAllPlayersCard();
	showBankerIcon();

	uint8 cbUserStatus = m_pLocalPlayer->GetUserStatus();
	if (pStatusSend->bSendOver && cbUserStatus == US_PLAYING)
	{
		sendSendCardOverMsg();
	}

	return true;
}

//开牌场景;
bool SSSGameScene::onGameSceneOpenCard(void* pData, int nDataSize)
{
	//校验数据;
	CC_ASSERT(nDataSize == sizeof(SSS_CMD_S_StatusOpen));
	SSS_CMD_S_StatusOpen* pStatusOpen = (SSS_CMD_S_StatusOpen*)pData;

	_wBuildCardTime = pStatusOpen->BaseStatus.wBuildCardTime;
	_wRobBankerTime = pStatusOpen->BaseStatus.wRobBankerTime;
	_wUserChipTime = pStatusOpen->BaseStatus.wUserChipTime;

	_wSelfSpecialType = pStatusOpen->wSpecialType;
	_wBankerUser = pStatusOpen->wBankerUser;

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		_aryActiveStatus[i] = pStatusOpen->BaseStatus.cbHandStatus[i];
	}

	memcpy(_aryHandCardData, pStatusOpen->cbHandCardData, sizeof(_aryHandCardData));
	uint16 wMyChairID = getSelfChairID();
	CC_ASSERT(wMyChairID < SSS_GAME_PLAYER);

	if (wMyChairID < SSS_GAME_PLAYER)
	{
		memcpy(_aryFrontCard[wMyChairID], pStatusOpen->cbHandCardData, SSS_MIN_ITEM_COUNT);
		memcpy(_aryMidCard[wMyChairID], &pStatusOpen->cbHandCardData[3], SSS_MAX_ITEM_COUNT);
		memcpy(_aryBackCard[wMyChairID], &pStatusOpen->cbHandCardData[8], SSS_MAX_ITEM_COUNT);
	}

	showAllPlayersCard();
	showBankerIcon();

    for (int i = 0; i<SSS_GAME_PLAYER; i++)
	{
		if (_aryActiveStatus[i] != SSS_HAND_STATUS_NULL )
		{
			uint16 wViewID = SwitchViewChairID(i);
			m_aryPlayer[wViewID]->showHandStatus(_aryActiveStatus[i]);

			int nChipScore = pStatusOpen->lUserChipScore[i];
			if (nChipScore > 0)
			{
				m_aryPlayer[wViewID]->updateUserChip(nChipScore);
			}
		}
	}

	switch (_aryActiveStatus[wMyChairID])
	{
	case SSS_HAND_STATUS_SORTED:
		_txtTip->setString(utility::a_u8("等待其他玩家开牌..."));
		m_aryPlayer[SSS_VIEW_SELF_ID]->showCard(_aryFrontCard[wMyChairID], _aryMidCard[wMyChairID], _aryBackCard[wMyChairID], SSS_HAND_STATUS_SORTED);
		break;
	case SSS_HAND_STATUS_GIVEUP:
		_txtTip->setString(utility::a_u8("等待其他玩家开牌..."));
		break;
	case SSS_HAND_STATUS_DISORDER:
		if (_wSelfSpecialType!=SSS_CT_INVALID)
		{
			m_GameLogic.SortCardList(_aryHandCardData, SSS_MAX_COUNT);
			showCurHandCard(SSS_MAX_COUNT);
			showSpecialPanel(true);
		}
		else
		{
			showOperatePanel(true);
		}
		break;
	default:
		break;
	}

	return true;
}

//比牌场景;
bool SSSGameScene::onGameSceneCompareCard(void* pData, int nDataSize)
{
	bool bCompareOver = false;
	uint16	wHandCardType[SSS_GAME_PLAYER][SSS_GROUP_COUNT] = {0};
	int		nCompareResult[SSS_GAME_PLAYER][SSS_GROUP_COUNT] = { 0 };
	int		aryUserChipScore[SSS_GAME_PLAYER] = {};

	if (eSSSGameRuleClassic==(m_PrivateRoomInfo.bGameRuleIdex&eSSSGameRuleClassic))
	{
		//校验数据;
		CC_ASSERT(nDataSize == sizeof(SSS_CMD_S_StatusClassicCompare));
		SSS_CMD_S_StatusClassicCompare* pSC = (SSS_CMD_S_StatusClassicCompare*)pData;

		_wBuildCardTime = pSC->wBuildCardTime;
		_txtTip->setString("");

		memcpy(_aryActiveStatus, pSC->CompareStatus.cbHandStatus, sizeof(_aryActiveStatus));

		//ArmatureAnimation* pAniStart = _pArmatureStart->getAnimation();
		//if (pAniStart != nullptr)
		//{
		//	pAniStart->play("GameStart1", -1, 0);
		//	_pArmatureStart->setVisible(true);
		//}

		memcpy(_aryFrontCard, pSC->CompareStatus.cbFrontCard, sizeof(_aryFrontCard));
		memcpy(_aryMidCard, pSC->CompareStatus.cbMidCard, sizeof(_aryMidCard));
		memcpy(_aryBackCard, pSC->CompareStatus.cbBackCard, sizeof(_aryBackCard));

		memcpy(wHandCardType, pSC->CompareStatus.wHandCardType, sizeof(wHandCardType));
		memcpy(nCompareResult, pSC->CompareStatus.nCompareResult, sizeof(nCompareResult));

		bCompareOver = pSC->bCompareOver;
	}
	else
	{
		//校验数据;
		CC_ASSERT(nDataSize == sizeof(SSS_CMD_S_StatusBankerCompare));
		SSS_CMD_S_StatusBankerCompare* pSBC = (SSS_CMD_S_StatusBankerCompare*)pData;

		_wBankerUser = pSBC->wBankerUser;
		_wBuildCardTime = pSBC->wBuildCardTime;
		_txtTip->setString("");

		memcpy(_aryActiveStatus, pSBC->CompareStatus.cbHandStatus, sizeof(_aryActiveStatus));

		//ArmatureAnimation* pAniStart = _pArmatureStart->getAnimation();
		//if (pAniStart != nullptr)
		//{
		//	pAniStart->play("GameStart1", -1, 0);
		//	_pArmatureStart->setVisible(true);
		//}

		memcpy(_aryFrontCard, pSBC->CompareStatus.cbFrontCard, sizeof(_aryFrontCard));
		memcpy(_aryMidCard, pSBC->CompareStatus.cbMidCard, sizeof(_aryMidCard));
		memcpy(_aryBackCard, pSBC->CompareStatus.cbBackCard, sizeof(_aryBackCard));

		bCompareOver = pSBC->bCompareOver;

		for (int i = 0; i < SSS_GAME_PLAYER; i++)
		{
			for (int j = 0; j < SSS_GROUP_COUNT; j++)
			{
				wHandCardType[i][j] = pSBC->CompareStatus.wHandCardType[i][j];
				nCompareResult[i][j] = pSBC->CompareStatus.cbOtherCmResult[i][j];
			}

			aryUserChipScore[i] = pSBC->lUserChipScore[i];
		}

		showBankerIcon();
	}

    // 展示所有手牌和分数;
	for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		if (_aryActiveStatus[i] != SSS_HAND_STATUS_NULL)
		{
			uint16 wViewID = SwitchViewChairID(i);

			// 特殊处理A32;
			for (uint8 j = 0; j < SSS_GROUP_COUNT; j++)
			{
				uint8 aryTmpCardData[SSS_MAX_ITEM_COUNT] = { 0 };
				int nItemCount = j > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;

				if (0==j)
				{
					if (cardTypeTo32A(_aryFrontCard[i], nItemCount, aryTmpCardData, nItemCount))
					{
						memcpy(_aryFrontCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
					}
				}
				else if (1==j)
				{
					if (cardTypeTo32A(_aryMidCard[i], nItemCount, aryTmpCardData, nItemCount))
					{
						memcpy(_aryMidCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
					}
				}
				else if (2==j)
				{
					if (cardTypeTo32A(_aryBackCard[i], nItemCount, aryTmpCardData, nItemCount))
					{
						memcpy(_aryBackCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
					}
				}
			}

			m_aryPlayer[wViewID]->showCard(_aryFrontCard[i], _aryMidCard[i], _aryBackCard[i], _aryActiveStatus[i]);
			m_aryPlayer[wViewID]->setGameScore(nCompareResult[i], wHandCardType[i]);

			int nChipScore = aryUserChipScore[i];
			if (nChipScore > 0)
			{
				m_aryPlayer[wViewID]->updateUserChip(nChipScore);
			}
		}
    }

	uint8 cbUserStatus = m_pLocalPlayer->GetUserStatus();
	if (!bCompareOver && cbUserStatus == US_PLAYING)
	{
		sendCompareOverMsg();
	}

	return true;
}

void SSSGameScene::onSubGameStart(const void * pBuffer, uint16 wDataSize)
{
	//校验数据;
	CC_ASSERT(wDataSize == sizeof(SSS_CMD_S_GameStart));
	SSS_CMD_S_GameStart* pGameStart = (SSS_CMD_S_GameStart*)pBuffer;

	//重置数据;
	ResetAllData();

	_wSelfSpecialType = pGameStart->wSpecialType;
	_cbSendCardCount = pGameStart->cbCardCount;
	_wBankerUser = pGameStart->wBankerChairID;

	memcpy(_aryHandCardData, pGameStart->cbHandCardData, sizeof(_aryHandCardData));
	if (_cbSendCardCount > 0)
	{
		m_GameLogic.SortCardList(_aryHandCardData, _cbSendCardCount);
	}

	for (uint8 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		_aryActiveStatus[i] = pGameStart->cbHandStatus[i];
	}

	if (_cbSendCardCount>0)
	{
		ArmatureAnimation* pAniStart = _pArmatureStart->getAnimation();
		if (pAniStart != nullptr)
		{
			pAniStart->play("GameStart2", -1, 0);
			_pArmatureStart->setVisible(true);
		}

		showBankerIcon();
	}
	else
	{
		SSS_CMD_S_StartChip mStartChip = {0};
		mStartChip.wBankerUser = _wBankerUser;

		onSubStartChip(&mStartChip, sizeof(SSS_CMD_S_StartChip));
	}

	// 隐藏同IP显示;
	IpTipScene::Instance().hide();
}

//开始抢庄;
void SSSGameScene::onSubStartRob(const void * pBuffer, uint16 wDataSize)
{
	_RobPanel->setVisible(true);
}

//玩家抢庄;
void SSSGameScene::onSubUserRob(const void * pBuffer, uint16 wDataSize)
{
	//校验数据;
	CC_ASSERT(wDataSize == sizeof(SSS_CMD_S_UserRob));
	SSS_CMD_S_UserRob* pUserRob = (SSS_CMD_S_UserRob*)pBuffer;
	
	uint16 wViewID = SwitchViewChairID(pUserRob->wRobUser);

	if (SSS_VIEW_SELF_ID==wViewID)
	{
		_RobPanel->setVisible(false);
		setOperateStatus(SSS_OS_CALLBANK);
	}

	// 声音;
	std::string strRobResult = StringUtils::format("%s", pUserRob->bRobResult ? "Qiangzhuan" : "Buqiang");
	std::string strSound = StringUtils::format("woman/%s", strRobResult.c_str());

	if (m_aryPlayer[wViewID]->GetGender() == enMan)
	{
		strSound = StringUtils::format("man/%s", strRobResult.c_str());
	}

	playEffect(strSound);
}

//开始下注;
void SSSGameScene::onSubStartChip(const void * pBuffer, uint16 wDataSize)
{
	//校验数据;
	CC_ASSERT(wDataSize == sizeof(SSS_CMD_S_StartChip));
	SSS_CMD_S_StartChip* pStartChip = (SSS_CMD_S_StartChip*)pBuffer;
	
	_RobPanel->setVisible(false);

	CC_ASSERT(pStartChip->wBankerUser<SSS_GAME_PLAYER);
	if (pStartChip->wBankerUser<SSS_GAME_PLAYER)
	{
		_wBankerUser = pStartChip->wBankerUser;
		uint16 wViewID = SwitchViewChairID(pStartChip->wBankerUser);
		m_aryPlayer[wViewID]->setBankerVisible(true);

		if (SSS_VIEW_SELF_ID!=wViewID)
		{
			_YaZhuPanel->setVisible(true);
			setOperateStatus(SSS_OS_ADDSCORE1);
		}
		else
		{
			setOperateStatus(SSS_OS_ADDSCORE0);
		}

		std::string strSound = "woman/banker";
		if (m_aryPlayer[wViewID]->GetGender() == enMan)
		{
			strSound = "man/banker";
		}

		playEffect(strSound);
	}
}

//玩家下注;
void SSSGameScene::onSubUserChip(const void * pBuffer, uint16 wDataSize)
{
	//校验数据;
	CC_ASSERT(wDataSize == sizeof(SSS_CMD_S_UserChip));
	SSS_CMD_S_UserChip* pUserChip = (SSS_CMD_S_UserChip*)pBuffer;
	
	uint16 wViewID = SwitchViewChairID(pUserChip->wChipUser);
	m_aryPlayer[wViewID]->updateUserChip(pUserChip->lChipScore);

	if (SSS_VIEW_SELF_ID == wViewID)
	{
		_YaZhuPanel->setVisible(false);
		setOperateStatus(SSS_OS_ADDSCORE0);
	}

	// 声音;
	std::string strSound = StringUtils::format("woman/Chip%d", pUserChip->lChipScore);
	if (m_aryPlayer[wViewID]->GetGender() == enMan)
	{
		strSound = StringUtils::format("man/Chip%d", pUserChip->lChipScore);
	}
	playEffect(strSound);
}

//发送剩下的牌;
void SSSGameScene::onSubSendLeftCard(const void * pBuffer, uint16 wDataSize)
{
	//校验数据;
	CC_ASSERT(wDataSize == sizeof(SSS_CMD_S_SendLeftCard));
	SSS_CMD_S_SendLeftCard* pLeftCard = (SSS_CMD_S_SendLeftCard*)pBuffer;

	memcpy(_aryHandCardData, pLeftCard->cbHandCardData, sizeof(_aryHandCardData));

	onSubStartOpen(nullptr, 0);
}

//开始开牌;
void SSSGameScene::onSubStartOpen(const void * pBuffer, uint16 wDataSize)
{
	setOperateStatus(SSS_OS_NULL);
	_YaZhuPanel->setVisible(false);

	if (SSS_CT_INVALID==_wSelfSpecialType)
	{
		_SendCardPanel->setVisible(false);
		_SendCardPanel->removeAllChildren();
	}

	if ((m_PrivateRoomInfo.bGameRuleIdex&eSSSGameRuleClassic) == 0)
	{
		showAllPlayersCard();
	}

	uint16 wSelfChairID = getSelfChairID();
	if (_aryActiveStatus[wSelfChairID] != SSS_HAND_STATUS_NULL)
	{
		if (_wSelfSpecialType != SSS_CT_INVALID)
		{
			showSpecialPanel(true);
		}
		else
		{
			showOperatePanel(true);
		}
	}
}

//开牌;
void SSSGameScene::onSubOpenCard(const void * pBuffer, uint16 wDataSize)
{
	CC_ASSERT(sizeof(SSS_CMD_S_OpenCard) == wDataSize);
	SSS_CMD_S_OpenCard* pOpenCard = (SSS_CMD_S_OpenCard*)pBuffer;

	uint16 wSelfChairID = getSelfChairID();
	uint16 wViewID = SwitchViewChairID(pOpenCard->wChairID);
	if (pOpenCard->wChairID == wSelfChairID)
	{
		closeClock(_imgOperClock);
		_OperatePanel->setVisible(false);

		_SendCardPanel->setVisible(false);
		_SendCardPanel->removeAllChildren();

		m_aryPlayer[wViewID]->showCard(_aryTricksFrontCard, _aryTricksMidCard, _aryTricksBackCard, SSS_HAND_STATUS_SORTED, true);

		_txtTip->setString(utility::a_u8("等待其他玩家开牌..."));

		uint8 cbGender = m_pLocalPlayer->GetGender();
		std::string strPath = "";
		if (0 == cbGender)
		{
			strPath += "man/m_complete";
		}
		else
		{
			strPath += "woman/f_complete";
		}
		playEffect(strPath);
	}
	else
	{
		m_aryPlayer[wViewID]->showHandStatus(SSS_HAND_STATUS_SORTED);
	}
}

//比牌结果;
void SSSGameScene::onSubClassicCompareCard(const void * pBuffer, uint16 wDataSize)
{
	CC_ASSERT(wDataSize == sizeof(SSS_CMD_S_ClassicCompareCard));
	SSS_CMD_S_ClassicCompareCard* pCompare = (SSS_CMD_S_ClassicCompareCard*)pBuffer;

	_OperatePanel->setVisible(false);
	_txtTip->setString("");

	closeClock(_imgGameClock);

	memcpy(_aryActiveStatus, pCompare->cbHandStatus, sizeof(_aryActiveStatus));
	memcpy(_aryFrontCard, pCompare->cbFrontCard, sizeof(_aryFrontCard));
	memcpy(_aryMidCard, pCompare->cbMidCard, sizeof(_aryMidCard));
	memcpy(_aryBackCard, pCompare->cbBackCard, sizeof(_aryBackCard));
	memcpy(_arySpecialType, pCompare->wSpecialType, sizeof(_arySpecialType));

	memcpy(_arySpecialCompareResult, pCompare->nSpecialCompareResult, sizeof(_arySpecialCompareResult));
	memcpy(_aryThreeKillResult, pCompare->cbThreeKillResult, sizeof(_aryThreeKillResult));

	// 展示所有手牌;
	for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		if (SSS_HAND_STATUS_NULL==_aryActiveStatus[i])
		{
			continue;
		}

		uint16 wViewID = SwitchViewChairID(i);

		if (SSS_CT_INVALID==pCompare->wSpecialType[i])
		{
			// 特殊处理A32;
			for (uint8 j = 0; j < SSS_GROUP_COUNT; j++)
			{
				uint8 aryTmpCardData[SSS_MAX_ITEM_COUNT] = { 0 };
				int nItemCount = j > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;

				if (0 == j)
				{
					if (cardTypeTo32A(_aryFrontCard[i], nItemCount, aryTmpCardData, nItemCount))
					{
						memcpy(_aryFrontCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
					}
				}
				else if (1 == j)
				{
					if (cardTypeTo32A(_aryMidCard[i], nItemCount, aryTmpCardData, nItemCount))
					{
						memcpy(_aryMidCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
					}
				}
				else if (2 == j)
				{
					if (cardTypeTo32A(_aryBackCard[i], nItemCount, aryTmpCardData, nItemCount))
					{
						memcpy(_aryBackCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
					}
				}
			}

			m_aryPlayer[wViewID]->showCard(_aryFrontCard[i], _aryMidCard[i], _aryBackCard[i], _aryActiveStatus[i], true);
			m_aryPlayer[wViewID]->setGameScore(pCompare->nCompareResult[i], pCompare->wHandCardType[i]);
		}
		else
		{
			m_aryPlayer[wViewID]->showCard(_aryFrontCard[i], _aryMidCard[i], _aryBackCard[i], _aryActiveStatus[i]);
			m_aryPlayer[wViewID]->showSepShadow(true);

			SCORE aryScore[SSS_GROUP_COUNT] = {0};
			uint16 aryCardType[SSS_GROUP_COUNT] = { 0 };
			m_aryPlayer[wViewID]->setGameScore(aryScore, aryCardType);
		}
	}

	_cbCurOpenCardAniIndex = 0;

	ArmatureAnimation* pAniStart = _pArmatureStart->getAnimation();
	if (pAniStart != nullptr)
	{
		pAniStart->play("GameStart1", -1, 0);
		_pArmatureStart->setVisible(true);
	}

	uint8 cbGender = m_pLocalPlayer->GetGender();
	std::string strPath = "";
	if (0 == cbGender)
	{
		strPath += "man/m_compare";
	}
	else
	{
		strPath += "woman/f_compare";
	}
	playEffect(strPath);


	for (uint8 i = 0; i < 6; i++)
	{
		uint8 cbWinChairID = pCompare->aryShootState[i][0];
		uint8 cbLoseChairID = pCompare->aryShootState[i][1];
		if (cbWinChairID != 255)
		{
			if (!m_GameOverAni->isExist(cbWinChairID, cbLoseChairID))
			{
				uint16 wWinViewID = SwitchViewChairID(cbWinChairID);
				tagSSSGunInfo* pWinInfo = new tagSSSGunInfo;
				pWinInfo->wViewID = wWinViewID;
				pWinInfo->ptPos = m_aryPlayer[wWinViewID]->getHandCardPos(1, 2);
				pWinInfo->cbGender = m_aryPlayer[wWinViewID]->GetGender();
				pWinInfo->nScore = pCompare->aryShootDaoShu[cbWinChairID][cbLoseChairID];

				uint16 wLoseViewID = SwitchViewChairID(cbLoseChairID);
				tagSSSGunInfo* pLoseInfo = new tagSSSGunInfo;
				pLoseInfo->wViewID = wLoseViewID;
				pLoseInfo->ptPos = m_aryPlayer[wLoseViewID]->getHandCardPos(1, 2);
				pLoseInfo->cbGender = m_aryPlayer[wLoseViewID]->GetGender();
				pLoseInfo->nScore = pCompare->aryShootDaoShu[cbLoseChairID][cbWinChairID];

				tagSSSTwoGunInfos* pInfo = new tagSSSTwoGunInfos;
				pInfo->pWinnerInfo = pWinInfo;
				pInfo->pLoserInfo = pLoseInfo;
				m_GameOverAni->addGunPlay(pInfo);
			}
		}
	}
}

//带庄家比牌结果;
void SSSGameScene::onSubBankerCompareCard(const void * pBuffer, uint16 wDataSize)
{
	CC_ASSERT(wDataSize == sizeof(SSS_CMD_S_BankerCompareCard));
	SSS_CMD_S_BankerCompareCard* pCompare = (SSS_CMD_S_BankerCompareCard*)pBuffer;

	_OperatePanel->setVisible(false);
	_txtTip->setString("");

	closeClock(_imgGameClock);

	memcpy(_aryActiveStatus, pCompare->cbHandStatus, sizeof(_aryActiveStatus));
	memcpy(_aryFrontCard, pCompare->cbFrontCard, sizeof(_aryFrontCard));
	memcpy(_aryMidCard, pCompare->cbMidCard, sizeof(_aryMidCard));
	memcpy(_aryBackCard, pCompare->cbBackCard, sizeof(_aryBackCard));

	int aryCompareResult[SSS_GAME_PLAYER][SSS_GROUP_COUNT] = {0};

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		for (int j = 0; j < SSS_GROUP_COUNT; j++)
		{
			aryCompareResult[i][j] = pCompare->cbOtherCmResult[i][j];
		}
	}

	// 展示所有手牌;
	for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		if (SSS_HAND_STATUS_NULL == _aryActiveStatus[i])
		{
			continue;
		}

		bool bShowScore = (i != _wBankerUser);
		uint16 wViewID = SwitchViewChairID(i);

		// 特殊处理A32;
		for (uint8 j = 0; j < SSS_GROUP_COUNT; j++)
		{
			uint8 aryTmpCardData[SSS_MAX_ITEM_COUNT] = { 0 };
			int nItemCount = j > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;

			if (0 == j)
			{
				if (cardTypeTo32A(_aryFrontCard[i], nItemCount, aryTmpCardData, nItemCount))
				{
					memcpy(_aryFrontCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
				}
			}
			else if (1 == j)
			{
				if (cardTypeTo32A(_aryMidCard[i], nItemCount, aryTmpCardData, nItemCount))
				{
					memcpy(_aryMidCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
				}
			}
			else if (2 == j)
			{
				if (cardTypeTo32A(_aryBackCard[i], nItemCount, aryTmpCardData, nItemCount))
				{
					memcpy(_aryBackCard[i], aryTmpCardData, sizeof(uint8)*nItemCount);
				}
			}
		}

		m_aryPlayer[wViewID]->showCard(_aryFrontCard[i], _aryMidCard[i], _aryBackCard[i], _aryActiveStatus[i], true);
		m_aryPlayer[wViewID]->setGameScore(aryCompareResult[i], pCompare->wHandCardType[i], bShowScore);
	}

	_cbCurOpenCardAniIndex = 0;

	ArmatureAnimation* pAniStart = _pArmatureStart->getAnimation();
	if (pAniStart != nullptr)
	{
		pAniStart->play("GameStart1", -1, 0);
		_pArmatureStart->setVisible(true);
	}

	uint8 cbGender = m_pLocalPlayer->GetGender();
	std::string strPath = "";
	if (0 == cbGender)
	{
		strPath += "man/m_compare";
	}
	else
	{
		strPath += "woman/f_compare";
	}
	playEffect(strPath);
}

//发牌结束;
void SSSGameScene::sendSendCardOverMsg()
{
	SendSocketData(SSS_SUB_C_SEND_OVER);
}

//开牌操作;
void SSSGameScene::sendOpenCardMsg()
{
	SSS_CMD_C_OpenCard mOpenCard;
	memset(&mOpenCard, 0, sizeof(mOpenCard));
	memcpy(mOpenCard.cbFrontCard, _aryTricksFrontCard, sizeof(_aryTricksFrontCard));
	memcpy(mOpenCard.cbMidCard, _aryTricksMidCard, sizeof(_aryTricksMidCard));
	memcpy(mOpenCard.cbBackCard, _aryTricksBackCard, sizeof(_aryTricksBackCard));

	SendSocketData(SSS_SUB_C_OPEN_CARD, &mOpenCard, sizeof(SSS_CMD_C_OpenCard));
}

//比牌完成;
void SSSGameScene::sendCompareOverMsg()
{
	if (m_IsGameRecord)
	{
		onSubGameEnd(&m_GameEnd, sizeof(SSS_CMD_S_GameEnd));
	}
	else
	{
		SendSocketData(SSS_SUB_C_COMPARE_OVER);
	}
}

//显示当前手牌;
void SSSGameScene::showCurHandCard(uint8 cbCardCount)
{
	_SendCardPanel->setVisible(true);
	_SendCardPanel->removeAllChildren();

	float fInitX = _SendCardPanel->getContentSize().width;
	float fTargetX = (SSS_MAX_COUNT == cbCardCount) ? 0.f : 200.f;
	for (int i = 0; i < cbCardCount; i++)
	{
		SSSBigCardSprite* pCardSprite = SSSBigCardSprite::create(_aryHandCardData[i]);
		pCardSprite->setPositionX(fTargetX);
		_SendCardPanel->addChild(pCardSprite);

		fTargetX += 56.f;
	}
}

//显示庄家图标;
void SSSGameScene::showBankerIcon()
{
	if (INVALID_CHAIR != _wBankerUser)
	{
		uint16 wViewID = SwitchViewChairID(_wBankerUser);
		m_aryPlayer[wViewID]->setBankerVisible(true);
	}
}

// 设置状态;
void SSSGameScene::setOperateStatus(SSS_OPERATE_STATUS ops)
{
	_sprOtherCallBanker->setVisible(ops == SSS_OS_CALLBANK);
	_sprOtherAddScore->setVisible(ops == SSS_OS_ADDSCORE0);
	_sprSelfAddScore->setVisible(ops == SSS_OS_ADDSCORE1);
}

void SSSGameScene::showOperatePanel(bool bShow)
{
	_OperatePanel->setVisible(bShow);
    if ( bShow )
	{
		openClock(_imgOperClock, _wBuildCardTime, nullptr);
		openClock(_imgGameClock, _wBuildCardTime, nullptr);

		_btnCompare->setVisible(false);
		_btnReset->setVisible(false);

		m_GameLogic.SortCardList(_aryHandCardData, SSS_MAX_COUNT);
		_OperateCardPanel->showHandCard(_aryHandCardData, SSS_MAX_COUNT);
		_OperateCardPanel->setVisible(true);

		m_AnalyseType = m_GameLogic.GetType(_aryHandCardData, SSS_HAND_CARD_COUNT);
		updateCardTypeButtons();
	}
}

//显示特殊牌面板;
void SSSGameScene::showSpecialPanel(bool bShow)
{
	_SpecialPanel->setVisible(bShow);

	if (bShow)
	{
		openClock(_imgGameClock, _wBuildCardTime, nullptr);

		string strImagePath = C13SGameLogic::getCardTypeImagePath(_wSelfSpecialType);
		if (!strImagePath.empty())
		{
			_sprSpecialType->setTexture(strImagePath);
			_sprSpecialType->setVisible(true);
		}
		else
		{
			_sprSpecialType->setVisible(false);
		}

		_btnRefuseCards->setVisible(true);
		_btnCommitSpecial->setVisible(true);
	}
}

//点击随便机组牌按钮;
void SSSGameScene::onRandomButtonClick(Ref* pSender)
{
	tag13SAnalyseType AnalyseType = m_GameLogic.GetType(_aryHandCardData, SSS_HAND_CARD_COUNT);

	uint8 aryFrontCard[SSS_MIN_ITEM_COUNT] = {0};
	uint8 aryMidCard[SSS_MAX_ITEM_COUNT] = { 0 };
	uint8 aryBackCard[SSS_MAX_ITEM_COUNT] = { 0 };
	m_GameLogic.TheBestCard(AnalyseType, _aryHandCardData, SSS_HAND_CARD_COUNT, aryFrontCard, aryMidCard, aryBackCard);

	if (0 == aryFrontCard[0] || 0 == aryMidCard[0] || 0 == aryBackCard[0])
	{
		PopScene::Instance().show(utility::a_u8("未找到合适牌型请手工配牌！"));
		return;
	}

	addTricksCard(0, aryFrontCard, SSS_MIN_ITEM_COUNT);
	addTricksCard(1, aryMidCard, SSS_MAX_ITEM_COUNT);
	addTricksCard(2, aryBackCard, SSS_MAX_ITEM_COUNT);

	_OperateCardPanel->showHandCard(nullptr, 0);

	disableCardTypeButtons();

	onChooseFinished();
}

//重置按钮被点击;
void SSSGameScene::onResetButtonClick(Ref* pSender)
{
	playBtnClickEffect();
	if (_aryTricksFrontCard[0] + _aryTricksMidCard[0] + _aryTricksBackCard[0] == 0)
	{
		return;
	}

	uint16 wSelfChairID = getSelfChairID();
	if (_aryActiveStatus[wSelfChairID] != SSS_HAND_STATUS_NULL)
	{
		for (int i = 0; i < SSS_GROUP_COUNT; i++)
		{
			_aryTricksCardPanel[i]->removeAllChildren();
			_aryButtonRechoose[i]->setEnabled(false);
			_arySprCardType[i]->setVisible(false);
		}

		m_GameLogic.SortCardList(_aryHandCardData, sizeof(_aryHandCardData));
		_OperateCardPanel->showHandCard(_aryHandCardData, sizeof(_aryHandCardData));

		zeromemory(_aryTricksFrontCard, sizeof(_aryTricksFrontCard));
		zeromemory(_aryTricksMidCard, sizeof(_aryTricksMidCard));
		zeromemory(_aryTricksBackCard, sizeof(_aryTricksBackCard));

		_OperateCardPanel->setVisible(true);

		m_AnalyseType = m_GameLogic.GetType(_aryHandCardData, sizeof(_aryHandCardData));
		updateCardTypeButtons();
	}
}

void SSSGameScene::onCompareButtonClick(Ref* pSender)
{
	playBtnClickEffect();

	for (int i = 0; i < SSS_GROUP_COUNT; i++)
	{
		if (_aryTricksCardPanel[i]->getChildrenCount() == 0)
		{
			PopScene::Instance().show(utility::a_u8("请分配好你的牌序~"));
			return;
		}
	}

	if (false==checkCardPutRule())
	{
		return;
	}

	uint16 wSelfChairID = getSelfChairID();
	if (_aryActiveStatus[wSelfChairID] != SSS_HAND_STATUS_NULL)
	{
		showOperatePanel(false);
		sendOpenCardMsg();
	}
}

//邀请按钮被点击;
void SSSGameScene::onInviteButtonClick(Ref* pSender)
{
	playBtnClickEffect();

	std::string strUTFGameTitle = utility::a_u8(m_strGameTitle);

	std::string strUrl = GlobalJosn::getInstance()->getShareInfoByKind(SH_KIND_WEIXIN_URL);
	std::string strUrlInfo = StringUtils::format("%s?param=%d", strUrl.c_str(), m_PrivateRoomInfo.dwRoomNum);

	std::string strRoomID = StringUtils::format("房间号(%d), ", m_PrivateRoomInfo.dwRoomNum);
	std::string strShareRule = strRoomID + m_strGameRuleInfo + StringUtils::format("人数: %d/%d", getCurPlayerCount(), SSS_GAME_PLAYER);

	MissionWeiXin::Instance().shareUrlWeiXin(strUrlInfo, utility::a_u8(m_strGameTitle), utility::a_u8(strShareRule));

	//SelectShareScene::Instance().shareRoomInfo(strUrlInfo, strUTFGameTitle, strShareRule, 0);
}

//重选按钮被点击;
void SSSGameScene::onRechooseButtonClick(Ref* pSender)
{
	Button* pBtn = (Button*)pSender;
	int nIndex = pBtn->getTag();
	CC_ASSERT(nIndex<SSS_GROUP_COUNT);

	playBtnClickEffect();

	if (_aryTricksCardPanel[nIndex]->getChildrenCount() == 0)
	{
		return;
	}

	log("reset----%d", nIndex);

	_aryTricksCardPanel[nIndex]->removeAllChildren();
	uint8 aryCardData[SSS_MAX_COUNT] = { 0 };
	uint8 cbCardCount = _OperateCardPanel->getHandCardData(aryCardData, sizeof(aryCardData));

	int nItemCount = nIndex > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
	for (int j = 0; j < nItemCount; j++)
	{
		if (0 == nIndex)
		{
			aryCardData[cbCardCount++] = _aryTricksFrontCard[j];
			_aryTricksFrontCard[j] = 0;
		}
		else if (1 == nIndex)
		{
			aryCardData[cbCardCount++] = _aryTricksMidCard[j];
			_aryTricksMidCard[j] = 0;
		}
		else if (2 == nIndex)
		{
			aryCardData[cbCardCount++] = _aryTricksBackCard[j];
			_aryTricksBackCard[j] = 0;
		}

		if (cbCardCount >= SSS_MAX_COUNT)
		{
			break;
		}
	}

	m_GameLogic.SortCardList(aryCardData, cbCardCount);
	_OperateCardPanel->showHandCard(aryCardData, cbCardCount);
	_OperateCardPanel->setVisible(true);

	_arySprCardType[nIndex]->setVisible(false);
	_aryButtonRechoose[nIndex]->setEnabled(false);
	_arySprCardShadow[nIndex]->setVisible(false);

	_btnCompare->setVisible(false);
	_btnReset->setVisible(false);

	m_AnalyseType = m_GameLogic.GetType(aryCardData, cbCardCount);
	updateCardTypeButtons();
}

//面板触摸事件;
void SSSGameScene::onPanelTouchEvent(Ref* pSender, Widget::TouchEventType iEventType)
{
	Layout* panel = (Layout*)pSender;
	int nIndex = panel->getTag();
	CC_ASSERT(nIndex<SSS_GROUP_COUNT);

	if (iEventType == Widget::TouchEventType::BEGAN)
	{
		playBtnClickEffect();

		if (_aryTricksCardPanel[nIndex]->getChildrenCount() >0)
		{
			return;
		}

		log("set card data ----%d", nIndex);

		uint8 aryCardData[SSS_MAX_COUNT] = { 0 };
		uint8 cbCardCount = 0;
		_OperateCardPanel->getShootCardData(aryCardData, cbCardCount, sizeof(aryCardData));

		int nItemCount = nIndex > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;

		//bool bRet = checkCardPutRule();
		if (cbCardCount == nItemCount)
		{
			addTricksCard(nIndex, aryCardData, cbCardCount);

			zeromemory(aryCardData, sizeof(aryCardData));
			cbCardCount = 0;
			_OperateCardPanel->getDownCardData(aryCardData, cbCardCount, sizeof(aryCardData));
			_OperateCardPanel->showHandCard(aryCardData, cbCardCount);

			m_AnalyseType = m_GameLogic.GetType(aryCardData, cbCardCount);
			updateCardTypeButtons();
		}
		else
		{
			return;
		}

		onChooseFinished();
	}
	else if(iEventType == Widget::TouchEventType::ENDED)
	{
		uint8 aryCardData[SSS_MAX_COUNT] = { 0 };
		uint8 cbCardCount = 0;

		_OperateCardPanel->getDownCardData(aryCardData, cbCardCount, sizeof(aryCardData));

		//当还剩下3张牌时自动被填充到空面板处;
		if (SSS_MIN_ITEM_COUNT == cbCardCount || SSS_MAX_ITEM_COUNT == cbCardCount)
		{
			int nNullIndex = -1;
			for (int i = 0; i < SSS_GROUP_COUNT; i++)
			{
				if (_aryTricksCardPanel[i]->getChildrenCount() == 0)
				{
					nNullIndex = i;
					break;
				}
			}

			//bool bRet = checkCardPutRule();
			if (nNullIndex >= 0)
			{
				int nItemCount = nNullIndex > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
				addTricksCard(nNullIndex, aryCardData, nItemCount);
				//清空手牌面板;
				_OperateCardPanel->showHandCard(nullptr, 0);

				disableCardTypeButtons();

				onChooseFinished();
			}
		}
	}
}

//抢注按钮点击事件;
void SSSGameScene::onRobYesButtonClick(Ref* pSender)
{
	SSS_CMD_C_RobBanker mRob;
	mRob.bRob = true;
	SendSocketData(SSS_SUB_C_ROB_BANKER, &mRob, sizeof(SSS_CMD_C_RobBanker));
}

//抢注按钮点击事件;
void SSSGameScene::onRobNoButtonClick(Ref* pSender)
{
	SSS_CMD_C_RobBanker mRob;
	mRob.bRob = false;
	SendSocketData(SSS_SUB_C_ROB_BANKER, &mRob, sizeof(SSS_CMD_C_RobBanker));
}

//压注按钮点击事件;
void SSSGameScene::onYaZhuButtonClick(Ref* pSender)
{
	_YaZhuPanel->setVisible(false);

	Button* pBtn = (Button*)pSender;
	int nScore = __min(5, __max(3, pBtn->getTag()));
	SSS_CMD_C_ChipScore ChipScore = {0};
	ChipScore.lScore = nScore;

	SendSocketData(SSS_SUB_C_CHIP_SCORE, &ChipScore, sizeof(ChipScore));
}

//不摆特殊牌按钮点击事件;
void SSSGameScene::onRefuseCardsButtonClick(Ref* pSender)
{
	_SendCardPanel->setVisible(false);
	_SendCardPanel->removeAllChildren();

	showSpecialPanel(false);

	showOperatePanel(true);
}

//确定特殊牌按钮点击事件;
void SSSGameScene::onCommitSpecialButtonClick(Ref* pSender)
{
	_SendCardPanel->setVisible(false);
	_SendCardPanel->removeAllChildren();

	showSpecialPanel(false);

	SSS_CMD_C_OpenCard mOpenCard;
	zeromemory(&mOpenCard, sizeof(SSS_CMD_C_OpenCard));
	mOpenCard.wSpecialType = _wSelfSpecialType;

	SendSocketData(SSS_SUB_C_OPEN_CARD, &mOpenCard, sizeof(SSS_CMD_C_OpenCard));
}

//一对;
void SSSGameScene::onDuiZiButtonClick(Ref* pSender)
{
	uint8 aryShootIndex[2] = {0};
	uint8 cbCardCount = 2;
	for (uint8 i = 0; i < 20; i++)
	{
		if (false==m_AnalyseType.bbOnePare[i])
		{
			if (m_AnalyseType.cbOnePare[i * 2] == 0 && m_AnalyseType.cbOnePare[i * 2 + 1] == 0)
			{
				zeromemory(m_AnalyseType.bbOnePare, sizeof(m_AnalyseType.bbOnePare));
				i = 0;
			}
			aryShootIndex[0] = m_AnalyseType.cbOnePare[i * 2];
			aryShootIndex[1] = m_AnalyseType.cbOnePare[i * 2 + 1];
			_OperateCardPanel->shootCardIndex(aryShootIndex, cbCardCount);
			m_AnalyseType.bbOnePare[i] = true;

			break;
		}
	}
}

//两对;
void SSSGameScene::onLiangDuiButtonClick(Ref* pSender)
{
	uint8 aryShootIndex[4] = { 0 };
	uint8 cbCardCount = 4;
	for (uint8 i = 0; i < 20; i++)
	{
		if (false == m_AnalyseType.bbTwoPare[i])
		{
			if (m_AnalyseType.cbTwoPare[i * 4] == 0 && m_AnalyseType.cbTwoPare[i * 4 + 1] == 0)
			{
				zeromemory(m_AnalyseType.bbTwoPare, sizeof(m_AnalyseType.bbTwoPare));
				i = 0;
			}
			aryShootIndex[0] = m_AnalyseType.cbTwoPare[i * 4];
			aryShootIndex[1] = m_AnalyseType.cbTwoPare[i * 4 + 1];
			aryShootIndex[2] = m_AnalyseType.cbTwoPare[i * 4 + 2];
			aryShootIndex[3] = m_AnalyseType.cbTwoPare[i * 4 + 3];
			_OperateCardPanel->shootCardIndex(aryShootIndex, cbCardCount);
			m_AnalyseType.bbTwoPare[i] = true;

			break;
		}
	}
}

//三条;
void SSSGameScene::onSanTiaoButtonClick(Ref* pSender)
{
	uint8 aryShootIndex[3] = { 0 };
	uint8 cbCardCount = 3;
	for (uint8 i = 0; i < 20; i++)
	{
		if (false == m_AnalyseType.bbThreeSame[i])
		{
			if (m_AnalyseType.cbThreeSame[i * 3] == 0 && m_AnalyseType.cbThreeSame[i * 3 + 1] == 0)
			{
				zeromemory(m_AnalyseType.bbThreeSame, sizeof(m_AnalyseType.bbThreeSame));
				i = 0;
			}
			aryShootIndex[0] = m_AnalyseType.cbThreeSame[i * 3];
			aryShootIndex[1] = m_AnalyseType.cbThreeSame[i * 3 + 1];
			aryShootIndex[2] = m_AnalyseType.cbThreeSame[i * 3 + 2];
			_OperateCardPanel->shootCardIndex(aryShootIndex, cbCardCount);
			m_AnalyseType.bbThreeSame[i] = true;

			break;
		}

	}
}

//顺子;
void SSSGameScene::onShunZiButtonClick(Ref* pSender)
{
	uint8 aryShootIndex[5] = { 0 };
	uint8 cbCardCount = 5;
	for (uint8 i = 0; i < 20; i++)
	{
		if (false == m_AnalyseType.bbStraight[i])
		{
			if (m_AnalyseType.cbStraight[i * 5] == 0 && m_AnalyseType.cbStraight[i * 5 + 1] == 0)
			{
				zeromemory(m_AnalyseType.bbStraight, sizeof(m_AnalyseType.bbStraight));
				i = 0;
			}
			aryShootIndex[0] = m_AnalyseType.cbStraight[i * 5];
			aryShootIndex[1] = m_AnalyseType.cbStraight[i * 5 + 1];
			aryShootIndex[2] = m_AnalyseType.cbStraight[i * 5 + 2];
			aryShootIndex[3] = m_AnalyseType.cbStraight[i * 5 + 3];
			aryShootIndex[4] = m_AnalyseType.cbStraight[i * 5 + 4];
			_OperateCardPanel->shootCardIndex(aryShootIndex, cbCardCount);
			m_AnalyseType.bbStraight[i] = true;

			break;
		}

	}
}

//同花;
void SSSGameScene::onTongHuaButtonClick(Ref* pSender)
{
	uint8 aryShootIndex[5] = { 0 };
	uint8 cbCardCount = 5;
	for (uint8 i = 0; i < 20; i++)
	{
		if (false == m_AnalyseType.bbFlush[i])
		{
			if (m_AnalyseType.cbFlush[i * 5] == 0 && m_AnalyseType.cbFlush[i * 5 + 1] == 0)
			{
				zeromemory(m_AnalyseType.bbFlush, sizeof(m_AnalyseType.bbFlush));
				i = 0;
			}
			aryShootIndex[0] = m_AnalyseType.cbFlush[i * 5];
			aryShootIndex[1] = m_AnalyseType.cbFlush[i * 5 + 1];
			aryShootIndex[2] = m_AnalyseType.cbFlush[i * 5 + 2];
			aryShootIndex[3] = m_AnalyseType.cbFlush[i * 5 + 3];
			aryShootIndex[4] = m_AnalyseType.cbFlush[i * 5 + 4];
			_OperateCardPanel->shootCardIndex(aryShootIndex, cbCardCount);
			m_AnalyseType.bbFlush[i] = true;

			break;
		}

	}
}

//葫芦;
void SSSGameScene::onHuLuButtonClick(Ref* pSender)
{
	uint8 aryShootIndex[5] = { 0 };
	uint8 cbCardCount = 5;
	for (uint8 i = 0; i < 20; i++)
	{
		if (false == m_AnalyseType.bbGourd[i])
		{
			if (m_AnalyseType.cbGourd[i * 5] == 0 && m_AnalyseType.cbGourd[i * 5 + 1] == 0)
			{
				zeromemory(m_AnalyseType.bbGourd, sizeof(m_AnalyseType.bbGourd));
				i = 0;
			}
			aryShootIndex[0] = m_AnalyseType.cbGourd[i * 5];
			aryShootIndex[1] = m_AnalyseType.cbGourd[i * 5 + 1];
			aryShootIndex[2] = m_AnalyseType.cbGourd[i * 5 + 2];
			aryShootIndex[3] = m_AnalyseType.cbGourd[i * 5 + 3];
			aryShootIndex[4] = m_AnalyseType.cbGourd[i * 5 + 4];
			_OperateCardPanel->shootCardIndex(aryShootIndex, cbCardCount);
			m_AnalyseType.bbGourd[i] = true;
			break;
		}
	}
}

//铁支;
void SSSGameScene::onTieZhiButtonClick(Ref* pSender)
{
	uint8 aryShootIndex[4] = { 0 };
	uint8 cbCardCount = 4;
	for (uint8 i = 0; i < 20; i++)
	{
		if (false == m_AnalyseType.bbFourSame[i])
		{
			if (m_AnalyseType.cbFourSame[i * 4] == 0 && m_AnalyseType.cbFourSame[i * 4 + 1] == 0)
			{
				zeromemory(m_AnalyseType.bbFourSame, sizeof(m_AnalyseType.bbFourSame));
				i = 0;
			}
			aryShootIndex[0] = m_AnalyseType.cbFourSame[i * 4];
			aryShootIndex[1] = m_AnalyseType.cbFourSame[i * 4 + 1];
			aryShootIndex[2] = m_AnalyseType.cbFourSame[i * 4 + 2];
			aryShootIndex[3] = m_AnalyseType.cbFourSame[i * 4 + 3];
			_OperateCardPanel->shootCardIndex(aryShootIndex, cbCardCount);
			m_AnalyseType.bbFourSame[i] = true;

			break;
		}
	}
}

//同花顺;
void SSSGameScene::onTongHuaShunButtonClick(Ref* pSender)
{
	uint8 aryShootIndex[5] = { 0 };
	uint8 cbCardCount = 5;
	for (uint8 i = 0; i < 20; i++)
	{
		if (false == m_AnalyseType.bbStraightFlush[i])
		{
			if (m_AnalyseType.cbStraightFlush[i * 5] == 0 && m_AnalyseType.cbStraightFlush[i * 5 + 1] == 0)
			{
				zeromemory(m_AnalyseType.bbStraightFlush, sizeof(m_AnalyseType.bbStraightFlush));
				i = 0;
			}
			aryShootIndex[0] = m_AnalyseType.cbStraightFlush[i * 5];
			aryShootIndex[1] = m_AnalyseType.cbStraightFlush[i * 5 + 1];
			aryShootIndex[2] = m_AnalyseType.cbStraightFlush[i * 5 + 2];
			aryShootIndex[3] = m_AnalyseType.cbStraightFlush[i * 5 + 3];
			aryShootIndex[4] = m_AnalyseType.cbStraightFlush[i * 5 + 4];
			_OperateCardPanel->shootCardIndex(aryShootIndex, cbCardCount);
			m_AnalyseType.bbStraightFlush[i] = true;

			break;
		}
	}
}

// 开始发牌;
void SSSGameScene::startSendCardAni()
{
	_SendCardPanel->setVisible(true);
	_SendCardPanel->removeAllChildren();

	float fActionTime = 0.12f;
	float fInitX = _SendCardPanel->getContentSize().width;
	float fTargetX = (SSS_MAX_COUNT==_cbSendCardCount) ? 0.f : 200.f;
	float fDelaySendTime = 0.01f;
	for (int i = 0; i < _cbSendCardCount; i++)
	{
		SSSBigCardSprite* pCardSprite = SSSBigCardSprite::create(_aryHandCardData[i]);
		pCardSprite->setPositionX(fInitX);
		pCardSprite->setPositionY(30.f);
		pCardSprite->setScale(0.5f);
		_SendCardPanel->addChild(pCardSprite);

		auto pAction = Spawn::create(MoveTo::create(fActionTime, Vec2(fTargetX, 0.f)), ScaleTo::create(fActionTime, 1.0f), nullptr);
		pCardSprite->runAction(Sequence::create(DelayTime::create(fDelaySendTime), pAction, nullptr));

		fTargetX += 56.f;
		fDelaySendTime += 0.05f;
	}
	playSendCardEffect();

	auto callback = [=]() {

		if ((m_PrivateRoomInfo.bGameRuleIdex&eSSSGameRuleClassic)>0)
		{
			uint8 aryFrontCard[SSS_MIN_ITEM_COUNT] = { 0 };
			uint8 aryMidCard[SSS_MAX_ITEM_COUNT] = { 0 };
			uint8 aryBackCard[SSS_MAX_ITEM_COUNT] = { 0 };

			for (int i = 0; i < SSS_GAME_PLAYER; i++)
			{
				if (SSS_HAND_STATUS_NULL == _aryActiveStatus[i])
				{
					continue;
				}

				uint16 wViewID = SwitchViewChairID(i);
				m_aryPlayer[wViewID]->showCard(aryFrontCard, aryMidCard, aryBackCard, SSS_HAND_STATUS_DISORDER, true);
			}
		}

		sendSendCardOverMsg();
	};

	_SendCardPanel->runAction(Sequence::create(DelayTime::create(fActionTime + fDelaySendTime), CallFunc::create(callback), nullptr));
}

// 开始比牌;
void SSSGameScene::startCompareCardAni()
{
	uint8 cbGamePlayerCount = 0;
	uint8 cbSpecialTypeCount = 0;

	for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		if (SSS_HAND_STATUS_NULL == _aryActiveStatus[i])
		{
			continue;
		}

		cbGamePlayerCount++;
		if (SSS_CT_INVALID != _arySpecialType[i])
		{
			cbSpecialTypeCount++;
		}
	}

	if (cbGamePlayerCount != cbSpecialTypeCount)
	{
		oneGroupFinished();
	}
	else
	{
		checkSpecialTypeAni();
	}
}

// 动画回调;
void SSSGameScene::movementEventCallFunc(cocostudio::Armature *armature, cocostudio::MovementEventType movementType, const std::string& movementID)
{
	// 播放完成;
	if (movementType == cocostudio::COMPLETE)
	{
		if ("GameStart2" == movementID)
		{
			// 发牌动画;
			startSendCardAni();
			_pArmatureStart->setVisible(false);
		}
		else if ("GameStart1" == movementID)
		{
			startCompareCardAni();
			_pArmatureStart->setVisible(false);
		}
		else if ("KillAlleffect" == movementID)
		{
			_pArmaAllKillEffect->setVisible(false);

			killAllAniFinished();
		}
	}
}

void SSSGameScene::addTricksCard(int nIndex, uint8 aryCardData[SSS_MAX_ITEM_COUNT], uint8 cbCardCount)
{
	CC_ASSERT(nIndex<SSS_GROUP_COUNT);

	int nItemCount = nIndex > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
	uint8 cbTmpCardData[SSS_MAX_ITEM_COUNT] = { 0 };
	if (false==cardTypeTo32A(aryCardData, nItemCount, cbTmpCardData, nItemCount))
	{
		memcpy(cbTmpCardData, aryCardData, cbCardCount);
	}

	uint8* pTrickCard = nullptr;
	if (0 == nIndex)
	{
		memcpy(_aryTricksFrontCard, cbTmpCardData, SSS_MIN_ITEM_COUNT*sizeof(uint8));
		pTrickCard = _aryTricksFrontCard;
	}
	else if (1 == nIndex)
	{
		memcpy(_aryTricksMidCard, cbTmpCardData, SSS_MAX_ITEM_COUNT*sizeof(uint8));
		pTrickCard = _aryTricksMidCard;
	}
	else if (2 == nIndex)
	{
		memcpy(_aryTricksBackCard, cbTmpCardData, SSS_MAX_ITEM_COUNT*sizeof(uint8));
		pTrickCard = _aryTricksBackCard;
	}

	_aryTricksCardPanel[nIndex]->removeAllChildren();

	int iHandCardSpace = 0;
	for (int i = 0; i<nItemCount; i++)
	{
		SSSBigCardSprite* pCardSprite = SSSBigCardSprite::create(pTrickCard[i]);

		if (0==iHandCardSpace)
		{
			const Size& cardSize = _aryTricksCardPanel[nIndex]->getContentSize();
			iHandCardSpace = (cardSize.width - pCardSprite->getContentSize().width) / (nItemCount - 1);
		}
		pCardSprite->setPosition(i * iHandCardSpace, 0);

		_aryTricksCardPanel[nIndex]->addChild(pCardSprite);
	}

	uint8 cbCardType = m_GameLogic.GetCardType(aryCardData, nItemCount, m_GameLogic.btCardSpecialData);
	if (cbCardType>0)
	{
		std::string strPath = C13SGameLogic::getCardTypeImagePath(cbCardType);
		if (strPath.size()>0)
		{
			_arySprCardType[nIndex]->setTexture(strPath);
			_arySprCardType[nIndex]->setVisible(true);
		}
		else
		{
			_arySprCardType[nIndex]->setVisible(false);
		}
	}

	_aryButtonRechoose[nIndex]->setEnabled(true);

	if (nIndex < 1)
	{
		_arySprCardShadow[0]->setVisible(false);
	}
	else
	{
		_arySprCardShadow[1]->setVisible(false);
		_arySprCardShadow[2]->setVisible(false);
	}
}

bool SSSGameScene::inTricksCardPanel(int nIndex, uint8 cbCardData)
{
	CC_ASSERT(nIndex<SSS_GROUP_COUNT);

	int nItemCount = nIndex > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;

	uint8* pTrickCard = nullptr;
	if (0 == nIndex)
	{
		pTrickCard = _aryTricksFrontCard;
	}
	else if (1 == nIndex)
	{
		pTrickCard = _aryTricksMidCard;
	}
	else if (2 == nIndex)
	{
		pTrickCard = _aryTricksBackCard;
	}
	else
	{
		return false;
	}

	for (int i = 0; i < nItemCount; i++)
	{
		if (pTrickCard[i] == cbCardData)
		{
			return true;
		}
	}

	return false;
}

void SSSGameScene::onChooseFinished()
{
	int nTricksCount = 0;
	for (int n = 0; n < SSS_GROUP_COUNT; n++)
	{
		nTricksCount += _aryTricksCardPanel[n]->getChildrenCount();
	}

	if (nTricksCount == SSS_MAX_COUNT)
	{
		_btnCompare->setVisible(true);

		_OperateCardPanel->setVisible(false);

		_btnReset->setVisible(true);
	}
}

void SSSGameScene::oneGroupFinished()
{
	if (_cbCurOpenCardAniIndex >= 3)
	{
		m_GameOverAni->showAnimation(CC_CALLBACK_1(SSSGameScene::oneShootFinished, this));
	}
	else
	{
		bool bSetCallback = false;
		for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
		{
			if ((_aryActiveStatus[i] != SSS_HAND_STATUS_NULL)&&(SSS_CT_INVALID==_arySpecialType[i]))
			{
				uint16 wViewID = SwitchViewChairID(i);
				bool bPlaySubScore = (i != _wBankerUser);
				if (false==bSetCallback)
				{
					m_aryPlayer[wViewID]->playScoreAni(_cbCurOpenCardAniIndex, CC_CALLBACK_0(SSSGameScene::oneGroupFinished, this), true, bPlaySubScore);
					bSetCallback = true;
				}
				else
				{
					m_aryPlayer[wViewID]->playScoreAni(_cbCurOpenCardAniIndex, nullptr, false, (i != _wBankerUser));
				}
			}
		}

		_cbCurOpenCardAniIndex++;
	}
}

void SSSGameScene::oneShootFinished(tagSSSTwoGunInfos* pGunInfos)
{
	if (nullptr==pGunInfos)
	{
		checkSpecialTypeAni();
	}
	else
	{
		uint16 wLoserViewID = pGunInfos->pLoserInfo->wViewID;
		m_aryPlayer[wLoserViewID]->playSubScoreAni(1, pGunInfos->pLoserInfo->nScore);

		uint16 wWinnerViewID = pGunInfos->pWinnerInfo->wViewID;
		m_aryPlayer[wWinnerViewID]->playSubScoreAni(1, pGunInfos->pWinnerInfo->nScore, CC_CALLBACK_0(SSSGameScene::shootScoreAniFinished, this));
	}
}

//打枪加分动画结束;
void SSSGameScene::shootScoreAniFinished()
{
	tagSSSTwoGunInfos* pTmpGunInfo = m_GameOverAni->getNoPlayInfo();
	if (nullptr == pTmpGunInfo)
	{
		checkSpecialTypeAni();
	}
	else
	{
		m_GameOverAni->showAnimation(CC_CALLBACK_1(SSSGameScene::oneShootFinished, this));
	}
}

void SSSGameScene::checkSpecialTypeAni()
{
	uint8 cbSpecialTypeCount = 0;

	for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		if (SSS_HAND_STATUS_NULL == _aryActiveStatus[i])
		{
			continue;
		}

		if (SSS_CT_INVALID != _arySpecialType[i])
		{
			cbSpecialTypeCount++;
		}
	}

	if (cbSpecialTypeCount>0)
	{
		for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
		{
			if (SSS_HAND_STATUS_NULL == _aryActiveStatus[i])
			{
				continue;
			}

			uint16 wViewID = SwitchViewChairID(i);
			if (SSS_VIEW_SELF_ID == wViewID)
			{
				m_aryPlayer[wViewID]->playSubScoreAni(1, _arySpecialCompareResult[i], CC_CALLBACK_0(SSSGameScene::specialTypeAniFinished, this));
			}
			else
			{
				m_aryPlayer[wViewID]->playSubScoreAni(1, _arySpecialCompareResult[i]);
			}

			if (_arySpecialType[i] != SSS_CT_INVALID)
			{
				m_aryPlayer[wViewID]->showSepShadow(false);
				m_aryPlayer[wViewID]->showCardType(_arySpecialType[i]);

				playSpecialTypeEffect(m_aryPlayer[wViewID]->GetGender(), _arySpecialType[i]);
			}
		}
	}
	else
	{
		sendCompareOverMsg();
	}
}

//特殊牌动画播放完成;
void SSSGameScene::specialTypeAniFinished()
{
	checkKillAllAni();
}

void SSSGameScene::checkKillAllAni()
{
	if (INVALID_CHAIR==_wKillAllUserChairID)
	{
		sendCompareOverMsg();
	}
	else
	{
		ArmatureAnimation* pAniKillAll = _pArmaAllKillEffect->getAnimation();
		if (pAniKillAll != nullptr)
		{
			pAniKillAll->play("KillAlleffect", -1, 0);
			_pArmaAllKillEffect->setVisible(true);
		}
	}
}

//全垒打动画播放完成;
void SSSGameScene::killAllAniFinished()
{
	for (uint16 i = 0; i < SSS_GAME_PLAYER; i++)
	{
		if (SSS_HAND_STATUS_NULL == _aryActiveStatus[i])
		{
			continue;
		}

		uint16 wViewID = SwitchViewChairID(i);
		if (SSS_VIEW_LEFT_ID == wViewID)
		{
			m_aryPlayer[wViewID]->playSubScoreAni(1, _aryThreeKillResult[i], CC_CALLBACK_0(SSSGameScene::sendCompareOverMsg, this));
		}
		else
		{
			m_aryPlayer[wViewID]->playSubScoreAni(1, _aryThreeKillResult[i]);
		}
	}
}

//更新牌类型按钮状态;
void SSSGameScene::updateCardTypeButtons()
{
	_btnDuiZi->setEnabled(m_AnalyseType.bOnePare);
	_btnLiangDui->setEnabled(m_AnalyseType.bTwoPare);
	_btnSanTiao->setEnabled(m_AnalyseType.bThreeSame);
	_btnShunZi->setEnabled(m_AnalyseType.bStraight);
	_btnTongHua->setEnabled(m_AnalyseType.bFlush);
	_btnHuLu->setEnabled(m_AnalyseType.bGourd);
	_btnTieZhi->setEnabled(m_AnalyseType.bFourSame);
	_btnTongHuaShun->setEnabled(m_AnalyseType.bStraightFlush);
}

//禁用牌类型按钮状态;
void SSSGameScene::disableCardTypeButtons()
{
	_btnDuiZi->setEnabled(false);
	_btnLiangDui->setEnabled(false);
	_btnSanTiao->setEnabled(false);
	_btnShunZi->setEnabled(false);
	_btnTongHua->setEnabled(false);
	_btnHuLu->setEnabled(false);
	_btnTieZhi->setEnabled(false);
	_btnTongHuaShun->setEnabled(false);
}

//游戏结束;
void SSSGameScene::onSubGameEnd(const void * pBuffer, uint16 wDataSize)
{
	//校验数据;
	CC_ASSERT(wDataSize == sizeof(SSS_CMD_S_GameEnd));
	SSS_CMD_S_GameEnd* pGameEnd = (SSS_CMD_S_GameEnd*)pBuffer;

	_txtTip->setString("");

	uint16 wSelfChairID = getSelfChairID();

	SCORE lMyResultScore = pGameEnd->lGameScore[wSelfChairID];

	if (false==m_IsGameRecord)
	{
		if (pGameEnd->isPrivateEnd)
		{
			_btnReady->setVisible(false);
			_btnPrivateEnd->setVisible(true);
		}
		else
		{
			_btnReady->setVisible(true);
			_btnPrivateEnd->setVisible(false);
		}
	}
	else
	{
		_btnReady->setVisible(false);
		_btnPrivateEnd->setVisible(false);
	}

	_ResultPanel->setVisible(true);
	ArmatureAnimation* pAniResult = _pArmatureResult->getAnimation();
	if (pAniResult != nullptr)
	{
		if (lMyResultScore > 0)
		{
			pAniResult->play("Win", -1, 0);
			playEffect("Win");
		}
		else if (lMyResultScore < 0)
		{
			pAniResult->play("Lose", -1, 0);
			playEffect("Loss");
		}
		else
		{
			pAniResult->play("Draw", -1, 0);
		}

		_pArmatureResult->setVisible(true);
	}

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		if (_aryActiveStatus[i] != SSS_HAND_STATUS_NULL)
		{
			uint16 wViewID = SwitchViewChairID(i);

			SCORE lTotalScore = pGameEnd->lGameScore[i];

			playResultScoreAni(wViewID, lTotalScore, 0);
		}
	}
}

//用户进入;
void SSSGameScene::OnEventUserEnter(GamePlayer * pPlayer)
{
	if (pPlayer->GetChairID() == getSelfChairID())
	{
		//更新准备按钮状态;
		uint8 cbUserStatus = pPlayer->GetUserStatus();
		if (cbUserStatus >= US_READY || _cbGameStatus>SSS_GS_WK_FREE)
		{
			_btnStartGame->setEnabled(false);

			//_ResultPanel->setVisible(false);
		}
		else
		{
			//_btnStartGame->setVisible(true);
		}
	}
}

//玩家状态改变;
void SSSGameScene::OnEventUserStatus(GamePlayer * pPlayer)
{
	OnEventUserEnter(pPlayer);
}

//选牌回调;
void SSSGameScene::selectCardCallback(uint8* arySelCardData, uint8 cbSelCardCount)
{
	uint8 aryShootCardData[SSS_MAX_COUNT] = { 0 };
	uint8 cbShootCardCount = 0;
	_OperateCardPanel->getShootCardData(aryShootCardData, cbShootCardCount, SSS_MAX_COUNT);

	if (3==cbShootCardCount)
	{
		if (0==_aryTricksCardPanel[0]->getChildrenCount())
		{
			_arySprCardShadow[0]->setVisible(true);
		}
	}
	else if (5 == cbShootCardCount)
	{
		for (uint8 i = 1; i < SSS_GROUP_COUNT; i++)
		{
			if (0 == _aryTricksCardPanel[i]->getChildrenCount())
			{
				_arySprCardShadow[i]->setVisible(true);
			}
		}
	}
	else
	{
		for (uint8 i = 0; i < SSS_GROUP_COUNT; i++)
		{
			_arySprCardShadow[i]->setVisible(false);
		}
	}
}

// 播放结束积分动画;
void SSSGameScene::playResultScoreAni(int nIndex, SCORE lScore, SCORE lXinScore)
{
	CC_ASSERT(nIndex < SSS_GAME_PLAYER);

	auto pAction1 = ScaleTo::create(0.15f, 0.8f);
	auto pAction2 = ScaleTo::create(0.18f, 1.5f);
	auto pAction3 = ScaleTo::create(0.12f, 1.2f);

	TextAtlas* txtResult = _pTxtResultScore[nIndex];
	//TextAtlas* txtXin = _pTxtXinScore[nIndex];

	//if (0 != lXinScore)
	//{
	//	txtXin->setVisible(true);
	//	txtXin->setScale(0);

	//	if (lXinScore >= 0)
	//	{
	//		txtXin->setString(StringUtils::format(".%d", lXinScore));
	//	}
	//	else
	//	{
	//		txtXin->setString(StringUtils::format("/%d", std::abs(lXinScore)));
	//	}

	//	txtXin->runAction(Sequence::create(pAction1->clone(), pAction2->clone(), pAction3->clone(), nullptr));
	//}
	//else
	//{
	//	txtXin->setVisible(false);
	//}

	if (0 != lScore)
	{
		txtResult->setVisible(true);
		txtResult->setScale(0);

		if (lScore >= 0)
		{
			txtResult->setProperty(StringUtils::format("/%d", lScore), "Games/13S/Table/imgPositiveFont.png", 26, 35, "/");
		}
		else
		{
			txtResult->setProperty(StringUtils::format("/%d", std::abs(lScore)), "Games/13S/Table/imgNegativeFont.png", 26, 35, "/");
		}

		txtResult->runAction(Sequence::create(pAction1, pAction2, pAction3, nullptr));
	}
	else
	{
		txtResult->setVisible(false);
	}
}

void SSSGameScene::showAllPlayersCard()
{
    for (int i = 0; i<SSS_GAME_PLAYER; i++ )
	{
		if (_aryActiveStatus[i]!=SSS_HAND_STATUS_NULL)
		{
			uint16 wViewID = SwitchViewChairID(i);
			m_aryPlayer[wViewID]->showCard(_aryFrontCard[i], _aryMidCard[i], _aryBackCard[i], _aryActiveStatus[i], true);
        }
    }
}

void SSSGameScene::openClock(Sprite* sprClock, int iLeftTime, const std::function<void()>& callFunc/* = nullptr*/)
{
	sprClock->setVisible(true);
	sprClock->stopAllActions();

	TextAtlas* txtClockNum = static_cast<TextAtlas*>(sprClock->getChildByName("txtClockNum"));
	txtClockNum->setString(StringUtils::format("%02d", iLeftTime));
	txtClockNum->setTag(iLeftTime);

	auto callback = [=]() {
		int iTime = __max(txtClockNum->getTag(), 0);
		txtClockNum->setString(StringUtils::format("%02d", iTime--));
		txtClockNum->setTag(iTime);
		if (iTime == 3)
		{
			sprClock->runAction(RepeatForever::create(JumpBy::create(0.9f, Vec2(0, 0), 20, 3)));
		}

		if (iTime == 0)
		{
			//sprClock->stopAllActions();
			if (callFunc != nullptr)
			{
				callFunc();
			}
		}
	};

	sprClock->runAction(RepeatForever::create(Sequence::create(DelayTime::create(1.0f), CallFunc::create(callback), nullptr)));
}

void SSSGameScene::closeClock(Sprite* sprClock)
{
	sprClock->stopAllActions();
	sprClock->setVisible(false);
}


//玩家金币改变;
void SSSGameScene::OnUserScore(GamePlayer* pPlayer)
{
	CC_ASSERT(pPlayer!=nullptr);
	if (pPlayer == nullptr) return;

	// 不再桌子上;
	CC_ASSERT(pPlayer->GetTableID() != INVALID_TABLE && pPlayer->GetChairID() != INVALID_CHAIR);
	if (pPlayer->GetTableID() == INVALID_TABLE || pPlayer->GetChairID() == INVALID_CHAIR) return;

	// 不是同一桌子玩家;
	CC_ASSERT(pPlayer->GetTableID() == getSelfGamePlayer()->GetTableID());
	if (pPlayer->GetTableID() != getSelfGamePlayer()->GetTableID()) return;

	cocos2d::log(a_u8c("用户%s，score = %d"), pPlayer->GetNickName().c_str(), pPlayer->GetUserScore());

	((SSS_GamePlayer*)pPlayer)->updateScore();
}

// 玩家坐标;
Vec2 SSSGameScene::GetPlayerPosByUserID(uint32 dwUserID)
{
	SSS_GamePlayer* pPlayer = (SSS_GamePlayer*)getPlayerByUserID(dwUserID);

	if (pPlayer == nullptr)
	{
		return Vec2();
	}

	//const Vec2& ptHeadPos = pPlayer->getHeadPos();
	//Vec2 ptWorldPos = pPlayer->convertToWorldSpace(ptHeadPos);

	return pPlayer->getHeadPos();
}

//调用;
GamePlayer* SSSGameScene::CreatePlayer(IClientUserItem * pIClientUserItem)
{
	if (pIClientUserItem->GetChairID() == INVALID_CHAIR)
	{
		return NULL;
	}

	if (pIClientUserItem->GetUserID() == UserInfo::Instance().getUserID())
	{
		m_pLocalPlayer->setUserItem(pIClientUserItem);
		return m_pLocalPlayer;
	}
	else
	{
		WORD wViewID = SwitchViewChairID(pIClientUserItem->GetChairID());
		CC_ASSERT(wViewID!=INVALID_CHAIR);
		SSS_GamePlayer* pPlayer = m_aryPlayer[wViewID];
		pPlayer->setUserItem(pIClientUserItem);
		return pPlayer;
	}
	return NULL;
}

//椅子号视图转换;
WORD SSSGameScene::SwitchViewChairID(WORD wChairID)
{
	//参数判断;
	if (wChairID == INVALID_CHAIR) return INVALID_CHAIR;

	WORD wSelfChairID = getSelfChairID();
	if (wSelfChairID == INVALID_CHAIR) return INVALID_CHAIR;

	//转换椅子;
	WORD wChairCount = SSS_GAME_PLAYER;
	WORD wViewChairID = (wChairID + wChairCount - wSelfChairID + SSS_VIEW_SELF_ID) % wChairCount;

	return wViewChairID;
}

//本人进入游戏  GameFrameBase.cpp调用;
void SSSGameScene::upSelfPlayerInfo()
{
	log("Self Enter!!");

	return;
}

//牌型A32转32A;
bool SSSGameScene::cardTypeTo32A(const uint8 arySrcCardData[SSS_MIN_ITEM_COUNT], const uint8 cbCardCount, uint8* aryTargetCardData, const uint8 cbTargetCardCount)
{
	CC_ASSERT(cbCardCount >= SSS_MIN_ITEM_COUNT && cbCardCount == cbTargetCardCount);
	if (cbCardCount<SSS_MIN_ITEM_COUNT || cbCardCount != cbTargetCardCount) return false;

	zeromemory(aryTargetCardData, sizeof(BYTE)*cbTargetCardCount);

	uint8 cbFirstCardValue = m_GameLogic.GetCardValue(arySrcCardData[0]);
	uint8 cbLastCardValue = m_GameLogic.GetCardValue(arySrcCardData[cbCardCount-1]);
	if (0x01==cbFirstCardValue && 0x02==cbLastCardValue)
	{
		uint8 cbCurCardValue = m_GameLogic.GetCardValue(arySrcCardData[1]);
		for (uint8 i = 2; i < cbCardCount; i++)
		{
			uint8 cbTmpCardValue = m_GameLogic.GetCardValue(arySrcCardData[i]);
			if (cbCurCardValue != (cbTmpCardValue+1))
			{
				break;
			}
			cbCurCardValue = cbTmpCardValue;
		}

		if (cbCurCardValue==cbLastCardValue)
		{
			aryTargetCardData[cbTargetCardCount - 1] = arySrcCardData[0];

			for (uint8 i = 1; i < cbCardCount; i++)
			{
				aryTargetCardData[i-1] = arySrcCardData[i];
			}

			return true;
		}
	}

	return false;
}

//检测扑克牌摆放规则;
bool SSSGameScene::checkCardPutRule()
{
	bool bShowTip = false;
	do
	{
		if (_aryTricksCardPanel[0]->getChildrenCount()>0 && _aryTricksCardPanel[1]->getChildrenCount() > 0)
		{
			// 首道比中道;
			uint8 cbResult = m_GameLogic.CompareCard(_aryTricksFrontCard, _aryTricksMidCard, SSS_MIN_ITEM_COUNT, SSS_MAX_ITEM_COUNT, m_bClassicRule);
			if (0 == cbResult)
			{
				bShowTip = true;

				_aryTricksCardPanel[0]->removeAllChildren();
				_aryTricksCardPanel[1]->removeAllChildren();
				uint8 aryCardData[SSS_MAX_COUNT] = { 0 };
				uint8 cbCardCount = _OperateCardPanel->getHandCardData(aryCardData, sizeof(aryCardData));

				if ((cbCardCount + SSS_MIN_ITEM_COUNT) <= SSS_MAX_COUNT)
				{
					memcpy(&aryCardData[cbCardCount], _aryTricksFrontCard, SSS_MIN_ITEM_COUNT);
					memset(_aryTricksFrontCard, 0, sizeof(_aryTricksFrontCard));
					cbCardCount += SSS_MIN_ITEM_COUNT;
				}

				if ((cbCardCount + SSS_MAX_ITEM_COUNT) <= SSS_MAX_COUNT)
				{
					memcpy(&aryCardData[cbCardCount], _aryTricksMidCard, SSS_MAX_ITEM_COUNT);
					memset(_aryTricksMidCard, 0, sizeof(_aryTricksMidCard));
					cbCardCount += SSS_MAX_ITEM_COUNT;
				}

				m_GameLogic.SortCardList(aryCardData, cbCardCount);
				_OperateCardPanel->showHandCard(aryCardData, cbCardCount);
				_OperateCardPanel->setVisible(true);

				_arySprCardType[0]->setVisible(false);
				_arySprCardType[1]->setVisible(false);

				_aryButtonRechoose[0]->setEnabled(false);
				_aryButtonRechoose[1]->setEnabled(false);

				_arySprCardShadow[0]->setVisible(false);
				_arySprCardShadow[1]->setVisible(false);

				_btnCompare->setVisible(false);
				_btnReset->setVisible(false);

				m_AnalyseType = m_GameLogic.GetType(aryCardData, cbCardCount);
				updateCardTypeButtons();

				break;
			}
		}

		if (_aryTricksCardPanel[1]->getChildrenCount() > 0 && _aryTricksCardPanel[2]->getChildrenCount() > 0)
		{
			// 中道比尾道;
			uint8 cbResult = m_GameLogic.CompareCard(_aryTricksMidCard, _aryTricksBackCard, SSS_MAX_ITEM_COUNT, SSS_MAX_ITEM_COUNT, m_bClassicRule);
			if (0 == cbResult)
			{
				bShowTip = true;

				_aryTricksCardPanel[1]->removeAllChildren();
				_aryTricksCardPanel[2]->removeAllChildren();
				uint8 aryCardData[SSS_MAX_COUNT] = { 0 };
				uint8 cbCardCount = _OperateCardPanel->getHandCardData(aryCardData, sizeof(aryCardData));

				if ((cbCardCount + SSS_MAX_ITEM_COUNT) <= SSS_MAX_COUNT)
				{
					memcpy(&aryCardData[cbCardCount], _aryTricksMidCard, SSS_MAX_ITEM_COUNT);
					memset(_aryTricksMidCard, 0, sizeof(_aryTricksMidCard));
					cbCardCount += SSS_MAX_ITEM_COUNT;
				}

				if ((cbCardCount + SSS_MAX_ITEM_COUNT) <= SSS_MAX_COUNT)
				{
					memcpy(&aryCardData[cbCardCount], _aryTricksBackCard, SSS_MAX_ITEM_COUNT);
					memset(_aryTricksBackCard, 0, sizeof(_aryTricksBackCard));
					cbCardCount += SSS_MAX_ITEM_COUNT;
				}

				m_GameLogic.SortCardList(aryCardData, cbCardCount);
				_OperateCardPanel->showHandCard(aryCardData, cbCardCount);
				_OperateCardPanel->setVisible(true);

				_arySprCardType[1]->setVisible(false);
				_arySprCardType[2]->setVisible(false);

				_aryButtonRechoose[1]->setEnabled(false);
				_aryButtonRechoose[2]->setEnabled(false);

				_arySprCardShadow[1]->setVisible(false);
				_arySprCardShadow[2]->setVisible(false);

				_btnCompare->setVisible(false);
				_btnReset->setVisible(false);

				m_AnalyseType = m_GameLogic.GetType(aryCardData, cbCardCount);
				updateCardTypeButtons();

				break;
			}
		}
	} while (false);

	if (bShowTip)
	{
		// 缩放提示;
		_imgQualifiedTips->setScale(0.5f);
		auto actSeq = Sequence::create(Show::create(), EaseElasticOut::create(ScaleTo::create(0.5f, 1.0f)), DelayTime::create(2.0f), Hide::create(), nullptr);
		_imgQualifiedTips->runAction(actSeq);

		return false;
	}

	return true;
}

// 获取当前玩家数量;
uint8 SSSGameScene::getCurPlayerCount()
{
	uint8 cbPlayerCount = 0;
	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		GamePlayer* pPlayer = m_aryPlayer[i];
		if (pPlayer != nullptr && pPlayer->getUserItem(false) != nullptr)
		{
			cbPlayerCount++;
		}
	}

	return cbPlayerCount;
}

/************************************* 语音 ***********************************************************/
// 按住语音按钮;
void SSSGameScene::OnButtonVoiceTouched(Ref*, Widget::TouchEventType type)
{
	if (Widget::TouchEventType::BEGAN == type)
	{
		// 暂停播放背景音乐;
		CocosDenshion::SimpleAudioEngine::getInstance()->pauseBackgroundMusic();

		if (m_pVoiceNode->isVisible())
		{
			m_pVoiceNode->setVisible(false);
			m_pVoiceNode->stopAllActions();

			YvVoiceManager::GetInstance()->StopRecord();
			return;
		}

		m_pVoiceNode->setVisible(true);

		// 启动帧动画;
		auto action = CSLoader::createTimeline("Games/13S/VoiceNode.csb");
		action->gotoFrameAndPlay(0);
		m_pVoiceNode->runAction(action);

		YvVoiceManager::GetInstance()->StartRecord();
	}
	else if ((Widget::TouchEventType::CANCELED == type) || (Widget::TouchEventType::ENDED == type))
	{
		// 继续播放背景音乐;
		CocosDenshion::SimpleAudioEngine::getInstance()->resumeBackgroundMusic();

		if (!m_pVoiceNode->isVisible())
		{
			return;
		}

		m_pVoiceNode->setVisible(false);
		m_pVoiceNode->stopAllActions();

		YvVoiceManager::GetInstance()->StopRecord();
	}
}

//获到性别字符串;
std::string SSSGameScene::getUserGender(int cbGender)
{
	if (cbGender == 0)
	{
		return "man";
	}

	return "woman";
}

//播放发牌声音;
void SSSGameScene::playSendCardEffect()
{
	CocosDenshion::SimpleAudioEngine* pAudio = CocosDenshion::SimpleAudioEngine::getInstance();
	pAudio->playEffect("Games/13S/Sound/deal.mp3");
}

// 播放特殊牌型声音;
void SSSGameScene::playSpecialTypeEffect(uint8 cbGender, uint8 cbCardType)
{
	CocosDenshion::SimpleAudioEngine* pAudio = CocosDenshion::SimpleAudioEngine::getInstance();
	std::string strCardTypePath = C13SGameLogic::getCardTypeSoundPath(cbGender, cbCardType);
	log("the strAudioRes is== %s", strCardTypePath.c_str());
	pAudio->playEffect(strCardTypePath.c_str());
}

//播放快捷语音;
void SSSGameScene::playFastVoice(int cbGender, int voiceIndex)
{
	CocosDenshion::SimpleAudioEngine* pAudio = CocosDenshion::SimpleAudioEngine::getInstance();
	std::string strGender = getUserGender(cbGender);
	std::string strAudioRes = StringUtils::format("Games/13S/Sound/FastVoice/%s/%d.mp3", strGender.c_str(), voiceIndex);
	log("the strAudioRes is== %s", strAudioRes.c_str());
	pAudio->playEffect(strAudioRes.c_str());
}

//播放音效;
void SSSGameScene::playEffect(std::string strPath)
{
	CocosDenshion::SimpleAudioEngine* pAudio = CocosDenshion::SimpleAudioEngine::getInstance();
	std::string strAudioRes = StringUtils::format("Games/13S/Sound/%s.mp3", strPath.c_str());
	pAudio->playEffect(strAudioRes.c_str());
}

//播放点击音效;
void SSSGameScene::playBtnClickEffect()
{
	CocosDenshion::SimpleAudioEngine* pAudio = CocosDenshion::SimpleAudioEngine::getInstance();
	pAudio->playEffect("Games/13S/Sound/button_click.mp3");
}

/************************************* 房间信息 ***********************************************************/
// 房间信息消息;
void SSSGameScene::OnSocketSubPrivateRoomInfo(CMD_GF_Private_Room_Info* pNetInfo)
{
	m_PrivateRoomInfo = *pNetInfo;

	m_dwRoomID = pNetInfo->dwRoomNum;

	string strRoomID = StringUtils::format("%d", m_dwRoomID);
	_txtRoomID->setString(strRoomID);
	_txtRoomID->setVisible(true);

	uint32 dwPlayCout = __max(pNetInfo->dwPlayCout+1, 1);
	dwPlayCout = __min(dwPlayCout, pNetInfo->dwPlayTotal);

	m_dwPlayCout = dwPlayCout;

	string strPlayCount = StringUtils::format("%u/%u", dwPlayCout, pNetInfo->dwPlayTotal);
	cocos2d::log("dwPlayCout = %d", pNetInfo->dwPlayCout);
	_txtJushu->setString(utility::a_u8(strPlayCount));
	_txtJushu->setVisible(true);

	ShowGameRule(pNetInfo);

	DWORD dwGameRule = m_PrivateRoomInfo.bGameRuleIdex;
	m_bClassicRule = (dwGameRule & eSSSGameRuleClassic) > 0;
	m_GameLogic.setClassicRule(m_bClassicRule);

	SSS_GamePlayer* pPlayer = (SSS_GamePlayer*)getPlayerByUserID(pNetInfo->dwCreateUserID);
	if (pPlayer != nullptr)
	{
		pPlayer->setOwner(true);
	}

	if (pNetInfo->bStartGame)
	{
		//如果游戏已开始则隐藏“返回大厅”按钮，显示“解散房间”按钮;
		_btnInvite->setVisible(false);
		_btnStartGame->setVisible(false);
		_btnDismiss->setVisible(true);
		_btnLeave->setVisible(false);

		//私人场已经开始，重连上游戏自带发送准备消息;
		GamePlayer* pSelfPlayer = getSelfGamePlayer();
		if (!_ResultPanel->isVisible() && (pSelfPlayer != nullptr) && (pSelfPlayer->GetUserStatus() == US_SIT) && (_cbGameStatus == SSS_GS_WK_FREE))
		{
			SendUserReady();
		}
	}
	else
	{
		GamePlayer* pPlayer = getSelfGamePlayer();
		//如果房间主人是自已则隐藏“返回大厅”按钮，显示“解散房间”按钮;
		if (pPlayer != nullptr && pNetInfo->dwCreateUserID == pPlayer->GetUserID())
		{
			_btnLeave->setVisible(false);
			_btnDismiss->setVisible(true);
		}

		//游戏未开始显示微信分享按钮;
		if (pNetInfo->dwPlayCout <= 0)
		{
			_btnInvite->setVisible(true);
			_btnStartGame->setVisible(true);
		}
	}
}

// 游戏规则
void SSSGameScene::ShowGameRule(CMD_GF_Private_Room_Info* pNetInfo)
{
	if (pNetInfo == nullptr) return;

	std::string strPlayCount = StringUtils::format("%d局, ", pNetInfo->dwPlayTotal);

	std::string strGameSet = "";
	uint32 dwGameRule = m_PrivateRoomInfo.bGameRuleIdex;
	m_strGameTitle = "十三张~抢庄玩法";

	if ((dwGameRule & eSSSGameRuleRobBanker) > 0)
	{
		strGameSet += "抢庄玩法, ";
		_txtRoomRule->setString(utility::a_u8("抢庄玩法"));
	}

	if ((dwGameRule & eSSSGameRuleFixBanker) > 0)
	{
		strGameSet += "霸王庄玩法, ";
		_txtRoomRule->setString(utility::a_u8("霸王庄玩法"));
		m_strGameTitle = "十三张~霸王庄玩法";
	}

	if ((dwGameRule & eSSSGameRuleTurnBanker) > 0)
	{
		strGameSet += "轮庄玩法, ";
		_txtRoomRule->setString(utility::a_u8("轮庄玩法"));
		m_strGameTitle = "十三张~轮庄玩法";
	}

	if ((dwGameRule & eSSSGameRuleClassic) > 0)
	{
		strGameSet += "经典玩法, ";
		_txtRoomRule->setString(utility::a_u8("经典玩法"));
		m_strGameTitle = "十三张~经典玩法";
	}

	m_strGameRuleInfo = strPlayCount + strGameSet;

}

// 私人场结束;
void SSSGameScene::OnSocketSubPrivateEnd(void* data, int dataSize)
{
	m_bPrivateEnd = true;

	// 申请解散界面;
	DismissScene::Instance().hide();

	DataStream kDataStream(data, dataSize);
	SSS_CMD_S_Private_End_Info kNetInfo;
	kNetInfo.StreamValue(kDataStream, false);

	_aryResultItem.clear();

	// 是不是欢乐场;
	bool bUnionScore = (m_PrivateRoomInfo.cbUnionGoldOpen == 1);

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		if (kNetInfo.aryActiveStatus[i] == 0)
		{
			continue;
		}

		tagSSSOpenResultItem mItem;
		mItem.lGameScore = kNetInfo.lUserScore[i];
		//if (bUnionScore)
		//{
		//	mItem.lUnionScore = mItem.lGameScore * m_PrivateRoomInfo.lScoreMultiple;
		//}
		//else
		{
			mItem.lUnionScore = mItem.lGameScore * m_PrivateRoomInfo.cbBaseScore;
		}

		GamePlayer* player = getPlayerByChairID(i);
		if (player!=nullptr)
		{
			std::string strName = player->GetNickName();
			strncpy(mItem.szNickName, strName.c_str(), countarray(mItem.szNickName) - 1);
			mItem.dwGameID = player->GetGameID();
			mItem.bOwner = (player->GetUserID() == m_PrivateRoomInfo.dwCreateUserID);

			std::string strHttpHead = player->GetHeadHttp();
			strncpy(mItem.szHttpHead, strHttpHead.c_str(), countarray(mItem.szHttpHead) - 1);
		}

		mItem.cbWinTimes = kNetInfo.aryWinTimes[i];
		mItem.cbLoseTimes = kNetInfo.aryLoseTimes[i];
		mItem.cbShootTimes = kNetInfo.aryShootTimes[i];
		mItem.cbKillAllTimes = kNetInfo.aryKillAllTimes[i];

		_aryResultItem.push_back(mItem);
	}


	// 工会欢乐场;
	if (bUnionScore)
	{
		int nCount = _aryResultItem.size();

		// 寻找大赢家;
		SCORE lMaxScore = 0;
		for (size_t i = 0; i < nCount; i++)
		{
			tagSSSOpenResultItem* pData = &(_aryResultItem.at(i));

			if (pData->lGameScore > lMaxScore)
			{
				lMaxScore = pData->lGameScore;
			}
		}

		// 统计大赢家数量;
		int iMaxScoreCount = 0;
		for (int j = 0; j < nCount; j++)
		{
			tagSSSOpenResultItem* pData = &(_aryResultItem.at(j));

			if ((lMaxScore > 0) && (pData->lGameScore == lMaxScore))
			{
				iMaxScoreCount++;
			}
		}

		if (iMaxScoreCount > 0)
		{
			SCORE lGameGold = m_PrivateRoomInfo.lGameGold*m_PrivateRoomInfo.dwPlayCost;
			// 计算玩家积分;
			SCORE lRevenue = floor(lGameGold / iMaxScoreCount);

			// 重新计算积分, 统计扣税;
			for (int k = 0; k < nCount; k++)
			{
				tagSSSOpenResultItem* pData = &(_aryResultItem.at(k));
				if ((lMaxScore > 0) && (pData->lGameScore == lMaxScore))
				{
					if (pData->lUnionScore > lRevenue)
					{
						pData->lUnionScore -= lRevenue;
					}
					else
					{
						pData->lUnionScore = 0;
					}
				}

				// 这里直接设置为欢乐总积分
				pData->lAllUnionScore = pData->lUnionScore + m_PrivateScoreInfo.kScoreInfoArray[k];
			}
		}
	}

	if (_ResultPanel->isVisible() == false)
	{
		_OpenResultScene->updateUIData(m_dwRoomID, &_aryResultItem, true);
		_OpenResultScene->setVisible(true);
	}
	else
	{
		_btnPrivateEnd->setVisible(true);
		_btnReady->setVisible(false);
	}

	// 游戏结束停止网络;
	PrivateRoomEnd();
}

void SSSGameScene::onEventShowPrivate(cocos2d::EventCustom *event)
{
	//if (m_pPrivateScene)
	//{
	//	m_pPrivateScene->pushScene();
	//}
}

// 请求解散房间;
void SSSGameScene::OnSocketSubPrivateDismissInfo(CMD_GF_Private_Dismiss_Info* pNetInfo)
{
	std::string aryName[SSS_GAME_PLAYER];
	BYTE aryResult[SSS_GAME_PLAYER] = { 0 };	// 0 未选择 1 同意 2 不同意;

	bool bHasSelf = false;

	uint32 dwMyChairID = getSelfChairID();
	for (uint32 i = 0; i < pNetInfo->dwDissUserCout; i++)
	{
		uint32 dwChairID = pNetInfo->dwDissChairID[i];
		GamePlayer* pPlayer = getPlayerByChairID(dwChairID);
		if (pPlayer != nullptr && dwChairID < SSS_GAME_PLAYER)
		{
			aryResult[dwChairID] = 1;
		}

		if (dwMyChairID == dwChairID)
		{
			bHasSelf = true;
		}
	}

	for (uint32 i = 0; i < pNetInfo->dwNotAgreeUserCout; i++)
	{
		uint32 dwChairID = pNetInfo->dwNotAgreeChairID[i];
		GamePlayer* pPlayer = getPlayerByChairID(dwChairID);
		if (pPlayer != nullptr && dwChairID < SSS_GAME_PLAYER)
		{
			aryResult[dwChairID] = 2;
		}

		if (dwMyChairID == dwChairID)
		{
			bHasSelf = true;
		}
	}

	GamePlayer* players[SSS_GAME_PLAYER];

	for (int i = 0; i < SSS_GAME_PLAYER; i++)
	{
		players[i] = getPlayerByChairID(i);
	}

	DismissScene::Instance().show(aryResult, players, !bHasSelf, SSS_GAME_PLAYER);
}

void SSSGameScene::OnSocketSubPrivateDismissResult(CMD_GF_Private_Dismiss_Result* pNetInfo)
{
	if (pNetInfo->bSuccess && false == m_PrivateRoomInfo.bStartGame)
	{
		EventLeaveGame(nullptr);
	}
	else
	{
		DismissScene::Instance().hide();
	}
}

//////////////////////////////// 游戏录像 //////////////////////////////////////////
// 开始录像播放
void SSSGameScene::StartGameRecord()
{
	if (m_GameRecord.playersVec.size() < 2)
	{
		return;
	}

	// 初始化房间信息;
	OnSocketSubPrivateRoomInfo(&m_GameRecord.roomInfo);

	m_iActRecordIdex = 0;
	m_txtRecordPercent->setString(utility::toString(m_iActRecordIdex * 100 / m_GameRecord.actionVec.size(), "%"));

	schedule(schedule_selector(GameFrameBase::NextRecordAction), m_RecordTime);

	if ((m_GameRecord.wBankerUser != INVALID_CHAIR)&&(m_GameRecord.wBankerUser<SSS_GAME_PLAYER))
	{
		SSS_CMD_S_StartChip startChip = {0};
		startChip.wBankerUser = m_GameRecord.wBankerUser;

		onSubStartChip(&startChip, sizeof(SSS_CMD_S_StartChip));
	}

	return;
}

void SSSGameScene::NextRecordAction(float dt)
{
	cocos2d::log("NextRecordAction...m_iActRecordIdex = %d", m_iActRecordIdex);

	// 已经播放完了;
	if (m_iActRecordIdex >= (int)m_GameRecord.actionVec.size() || !isVisible())
	{
		m_txtRecordPercent->setString("100%");
		m_btnPlay->setVisible(true);
		m_btnPause->setVisible(false);

		unschedule(schedule_selector(GameFrameBase::NextRecordAction));
		return;
	}

	// 下一个操作记录;
	tagGameRecordOperateResult& kAction = m_GameRecord.actionVec[m_iActRecordIdex];

	// 游戏开始;
	if (kAction.wSubCmdID == SSS_SUB_S_USER_ROB)
	{
		SSS_CMD_S_UserRob userRob;
		kAction.subMessageData.popValue(&userRob, sizeof(SSS_CMD_S_UserRob));

		onSubUserRob(&userRob, sizeof(SSS_CMD_S_UserRob));
	}
	// 玩家叫分;
	else if (kAction.wSubCmdID == SSS_SUB_S_START_CHIP)
	{
		SSS_CMD_S_StartChip startChip;
		kAction.subMessageData.popValue(&startChip, sizeof(SSS_CMD_S_StartChip));

		onSubStartChip(&startChip, sizeof(SSS_CMD_S_StartChip));
	}
	// 确认地主;
	else if (kAction.wSubCmdID == SSS_SUB_S_USER_CHIP)
	{
		SSS_CMD_S_UserChip userChip;
		kAction.subMessageData.popValue(&userChip, sizeof(SSS_CMD_S_UserChip));

		onSubUserChip(&userChip, sizeof(SSS_CMD_S_UserChip));
	}
	// 玩家出牌;
	else if (kAction.wSubCmdID == SSS_SUB_S_CLASSIC_CMP_CARD)
	{
		SSS_CMD_S_ClassicCompareCard cmpCard;
		kAction.subMessageData.popValue(&cmpCard, sizeof(SSS_CMD_S_ClassicCompareCard));

		onSubClassicCompareCard(&cmpCard, sizeof(SSS_CMD_S_ClassicCompareCard));
	}
	// 玩家放弃出牌;
	else if (kAction.wSubCmdID == SSS_SUB_S_BANKER_CMP_CARD)
	{
		SSS_CMD_S_BankerCompareCard cmpCard;
		kAction.subMessageData.popValue(&cmpCard, sizeof(SSS_CMD_S_BankerCompareCard));
		onSubBankerCompareCard(&cmpCard, sizeof(SSS_CMD_S_BankerCompareCard));
	}
	// 游戏结束;
	else if (kAction.wSubCmdID == SSS_SUB_S_GAME_END)
	{
		//SSS_CMD_S_GameEnd GameEnd;
		kAction.subMessageData.popValue(&m_GameEnd, sizeof(SSS_CMD_S_GameEnd));

		//onSubGameEnd(&GameEnd, sizeof(SSS_CMD_S_GameEnd));
	}

	m_iActRecordIdex++;
	m_txtRecordPercent->setString(utility::toString(m_iActRecordIdex * 100 / m_GameRecord.actionVec.size(), "%"));
}

std::string SSSGameScene::getGameRule(uint32 dwGameRule)
{
	std::string strGameSet = "";

	if ((dwGameRule & eSSSGameRuleRobBanker) > 0)
	{
		strGameSet += "抢庄玩法, ";
	}

	if ((dwGameRule & eSSSGameRuleFixBanker) > 0)
	{
		strGameSet += "霸王庄玩法, ";
	}

	if ((dwGameRule & eSSSGameRuleTurnBanker) > 0)
	{
		strGameSet += "轮庄玩法, ";
	}

	if ((dwGameRule & eSSSGameRuleClassic) > 0)
	{
		strGameSet += "经典玩法, ";
	}

	return strGameSet;
}