#include "SimpleAudioEngine.h"
#include "ImagicDownManager.h"
#include "ActionEx.h"
#include "13S_CMD.h"
#include "13S_GameLogic.h"
#include "13S_GamePlayer.h"
#include "13S_BigCardSprite.h"

SSS_GamePlayer::SSS_GamePlayer(WORD wViewID, Layout* pRootLayout) :
GamePlayer(NULL), m_bReady(false), m_cbViewID(wViewID), m_pRootLayout(pRootLayout)
{
	init();
}

SSS_GamePlayer::~SSS_GamePlayer()
{

}

bool SSS_GamePlayer::init()
{
	//玩家昵称;
	m_pTxtNickName = static_cast<Text*>(m_pRootLayout->getChildByName("txtNickName"));
	CC_ASSERT(m_pTxtNickName!=nullptr);
	m_pTxtNickName->setString("");

	m_pBtnUserHead = static_cast<Button*>(m_pRootLayout->getChildByName("btnUserHead"));
	CC_ASSERT(m_pBtnUserHead != nullptr);

	//头像;
	m_pSprHead = static_cast<Sprite*>(m_pBtnUserHead->getChildByName("imgUserHead"));
	CC_ASSERT(m_pSprHead!=nullptr);
	m_pSprHead->setVisible(false);

	//筹码;
	m_pTxtChip = static_cast<TextBMFont*>(m_pRootLayout->getChildByName("txtChip"));
	CC_ASSERT(m_pTxtChip != nullptr);
	m_pTxtChip->setString("");

	//积分;
	m_pTxtScore = static_cast<Text*>(m_pRootLayout->getChildByName("txtScore"));
	CC_ASSERT(m_pTxtScore != nullptr);
	m_pTxtScore->setString("");

	//房主标志;
	m_pSprOwner = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprOwner"));
	CC_ASSERT(m_pSprOwner != nullptr);
	m_pSprOwner->setVisible(false);

	//庄标志;
	m_pSprBanker = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprBanker"));
	CC_ASSERT(m_pSprBanker != nullptr);
	m_pSprBanker->setVisible(false);

	//准备标志;
	m_pSprReady = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprReadyIcon"));
	CC_ASSERT(m_pSprReady != nullptr);
	m_pSprReady->setVisible(false);

	//状态标志;
	m_pSprStatus = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprStatus"));
	CC_ASSERT(m_pSprStatus != nullptr);
	m_pSprStatus->setVisible(false);

	m_pArmatureStatus = static_cast<Armature*>(m_pRootLayout->getChildByName("armaStatusNode"));
	CC_ASSERT(m_pArmatureStatus != nullptr);
	m_pArmatureStatus->setVisible(false);

	m_pArmaCardTypeNode = static_cast<Armature*>(m_pRootLayout->getChildByName("armaCardTypeNode"));
	CC_ASSERT(m_pArmaCardTypeNode != nullptr);
	m_pArmaCardTypeNode->setVisible(false);

	//断线标志;
	m_pSprOffline = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprOffline"));
	CC_ASSERT(m_pSprOffline != nullptr);
	m_pSprOffline->setVisible(false);

	// 遮罩层;
	m_pSprSepShadow = static_cast<Sprite*>(m_pRootLayout->getChildByName("imgSepShadow"));
	CC_ASSERT(m_pSprSepShadow != nullptr);
	m_pSprSepShadow->setVisible(false);

	zeromemory(m_arySpriteCard, sizeof(m_arySpriteCard));
	for (int i = 0; i < SSS_GROUP_COUNT; i++)
	{
		auto panelCard = static_cast<Layout*>(m_pRootLayout->getChildByName(StringUtils::format("panelHandCard%d", i)));
		CC_ASSERT(panelCard != nullptr);

		m_aryPanelHandCard[i] = panelCard;

		int nItemCount = i>0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
		for (int j = 0; j < nItemCount; j++)
		{
			Sprite* sprCard = static_cast<Sprite*>(panelCard->getChildByName(StringUtils::format("sprCard%d", j)));
			CC_ASSERT(sprCard!=nullptr);
			sprCard->setVisible(false);

			m_arySpriteCard[i][j] = sprCard;
		}

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

		m_arySprCardType[i] = sprCardType;
	}

	//游戏分面板;
	m_pPanelGameScore = static_cast<Layout*>(m_pRootLayout->getChildByName("panelGameScore"));
	CC_ASSERT(m_pPanelGameScore != nullptr);
	m_pPanelGameScore->setVisible(false);

	for (int i = 0; i < SSS_GROUP_COUNT; i++)
	{
		string strName = StringUtils::format("atlasScore%d", i);
		m_aryTxtAtlasScore[i] = static_cast<TextAtlas*>(m_pPanelGameScore->getChildByName(strName));
		CC_ASSERT(m_aryTxtAtlasScore[i]!=nullptr);
		m_aryTxtAtlasScore[i]->setString("");
	}

	//总分;
	m_pTxtAtlasScoreCount = static_cast<TextAtlas*>(m_pPanelGameScore->getChildByName("atlasScoreCount"));
	CC_ASSERT(m_pTxtAtlasScoreCount != nullptr);
	m_pTxtAtlasScoreCount->setString("");

	//聊天框背景;
	m_pImgChatView = static_cast<ImageView*>(m_pRootLayout->getChildByName("img9ChatBubble"));
	CC_ASSERT(m_pImgChatView != nullptr);
	m_pImgChatView->setVisible(false);

	auto panelChat = static_cast<Layout*>(m_pImgChatView->getChildByName("ChatMsgPanel"));
	CC_ASSERT(panelChat != nullptr);

	//聊天内容;
	m_pTxtChatInfo = static_cast<Text*>(panelChat->getChildByName("txtChatMsg"));
	CC_ASSERT(m_pTxtChatInfo != nullptr);

	//语音气泡;
	m_pVoiceBubble = static_cast<Node*>(m_pRootLayout->getChildByName("voice"));
	CC_ASSERT(m_pVoiceBubble != nullptr);
	m_pVoiceBubble->setVisible(false);

	auto speek_bg = (Sprite*)m_pVoiceBubble->getChildByName("speek_bg");
	CC_ASSERT(speek_bg != nullptr);

	m_pSprVoiceAni = (Sprite*)speek_bg->getChildByName("voice_ing");
	CC_ASSERT(m_pSprVoiceAni != nullptr);

	return true;
}

