wnmj/Classes/Games/ZJH/ZJH_GamePlayer.cpp

#include "ZJH_GamePlayer.h"
#include "ImagicDownManager.h"
#include "ActionEx.h"
#include "ZJH_CMD.h"
#include "ZJH_GameLogic.h"
#include "SimpleAudioEngine.h"

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

ZJHGamePlayer::~ZJHGamePlayer()
{

}

bool ZJHGamePlayer::init()
{
	// 已下注精灵;
	m_pSprAllAddChip = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprAllAddChip"));
	CC_ASSERT(m_pSprAllAddChip != nullptr);
	m_pSprAllAddChip->setVisible(false);

	// 已下注文本;
	m_pTxtAllAddChip = static_cast<Text*>(m_pSprAllAddChip->getChildByName("txtNum"));
	CC_ASSERT(m_pTxtAllAddChip != nullptr);

	// 当前下注精灵;
	m_pSprCurAddChip = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprCurAddChip"));
	CC_ASSERT(m_pSprCurAddChip != nullptr);
	m_pSprCurAddChip->setVisible(false);

	// 当前下注文本;
	m_pTxtCurAddChip = static_cast<Text*>(m_pSprCurAddChip->getChildByName("txtNum"));
	CC_ASSERT(m_pTxtCurAddChip != nullptr);

	// 超时精灵;
	m_pSprTimeOut = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprTimeOut"));
	CC_ASSERT(m_pSprTimeOut != nullptr);

	// 时钟节点;
	Node* pNodeTimer = m_pRootLayout->getChildByName("nodeTimer");
	CC_ASSERT(pNodeTimer!=nullptr);
	int nTimerZOrder = pNodeTimer->getLocalZOrder();
	pNodeTimer->removeFromParent();

	Sprite* sprTimerBg = Sprite::create("Games/ZJH/Table/Timer.png");
	CC_ASSERT(sprTimerBg != nullptr);
	//sprTimerBg->setColor(Color3B(0x5a, 0xff, 0));

	// 时钟进度条;
	m_pProgressTimer = ProgressTimer::create(sprTimerBg);
	CC_ASSERT(m_pProgressTimer != nullptr);
	m_pProgressTimer->setType(ProgressTimer::Type::RADIAL);
	m_pProgressTimer->setPosition(m_pSprTimeOut->getPosition());
	m_pProgressTimer->setLocalZOrder(nTimerZOrder);
	m_pProgressTimer->setVisible(false);
	m_pRootLayout->addChild(m_pProgressTimer);

	// 玩家昵称;
	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_pBtnCompareCard = static_cast<Button*>(m_pRootLayout->getChildByName("btnUserCompare"));
	//CC_ASSERT((ZJH_VIEW_SELF_ID == m_cbViewID)&&(m_pBtnCompareCard==nullptr));
	if (m_pBtnCompareCard!=nullptr)
	{
		m_pBtnCompareCard->setVisible(false);
		m_pBtnCompareCard->addClickEventListener(CC_CALLBACK_1(ZJHGamePlayer::onCompareButtonClick, this));
	}

	// 看牌按钮;
	m_pBtnLookCard = static_cast<Button*>(m_pRootLayout->getChildByName("btnLookCard"));
	//CC_ASSERT((ZJH_VIEW_SELF_ID == m_cbViewID) && (m_pBtnLookCard != nullptr));
	if (m_pBtnLookCard != nullptr)
	{
		m_pBtnLookCard->setVisible(false);
	}

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

	//积分;
	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_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_pArmatureCardType = static_cast<Armature*>(m_pRootLayout->getChildByName("armCardType"));
	CC_ASSERT(m_pArmatureCardType != nullptr);
	m_pArmatureCardType->setVisible(false);

	//选择动画;
	m_pArmatureSelect = static_cast<Armature*>(m_pRootLayout->getChildByName("armSelect"));
	//CC_ASSERT((ZJH_VIEW_SELF_ID == m_cbViewID) && (m_pArmatureSelect == nullptr));
	if (m_pArmatureSelect != nullptr)
	{
		m_pArmatureSelect->setVisible(false);
	}

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

	auto panelCard = static_cast<Layout*>(m_pRootLayout->getChildByName("panelHandCard"));
	CC_ASSERT(panelCard != nullptr);

	m_aryPanelHandCard = panelCard;

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

		m_arySpriteCard[i] = sprCard;
	}

	m_sprCardType = static_cast<Sprite*>(m_pRootLayout->getChildByName("sprCardType"));
	//CC_ASSERT((ZJH_VIEW_SELF_ID != m_cbViewID) && (m_sprCardType != nullptr));
	if (m_sprCardType!=nullptr)
	{
		m_sprCardType->setVisible(false);
	}

	m_pTxtOperTip = static_cast<TextBMFont*>(m_pRootLayout->getChildByName("fntOperTip"));
	CC_ASSERT(m_pTxtOperTip != nullptr);
	m_pTxtOperTip->setVisible(false);
	m_ptInitOperTip = m_pTxtOperTip->getPosition();

	//聊天框背景;
	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);

	//比牌选择回调;
	_fnCompareCardSelect = nullptr;

	return true;
}

