/**
* 同意用户离开
* @param bDeskStation 玩家ID
* @param pNetHead 参数基类
* @param pData 网络数据包
* @param uSize 数据包大小
* @param uSocketID 参数基类
* @param bWatchUser 是否旁观
*/
bool CServerGameDesk::H048_ArgeeStopThing(BYTE bDeskStation, NetMessageHead * pNetHead, void * pData, UINT uSize, UINT uSocketID, bool bWatchUser)
{
if(bWatchUser)
return false;
StopResultStruct * pStop=(StopResultStruct *)pData;
if(pStop->bArgee==1)
{
//同意
StopResultStruct stop;
stop.bArgee=true;
SendGameData((bDeskStation+2)%4,&stop,sizeof(stop),MDM_GM_GAME_NOTIFY,ASS_AGREE_STOP,0);
MessageStruct Mess;
memset(&Mess,0,sizeof(Mess));
lstrcpy(Mess.Message,"敌家经过商量，提前结束了本局！");
SendGameData((bDeskStation+1)%4,&Mess,sizeof(Mess),MDM_GM_GAME_NOTIFY,ASS_MESSAGE,0);
SendGameData((bDeskStation+3)%4,&Mess,sizeof(Mess),MDM_GM_GAME_NOTIFY,ASS_MESSAGE,0);
memset(&Mess,0,sizeof(Mess));
lstrcpy(Mess.Message,"拣分的双方经过商量，提前结束了本局！");
SendWatchData(m_bMaxPeople,&Mess,sizeof(Mess),MDM_GM_GAME_NOTIFY,ASS_MESSAGE,0);
//结束游戏
if (m_bGameStation==GS_PLAY_GAME)
GameFinish(bDeskStation, GF_PREEND);//提前结束
}
else
{
StopResultStruct stop;
stop.bArgee=false;
SendGameData((bDeskStation+2)%4,&stop,sizeof(stop),MDM_GM_GAME_NOTIFY,ASS_AGREE_STOP,0);
}
return true;
}
/**
* 同意用户离开
* @param bDeskStation 玩家ID
* @param pNetHead 参数基类
* @param pData 网络数据包
* @param uSize 数据包大小
* @param uSocketID 参数基类
* @param bWatchUser 是否旁观
*/
bool CServerGameDesk::H0011_UserBuZhen(BYTE bDeskStation, NetMessageHead * pNetHead, void * pData, UINT uSize, UINT uSocketID, bool bWatchUser)
{
///if(bWatchUser) return true;
tagBuZhen * bz=(tagBuZhen *)pData;
m_Logic.UserBuZhen (*bz);
m_bBuzhen[bDeskStation]=true;
for (int i=0;i<4;i++) SendGameData(i,bz,sizeof(*bz),MDM_GM_GAME_NOTIFY,ASS_BUZHEN,0);
SendWatchData(m_bMaxPeople,bz,sizeof(*bz),MDM_GM_GAME_NOTIFY,ASS_BUZHEN,0);
if(m_Logic.GetBuzhenCount() >= GetPlayerCount()&&GS_BUZHEN==m_bGameStation)
{
m_bGameStation=GS_PLAY_GAME;
//发送开始消息
tagNextStep s;
s.station=m_Logic.m_iNowOutPeople;
for (int i=0;i<4;i++) SendGameData(i,&s,sizeof(s),MDM_GM_GAME_NOTIFY,ASS_NEXT_STEP,0);
SendWatchData(m_bMaxPeople,&s,sizeof(s),MDM_GM_GAME_NOTIFY,ASS_NEXT_STEP,0);
KillTimer(TIME_USER_OUT_CARD) ;
m_iTimerCount = m_iLessCount + 3 ;
SetTimer(TIME_USER_OUT_CARD ,1000) ;
}
return true;
}
//发送准备或退出消息
void CClientGameDlg::ReadyOrQuit(bool bReadyOrQuit)
{
TGetReady tGetReady; //准备消息包
tGetReady.byDeskStation = m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation;
if(bReadyOrQuit)
SendGameData(&tGetReady,sizeof(tGetReady),MDM_GM_GAME_NOTIFY,ASS_GETREADY,0);
else
SendGameData(&tGetReady,sizeof(tGetReady),MDM_GM_GAME_NOTIFY,ASS_QUIT,0);
}
//================================================================================
// 功能 : 发送簸簸数据
//================================================================================
void CClientGameDlg::SendBoboData()
{
tSetBoboStruct tSetBobo;
tSetBobo.i64BoboMoney = m_i64TempBobo;
tSetBobo.byMyDesk = m_iMyLogDesk;
SendGameData(&tSetBobo,sizeof(tSetBobo),MDM_GM_GAME_NOTIFY,ASS_SET_BOBO_DATA,0);
}
/**
* 同意用户离开
* @param bDeskStation 玩家ID
* @param pNetHead 参数基类
* @param pData 网络数据包
* @param uSize 数据包大小
* @param uSocketID 参数基类
* @param bWatchUser 是否旁观
*/
bool CServerGameDesk::H046_StopThing(BYTE bDeskStation, NetMessageHead * pNetHead, void * pData, UINT uSize, UINT uSocketID, bool bWatchUser)
{
if(bWatchUser)
return false;
SendGameData((bDeskStation+2)%4,MDM_GM_GAME_NOTIFY,ASS_STOP_THING,0);
return true;
}
//========================================================================================
// 功能 : 发送分牌消息
//========================================================================================
void CClientGameDlg::SendSeparatorCardData()
{
if(m_byUserOperatorType[m_iMyLogDesk] == TYPE_GIVE_UP)
return ;
if(m_Logic.IsThreeTenOrThreThreeSixe(m_iUserCard[m_iMyLogDesk],0x04) != 0x00)
{
srand(GetTickCount()+m_iMyLogDesk);
int iRand = rand()%100;
if(iRand > 90)
{
Bnt_Give_Up();
return ;
}
}
T_CS_SeparatCard tSeparatCard;
tSeparatCard.byDeskStation = m_iMyLogDesk;
tSeparatCard.byLeftCardShap = m_Logic.GetCardShape(&m_bySeparatorCard[0],0x02);
tSeparatCard.byRightCardShap = m_Logic.GetCardShape(&m_bySeparatorCard[2],0x02);
tSeparatCard.bySeparatCard[0] = m_bySeparatorCard[0];
tSeparatCard.bySeparatCard[1] = m_bySeparatorCard[1];
tSeparatCard.bySeparatCard[2] = m_bySeparatorCard[2];
tSeparatCard.bySeparatCard[3] = m_bySeparatorCard[3];
SendGameData(&tSeparatCard,sizeof(tSeparatCard),MDM_GM_GAME_NOTIFY,ASS_CS_SEPARAT_CARD,0);
}
//========================================================================================
//敲操作(全疯了下注操作)
//========================================================================================
void CClientGameDlg::Bnt_Set_All()
{
tagUserProcess tUserProcess;
tUserProcess.iVrebType = TYPE_ALL_NOTE;
tUserProcess.iNote = m_i64Bobo[m_iMyLogDesk];
SendGameData(&tUserProcess,sizeof(tUserProcess),MDM_GM_GAME_NOTIFY,ASS_VREB_CHECK,0);
}
// 控件开始按钮被点击
bool CClientGameDlg::OnControlHitBegin()
{
if ((GetStationParameter()==GS_WAIT_SETGAME||GetStationParameter()==GS_WAIT_NEXT||GetStationParameter()==GS_WAIT_AGREE))
{
SendGameData(MDM_GM_GAME_NOTIFY,ASS_GM_AGREE_GAME,0);
}
ResetGameStation(RS_GAME_BEGIN);
KillAllTimer();
return true;
}
//定时器消息
bool CClientGameDlg::OnGameTimer(BYTE bDeskStation, UINT uTimeID, UINT uTimeCount)
{
switch (uTimeID)
{
case TIMER_GETREADY:
{
KillTimer(TIMER_GETREADY);
ReadyOrQuit(true);
SendGameData(MDM_GM_GAME_NOTIFY,ASS_GM_AGREE_GAME,0);
}
break;
case TIMER_CALLLEVELCARD:
{
OutputDebugString("chs 叫主完成");
KillTimer(TIMER_CALLLEVELCARD);
SendGameData(NULL,0,MDM_GM_GAME_NOTIFY,ASS_CALL_COMPLETED,0);
}
break;
case TIMER_BURYBACKCARD:
#pragma region 埋牌
{
KillTimer(TIMER_BURYBACKCARD);
//从玩家手中选8张牌，埋牌
TSendCards tSendCards;
tSendCards.byCardCount = 8;
tSendCards.byDeskStation = m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation;
memcpy(tSendCards.byCards,&m_byCards[25],sizeof(BYTE)*8);
memset(m_byBackCard,0,sizeof(m_byBackCard));
memcpy(m_byBackCard,&m_byCards[25],sizeof(BYTE)*8);
SendGameData(&tSendCards,sizeof(TSendCards),MDM_GM_GAME_NOTIFY,ASS_BURYCARD,0);
}
break;
#pragma endregion 埋牌
case TIMER_OUTCARD:
{
KillTimer(TIMER_OUTCARD);
OutTimeAutoOutCard();
}
break;
}
return true;
}
///用户设置托管
///@param BYTE bDeskStation [in] 设置托管的玩家
///@param AutoCardStruct *bAuto [in] 托管信息结构
///@return 函数返回true
BOOL CServerGameDesk::UserAuto(BYTE bDeskStation,AutoCardStruct *bAuto)
{
m_bIsAuto[bDeskStation] = bAuto->bAutoCard;
bAuto->bDeskStation=bDeskStation;
for(int i=0;i<m_bMaxPeople;i++)
{
SendGameData(i,bAuto,sizeof(AutoCardStruct),MDM_GM_GAME_NOTIFY,ASS_AUTO,0);
}
SendWatchData(m_bMaxPeople,bAuto,sizeof(AutoCardStruct),MDM_GM_GAME_NOTIFY,ASS_AUTO,0);
return TRUE;
}
/**
* 游戏开始
*/
bool CServerGameDesk::H001_GameBegin(BYTE bBeginFlag)
{
if (__super::GameBegin(bBeginFlag)==false)
return false;
//设置状态
m_bQueryQuit=false;
m_iBeenPlayGame++;
m_bGameStation=GS_BUZHEN;
//发送开始消息
BeginGameStruct BeginMessage;
BeginMessage.iPlayCount=m_iBeenPlayGame;
for (int i=0;i<4;i++) SendGameData(i,&BeginMessage,sizeof(BeginMessage),MDM_GM_GAME_NOTIFY,ASS_BEGIN_UPGRADE,0);
SendWatchData(m_bMaxPeople,&BeginMessage,sizeof(BeginMessage),MDM_GM_GAME_NOTIFY,ASS_BEGIN_UPGRADE,0);
return TRUE;
}
//时间到，自动出牌
void CClientGameDlg::OutTimeAutoOutCard()
{
T_CS_OutCard tCSOutCard;
if(m_isFirstOutCard)
{
#pragma region 单圈首家出牌
//TODO： 选最小的单牌出牌
tCSOutCard.byCardNums = 1;
tCSOutCard.byDeskStation = m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation;
tCSOutCard.isFirst = true;
tCSOutCard.byCards[0] = m_vbyCards.back();
tCSOutCard.cardShape = E_CS_SINGLE;
#pragma endregion 单圈首家出牌
}
else
{
#pragma region 单圈非首家出牌
//跟着庄家出牌
tCSOutCard.byCardNums = m_tFirstPlayerCard.byCardNums;
tCSOutCard.byDeskStation = m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation;
tCSOutCard.isFirst = false;
BYTE* pbyCards = new BYTE[tCSOutCard.byCardNums];
int icardcount = 0;
FindCardsCompatibleWithFirst(m_tFirstPlayerCard,pbyCards,&icardcount);
CString cs;
cs.Format("chs tCSOutCard.byCardNums:%d , icardcount:%d",tCSOutCard.byCardNums,icardcount);
OutputDebugString(cs);
ASSERT( tCSOutCard.byCardNums == icardcount);
memcpy(tCSOutCard.byCards,pbyCards,sizeof(BYTE)*icardcount);
delete[] pbyCards;
m_cLogic.GetOutCardShape(tCSOutCard.byCards,tCSOutCard.byCardNums,tCSOutCard, m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation,m_byGameLevel[0],false);
#pragma endregion 单圈非首家出牌
}
for (int i = 0;i<tCSOutCard.byCardNums;++i)
{
CString cs;
cs.Format("chs 自动出牌：Card%d : %d",i,tCSOutCard.byCards[i]);
OutputDebugString(cs);
}
SendGameData(&tCSOutCard,sizeof(T_CS_OutCard),MDM_GM_GAME_NOTIFY,ASS_OUT_CARD,0);
memcpy(&m_tCurrentOutCard,&tCSOutCard,sizeof(T_CS_OutCard));
}
//========================================================================================
//跟操作
//========================================================================================
void CClientGameDlg::Bnt_Follow()
{
tagUserProcess tUserProcess;
if(m_i64FrontNote < m_i64Bobo[m_iMyLogDesk])
{
tUserProcess.iVrebType = TYPE_FOLLOW;
tUserProcess.iNote = m_i64FrontNote;
}
else
{
tUserProcess.iVrebType = TYPE_ALL_NOTE;
tUserProcess.iNote = m_i64Bobo[m_iMyLogDesk];
}
SendGameData(&tUserProcess,sizeof(tUserProcess),MDM_GM_GAME_NOTIFY,ASS_VREB_CHECK,0);
}
void CClientGameDlg::OnCancel()
{
//查询状态
if (! CanLeftDesk())
{
return;
}
KillAllTimer();
AFCCloseFrame();
SendGameData(MDM_GR_USER_ACTION,ASS_GR_USER_UP,0); //发送起立消息
__super::OnCancel();
}
bool CServerGameDesk::H021_UserPass(BYTE bDeskStation, NetMessageHead * pNetHead, void * pData, UINT uSize, UINT uSocketID, bool bWatchUser)
{
//发送开始消息
m_Logic.m_iNowOutPeople=m_Logic.GetNextStation (bDeskStation);
tagNextStep s;
s.station=m_Logic.m_iNowOutPeople;
for (int i=0;i<4;i++) SendGameData(i,&s,sizeof(s),MDM_GM_GAME_NOTIFY,ASS_NEXT_STEP,0);
SendWatchData(m_bMaxPeople,&s,sizeof(s),MDM_GM_GAME_NOTIFY,ASS_NEXT_STEP,0);
KillTimer(TIME_USER_OUT_CARD) ;
m_iTimerCount = m_iLessCount + 3 ;
SetTimer(TIME_USER_OUT_CARD ,1000) ;
return true;
}
//用户处理结果
LRESULT CClientGameDlg::OnHitActiveResult(WPARAM wparam, LPARAM lparam)
{
if (GetStationParameter() == GS_PLAY_GAME)
{
if (m_iNowOutPeople != GetMeUserInfo()->bDeskStation)
return 0L;
KillAllTimer();
int ret = (int) wparam;
tagUserProcess process;
process.iVrebType = ret; // 下注类型
process.iNote =(__int64)lparam; // 下注数(只有下注和加注才设置此值)
SendGameData(&process,sizeof(process),MDM_GM_GAME_NOTIFY,ASS_VREB_CHECK,0);
}
return 0L;
}
/**
* 用户请求离开
* @param bDeskStation 请求玩家ID
* @param szMessage 请求消息内容
*/
BOOL CServerGameDesk::H041_UserHaveThing(BYTE bDeskStation, char * szMessage)
{
if (m_bGameStation<GS_BUZHEN) return TRUE;
m_bdesk=bDeskStation;
m_iLeaveArgee|=1<<bDeskStation;
if (m_iLeaveArgee!=15)
{
HaveThingStruct HaveThing;
HaveThing.pos=bDeskStation;
::CopyMemory(HaveThing.szMessage,szMessage,60*sizeof(char));
for (int i=0;i<m_bMaxPeople;i++)
if (i!=bDeskStation) SendGameData(i,&HaveThing,sizeof(HaveThing),MDM_GM_GAME_NOTIFY,ASS_HAVE_THING,0);
}
else GameFinish(bDeskStation,GF_SALE);
return TRUE;
}
///处理超端消息
///@param BYTE bDeskStation [in] 设置超端的玩家
///@param SuperStruct *pSuper [in] 超端信息结构
///@return 函数返回true
BOOL CServerGameDesk::HandleSuperInfo(BYTE bDeskStation,SuperStruct *pSuper)
{
if (!m_bIsSuper[bDeskStation] || m_bGameStation == GS_SEND_CARD)//已经不是超端玩家 设置无效 || 已经发牌了
{
pSuper->bDeskStation = 255;
pSuper->bSuperTag = 0;
}
else
{
m_bSuperSet = true;
m_iSuperSet[0] = pSuper->bDeskStation;
m_iSuperSet[1] = pSuper->bSuperTag;
}
SendGameData(bDeskStation,pSuper,sizeof(SuperStruct),MDM_GM_GAME_NOTIFY,ASS_SUPER,0);
return TRUE;
}
/**
* 同意用户离开
* @param bDeskStation 玩家ID
* @param bArgee 是否同意
*/
BOOL CServerGameDesk::H044_ArgeeUserLeft(BYTE bDeskStation, BOOL bArgee)
{
if (bArgee) m_iLeaveArgee|=1<<bDeskStation;
else //m_iLeaveArgee&=~1<<bDeskStation;
{
m_iLeaveArgee = 0;
}
if (m_iLeaveArgee!=15)
{
m_bQueryQuit=true;
LeaveResultStruct Leave;
Leave.bDeskStation=bDeskStation;
Leave.bArgeeLeave=bArgee;
for (int i=0;i<m_bMaxPeople;i++)
if (i!=bDeskStation) SendGameData(i,&Leave,sizeof(Leave),MDM_GM_GAME_NOTIFY,ASS_LEFT_RESULT,0);
}
else GameFinish(m_bdesk,GF_SALE);
return TRUE;
}
//用户选择下注数
LRESULT CClientGameDlg::OnSelectNote(WPARAM wparam,LPARAM lparam)
{
int ret = (int)wparam;
switch(ret)
{
case 1://最大
{
tagUserProcess process;
memset(&process,NULL,sizeof(process));
//下注数(只有下注和加注才设置此值) 因为改为__int64后lparam无法容纳而修改 xyh:20110729
switch((int)lparam)
{
case 0: //第一个下注按钮
{
process.iNote = 4*m_iBaseNote + GetMaxNote(m_iThisTurnNote);
break;
}
case 1: //第二个下注按钮
{
process.iNote = 2*m_iBaseNote + GetMaxNote(m_iThisTurnNote);
break;
}
case 2: //第三个下注按钮
{
process.iNote = 1*m_iBaseNote + GetMaxNote(m_iThisTurnNote);
break;
}
default:
break;
}
process.iVrebType = (m_iNowBigNote == 0)?TYPE_NOTE:TYPE_ADD;//下注类型
SendGameData(&process,sizeof(process),MDM_GM_GAME_NOTIFY,ASS_VREB_CHECK,0);
}
default:
break;
}
return TRUE;
}
/**
* 游戏开始
*/
BOOL CServerGameDesk::BeginPlayUpGrade()
{
//设置数据
m_bGameStation=GS_PLAY_GAME;
// m_iBaseOutCount=0;
// m_Logic.m_iOutCardPeople=m_Logic.m_iUpGradePeople;
// m_iFirstOutPeople=m_Logic.m_iUpGradePeople;
// m_iGamePoint=0;
// ::memset(m_iDeskCardCount,0,sizeof(m_iDeskCardCount));
//排列扑克
///for (int i=0;i<4;i++) m_Logic.SortCard(m_iUserCard[i],NULL,m_iUserCardCount[i]);
//发送游戏开始消息
BeginPlayStruct Begin;
// Begin.iOutDeskStation=m_Logic.m_iOutCardPeople;
for (int i=0;i<m_bMaxPeople;i++) SendGameData(i,&Begin,sizeof(Begin),MDM_GM_GAME_NOTIFY,ASS_GAME_PLAY,0);
SendWatchData(m_bMaxPeople,&Begin,sizeof(Begin),MDM_GM_GAME_NOTIFY,ASS_GAME_PLAY,0);
return TRUE;
}
//========================================================================================
//大操作(加注操作)
//========================================================================================
void CClientGameDlg::Bnt_Big()
{
m_i64MyAddNote = m_i64FrontNote;
if(m_i64FrontNote > m_i64Bobo[m_iMyLogDesk])
{
m_i64MyAddNote = m_i64Bobo[m_iMyLogDesk];
}
else
{
__int64 iTempMoney = 0x00;
iTempMoney = m_i64Bobo[m_iMyLogDesk] - m_i64MyAddNote;
int itemp =rand()%3;
m_i64MyAddNote +=((iTempMoney * (itemp + 1))/4);
}
tagUserProcess tUserProcess;
tUserProcess.iVrebType = TYPE_ADD;
tUserProcess.iNote = m_i64MyAddNote;
SendGameData(&tUserProcess,sizeof(tUserProcess),MDM_GM_GAME_NOTIFY,ASS_VREB_CHECK,0);
}
//框架消息处理函数
bool CServerGameDesk::HandleFrameMessage(BYTE bDeskStation, NetMessageHead * pNetHead, void * pData, UINT uSize, UINT uSocketID, bool bWatchUser)
{
DebugPrintf("接收到框架消息 位置=【%d】 ID=【%d】",bDeskStation,pNetHead->bAssistantID);
switch(pNetHead->bAssistantID)
{
case ASS_GM_FORCE_QUIT: //强行退出//安全退出
{
char cKey[10];
CString sPath=CBcfFile::GetAppPath();
int iResult = 1;
if (CBcfFile::IsFileExist(sPath + "SpecialRule.bcf"))
{
CBcfFile fsr( sPath + "SpecialRule.bcf");
sprintf(cKey, "%d", NAME_ID);
iResult = fsr.GetKeyVal (_T("ForceQuitAsAuto"), cKey, 0);
}
if(iResult == 0)
{
UserQuitStruct s_UserQuit;
s_UserQuit.bDeskStation = bDeskStation;
for(int i = 0; i < PLAY_COUNT; ++i)
{
if(i != bDeskStation);
{
SendGameData(i,&s_UserQuit,sizeof(UserQuitStruct),MDM_GM_GAME_NOTIFY,ASS_USER_QUIT_GAME,0);
}
}
SendWatchData(m_bMaxPeople,&s_UserQuit,sizeof(UserQuitStruct),MDM_GM_GAME_NOTIFY,ASS_USER_QUIT_GAME,0);
return __super::HandleFrameMessage( bDeskStation, pNetHead, pData, uSize, uSocketID, bWatchUser);
}
return true;
}
}
return __super::HandleFrameMessage( bDeskStation, pNetHead, pData, uSize, uSocketID, bWatchUser);
}
//--------------------------------------------------------------------------------
//处理玩家摊牌动作;
void CServerGameDesk::HandTanPaiAction(BYTE byDStation,BYTE byDownCard[])
{
//安全判断
if(!m_bIsInGame[byDStation] || NULL == byDownCard || m_bHaveBaiPai[byDStation] || m_bGameStation != GS_PLAY_GAME)
{
return;
}
::CopyMemory(m_bBullCard[byDStation],byDownCard,sizeof(BYTE)*USER_HAND_CARD); //摆牌数据
m_byCardShape[byDStation] = m_Logic.GetShape(m_byUCard[byDStation],m_iUCCount[byDStation],byDownCard);
TanPaiStruct tanpai;
tanpai.byStaiton = byDStation;
tanpai.byShape = m_byCardShape[byDStation];
if(m_bWatchOther[byDStation])
{
::CopyMemory(tanpai.byDownCard,m_bBullCard[byDStation],sizeof(m_bBullCard[byDStation]));
}
for (int i = 0; i < PLAY_COUNT; ++i)
{
if(m_pUserInfo[i])
{
SendGameData(i,&tanpai,sizeof(tanpai),MDM_GM_GAME_NOTIFY,ASS_TAN_PAI,0);
}
}
SendWatchData(m_bMaxPeople,&tanpai,sizeof(tanpai),MDM_GM_GAME_NOTIFY,ASS_TAN_PAI,0);
m_bHaveBaiPai[byDStation] = true;
//检测是否所有人都已摊牌
if(CheckTanPaiFinish())
{
GameFinish(byDStation,GF_NORMAL);
}
}
/**
* 用户设置游戏
*/
BOOL CServerGameDesk::UserSetGame(UserArgeeGame * pGameSet)
{
//效验数据
if (m_bGameStation!=GS_WAIT_SETGAME) return FALSE;
//效验数据
if (((pGameSet->iPlayCount<=0)||(pGameSet->iPlayCount>99)))
return FALSE;
//设置数据
m_iLessCount=pGameSet->iPlayCount;
// m_iPlayCardCount=1;//(pGameSet->iCardCount&1)?1:2;//2:3;
m_iBeenPlayGame=0;
m_bGameStation=GS_WAIT_ARGEE;
//发送消息
UserArgeeGame Agree;
Agree.iPlayCount=m_iLessCount;
// Agree.iCardCount=m_iPlayCardCount;
for (int i=0;i<4;i++) SendGameData(i,&Agree,sizeof(Agree),MDM_GM_GAME_NOTIFY,ASS_UG_USER_SET,0);
SendWatchData(m_bMaxPeople,&Agree,sizeof(Agree),MDM_GM_GAME_NOTIFY,ASS_UG_USER_SET,0);
return TRUE;
}
//========================================================================================
//丢操作(放弃操作)
//========================================================================================
void CClientGameDlg::Bnt_Give_Up()
{
tagUserProcess tUserProcess;
tUserProcess.iVrebType = TYPE_GIVE_UP;
SendGameData(&tUserProcess,sizeof(tUserProcess),MDM_GM_GAME_NOTIFY,ASS_VREB_CHECK,0);
}
/**
* 获取游戏状态信息
*/
bool CServerGameDesk::OnGetGameStation(BYTE bDeskStation, UINT uSocketID, bool bWatchUser)
{
switch (m_bGameStation)
{
case GS_WAIT_SETGAME: //游戏没有开始状态
{
GameStation_1 GameStation;
::memset(&GameStation,0,sizeof(GameStation));
GameStation.iMainVersion=MAIN_VERSION;
GameStation.iLessVersion=ASS_VERSION;
GameStation.uRunPublish=m_pDataManage->m_InitData.uRunPublish;
GameStation.basepoint=m_pDataManage->m_InitData.uBasePoint;
//发送数据
SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,sizeof(GameStation));
MessageStruct Mess;
ZeroMemory(Mess.Message,200);
lstrcpy(Mess.Message,"欢迎您参加四国军棋游戏，祝您玩得开心！");
SendGameData(bDeskStation,&Mess,sizeof(Mess),MDM_GM_GAME_NOTIFY,ASS_MESSAGE,0);
return TRUE;
}
case GS_WAIT_ARGEE: //等待玩家开始状态
{
GameStation_2 GameStation;
::memset(&GameStation,0,sizeof(GameStation));
GameStation.iPlayCount=m_iLessCount;
GameStation.iMainVersion=MAIN_VERSION;
GameStation.iLessVersion=ASS_VERSION;
GameStation.uRunPublish=m_pDataManage->m_InitData.uRunPublish;
GameStation.basepoint=m_pDataManage->m_InitData.uBasePoint;
for(int i=0;i<MAX_I;i++)
for(int j=0;j<MAX_J;j++)
GameStation.mBoard[i][j]=m_Logic.mBoard[i][j];
//发送数据
SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,sizeof(GameStation));
return TRUE;
}
case GS_BUZHEN: //发牌状态(还未发牌)
case GS_PLAY_GAME: //游戏中状态
{
GameStation_3 GameStation;
::memset(&GameStation,0,sizeof(GameStation));
GameStation.iPlayCount=m_iLessCount;
GameStation.iTimerCount = m_iTimerCount ;
GameStation.iPunishPoint=m_PunishPoint[bDeskStation];
GameStation.iBeenPlayGame=m_iBeenPlayGame;
GameStation.m_iNowOutPeople=m_Logic.m_iNowOutPeople;
GameStation.m_iStartI=m_Logic.m_iStartI;
GameStation.m_iStartJ=m_Logic.m_iStartJ;
GameStation.m_iEndI=m_Logic.m_iEndI;
GameStation.m_iEndJ=m_Logic.m_iEndJ;
GameStation.uRunPublish=m_pDataManage->m_InitData.uRunPublish;
GameStation.basepoint=m_pDataManage->m_InitData.uBasePoint;
for(int i=0;i<MAX_I;i++)
for(int j=0;j<MAX_J;j++)
GameStation.mBoard[i][j]=m_Logic.mBoard[i][j];
int iSendSize=sizeof(GameStation);
SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,iSendSize);
return TRUE;
}
case GS_WAIT_NEXT: //等待下一盘游戏开始
{
GameStation_5 GameStation;
::memset(&GameStation,0,sizeof(GameStation));
GameStation.iPlayCount=m_iLessCount;
GameStation.iPunishPoint=m_PunishPoint[bDeskStation];
GameStation.iBeenPlayGame=m_iBeenPlayGame;
GameStation.uRunPublish=m_pDataManage->m_InitData.uRunPublish;
GameStation.basepoint=m_pDataManage->m_InitData.uBasePoint;
//发送数据
SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,sizeof(GameStation));
return TRUE;
}
}
return false;
}
/**
* 游戏结束
* @param bDeskStation 玩家ID
* @param bCloseFlag 结束类型
*/
bool CServerGameDesk::GameFinish(BYTE bDeskStation, BYTE bCloseFlag)
{
KillTimer(TIME_USER_OUT_CARD) ;
//得到最小数的金币
long m_dwMaxPoint=0;
bool bSetMaxMoney=false;
/*for (BYTE i=0;i<m_bMaxPeople;i++)
{
if (m_pUserInfo[i]!=NULL)
{
if (bSetMaxMoney==false)
{
bSetMaxMoney=true;
m_dwMaxPoint=(long int)m_pUserInfo[i]->m_UserData.dwPoint-1;
}
else
m_dwMaxPoint=__min(m_dwMaxPoint,(long int)m_pUserInfo[i]->m_UserData.dwPoint-1);
}
}
if(m_pDataManage->m_InitData.uComType!=TY_NORMAL_GAME && m_dwMaxPoint<0)
{
TRACE("出现错误，四国军棋金币或比赛游戏中，玩家的金币数为负数．");
return false;
}*/
//编写代码
switch (bCloseFlag)
{
case GF_PREEND: //提前结束
case GF_NORMAL: //游戏正常结束
{
int iBasePoint=m_pDataManage->m_InitData.uBasePoint;//倍数
//计算得分
//游戏结束
GameEndStruct GameEnd;
::memset(&GameEnd,0,sizeof(GameEnd));
m_Logic.CountFen(GameEnd.iTurePoint);
if (GF_PREEND == bCloseFlag)//提前结束
{
GameEnd.iTurePoint[bDeskStation] = GameEnd.iTurePoint[(bDeskStation+2)%4] = -2;//提出提前结束的一方
GameEnd.iTurePoint[(bDeskStation+1)%4] = GameEnd.iTurePoint[(bDeskStation+3)%4] = 2;//另一方
}
//设置基本分begin
m_pDataManage->m_InitData.uBasePoint = 1;
int base=-1;
int temp;
for(int i=1;i<m_bMaxPeople;i++)
{
if (m_pUserInfo[i]==NULL)
continue;
temp=m_Logic.GetBaseFen(m_pUserInfo[i]->m_UserData.dwPoint);
if(base>temp||-1==base)
base=temp;
}
for(int i=0; i<m_bMaxPeople; i++)
{
if(NULL == m_pUserInfo[i])
{
GameEnd.iTurePoint[i] = 0;
continue;
}
GameEnd.iTurePoint[i]*=base;
}
//设置基本分end
//设置数据
m_bGameStation=GS_WAIT_ARGEE;
for (int i=0;i<m_bMaxPeople;i++)
{
if (m_pUserInfo[i]!=NULL)
m_pUserInfo[i]->m_UserData.bUserState=USER_SITTING;
}
/*if (m_pDataManage->m_InitData.uComType!=TY_NORMAL_GAME)
{
GameEnd.iTurePoint[0]*=iBasePoint;
GameEnd.iTurePoint[1]*=iBasePoint;
GameEnd.iTurePoint[2]*=iBasePoint;
GameEnd.iTurePoint[3]*=iBasePoint;
for (BYTE i=0;i<m_bMaxPeople;i++)
{
if(GameEnd.iTurePoint[i]>0)
GameEnd.iTurePoint[i]=__min(m_dwMaxPoint,GameEnd.iTurePoint[i]);
if(GameEnd.iTurePoint[i]<0)
GameEnd.iTurePoint[i]=__max(-m_dwMaxPoint,GameEnd.iTurePoint[i]);
if (GameEnd.iTurePoint[i]>=100)
{
if(m_pDataManage->m_InitData.uComType!=SUP_MATCH_GAME)
GameEnd.iTurePoint[i]=GameEnd.iTurePoint[i]*49L/50L;
}
}
}*/
//写入数据库
/* bool temp_cut[PLAY_COUNT];
memset(temp_cut,0,sizeof(temp_cut));
ChangeUserPoint(GameEnd.iTurePoint, temp_cut);
__super::RecoderGameInfo(GameEnd.iChangeMoney);*/
//写入数据库
bool temp_cut[4];
memset(temp_cut,0,sizeof(temp_cut));
ChangeUserPoint(GameEnd.iTurePoint, temp_cut);
__super::RecoderGameInfo(GameEnd.iChangeMoney);
GameEnd.iDoublePointEffect = GetDoublePointEffect();//20081125
bool bNotCostPoint = (m_pDataManage->m_InitData.dwRoomRule & GRR_NOT_COST_POINT) > 0; /// 金币场不扣积分 add by wys 2010-11-1
if (true == bNotCostPoint)
{
memset(GameEnd.iTurePoint,0,sizeof(GameEnd.iTurePoint));
}
//发送数据
for (int i=0;i<m_bMaxPeople;i++)
SendGameData(i,&GameEnd,sizeof(GameEnd),MDM_GM_GAME_NOTIFY,ASS_CONTINUE_END,0);
SendWatchData(m_bMaxPeople,&GameEnd,sizeof(GameEnd),MDM_GM_GAME_NOTIFY,ASS_CONTINUE_END,0);
ReSetGameState(bCloseFlag);
__super::GameFinish(bDeskStation,GF_SALE);
return true;
}
case GF_SALE: //游戏安全结束
case GFF_FORCE_FINISH: //用户断线离开
{
int iBasePoint=m_pDataManage->m_InitData.uBasePoint;//倍数
//计算得分
// int iTurePoint=GetUpGrade(m_iGamePoint,m_iPlayCardCount);
//设置数据
m_bGameStation=GS_WAIT_ARGEE;
for (int i=0;i<m_bMaxPeople;i++)
{
if (m_pUserInfo[i]!=NULL)
m_pUserInfo[i]->m_UserData.bUserState=USER_SITTING;
}
GameCutStruct CutEnd;
CutEnd.bDeskStation=bDeskStation;
if(bCloseFlag==GF_SALE)
{
CutEnd.iTurePoint[bDeskStation]=0;
CutEnd.iTurePoint[(bDeskStation+1)%4]=0;
CutEnd.iTurePoint[(bDeskStation+2)%4]=0;
CutEnd.iTurePoint[(bDeskStation+3)%4]=0;
}
else
{
//设置分数
CutEnd.iTurePoint[bDeskStation]=0-m_pDataManage->m_InitData.uRunPublish;;
CutEnd.iTurePoint[(bDeskStation+1)%4]=0;
CutEnd.iTurePoint[(bDeskStation+2)%4]=0;
CutEnd.iTurePoint[(bDeskStation+3)%4]=0;
}
//发送信息
if (bCloseFlag==GF_SALE)
{
for (int i=0;i<m_bMaxPeople;i++) SendGameData(i,&CutEnd,sizeof(CutEnd),MDM_GM_GAME_NOTIFY,ASS_SALE_END,0);
SendWatchData(m_bMaxPeople,&CutEnd,sizeof(CutEnd),MDM_GM_GAME_NOTIFY,ASS_SALE_END,0);
}
else
{
//计算金币类和比赛类的实得分
/*if (m_pDataManage->m_InitData.uComType!=TY_NORMAL_GAME)
{
CutEnd.iTurePoint[0]*=iBasePoint;
CutEnd.iTurePoint[1]*=iBasePoint;
CutEnd.iTurePoint[2]*=iBasePoint;
CutEnd.iTurePoint[3]*=iBasePoint;
for (BYTE i=0;i<m_bMaxPeople;i++)
{
if(CutEnd.iTurePoint[i]>0)
CutEnd.iTurePoint[i]=__min(m_dwMaxPoint,CutEnd.iTurePoint[i]);
if(CutEnd.iTurePoint[i]<0)
CutEnd.iTurePoint[i]=__max(-m_dwMaxPoint,CutEnd.iTurePoint[i]);
if (CutEnd.iTurePoint[i]>=100)
{
if(m_pDataManage->m_InitData.uComType!=SUP_MATCH_GAME)
CutEnd.iTurePoint[i]=CutEnd.iTurePoint[i]*49L/50L;
}
}
}*/
/* bool temp_cut[PLAY_COUNT];
memset(temp_cut,0,sizeof(temp_cut));
for (int i=0;i<PLAY_COUNT;i++)
{
temp_cut[i]=(bDeskStation==i && CutEnd.iTurePoint[i]<0);
}
ChangeUserPoint(CutEnd.iTurePoint, temp_cut);
__super::RecoderGameInfo(CutEnd.iChangeMoney);*/
//写入数据库
bool temp_cut[4];
memset(temp_cut,0,sizeof(temp_cut));
for (int i=0;i<m_bMaxPeople;i++)
{
temp_cut[i]=(bDeskStation==i && CutEnd.iTurePoint[i]<0);
}
ChangeUserPoint(CutEnd.iTurePoint, temp_cut);
__super::RecoderGameInfo(CutEnd.iChangeMoney);
bool bNotCostPoint = (m_pDataManage->m_InitData.dwRoomRule & GRR_NOT_COST_POINT) > 0; /// 金币场不扣积分 add by wys 2010-11-1
if (true == bNotCostPoint)
{
memset(CutEnd.iTurePoint,0,sizeof(CutEnd.iTurePoint));
}
for (int i=0;i<m_bMaxPeople;i++)
SendGameData(i,&CutEnd,sizeof(CutEnd),MDM_GM_GAME_NOTIFY,ASS_CUT_END,0);
SendWatchData(m_bMaxPeople,&CutEnd,sizeof(CutEnd),MDM_GM_GAME_NOTIFY,ASS_CUT_END,0);
}
bCloseFlag=GFF_FORCE_FINISH;
ReSetGameState(bCloseFlag);
__super::GameFinish(bDeskStation,bCloseFlag);
return true;
}
}
//重置数据
ReSetGameState(bCloseFlag);
__super::GameFinish(bDeskStation,bCloseFlag);
return true;
}
/**
* 用户出牌
* @param bDeskStation 玩家ID
* @param pNetHead 参数基类
* @param pData 网络数据包
* @param uSize 数据包大小
* @param uSocketID 参数基类
* @param bWatchUser 是否旁观
*/
bool CServerGameDesk::H020_UserOutCard(BYTE bDeskStation, NetMessageHead * pNetHead, void * pData, UINT uSize, UINT uSocketID, bool bWatchUser)
{
//GameFinish(bDeskStation,GF_NORMAL);//*shingo*
//return true;
if (bWatchUser) return FALSE;
if(m_bGameStation!=GS_PLAY_GAME)
return true;
if (uSize!=sizeof(tagMove)) return FALSE;
if(bDeskStation!=m_Logic.m_iNowOutPeople)
return false;
tagMove * pOutCard=(tagMove *)pData;
tagMoveResult m;
memset(m.cPath, 255, sizeof(m.cPath));
/*if(pOutCard->m_iStartI==-1)
{//有玩家无子可下了
m.station=bDeskStation;
m.loseColor=m_Logic.GetColorFromStation(bDeskStation);
m.m_iStartI=-1;
m_Logic.ClearColorAllQiZi(m.loseColor);
int *p=new int;
*p=bDeskStation;
bool cor[4];
m_Logic.GetDeadPeople(cor);
m_Logic.mLoseStationList.AddTail(p);
for(int i=0; i<4; i++)
{
if(i == *p)
continue;
if(!cor[i])
{
TCHAR sz[100];
wsprintf(sz,"lose color %d",i);
Testlog(sz);
int *p1=new int;
*p1=bDeskStation;
m_Logic.mLoseStationList.AddTail(p1);
}
}
m.nextstation=m_Logic.GetNextStation(m.station);
}
else
{*/
m.station=bDeskStation;
m_Logic.UserMove(*pOutCard,m);
//}
if(m_Logic.IsFinish())
m.nextstation=-1;
m_Logic.m_iNowOutPeople=m.nextstation;
m.iStep = pOutCard->iStep;
memcpy(m.cPath, pOutCard->cPath, sizeof(m.cPath));
for (int i=0;i<m_bMaxPeople;i++)
SendGameData(i,&m,sizeof(m),MDM_GM_GAME_NOTIFY,ASS_OUT_CARD,0);
SendWatchData(m_bMaxPeople,&m,sizeof(m),MDM_GM_GAME_NOTIFY,ASS_OUT_CARD,0);
KillTimer(TIME_USER_OUT_CARD) ;
m_iTimerCount = m_iLessCount + 3 ;
SetTimer(TIME_USER_OUT_CARD ,1000) ;
if(m.loseColor >= 0)//m_Logic.IsStationLose(bDeskStation))
{
tagNextStep N;
if(pOutCard->m_iStartI==-1)
N.station =bDeskStation;
else
N.station=m_Logic.GetStationFromColor(m.loseColor);
N.station2=m_Logic.GetStationFromColor(m.loseColor2);
for (int i=0;i<4;i++)
SendGameData(i,&N,sizeof(N),MDM_GM_GAME_NOTIFY,ASS_LOSE,0);
SendWatchData(m_bMaxPeople,&N,sizeof(N),MDM_GM_GAME_NOTIFY,ASS_LOSE,0);
}
if(m_Logic.IsFinish())
{
m_bGameStation=GS_PLAY_GAME;
SetTimer(TIME_GAME_FINISH,2000);
}
return true;
}
//游戏消息处理函数
bool CClientGameDlg::HandleGameMessage(NetMessageHead * pNetHead, void * pNetData, UINT uDataSize, CTCPClientSocket * pClientSocket)
{
if (pNetHead->bMainID == MDM_GM_GAME_NOTIFY)
{
switch (pNetHead->bAssistantID)
{
case ASS_GM_GAME_STATION: ///<设置状态(平台调用的)
#pragma region 游戏状态
{
TGameStation *ptGameStation = (TGameStation*)pNetData;
if(ptGameStation == nullptr)
{
return -1;
}
if(uDataSize != sizeof(TGameStation))
{
return -1;
}
GameStationProc(*ptGameStation);
return true;
}
#pragma endregion 游戏状态
case ASS_GETREADY: //准备
#pragma region ASS_GETREADY
{
TGetReady *ptGetReady = (TGetReady*)pNetData;
if(ptGetReady == nullptr)
{
return -1;
}
else
{
}
}
break;
#pragma endregion ASS_GETREADY
case ASS_GAMELEVEL: //游戏级别消息
#pragma region ASS_GAMELEVEL
{
if (sizeof(TGameLevel) != uDataSize)
{
return -1;
}
TGameLevel *ptGameLevel = (TGameLevel*)pNetData;
if(ptGameLevel == NULL)
{
OutputDebugString("chs ASS_GAMELEVEL, ptGameLevel null pointer.");
return -1;
}
ShowCurrentGameLevel(ptGameLevel);
}
break;
#pragma endregion ASS_GAMELEVEL
case ASS_SEND_CARD: //发牌
#pragma region ASS_SEND_CARD
{
OutputDebugString("chs 发牌消息0");
TSendCards *ptSendCards = (TSendCards*)pNetData;
if(ptSendCards == nullptr)
{
return -1;
}
OutputDebugString("chs 发牌消息1");
ReceiveAndShowCards(ptSendCards);
}
break;
#pragma endregion ASS_SEND_CARD
case ASS_SHOWCALLLEVELCARD:
#pragma region ASS_SHOWCALLLEVELCARD
{
TCallLevelCard *ptCallLevelCard = (TCallLevelCard*)pNetData;
if(ptCallLevelCard == nullptr)
{
return -1;
}
}
break;
#pragma endregion ASS_SHOWCALLLEVELCARD
case ASS_WHOISBANKER: //通知谁是庄家，和级牌
#pragma region ASS_WHOISBANKER
{
//在庄家图像旁，贴上庄家图片
TCallLevelCard *ptCallLevelCard = (TCallLevelCard*)pNetData;
if (ptCallLevelCard == nullptr)
{
return -1;
}
//保存级牌的花色
m_byGameLevelColor = ptCallLevelCard->byLevelColor;
//保存当前的级牌
if(m_byGameLevelColor != 255)
{
memcpy(m_byGameLevel,ptCallLevelCard->byCallCard,sizeof(BYTE)*2);
}
//显示庄家的名字
//显示当前叫主的花色
//将手中的牌排序
//m_cLogic.SortCard(m_byCards,33,m_byGameLevelColor,m_byGameLevel[(m_pGameFrame->GetMyDeskStation())%2]);
//m_pIOperateCard->SetCardList(m_byCards,33);
BYTE byLevelcard = ptCallLevelCard->byCallCard[0];
BYTE byColor = (byLevelcard & 0xF0);
}
#pragma endregion ASS_WHOISBANKER
case ASS_SENDBACKCARD: //收底牌
#pragma region ASS_SENDBACKCARD
{
TSendCards *ptSendCard = (TSendCards*)pNetData;
if(ptSendCard == nullptr)
{
return -1;
}
if((m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation) == ptSendCard->byDeskStation)
{
//显示底牌
BYTE byCards[8] = {0};
memcpy(byCards,ptSendCard->byCards,sizeof(BYTE)*(ptSendCard->byCardCount));
//将底牌插入手中已有的牌中
for(int i = 0;i<8;++i)
{
m_byCards[25+i] = ptSendCard->byCards[i];
m_vbyCards.push_back(ptSendCard->byCards[i]);
}
//启动埋牌定时器,若时间到没有埋牌，则从玩家手中抽出8张牌，埋牌
SetGameTimer(m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation,GenerateRand(10),TIMER_BURYBACKCARD);
}
}
break;
#pragma endregion ASS_SENDBACKCARD
case ASS_BACKCARDBURIED: //底牌埋完了
#pragma region ASS_BACKCARDBURIED
{
//从所有牌中，删除底牌
for(int j=0; j<8;j++)
{
for(int i=0;i<33; i++)
{
if (m_byBackCard[j] == m_byCards[i])
{
m_byCards[i] = 255;
break;
}
}
}
//把牌重新赋值给 m_byCards
int iIndex = 0;
for(int i=0;i<33; i++)
{
if (m_byCards[i] != 255)
{
m_byCards[iIndex++] = m_byCards[i];
}
}
//清空m_vbyCards， 并把牌重新压入 m_vbyCards
m_vbyCards.clear();
for(int i=0; i<iIndex; i++)
{
if (m_byCards[i] != 255)
{
m_vbyCards.push_back(m_byCards[i]);
}
}
}
break;
#pragma endregion ASS_BACKCARDBURIED
case ASS_OUT_CARD: //出牌
#pragma region ASS_OUT_CARD
{
T_SC_OutCardPackage *pscOutCard = (T_SC_OutCardPackage *)pNetData;
if (pscOutCard == nullptr)
{
return -1;
}
//保存第一个玩家出的牌
if(pscOutCard->tPreoutCards.isFirst)
{
memcpy(&m_tFirstPlayerCard,&pscOutCard->tPreoutCards,sizeof(T_CS_OutCard));
}
//出牌玩家
if(pscOutCard->byOutCardPlayerDeskStation == m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation)
#pragma region 出牌玩家
{
if(pscOutCard->IsFirst)
{
m_isFirstOutCard = true; //一圈中第一个出牌
}
else
{
m_isFirstOutCard = false; //一圈中不是第一个出牌
}
//启动定时器出牌
SetGameTimer(m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation,GenerateRand(10),TIMER_OUTCARD);
}
#pragma endregion 出牌玩家
else //非出牌玩家
#pragma region 非出牌玩家
{
//TODO:保存单圈中第一个出牌的人的牌数据
if(pscOutCard->tPreoutCards.isFirst)
{
memcpy(&m_tFirstPlayerCard,&(pscOutCard->tPreoutCards),sizeof(T_CS_OutCard));
}
}
#pragma endregion 非出牌玩家
}
break;
#pragma endregion ASS_OUT_CARD
case ASS_OUTMIXEDCARD_FAILED: //甩牌失败
#pragma region 甩牌失败
{
T_SC_MixedCardFailed *ptMixedCard = (T_SC_MixedCardFailed*)pNetData;
if (ptMixedCard == NULL)
{
return -1;
}
if( uDataSize!= sizeof(T_SC_MixedCardFailed))
{
return -1;
}
//向服务器发送最小的牌
T_CS_OutCard tcsOutCard;
BYTE byDeskStation =m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation;
//如果是一圈的第一个出牌的人，直接将牌发送给服务器，由服务器判断是否能够出牌。 时钟和定时器不关，等收到出牌成功后再关闭定时器和时钟;//从手中删除已经出的牌
//TODO: 检查牌型，并打包发送出牌消息
m_cLogic.GetOutCardShape(ptMixedCard->byMinCard,ptMixedCard->byCardCount,tcsOutCard,byDeskStation,m_byGameLevel[0],true);
SendGameData(&tcsOutCard,sizeof(T_CS_OutCard),MDM_GM_GAME_NOTIFY,ASS_OUT_CARD,0);
//保存出牌数据
memcpy(m_tCurrentOutCard.byCards,ptMixedCard->byMinCard,sizeof(BYTE)*(ptMixedCard->byCardCount));
}
break;
#pragma endregion 甩牌失败
case ASS_OUTCARD_FAILED: //出牌失败
#pragma region 出牌失败
{
//TODO:还是需要保存首家的牌，以便当出牌失败，并且时钟已到时，可以自动选出要出的牌
T_SC_OutCardFailed *ptOutCardFailed = (T_SC_OutCardFailed*)pNetData;
if(ptOutCardFailed == NULL)
{
return -1;
}
if(uDataSize != sizeof(T_SC_OutCardFailed))
{
return -1;
}
}
break;
#pragma endregion 出牌失败
case ASS_OUTCARD_SUCCESS: //出牌成功
#pragma region 出牌成功
{
T_CS_OutCard *ptOutCards = (T_CS_OutCard*)pNetData;
if(ptOutCards == NULL)
{
return -1;
}
if(uDataSize != sizeof(T_CS_OutCard))
{
return -1;
}
//出牌人
if(ptOutCards->byDeskStation == m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation)
{
#pragma region 出牌成功
//TODO:隐藏出牌按钮、提示按钮、时钟、 删除出的牌
//显示出的牌
//庄家删除出的牌
int iOriginCounter = m_vbyCards.size();
m_cLogic.RemoveOutCards(m_byCards,&iOriginCounter,m_tCurrentOutCard.byCards,m_tCurrentOutCard.byCardNums);
m_cLogic.RemoveOutCards(m_byCards,&iOriginCounter,m_tCurrentOutCard.byCards,m_tCurrentOutCard.byCardNums);
for (int i= 0;i< m_tCurrentOutCard.byCardNums;++i)
{
for (vector<BYTE>::iterator it = m_vbyCards.begin();it != m_vbyCards.end();++it)
{
if(*it == m_tCurrentOutCard.byCards[i])
{
m_vbyCards.erase(it);
break;
}
}
}
#pragma region 重新显示手中可操作牌
// if(m_byGameLevelColor == 255)
// {
// m_cLogic.SortCard(m_byCards,m_vbyCards.size(),0x30,m_byGameLevel[(m_pGameFrame->GetMyDeskStation())%2]);
// CString cs;
// cs.Format("chs 玩家%d 排序2",m_pGameFrame->GetMyDeskStation());
// OutputDebugString(cs);
// }
// else
// {
// m_cLogic.SortCard(m_byCards,m_vbyCards.size(),m_byGameLevelColor,m_byGameLevel[(m_pGameFrame->GetMyDeskStation())%2]);
// CString cs;
// cs.Format("chs 玩家%d 排序2",m_pGameFrame->GetMyDeskStation());
// OutputDebugString(cs);
// }
#pragma endregion 重新显示手中可操作牌
}
#pragma endregion 出牌成功
else //非出牌人
{
}
}
break;
#pragma endregion 出牌成功
case ASS_SCORE:
#pragma region 得分
{
T_SC_Score *pScore = (T_SC_Score*)pNetData;
if(pScore == NULL)
{
return -1;
}
WCHAR wbuffer[50] = {0};
swprintf(wbuffer,L"%d",pScore->iScore);
}
break;
#pragma endregion 得分
case ASS_GAMEOVER:
#pragma region 游戏结束
{
ResetGameStatus();
SetGameTimer(m_pGameInfo->pMeUserInfo->GameUserInfo.bDeskStation,GenerateRand(10),TIMER_GETREADY);
}
break;
#pragma endregion 游戏结束
}
}
return __super::HandleGameMessage(pNetHead,pNetData,uDataSize,pClientSocket);
}