void SSS_GamePlayer::PlayerEnter()
{
	setInfoVisible(true);

	std::string strHttp = GetHeadHttp();
	cocos2d::log("%s", strHttp.c_str());
	uint32 dwUserID = GetUserID();
	ImagicDownManager::Instance().addDown(m_pSprHead, strHttp, dwUserID);

	//showChatInfo(utility::a_u8("作用：让目标动作赋予反弹力，且以目标动作结束位子开始反弹"));
}

void SSS_GamePlayer::PlayerLeave()
{
	if (m_isAllowLeave)
	{
		setInfoVisible(false);
		setReadyVisible(false);
		setOfflineVisible(false);
	}
}

//显示玩家聊天内容;
void SSS_GamePlayer::showChatInfo(const std::string strChatString)
{
	auto label = Label::createWithSystemFont(strChatString, "", 28);
	CC_ASSERT(label!=nullptr);

	m_pTxtChatInfo->setString(strChatString);
	const Size& labelSize = label->getContentSize();
	const Size& frameSize = m_pTxtChatInfo->getContentSize();

	int nRows = labelSize.width / frameSize.width;
	//int nRemainder = (int)labelSize.width % (int)frameSize.width;
	//if (nRemainder>0)
	//{
	//	nRows++;
	//}

	m_pImgChatView->setVisible(true);
	m_pTxtChatInfo->setPositionY(28.0f);

	auto callback = CallFunc::create([=](){
		m_pImgChatView->setVisible(false);
	});

	//有几行文字就向上移动几次;
	if (nRows > 0)
	{
		auto move = EaseSineInOut::create(MoveBy::create(0.4f, Vec2(0, labelSize.height)));
		auto seq = Sequence::create(DelayTime::create(2.5f), move, nullptr);

		m_pTxtChatInfo->runAction(Sequence::create(Repeat::create(seq, nRows), DelayTime::create(2.5f), callback, nullptr));
	}
	else
	{
		m_pTxtChatInfo->runAction(Sequence::create(DelayTime::create(2.5f), callback, nullptr));
	}
}