void ZJHGamePlayer::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 ZJHGamePlayer::PlayerLeave()
{
	if (m_isAllowLeave)
	{
		setInfoVisible(false);
		setReadyVisible(false);
		setOfflineVisible(false);
	}
}

//显示玩家聊天内容;
void ZJHGamePlayer::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 ZJHGamePlayer::showVoiceBubble()
{
	CC_ASSERT(m_pVoiceBubble != nullptr);

	m_pVoiceBubble->setVisible(true);

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

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

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

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

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

	m_pSprAllAddChip->setVisible(false);
	m_pSprCurAddChip->setVisible(false);

	m_pSprTimeOut->setVisible(false);
	m_pProgressTimer->setVisible(false);

	//手牌面板;
	for (int i = 0; i < ZJH_MAX_COUNT; i++)
	{
		m_arySpriteCard[i]->setVisible(false);
	}

	if (m_sprCardType != nullptr)
	{
		m_sprCardType->setVisible(false);
	}

	m_pSprStatus->setVisible(false);

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

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

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

	if (m_pBtnCompareCard != nullptr)
	{
		m_pBtnCompareCard->setVisible(false);
	}

	if (m_pBtnLookCard != nullptr)
	{
		m_pBtnLookCard->setVisible(false);
	}

	memset(m_aryCardData, 0, sizeof(m_aryCardData));
}

//玩家信息可见性;
void ZJHGamePlayer::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 ZJHGamePlayer::setOwner(bool bOwenr)
{
	CC_ASSERT(m_pSprOwner != nullptr);
	m_pSprOwner->setVisible(bOwenr);
}

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

	m_bReady = bVisible;
}

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

//开启时钟;
void ZJHGamePlayer::openClock(float fTime)
{
	auto callFunc = CallFunc::create([this]{
		m_pSprTimeOut->setVisible(true);
		auto actRepeat = RepeatForever::create(Sequence::create(FadeIn::create(1.0f), FadeOut::create(1.0f), nullptr));
		m_pSprTimeOut->runAction(actRepeat);
	});

	auto action = Sequence::create(Show::create(), ProgressTo::create(fTime, 100.f), Hide::create(), callFunc, nullptr);
	m_pProgressTimer->setColor(Color3B(0x5a, 0xff, 0));
	m_pProgressTimer->setPercentage(0.f);
	m_pProgressTimer->runAction(action);
	m_pProgressTimer->runAction(TintTo::create(fTime, 255, 0, 0));
}

//关闭时钟;
void ZJHGamePlayer::closeClock()
{
	m_pSprTimeOut->stopAllActions();
	m_pSprTimeOut->setVisible(false);

	m_pProgressTimer->stopAllActions();
	m_pProgressTimer->setVisible(false);
}

//设置选择比牌按钮状态;
void ZJHGamePlayer::setCompareVisible(bool bVisible)
{
	if (m_pBtnCompareCard == nullptr)
	{
		return;
	}

	m_pBtnCompareCard->setVisible(bVisible);

	ArmatureAnimation* pAniSelect = m_pArmatureSelect->getAnimation();
	if (pAniSelect != nullptr)
	{
		if (bVisible)
		{
			pAniSelect->play("SelectArrow", -1, 1);
		}
		else
		{
			pAniSelect->stop();
		}
	}

	m_pArmatureSelect->setVisible(bVisible);
}

//设置选择比牌按钮点击回调;
void ZJHGamePlayer::setCompareClickCallback(const std::function<void(uint16)>& callback)
{
	_fnCompareCardSelect = callback;
}

//设置选择看牌按钮状态;
void ZJHGamePlayer::setLookCardVisible(bool bVisible)
{
	if (m_pBtnLookCard == nullptr)
	{
		return;
	}

	m_pBtnLookCard->setVisible(bVisible);
}

