3638 lines
97 KiB
C++
3638 lines
97 KiB
C++
#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;
|
||
} |