//显示语音气泡;
void SSS_GamePlayer::showVoiceBubble()
{
	CC_ASSERT(m_pVoiceBubble != nullptr);

	m_pVoiceBubble->setVisible(true);

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

//隐藏语音气泡;
void SSS_GamePlayer::hideVoiceBubble()
{
	CC_ASSERT(m_pVoiceBubble != nullptr);

	m_pSprVoiceAni->stopAllActions();
	m_pVoiceBubble->setVisible(false);
}

//重置界面;
void SSS_GamePlayer::resetUI(bool bAll/* = false*/)
{
	if ( bAll )
	{
		setInfoVisible(false);
		setReadyVisible(false);
		setOfflineVisible(false);
	}

	////断线标志;
	//m_pSprOffline->setVisible(false);

	//手牌面板;
	for (int i = 0; i < SSS_GROUP_COUNT; i++)
	{
		int nItemCount = i > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
		for (int j = 0; j < nItemCount; j++)
		{
			m_arySpriteCard[i][j]->setVisible(false);
		}

		m_aryTxtAtlasScore[i]->setString("");
		m_arySprCardType[i]->setVisible(false);
	}

	m_pSprStatus->setVisible(false);
	m_pSprSepShadow->setVisible(false);

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

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

	m_pPanelGameScore->setVisible(false);

	memset(m_aryGameScore, 0, sizeof(m_aryGameScore));
	memset(m_aryCardType, 0, sizeof(m_aryCardType));
	memset(m_aryFrontCard, 0, sizeof(m_aryFrontCard));
	memset(m_aryMidCard, 0, sizeof(m_aryMidCard));
	memset(m_aryBackCard, 0, sizeof(m_aryBackCard));

	m_nScoreCount = 0;
}

//玩家信息可见性;
void SSS_GamePlayer::setInfoVisible(bool bVisible)
{
	CC_ASSERT(m_pSprHead!=nullptr);
	m_pSprHead->setVisible(bVisible);

	CC_ASSERT(m_pTxtNickName!=nullptr);
	m_pTxtNickName->setString(bVisible?GetNickName():"");
	m_pTxtNickName->setVisible(bVisible);

	CC_ASSERT(m_pTxtScore != nullptr);
	SCORE lScore = bVisible? GetUserScore() : 0;
	m_pTxtScore->setString(utility::toString<SCORE>(lScore));
	m_pTxtScore->setVisible(bVisible);
}

//设置是否为房主;
void SSS_GamePlayer::setOwner(bool bOwenr)
{
	CC_ASSERT(m_pSprOwner != nullptr);
	m_pSprOwner->setVisible(bOwenr);
}

//设置是否为庄家;
bool SSS_GamePlayer::setBankerVisible(bool bVisible)
{
	CC_ASSERT(m_pSprBanker != nullptr);
	m_pSprBanker->setVisible(bVisible);

	if (bVisible)
	{
		float fscale = m_pSprBanker->getScale();
		m_pSprBanker->setScale(0.2f);
		auto actCardType = Sequence::create(Show::create(), EaseElasticOut::create(ScaleTo::create(0.8f, fscale)), nullptr);
		m_pSprBanker->runAction(actCardType);
	}

	return false;
}

//设置准备状态;
void SSS_GamePlayer::setReadyVisible(bool bVisible)
{
	CC_ASSERT(m_pSprReady != nullptr);
	m_pSprReady->setVisible(bVisible);

	m_bReady = bVisible;
}

//设置断线状态;
void SSS_GamePlayer::setOfflineVisible(bool bVisible)
{
	CC_ASSERT(m_pSprOffline != nullptr);
	m_pSprOffline->setVisible(bVisible);
}

//增加牌;
void SSS_GamePlayer::addOneCard(uint8 cbData, uint8 cbRowIndex, uint8 cbColIndex)
{
	int nItemCount = cbRowIndex > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
	CC_ASSERT(cbRowIndex<SSS_GROUP_COUNT&&cbColIndex<nItemCount);
	if (cbColIndex>=nItemCount)
	{
		return;
	}

	//加载牌;
	SpriteFrameCache* pSpriteFrameCache = SpriteFrameCache::getInstance();
	std::string strName = StringUtils::format("S_0x%02X.png", cbData);
	SpriteFrame* pSpriteFrame = pSpriteFrameCache->getSpriteFrameByName(strName);
	CC_ASSERT(pSpriteFrame != nullptr);

	m_arySpriteCard[cbRowIndex][cbColIndex]->setSpriteFrame(pSpriteFrame);
	m_arySpriteCard[cbRowIndex][cbColIndex]->setVisible(true);
}

//更新积分;
void SSS_GamePlayer::updateScore()
{
	CC_ASSERT(m_pTxtScore != nullptr);
	SCORE lScore = GetUserScore();
	m_pTxtScore->setString(utility::toString<SCORE>(lScore));
}

//更新筹码;
void SSS_GamePlayer::updateUserChip(SCORE lChipScore)
{
	CC_ASSERT(m_pTxtChip != nullptr);
	if (lChipScore != 0)
	{
		std::string strChipScore = StringUtils::format("x%d", lChipScore);
		m_pTxtChip->setString(strChipScore);
	}
	else
	{
		m_pTxtChip->setString("");
	}
}

void SSS_GamePlayer::showGameScore(SCORE aryScore[SSS_GROUP_COUNT])
{
	//m_pPanelGameScore->setVisible(true);
	//for (int i = 1; i < BJ_GROUP_COUNT; i++)
	//{
	//	if (aryScore[i] >= 0)
	//	{
	//		m_aryTxtAtlasScore[i]->setString(StringUtils::format("/%d", aryScore[i]));
	//	}
	//	else
	//	{
	//		m_aryTxtAtlasScore[i]->setString(StringUtils::format(".%d", std::abs(aryScore[i])));
	//	}
	//}
}

void SSS_GamePlayer::setGameScore(SCORE aryScore[SSS_GROUP_COUNT], uint16 aryCardType[SSS_GROUP_COUNT], bool bShowScore/* = true*/)
{
	m_pPanelGameScore->setVisible(bShowScore);

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

	for (uint8 i = 0; i < SSS_GROUP_COUNT; i++)
	{
		m_aryGameScore[i] = aryScore[i];
		m_aryCardType[i] = aryCardType[i];
	}

	m_nScoreCount = 0;

	m_pTxtAtlasScoreCount->setProperty("0", "Games/13S/Table/imgPositiveFont.png", 26, 35, "/");
}

void SSS_GamePlayer::playScoreAni(int nIndex, const std::function<void()>& fnCallback, bool bPlaySound, bool bPlaySubScore/* = true*/)
{
	CC_ASSERT(nIndex < SSS_GROUP_COUNT);

	uint8* pTrickCard = nullptr;
	if (0 == nIndex)
	{
		pTrickCard = m_aryFrontCard;
	}
	else if (1 == nIndex)
	{
		pTrickCard = m_aryMidCard;
	}
	else if (2 == nIndex)
	{
		pTrickCard = m_aryBackCard;
	}
	else
	{
		return;
	}

	SpriteFrameCache* pSpriteFrameCache = SpriteFrameCache::getInstance();
	int nItemCount = nIndex > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
	for (uint8 j = 0; j < nItemCount; j++)
	{
		//加载牌;
		std::string strName = StringUtils::format("S_0x%02X.png", pTrickCard[j]);
		SpriteFrame* pSpriteFrame = pSpriteFrameCache->getSpriteFrameByName(strName);
		CC_ASSERT(pSpriteFrame != nullptr);

		m_arySpriteCard[nIndex][j]->setSpriteFrame(pSpriteFrame);
		m_arySpriteCard[nIndex][j]->setVisible(true);
	}

	// 牌型动画;
	Sprite* sprCardType = m_arySprCardType[nIndex];
	string strImagePath = C13SGameLogic::getCardTypeImagePath(m_aryCardType[nIndex]);
	if (!strImagePath.empty())
	{
		sprCardType->setTexture(strImagePath);

		sprCardType->setScaleX(0.5f);
		auto actCardType = Sequence::create(Show::create(), EaseElasticOut::create(ScaleTo::create(0.8f, 1)), Hide::create(), nullptr);
		sprCardType->runAction(actCardType);
	}

	if (bPlaySubScore)
	{
		playSubScoreAni(nIndex, m_aryGameScore[nIndex]);
	}

	CallFunc* func = CallFunc::create([=]() {
		if (fnCallback != nullptr)
		{
			fnCallback();
		}
	});

	// 缩放扑克;
	m_aryPanelHandCard[nIndex]->setScale(0.5f);
	auto actSeq = Sequence::create(EaseElasticOut::create(ScaleTo::create(0.8f, 1.0f)), DelayTime::create(0.1f), func, nullptr);
	m_aryPanelHandCard[nIndex]->runAction(actSeq);

	//if (SSS_VIEW_SELF_ID==m_cbViewID)
	if (bPlaySound)
	{
		std::string strSoundPath = C13SGameLogic::getCardTypeSoundPath(GetGender(), m_aryCardType[nIndex]);

		CocosDenshion::SimpleAudioEngine* pAudio = CocosDenshion::SimpleAudioEngine::getInstance();
		pAudio->playEffect(strSoundPath.c_str());
	}
}

void SSS_GamePlayer::playSubScoreAni(int nIndex, SCORE lScore, const std::function<void()>& fnCallback)
{
	// 积分动画;
	TextAtlas* pTempAtlasScore = m_aryTxtAtlasScore[nIndex];
	TextAtlas* pAtlasScore = (TextAtlas*)pTempAtlasScore->clone();
	pTempAtlasScore->getParent()->addChild(pAtlasScore);
	pAtlasScore->setScale(0);

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

	// 缩放积分;
	auto act = EaseElasticOut::create(ScaleTo::create(0.3f, 1));
	const Vec2 ptCount = m_pTxtAtlasScoreCount->getPosition();
	auto actMoveTo = MoveTo::create(0.4f, ptCount);
	auto actSpawn = Spawn::create(actMoveTo, FadeTo::create(0.4f, 80), nullptr);
	CallFunc* funcScore = CallFunc::create([=]() {
		m_nScoreCount += lScore;

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

		m_pTxtAtlasScoreCount->setScale(0.5f);
		m_pTxtAtlasScoreCount->runAction(EaseElasticOut::create(ScaleTo::create(0.3f, 1)));

		if (fnCallback!=nullptr)
		{
			fnCallback();
		}
	});
	pAtlasScore->runAction(Sequence::create(act, actSpawn, funcScore, RemoveSelf::create(), nullptr));
}

//显示牌;
void SSS_GamePlayer::showCard(uint8 aryFrontCard[SSS_MIN_ITEM_COUNT], uint8 aryMidCard[SSS_MAX_ITEM_COUNT], uint8 aryBackCard[SSS_MAX_ITEM_COUNT], uint8 cbHandStatus, bool bInitCard/* = false*/)
{
	SpriteFrameCache* pSpriteFrameCache = SpriteFrameCache::getInstance();

	if (bInitCard)
	{
		for (uint8 i = 0; i < SSS_GROUP_COUNT; i++)
		{
			int nItemCount = i > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
			for (uint8 j = 0; j < nItemCount; j++)
			{
				//加载牌;
				SpriteFrame* pSpriteFrame = pSpriteFrameCache->getSpriteFrameByName("S_0x00.png");
				CC_ASSERT(pSpriteFrame != nullptr);

				m_arySpriteCard[i][j]->setSpriteFrame(pSpriteFrame);
				m_arySpriteCard[i][j]->setVisible(true);
			}
		}
	}
	else
	{
		for (uint8 i = 0; i < SSS_GROUP_COUNT; i++)
		{
			uint8* pTrickCard = nullptr;
			if (0 == i)
			{
				pTrickCard = aryFrontCard;
			}
			else if (1 == i)
			{
				pTrickCard = aryMidCard;
			}
			else if (2 == i)
			{
				pTrickCard = aryBackCard;
			}
			else
			{
				return;
			}

			int nItemCount = i > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
			for (uint8 j = 0; j < nItemCount; j++)
			{
				//加载牌;
				std::string strName = StringUtils::format("S_0x%02X.png", pTrickCard[j]);
				SpriteFrame* pSpriteFrame = pSpriteFrameCache->getSpriteFrameByName(strName);
				CC_ASSERT(pSpriteFrame != nullptr);

				m_arySpriteCard[i][j]->setSpriteFrame(pSpriteFrame);
				m_arySpriteCard[i][j]->setVisible(true);
			}
		}
	}

	for (uint8 i = 0; i < SSS_MIN_ITEM_COUNT; i++)
	{
		m_aryFrontCard[i] = aryFrontCard[i];
	}

	for (uint8 i = 0; i < SSS_MAX_ITEM_COUNT; i++)
	{
		m_aryMidCard[i] = aryMidCard[i];
		m_aryBackCard[i] = aryBackCard[i];
	}

	showHandStatus(cbHandStatus);
}

void SSS_GamePlayer::showHandStatus(uint8 cbHandStatus)
{
	if (SSS_HAND_STATUS_GIVEUP == cbHandStatus)
	{
		ArmatureAnimation* pAniStatus = m_pArmatureStatus->getAnimation();
		if (pAniStatus != nullptr)
		{
			pAniStatus->stop();
		}
		m_pArmatureStatus->setVisible(false);

		m_pSprStatus->setVisible(true);
		m_pSprStatus->setTexture("Games/13S/Table/imgGiveUp.png");
	}
	else if (SSS_HAND_STATUS_DISORDER == cbHandStatus)
	{
		m_pArmatureStatus->setVisible(true);
		ArmatureAnimation* pAniStatus = m_pArmatureStatus->getAnimation();
		if (pAniStatus != nullptr)
		{
			pAniStatus->play("Operation", -1, 1);
		}
	}
	else if (SSS_HAND_STATUS_SORTED == cbHandStatus)
	{
		//m_pSprStatus->setVisible(true);
		//m_pSprStatus->setTexture("Games/BiJi/Table/imgCompare.png");
		m_pArmatureStatus->setVisible(true);
		ArmatureAnimation* pAniStatus = m_pArmatureStatus->getAnimation();
		if (pAniStatus != nullptr)
		{
			pAniStatus->play("OperationOK", -1, 0);
		}
	}
    else
	{
		m_pSprStatus->setVisible(false);

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

//显示手牌遮罩层;
void SSS_GamePlayer::showSepShadow(bool bVisible)
{
	m_pSprSepShadow->setVisible(bVisible);
}

//显示特殊牌类型;
void SSS_GamePlayer::showCardType(uint8 cbSpecialCardType)
{
	std::string strAniName = "";
	switch (cbSpecialCardType)
	{
	case SSS_CT_THREE_STRAIGHT:
	{
		strAniName = "Class11";
		break;
	}
	case SSS_CT_THREE_FLUSH:
	{
		strAniName = "Class10";
		break;
	}
	case SSS_CT_SIXPAIR:
	{
		strAniName = "Class9";
		break;
	}
	case SSS_CT_FIVEPAIR_THREE:
	{
		strAniName = "Class5";
		break;
	}
	case SSS_CT_FOUR_THREESAME:
	{
		strAniName = "Class4";
		break;
	}
	case SSS_CT_SAME_COLOR:
	{
		strAniName = "Class8";
		break;
	}
	case SSS_CT_ALL_SMALL:
	{
		strAniName = "Class7";
		break;
	}
	case SSS_CT_ALL_BIG:
	{
		strAniName = "Class6";
		break;
	}
	case SSS_CT_THREE_BOMB:
	{
		strAniName = "Class1";
		break;
	}
	case SSS_CT_THREE_STRAIGHTFLUSH:
	{
		strAniName = "Class2";
		break;
	}
	case SSS_CT_TWELVE_KING:
	{
		break;
	}
	case SSS_CT_THIRTEEN:
	{
		break;
	}
	case SSS_CT_THIRTEEN_FLUSH:
	{
		break;
	}
	default:
		break;
	}

	if (strAniName.empty())
	{
		return;
	}

	m_pArmaCardTypeNode->setVisible(true);
	ArmatureAnimation* pAniCardTypeNode = m_pArmaCardTypeNode->getAnimation();
	if (pAniCardTypeNode != nullptr)
	{
		pAniCardTypeNode->play(strAniName, -1, 0);
	}
}

//获取头像位置;
const Vec2 SSS_GamePlayer::getHeadPos()
{
	CC_ASSERT(m_pSprHead != nullptr);
	Vec2 pos = m_pSprHead->convertToWorldSpace(Vec2(m_pSprHead->getContentSize().width / 2, m_pSprHead->getContentSize().height / 2));
	return Vec2(pos.x, pos.y);
}

//获取手牌位置;
const Vec2 SSS_GamePlayer::getHandCardPos(uint8 cbRowIndex, uint8 cbColIndex)
{
	int nItemCount = cbRowIndex > 0 ? SSS_MAX_ITEM_COUNT : SSS_MIN_ITEM_COUNT;
	CC_ASSERT(cbRowIndex < SSS_GROUP_COUNT&&cbColIndex < nItemCount);
	if (cbColIndex >= nItemCount)
	{
		return Vec2::ZERO;
	}

	Sprite* sprCard = m_arySpriteCard[cbRowIndex][cbColIndex];
	CC_ASSERT(sprCard!=nullptr);

	return sprCard->getParent()->convertToWorldSpace(sprCard->getPosition());
}

//转换到世界坐标系;
Vec2 SSS_GamePlayer::convertToWorldSpace(const Vec2& nodePoint) const
{
	CC_ASSERT(m_pRootLayout != nullptr);
	return m_pRootLayout->convertToWorldSpace(nodePoint);
}

//增加子节点;
void SSS_GamePlayer::addChild(Node* pNode)
{
	CC_ASSERT(m_pRootLayout != nullptr);
	m_pRootLayout->addChild(pNode);
}

void SSS_GamePlayer::upPlayerState()
{
	//状态发生改变的用户;
	uint8 cbUserStatus = GetUserStatus();

	switch (cbUserStatus)
	{
	case US_SIT:
	{
		break;
	}
	case US_READY:
	{
		setReadyVisible(true);
		setOfflineVisible(false);
		break;
	}
	case US_PLAYING:
	{
		setReadyVisible(false);
		setOfflineVisible(false);
		break;
	}
	case US_OFFLINE:
	{
		setOfflineVisible(true);
		break;
	}
	default:
		break;
	}
}