//设置选择看牌按钮点击回调;
void ZJHGamePlayer::setLookCardClickCallback(const Widget::ccWidgetClickCallback& callback)
{
	if (m_pBtnLookCard != nullptr)
	{
		m_pBtnLookCard->addClickEventListener(callback);
	}
}

//显示背牌;
void ZJHGamePlayer::showBackCard()
{
	//加载牌;
	SpriteFrameCache* pSpriteFrameCache = SpriteFrameCache::getInstance();
	SpriteFrame* pSpriteFrame = pSpriteFrameCache->getSpriteFrameByName("L_0x00.png");
	CC_ASSERT(pSpriteFrame != nullptr);

	for (int i = 0; i < ZJH_MAX_COUNT; i++)
	{
		Sprite* sprCard = m_arySpriteCard[i];
		sprCard->setTag(0);
		sprCard->setSpriteFrame(pSpriteFrame);
		sprCard->setVisible(true);
	}
}

//显示操作提示;
void ZJHGamePlayer::showOperateTip(uint32 dwOper, int nData)
{
	std::string strOper;
	if ((dwOper&ZJH_OPERATE_FOLLOW)>0)
	{
		strOper = StringUtils::format("跟注%d", nData);
	}
	else if ((dwOper&ZJH_OPERATE_ADD_CHIP)>0)
	{
		strOper = StringUtils::format("加注%d", nData);
	}
	else if ((dwOper&ZJH_OPERATE_COMPARE_CARD)>0)
	{
		strOper = StringUtils::format("比牌%d", nData);
	}

	if (!strOper.empty())
	{
		m_pTxtOperTip->setString(utility::a_u8(strOper));

		//移动动画;
		auto moveby = EaseExponentialOut::create(MoveBy::create(1.0f, Vec2(0, 100)));
		m_pTxtOperTip->setPosition(m_ptInitOperTip);
		auto actSeq = Spawn::create(FadeOut::create(0.2f), ScaleTo::create(0.3f, 0.4f), nullptr);
		m_pTxtOperTip->setOpacity(255);
		m_pTxtOperTip->setScale(1.0f);
		m_pTxtOperTip->runAction(Sequence::create(Show::create(), moveby, DelayTime::create(0.8f), actSeq, Hide::create(), nullptr));
	}
}

//显示牌类型;
void ZJHGamePlayer::showCardType(uint8 cbCardType)
{
	ArmatureAnimation* pAniCardType = m_pArmatureCardType->getAnimation();
	if (pAniCardType == nullptr)
	{
		return;
	}

	m_pArmatureCardType->setVisible(true);

	switch (cbCardType)
	{
	case ZJH_CT_ERROR:
	{
		m_pArmatureCardType->setVisible(false);
		break;
	}
	case ZJH_CT_SINGLE:
	{
		pAniCardType->play("PokerType6");
		break;
	}
	case ZJH_CT_DOUBLE:
	{
		pAniCardType->play("PokerType5");
		break;
	}
	case ZJH_CT_SHUN_ZI:
	{
		pAniCardType->play("PokerType4");
		break;
	}
	case ZJH_CT_JIN_HUA:
	{
		pAniCardType->play("PokerType3");
		break;
	}
	case ZJH_CT_SHUN_JIN:
	{
		pAniCardType->play("PokerType2");
		break;
	}
	case ZJH_CT_BAO_ZI:
	{
		pAniCardType->play("PokerType1");
		break;
	}
	case ZJH_CT_SPECIAL:
	{
		pAniCardType->play("PokerType7");
		break;
	}
	default:
		break;
	}
}

//显示牌类型;
void ZJHGamePlayer::showCardTypeEx(uint8 cbCardType)
{
	if (nullptr==m_sprCardType)
	{
		return;
	}

	switch (cbCardType)
	{
	case ZJH_CT_ERROR:
	{
		m_sprCardType->setVisible(false);
		break;
	}
	case ZJH_CT_SINGLE:
	{
		m_sprCardType->setTexture("Games/ZJH/CardType/GaoPai.png");
		break;
	}
	case ZJH_CT_DOUBLE:
	{
		m_sprCardType->setTexture("Games/ZJH/CardType/DuiZi.png");
		break;
	}
	case ZJH_CT_SHUN_ZI:
	{
		m_sprCardType->setTexture("Games/ZJH/CardType/ShunZi.png");
		break;
	}
	case ZJH_CT_JIN_HUA:
	{
		m_sprCardType->setTexture("Games/ZJH/CardType/JinHua.png");
		break;
	}
	case ZJH_CT_SHUN_JIN:
	{
		m_sprCardType->setTexture("Games/ZJH/CardType/ShunJin.png");
		break;
	}
	case ZJH_CT_BAO_ZI:
	{
		m_sprCardType->setTexture("Games/ZJH/CardType/Baozi.png");
		break;
	}
	case ZJH_CT_SPECIAL:
	{
		m_sprCardType->setTexture("Games/ZJH/CardType/235.png");
		break;
	}
	default:
		break;
	}

	if (cbCardType>ZJH_CT_ERROR)
	{
		m_sprCardType->runAction(Sequence::create(DelayTime::create(0.5f), Show::create(), nullptr));
	}
}

//隐藏牌类型;
void ZJHGamePlayer::hideCardTypeEx()
{
	if (m_sprCardType != nullptr)
	{
		m_sprCardType->setVisible(false);
	}
}

//增加牌;
void ZJHGamePlayer::addOneCard(uint8 cbData, uint8 cbIndex)
{
	CC_ASSERT(cbIndex<ZJH_MAX_COUNT);
	if (cbIndex >= ZJH_MAX_COUNT)
	{
		return;
	}

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

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

	sprCard->setTag(cbData);
	sprCard->setSpriteFrame(pSpriteFrame);
	sprCard->setVisible(true);
}

//设置总下注;
void ZJHGamePlayer::setAllChip(SCORE lChip)
{
	m_pSprAllAddChip->setVisible(true);
	m_pTxtAllAddChip->setString(StringUtils::format("%d", lChip));
}

//设置加注;
void ZJHGamePlayer::setAddChip(SCORE lChip)
{
	m_pSprCurAddChip->setVisible(true);
	m_pTxtCurAddChip->setString(StringUtils::format("%d", lChip));
}

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

//显示牌;
void ZJHGamePlayer::showCard(uint8 aryCardData[ZJH_MAX_COUNT])
{
	SpriteFrameCache* pSpriteFrameCache = SpriteFrameCache::getInstance();

	for (uint8 i = 0; i < ZJH_MAX_COUNT; i++)
	{
		// 有牌值则跳过;
		if (m_arySpriteCard[i]->getTag()>0)
		{
			continue;
		}

		m_arySpriteCard[i]->setTag(aryCardData[i]);
		m_arySpriteCard[i]->setVisible(true);

		CallFuncN* callback = CallFuncN::create([=](Node* pNode){
			Sprite* pCardSprite = static_cast<Sprite*>(pNode);

			//加载牌;
			std::string strName = StringUtils::format("L_0x%02X.png", pCardSprite->getTag());
			SpriteFrame* pSpriteFrame = pSpriteFrameCache->getSpriteFrameByName(strName);
			CC_ASSERT(pSpriteFrame != nullptr);
			pCardSprite->setSpriteFrame(pSpriteFrame);
		});

		Action* pAction = Sequence::create(OrbitCamera::create(0.25f, 1, 0, 0, 90, 0, 0), callback, OrbitCamera::create(0.25f, 1, 0, 270, 90, 0, 0), nullptr);
		m_arySpriteCard[i]->runAction(pAction);
	}
}

void ZJHGamePlayer::showHandStatus(uint8 cbHandStatus)
{
	m_pSprStatus->setVisible(true);
	if (ZJH_ST_GAMING_LOOK == cbHandStatus)
	{
		m_pSprStatus->setTexture("Games/ZJH/Table/imgLookCard.png");
	}
	else if (ZJH_ST_GAMING_LOSE == cbHandStatus)
	{
		m_pSprStatus->setTexture("Games/ZJH/Table/imgCompLoser.png");
	}
	else if (ZJH_ST_GAMING_GIVEUP == cbHandStatus)
	{
		m_pSprStatus->setTexture("Games/ZJH/Table/imgGiveUp.png");
	}
    else
	{
		m_pSprStatus->setVisible(false);
	}
}

//隐藏手牌状态;
void ZJHGamePlayer::hideHandStatus()
{
	m_pSprStatus->setVisible(false);
}

//获取头像位置;
const Vec2 ZJHGamePlayer::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 ZJHGamePlayer::getHandCardPos(uint8 cbIndex)
{
	CC_ASSERT(cbIndex<ZJH_MAX_COUNT);
	if (cbIndex >= ZJH_MAX_COUNT)
	{
		cbIndex = 0;
	}

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

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

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

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

void ZJHGamePlayer::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;
	}
}

//点击比牌按钮;
void ZJHGamePlayer::onCompareButtonClick(Ref* pSender)
{
	if (_fnCompareCardSelect != nullptr)
	{
		_fnCompareCardSelect(GetChairID());
	}
}