1081 lines
34 KiB
C++
1081 lines
34 KiB
C++
#include "StdAfx.h"
|
|
#include "TableFrameSink.h"
|
|
|
|
const WORD CTableFrameSink::m_wPlayerCount = GAME_PLAYER; //游戏人数;
|
|
tagGameRuleCfg CTableFrameSink::m_stGameRuleCfg; //房间规则;
|
|
|
|
enum tagServerTimerEnum
|
|
{
|
|
IDI_SEND_CARD = 1, //发牌计时器;
|
|
IDI_ROB_BANKER, //抢庄计时器;
|
|
IDI_USER_CHIP, //下注计时器;
|
|
IDI_OPEN_CARD, //开牌计时器;
|
|
IDI_GAME_END, //结束定时器;
|
|
|
|
IDT_SEND_CARD = 10000, //发牌时间;
|
|
IDT_ROB_BANKER = 20000, //抢庄时间;
|
|
IDT_USER_CHIP = 20000, //下注时间;
|
|
IDT_OPEN_CARD = 20000, //开牌时间;
|
|
IDT_GAME_END = 2000, //结束时间;
|
|
};
|
|
|
|
CTableFrameSink::CTableFrameSink()
|
|
: m_pITableFrame(nullptr)
|
|
, m_pGameServiceOption(nullptr)
|
|
, m_dwOwnerID(INVALID_DWORD)
|
|
, m_pOpenRuleCfg(nullptr)
|
|
{
|
|
m_cbRobBankerCount = 0;
|
|
m_wBankerUser = INVALID_CHAIR;
|
|
ZeroMemory(m_lTableScore, sizeof(m_lTableScore));
|
|
ZeroMemory(m_bActiveUser, sizeof(m_bActiveUser));
|
|
ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
ZeroMemory(m_cbHandCardCount, sizeof(m_cbHandCardCount));
|
|
ZeroMemory(m_cbHandCardData, sizeof(m_cbHandCardData));
|
|
ZeroMemory(m_wRobBankerUser, sizeof(m_wRobBankerUser));
|
|
ZeroMemory(m_stOpenCardRlt, sizeof(m_stOpenCardRlt));
|
|
|
|
ZeroMemory(&m_PrivateEndInfo, sizeof(CMD_S_Private_End_Info));
|
|
}
|
|
|
|
CTableFrameSink::~CTableFrameSink(void)
|
|
{
|
|
SafeDelete(m_pOpenRuleCfg);
|
|
}
|
|
|
|
void * CTableFrameSink::QueryInterface(const IID &Guid, DWORD dwQueryVer)
|
|
{
|
|
QUERYINTERFACE(ITableFrameSink, Guid, dwQueryVer);
|
|
QUERYINTERFACE(ITableUserAction, Guid, dwQueryVer);
|
|
QUERYINTERFACE_IUNKNOWNEX(ITableFrameSink, Guid, dwQueryVer);
|
|
return nullptr;
|
|
}
|
|
|
|
bool CTableFrameSink::Initialization(IUnknownEx * pIUnknownEx)
|
|
{
|
|
ASSERT(nullptr != pIUnknownEx);
|
|
m_pITableFrame = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, ITableFrame);
|
|
ASSERT(nullptr != m_pITableFrame);
|
|
if (nullptr == m_pITableFrame) return false;
|
|
|
|
m_pGameServiceOption = m_pITableFrame->GetGameServiceOption();
|
|
ASSERT(nullptr != m_pGameServiceOption);
|
|
if (nullptr == m_pGameServiceOption) return false;
|
|
|
|
//开始模式;
|
|
m_pITableFrame->SetStartMode(START_MODE_ALL_READY);
|
|
|
|
return true;
|
|
}
|
|
|
|
void CTableFrameSink::RepositionSink()
|
|
{
|
|
m_cbRobBankerCount = 0;
|
|
|
|
ZeroMemory(m_lTableScore, sizeof(m_lTableScore));
|
|
ZeroMemory(m_bActiveUser, sizeof(m_bActiveUser));
|
|
ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
ZeroMemory(m_cbHandCardCount, sizeof(m_cbHandCardCount));
|
|
ZeroMemory(m_cbHandCardData, sizeof(m_cbHandCardData));
|
|
ZeroMemory(m_wRobBankerUser, sizeof(m_wRobBankerUser));
|
|
ZeroMemory(m_stOpenCardRlt, sizeof(m_stOpenCardRlt));
|
|
if (IsFixBankerMode())
|
|
{
|
|
ASSERT(m_wBankerUser>=0 && m_wBankerUser<GAME_PLAYER);
|
|
}
|
|
else
|
|
{
|
|
m_wBankerUser = INVALID_CHAIR;
|
|
}
|
|
}
|
|
|
|
//游戏状态;
|
|
bool CTableFrameSink::IsUserPlaying(WORD wChairID)
|
|
{
|
|
return wChairID >= 0 && wChairID < GAME_PLAYER && m_bActiveUser[wChairID];
|
|
}
|
|
|
|
bool CTableFrameSink::OnActionUserSitDown(WORD wChairID, IServerUserItem *pIServerUserItem, bool bLookonUser)
|
|
{
|
|
if (!bLookonUser && IsFixBankerMode() && INVALID_CHAIR==m_wBankerUser)
|
|
{
|
|
if (INVALID_DWORD==m_dwOwnerID || pIServerUserItem->GetUserID()==m_dwOwnerID)
|
|
{
|
|
m_wBankerUser = pIServerUserItem->GetChairID();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CTableFrameSink::OnActionUserStandUp(WORD wChairID, IServerUserItem *pIServerUserItem, bool bLookonUser)
|
|
{
|
|
if (!bLookonUser && m_pITableFrame->GetSitUserCount()==0)
|
|
{
|
|
m_wBankerUser = INVALID_CHAIR;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CTableFrameSink::OnTimerMessage(DWORD wTimerID, WPARAM wBindParam)
|
|
{
|
|
const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
|
|
switch (wTimerID)
|
|
{
|
|
case IDI_SEND_CARD:
|
|
{
|
|
return OnUserSendCard(INVALID_CHAIR);
|
|
}
|
|
case IDI_ROB_BANKER:
|
|
{
|
|
return OnUserRobBanker(INVALID_CHAIR, false);
|
|
}
|
|
case IDI_USER_CHIP:
|
|
{
|
|
return OnUserChipScore(INVALID_CHAIR, 3);
|
|
}
|
|
case IDI_OPEN_CARD:
|
|
{
|
|
return OnUserOpenCard(INVALID_CHAIR);
|
|
}
|
|
case IDI_GAME_END:
|
|
{
|
|
return OnEventGameConclude(INVALID_CHAIR, nullptr, GER_NORMAL);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CTableFrameSink::OnGameMessage(WORD wSubCmdID, VOID * pDataBuffer, WORD wDataSize, IServerUserItem * pIServerUserItem)
|
|
{
|
|
switch (wSubCmdID)
|
|
{
|
|
case SUB_C_SEND_OVER:
|
|
{
|
|
ASSERT(pIServerUserItem->GetUserStatus() == US_PLAYING);
|
|
if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;
|
|
|
|
WORD && wChairID = pIServerUserItem->GetChairID();
|
|
ASSERT(IsUserPlaying(wChairID));
|
|
if (!IsUserPlaying(wChairID)) return true;
|
|
|
|
return OnUserSendCard(wChairID);
|
|
}
|
|
case SUB_C_ROB_BANKER:
|
|
{
|
|
ASSERT(sizeof(CMD_C_RobBanker) == wDataSize);
|
|
if (sizeof(CMD_C_RobBanker) != wDataSize) return false;
|
|
|
|
ASSERT(pIServerUserItem->GetUserStatus() == US_PLAYING);
|
|
if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;
|
|
|
|
WORD && wChairID = pIServerUserItem->GetChairID();
|
|
ASSERT(IsUserPlaying(wChairID));
|
|
if (!IsUserPlaying(wChairID)) return true;
|
|
|
|
CMD_C_RobBanker *pRobBanker = (CMD_C_RobBanker *)pDataBuffer;
|
|
return OnUserRobBanker(wChairID, pRobBanker->bRob);
|
|
}
|
|
case SUB_C_CHIP_SCORE:
|
|
{
|
|
ASSERT(sizeof(CMD_C_ChipScore) == wDataSize);
|
|
if (sizeof(CMD_C_ChipScore) != wDataSize) return false;
|
|
|
|
ASSERT(pIServerUserItem->GetUserStatus() == US_PLAYING);
|
|
if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;
|
|
|
|
WORD && wChairID = pIServerUserItem->GetChairID();
|
|
ASSERT(IsUserPlaying(wChairID));
|
|
if (!IsUserPlaying(wChairID)) return true;
|
|
|
|
CMD_C_ChipScore *pChipScore = (CMD_C_ChipScore *)pDataBuffer;
|
|
return OnUserChipScore(wChairID, pChipScore->lScore);
|
|
}
|
|
case SUB_C_OPEN_CARD:
|
|
{
|
|
ASSERT(pIServerUserItem->GetUserStatus() == US_PLAYING);
|
|
if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;
|
|
|
|
WORD && wChairID = pIServerUserItem->GetChairID();
|
|
ASSERT(IsUserPlaying(wChairID));
|
|
if (!IsUserPlaying(wChairID)) return true;
|
|
|
|
return OnUserOpenCard(wChairID);
|
|
}
|
|
}
|
|
ASSERT(0);
|
|
return false;
|
|
}
|
|
|
|
//框架消息处理;
|
|
bool CTableFrameSink::OnFrameMessage(WORD wSubCmdID, VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool CTableFrameSink::OnEventSendGameScene(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbGameStatus, bool bSendSecret)
|
|
{
|
|
switch (cbGameStatus)
|
|
{
|
|
case GS_NN_FREE:
|
|
{
|
|
CMD_S_StatusFree stStatusFree = { 0 };
|
|
stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
|
|
stStatusFree.lMinFreeChip = GetMinFreeChip();
|
|
stStatusFree.lMaxFreeChip = GetMaxFreeChip();
|
|
|
|
return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusFree, sizeof(stStatusFree));
|
|
}
|
|
case GS_NN_SEND_CARD:
|
|
{
|
|
CMD_S_StatusSend stStatusSend = { 0 };
|
|
stStatusSend.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
|
|
stStatusSend.stStatusFree.lMinFreeChip = GetMinFreeChip();
|
|
stStatusSend.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
|
|
//stStatusSend.stStatusFree.cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
|
|
stStatusSend.stStatusFree.cbHandCardCount = MAX_COUNT;
|
|
CopyMemory(stStatusSend.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
|
|
stStatusSend.wBankerUser = m_wBankerUser;
|
|
stStatusSend.cbSendStatus = m_cbUserResponse[wChairID];
|
|
|
|
//翻四张抢庄模式;
|
|
//if (m_bActiveUser[wChairID] && BANKER_ROB4 == GetValidConfig()->wBankerRule)
|
|
if (m_bActiveUser[wChairID])
|
|
{
|
|
if (IsHasGameRule(eNNRuleEnum_BANKER_ROB4))
|
|
{
|
|
CopyMemory(stStatusSend.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
}
|
|
|
|
//if (IsHasSpecialNiu())
|
|
//{
|
|
// CopyMemory(stStatusSend.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
//}
|
|
//else if (IsBayonetMode() || (wChairID == m_wBankerUser))
|
|
//{
|
|
// CopyMemory(stStatusSend.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
//}
|
|
}
|
|
|
|
return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusSend, sizeof(stStatusSend));
|
|
}
|
|
case GS_NN_ROB_BANKER:
|
|
{
|
|
ASSERT(INVALID_CHAIR == m_wBankerUser);
|
|
|
|
CMD_S_StatusRob stStatusRob = { 0 };
|
|
stStatusRob.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
|
|
stStatusRob.stStatusFree.lMinFreeChip = GetMinFreeChip();
|
|
stStatusRob.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
|
|
//stStatusRob.stStatusFree.cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
|
|
stStatusRob.stStatusFree.cbHandCardCount = MAX_COUNT;
|
|
CopyMemory(stStatusRob.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
|
|
CopyMemory(stStatusRob.cbRobStatus, m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
|
|
//翻四张抢庄模式;
|
|
//if (m_bActiveUser[wChairID] && BANKER_ROB4 == GetValidConfig()->wBankerRule)
|
|
if (m_bActiveUser[wChairID] && IsHasGameRule(eNNRuleEnum_BANKER_ROB4))
|
|
{
|
|
CopyMemory(stStatusRob.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
|
|
//if (IsHasSpecialNiu())
|
|
//{
|
|
// CopyMemory(stStatusRob.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
//}
|
|
//else if (IsBayonetMode() || (wChairID == m_wBankerUser))
|
|
//{
|
|
// CopyMemory(stStatusRob.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
//}
|
|
}
|
|
|
|
return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusRob, sizeof(stStatusRob));
|
|
}
|
|
case GS_NN_USER_CHIP:
|
|
{
|
|
ASSERT(m_wBankerUser>=0 && m_wBankerUser<GAME_PLAYER && IsUserPlaying(m_wBankerUser));
|
|
CMD_S_StatusChip stStatusChip = { 0 };
|
|
stStatusChip.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
|
|
stStatusChip.stStatusFree.lMinFreeChip = GetMinFreeChip();
|
|
stStatusChip.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
|
|
//stStatusChip.stStatusFree.cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
|
|
stStatusChip.stStatusFree.cbHandCardCount = MAX_COUNT;
|
|
CopyMemory(stStatusChip.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
|
|
CopyMemory(stStatusChip.cbChipStatus, m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
CopyMemory(stStatusChip.lUserChipScore, m_lTableScore, sizeof(m_lTableScore));
|
|
stStatusChip.wBankerUser = m_wBankerUser;
|
|
|
|
//翻四张抢庄模式;
|
|
//if (m_bActiveUser[wChairID] && BANKER_ROB4 == GetValidConfig()->wBankerRule)
|
|
if (m_bActiveUser[wChairID] && IsHasGameRule(eNNRuleEnum_BANKER_ROB4))
|
|
{
|
|
CopyMemory(stStatusChip.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
|
|
//if (IsHasSpecialNiu())
|
|
//{
|
|
// CopyMemory(stStatusChip.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
//}
|
|
//else if (IsBayonetMode() || (wChairID == m_wBankerUser))
|
|
//{
|
|
// CopyMemory(stStatusChip.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
//}
|
|
}
|
|
|
|
return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusChip, sizeof(stStatusChip));
|
|
}
|
|
case GS_NN_OPEN_CARD:
|
|
{
|
|
//ASSERT(IsUserPlaying(m_wBankerUser));
|
|
CMD_S_StatusOpen stStatusOpen = { 0 };
|
|
|
|
stStatusOpen.wBankerUser = m_wBankerUser;
|
|
stStatusOpen.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
|
|
stStatusOpen.stStatusFree.lMinFreeChip = GetMinFreeChip();
|
|
stStatusOpen.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
|
|
stStatusOpen.stStatusFree.cbHandCardCount = MAX_COUNT;
|
|
CopyMemory(stStatusOpen.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
|
|
CopyMemory(stStatusOpen.lUserChipScore, m_lTableScore, sizeof(m_lTableScore));
|
|
|
|
CopyMemory(stStatusOpen.cbOpenStatus, m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
|
|
//玩家自己;
|
|
//stStatusOpen.cbOpenStatus = m_cbUserResponse[wChairID];
|
|
if (m_bActiveUser[wChairID] && (0 == m_cbUserResponse[wChairID]))
|
|
{
|
|
CopyMemory(stStatusOpen.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT));
|
|
}
|
|
else if (m_bActiveUser[wChairID] && 1 == m_cbUserResponse[wChairID])
|
|
{
|
|
stStatusOpen.cbHandCardType= m_stOpenCardRlt[wChairID].cbCardType;
|
|
CopyMemory(stStatusOpen.cbHandCardData, m_stOpenCardRlt[wChairID].cbSortCard, sizeof(m_stOpenCardRlt[wChairID].cbSortCard));
|
|
}
|
|
|
|
return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusOpen, sizeof(stStatusOpen));
|
|
}
|
|
case GS_NN_SHOW_CARD:
|
|
{
|
|
CMD_S_StatusAllOpen stAllOpen;
|
|
ZeroMemory(&stAllOpen, sizeof(CMD_S_StatusAllOpen));
|
|
|
|
stAllOpen.wBankerUser = m_wBankerUser;
|
|
|
|
stAllOpen.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
|
|
stAllOpen.stStatusFree.lMinFreeChip = GetMinFreeChip();
|
|
stAllOpen.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
|
|
stAllOpen.stStatusFree.cbHandCardCount = MAX_COUNT;
|
|
CopyMemory(stAllOpen.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
|
|
|
|
CopyMemory(stAllOpen.lUserChipScore, m_lTableScore, sizeof(m_lTableScore));
|
|
CopyMemory(stAllOpen.cbOpenStatus, m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
|
|
//所有人牌;
|
|
for (WORD i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
|
|
stAllOpen.cbHandCardType[i] = m_stOpenCardRlt[i].cbCardType;
|
|
CopyMemory(stAllOpen.cbHandCardData[i], m_stOpenCardRlt[i].cbSortCard, sizeof(m_stOpenCardRlt[i].cbSortCard));
|
|
}
|
|
|
|
return m_pITableFrame->SendGameScene(pIServerUserItem, &stAllOpen, sizeof(stAllOpen));
|
|
}
|
|
}
|
|
|
|
ASSERT(0);
|
|
return false;
|
|
}
|
|
|
|
bool CTableFrameSink::OnEventGameStart()
|
|
{
|
|
//RepositionSink();
|
|
srand(GetTickCount());
|
|
|
|
BYTE cbCardBuffer[MAX_COUNT*GAME_PLAYER] = { 0 };
|
|
//m_GameLogic.RandCardList(reinterpret_cast<BYTE *>(m_cbHandCardData), sizeof(m_cbHandCardData), ((GetValidConfig()->wGameRule&RULE_HUA_NIU)==0));
|
|
m_GameLogic.RandCardList(reinterpret_cast<BYTE *>(m_cbHandCardData), sizeof(m_cbHandCardData), false);
|
|
|
|
for (WORD i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
IServerUserItem * pIServerUserItem = m_pITableFrame->GetTableUserItem(i);
|
|
if (nullptr == pIServerUserItem) continue;
|
|
//if (pIServerUserItem->GetUserStatus() != US_PLAYING) continue;
|
|
|
|
BYTE cbUserStatus = pIServerUserItem->GetUserStatus();
|
|
BYTE cbReUserStatus = pIServerUserItem->GetReUserStatus();
|
|
if (cbUserStatus == US_PLAYING || (US_OFFLINE == cbUserStatus && cbReUserStatus == US_PLAYING))
|
|
{
|
|
m_bActiveUser[i] = true;
|
|
}
|
|
}
|
|
|
|
for (WORD i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
m_PrivateEndInfo.aryActiveStatus[i] = m_bActiveUser[i];
|
|
}
|
|
|
|
CMD_S_GameStart stGameStart = { 0 };
|
|
stGameStart.wBankerUser = m_wBankerUser;
|
|
//stGameStart.cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
|
|
stGameStart.cbHandCardCount = MAX_COUNT;
|
|
CopyMemory(stGameStart.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
|
|
for (WORD i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
ZeroMemory(&stGameStart.cbHandCardData, sizeof(stGameStart.cbHandCardData));
|
|
//if ( && BANKER_ROB4==GetValidConfig()->wBankerRule)
|
|
if (m_bActiveUser[i] && IsHasGameRule(eNNRuleEnum_BANKER_ROB4))
|
|
{
|
|
ASSERT(MAX_COUNT == stGameStart.cbHandCardCount);
|
|
CopyMemory(&stGameStart.cbHandCardData, m_cbHandCardData[i], sizeof(BYTE)*(MAX_COUNT-1));
|
|
}
|
|
|
|
//if (m_bActiveUser[i])
|
|
//{
|
|
// if (IsHasSpecialNiu())
|
|
// {
|
|
// ASSERT(MAX_COUNT == stGameStart.cbHandCardCount);
|
|
// CopyMemory(&stGameStart.cbHandCardData, m_cbHandCardData[i], sizeof(BYTE)*(MAX_COUNT - 1));
|
|
// }
|
|
// else if (IsBayonetMode() || (i == m_wBankerUser))
|
|
// {
|
|
// ASSERT(MAX_COUNT == stGameStart.cbHandCardCount);
|
|
// CopyMemory(&stGameStart.cbHandCardData, m_cbHandCardData[i], sizeof(BYTE)*MAX_COUNT);
|
|
// }
|
|
//}
|
|
|
|
m_pITableFrame->SendTableData(i, SUB_S_GAME_START, &stGameStart, sizeof(stGameStart));
|
|
}
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_START, &stGameStart, sizeof(stGameStart));
|
|
|
|
m_pITableFrame->SetGameStatus(GS_NN_SEND_CARD);
|
|
m_pITableFrame->SetGameTimer(IDI_SEND_CARD, IDT_SEND_CARD, 1, 0);
|
|
return true;
|
|
}
|
|
|
|
bool CTableFrameSink::OnEventGameConclude(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)
|
|
{
|
|
KillAllTimer();
|
|
m_pITableFrame->KillGameTimer(IDI_GAME_END);
|
|
|
|
m_pITableFrame->SetGameStatus(GS_NN_FREE);
|
|
|
|
ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
|
|
switch (cbReason)
|
|
{
|
|
case GER_DISMISS:
|
|
{
|
|
CMD_S_GameEnd stGameEnd = { 0 };
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END, &stGameEnd, sizeof(stGameEnd));
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END, &stGameEnd, sizeof(stGameEnd));
|
|
return m_pITableFrame->ConcludeGame(GAME_STATUS_FREE);
|
|
}
|
|
case GER_NORMAL:
|
|
{
|
|
CMD_S_GameEnd stGameEnd = { 0 };
|
|
|
|
// 拼刺刀模式;
|
|
if (IsBayonetMode())
|
|
{
|
|
ASSERT(m_wBankerUser == INVALID_CHAIR);
|
|
|
|
// 寻找最大玩家;
|
|
WORD wWinChairID = INVALID_CHAIR;
|
|
|
|
for (WORD i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
|
|
if (wWinChairID == INVALID_CHAIR)
|
|
{
|
|
wWinChairID = i;
|
|
}
|
|
else
|
|
{
|
|
if (!m_GameLogic.CompareCard(m_stOpenCardRlt[wWinChairID], m_stOpenCardRlt[i]))
|
|
{
|
|
wWinChairID = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 算分;
|
|
LONG lNiuMulti = m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[wWinChairID].cbCardType);
|
|
|
|
for (WORD i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
stGameEnd.cbCardType[i] = m_stOpenCardRlt[i].cbCardType;
|
|
CopyMemory(&stGameEnd.cbHandCardData[i], m_stOpenCardRlt[i].cbSortCard, sizeof(m_stOpenCardRlt[i].cbSortCard));
|
|
|
|
if (i == wWinChairID) continue;
|
|
|
|
stGameEnd.lGameScore[wWinChairID] += (m_lTableScore[i] * lNiuMulti);
|
|
stGameEnd.lGameScore[i] = -(m_lTableScore[i] * lNiuMulti);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(IsUserPlaying(m_wBankerUser));
|
|
|
|
// 其他模式;
|
|
for (WORD i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
stGameEnd.cbCardType[i] = m_stOpenCardRlt[i].cbCardType;
|
|
CopyMemory(&stGameEnd.cbHandCardData[i], m_stOpenCardRlt[i].cbSortCard, sizeof(m_stOpenCardRlt[i].cbSortCard));
|
|
if (i == m_wBankerUser) continue;
|
|
|
|
if (m_GameLogic.CompareCard(m_stOpenCardRlt[m_wBankerUser], m_stOpenCardRlt[i]))
|
|
{
|
|
//LONG lNiuMulti = IsHaveNiuFanMode() ? m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[m_wBankerUser].cbCardType) : 1;
|
|
LONG lNiuMulti = m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[m_wBankerUser].cbCardType);
|
|
stGameEnd.lGameScore[m_wBankerUser] += (m_lTableScore[i] * lNiuMulti);
|
|
stGameEnd.lGameScore[i] = -(m_lTableScore[i] * lNiuMulti);
|
|
}
|
|
else
|
|
{
|
|
//LONG lNiuMulti = IsHaveNiuFanMode() ? m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[i].cbCardType) : 1;
|
|
LONG lNiuMulti = m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[i].cbCardType);
|
|
stGameEnd.lGameScore[m_wBankerUser] -= (m_lTableScore[i] * lNiuMulti);
|
|
stGameEnd.lGameScore[i] = m_lTableScore[i] * lNiuMulti;
|
|
}
|
|
}
|
|
}
|
|
|
|
//计算税收;
|
|
LONG lRevenue[GAME_PLAYER] = { 0 };
|
|
for (WORD i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
lRevenue[i] = static_cast<LONG>(m_pITableFrame->CalculateRevenue(i, stGameEnd.lGameScore[i]));
|
|
stGameEnd.lGameScore[i] -= lRevenue[i];
|
|
stGameEnd.lRevenue[i] = lRevenue[i];
|
|
}
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END, &stGameEnd, sizeof(stGameEnd));
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END, &stGameEnd, sizeof(stGameEnd));
|
|
|
|
//写分;
|
|
tagScoreInfo ScoreInfoArray[GAME_PLAYER];
|
|
ZeroMemory(ScoreInfoArray, sizeof(ScoreInfoArray));
|
|
for (WORD i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
|
|
ScoreInfoArray[i].cbType = (stGameEnd.lGameScore[i] >= 0) ? SCORE_TYPE_WIN : SCORE_TYPE_LOSE;
|
|
ScoreInfoArray[i].lRevenue = lRevenue[i];
|
|
ScoreInfoArray[i].lScore = stGameEnd.lGameScore[i];
|
|
}
|
|
|
|
m_pITableFrame->addPrivatePlayCout(1);
|
|
|
|
//牌局结束后,每8局增加一点经验值;
|
|
if (IsPrivateEnd())
|
|
{
|
|
//tagPrivateFrameParameter* pPrivateFrame = m_pITableFrame->GetPrivateFrameInfo();
|
|
//SCORE lGrade = pPrivateFrame->dwPlayCost;
|
|
|
|
//for (WORD i = 0; i < GAME_PLAYER; i++)
|
|
//{
|
|
// ScoreInfoArray[i].lGrade = lGrade;
|
|
//}
|
|
|
|
ScoreInfoArray[0].lGrade = 2; //房主2倍;
|
|
for (WORD i = 1; i < GAME_PLAYER; i++)
|
|
{
|
|
ScoreInfoArray[i].lGrade = 1;
|
|
}
|
|
}
|
|
|
|
DataStream kDataStream;
|
|
m_pITableFrame->WriteTableScore(ScoreInfoArray, CountArray(ScoreInfoArray), kDataStream);
|
|
|
|
/********************************私人场统计****************************************/
|
|
|
|
bool isAllWin = true;
|
|
bool isAllLose = true;
|
|
for (WORD i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
|
|
// 赢次数;
|
|
if (stGameEnd.lGameScore[i] >= 0)
|
|
{
|
|
m_PrivateEndInfo.aryResultTypeCount[i][NN_RT_WIN]++;
|
|
}
|
|
|
|
// 牛牛次数;
|
|
if (stGameEnd.cbCardType[i] == NIU_TYPE_10)
|
|
{
|
|
m_PrivateEndInfo.aryResultTypeCount[i][NN_RT_NIUNIU]++;
|
|
}
|
|
|
|
if ((i != m_wBankerUser) && (stGameEnd.lGameScore[i] > 0))
|
|
{
|
|
// 有闲家赢，就不是通杀;
|
|
if (stGameEnd.lGameScore[i] > 0)
|
|
{
|
|
isAllWin = false;
|
|
}
|
|
// 有闲家输，就不是通赔;
|
|
else if (stGameEnd.lGameScore[i] < 0)
|
|
{
|
|
isAllLose = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isAllWin && m_wBankerUser < GAME_PLAYER)
|
|
{
|
|
m_PrivateEndInfo.aryResultTypeCount[m_wBankerUser][NN_RT_ALL_WIN]++;
|
|
}
|
|
|
|
if (isAllLose && m_wBankerUser < GAME_PLAYER)
|
|
{
|
|
m_PrivateEndInfo.aryResultTypeCount[m_wBankerUser][NN_RT_ALL_LOSE]++;
|
|
}
|
|
/********************************私人场统计****************************************/
|
|
|
|
//处理庄家;
|
|
if (IsRobBankerMode())
|
|
{
|
|
m_wBankerUser = INVALID_CHAIR;
|
|
}
|
|
//else if (BANKER_TURNS == GetValidConfig()->wBankerRule)
|
|
if (IsHasGameRule(eNNRuleEnum_BANKER_TURNS))
|
|
{
|
|
WORD wNextUser = m_wBankerUser;
|
|
for (WORD i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (++wNextUser == m_wPlayerCount)
|
|
{
|
|
wNextUser = 0;
|
|
}
|
|
if (m_bActiveUser[wNextUser])
|
|
{
|
|
m_wBankerUser = wNextUser;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_pITableFrame->ConcludeGame(GAME_STATUS_FREE);
|
|
return true;
|
|
}
|
|
}
|
|
ASSERT(0);
|
|
return false;
|
|
}
|
|
|
|
void CTableFrameSink::KillAllTimer()
|
|
{
|
|
m_pITableFrame->KillGameTimer(IDI_SEND_CARD);
|
|
m_pITableFrame->KillGameTimer(IDI_ROB_BANKER);
|
|
m_pITableFrame->KillGameTimer(IDI_USER_CHIP);
|
|
m_pITableFrame->KillGameTimer(IDI_OPEN_CARD);
|
|
}
|
|
|
|
//发送开始下注;
|
|
void CTableFrameSink::SendStartChip()
|
|
{
|
|
ASSERT(IsUserPlaying(m_wBankerUser));
|
|
|
|
CMD_S_StartChip stStartChip = { 0 };
|
|
stStartChip.wBankerUser = m_wBankerUser;
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_START_CHIP, &stStartChip, sizeof(stStartChip));
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_START_CHIP, &stStartChip, sizeof(stStartChip));
|
|
|
|
m_pITableFrame->SetGameStatus(GS_NN_USER_CHIP);
|
|
m_pITableFrame->SetGameTimer(IDI_USER_CHIP, IDT_USER_CHIP, 1, 0);
|
|
}
|
|
|
|
//是否由玩家没操作;
|
|
bool CTableFrameSink::IsUserNoOperate(bool bIgnoreBanker)
|
|
{
|
|
if (bIgnoreBanker)
|
|
{
|
|
for (int i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
if (i == m_wBankerUser) continue;
|
|
if (0 == m_cbUserResponse[i]) return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
if (0 == m_cbUserResponse[i]) return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//发牌完成;
|
|
bool CTableFrameSink::OnUserSendCard(WORD wChairID)
|
|
{
|
|
const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
|
|
ASSERT(GS_NN_SEND_CARD == cbGameStatus);
|
|
if (GS_NN_SEND_CARD != cbGameStatus) return true;
|
|
|
|
if (INVALID_CHAIR != wChairID)
|
|
{
|
|
ASSERT(IsUserPlaying(wChairID));
|
|
if (!IsUserPlaying(wChairID)) return true;
|
|
ASSERT(0 == m_cbUserResponse[wChairID]);
|
|
if (0 != m_cbUserResponse[wChairID]) return true;
|
|
|
|
m_cbUserResponse[wChairID] = 1;
|
|
if (IsUserNoOperate(false)) return true;
|
|
}
|
|
|
|
m_pITableFrame->KillGameTimer(IDI_SEND_CARD);
|
|
ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
|
|
//抢庄模式;
|
|
if (IsRobBankerMode())
|
|
{
|
|
ASSERT(INVALID_CHAIR == m_wBankerUser);
|
|
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_START_ROB);
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_START_ROB);
|
|
|
|
m_pITableFrame->SetGameStatus(GS_NN_ROB_BANKER);
|
|
m_pITableFrame->SetGameTimer(IDI_ROB_BANKER, IDT_ROB_BANKER, 1, 0);
|
|
}
|
|
else if (IsBayonetMode())
|
|
{
|
|
m_wBankerUser = INVALID_CHAIR;
|
|
|
|
// 让各个玩家都明牌;
|
|
for (int i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
m_lTableScore[i] = 1;
|
|
|
|
// 调用开牌把牌信息发送给客户端;
|
|
CMD_S_OpenCard stOpenCard = { 0 };
|
|
stOpenCard.wOpenUser = i;
|
|
stOpenCard.cbCardType = 0;
|
|
CopyMemory(stOpenCard.cbCardData, m_cbHandCardData[i], sizeof(m_cbHandCardData[i]));
|
|
|
|
m_pITableFrame->SendTableData(i, SUB_S_START_OPEN, &stOpenCard, sizeof(stOpenCard));
|
|
m_pITableFrame->SendLookonData(i, SUB_S_START_OPEN, &stOpenCard, sizeof(stOpenCard));
|
|
}
|
|
|
|
ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
m_pITableFrame->SetGameStatus(GS_NN_OPEN_CARD);
|
|
m_pITableFrame->SetGameTimer(IDI_OPEN_CARD, IDT_OPEN_CARD, 1, 0);
|
|
}
|
|
else
|
|
{
|
|
SendStartChip();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//叫庄事件;
|
|
bool CTableFrameSink::OnUserRobBanker(WORD wChairID, bool bRob)
|
|
{
|
|
const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
|
|
ASSERT(GS_NN_ROB_BANKER == cbGameStatus);
|
|
if (GS_NN_ROB_BANKER != cbGameStatus) return true;
|
|
|
|
//玩家操作;
|
|
if (INVALID_CHAIR != wChairID)
|
|
{
|
|
ASSERT(IsUserPlaying(wChairID));
|
|
if (!IsUserPlaying(wChairID)) return true;
|
|
ASSERT(0 == m_cbUserResponse[wChairID]);
|
|
if (0 != m_cbUserResponse[wChairID]) return true;
|
|
|
|
m_cbUserResponse[wChairID] = bRob ? 2 : 1;
|
|
if (bRob) m_wRobBankerUser[m_cbRobBankerCount++] = wChairID;
|
|
|
|
CMD_S_UserRob stUserRob = { 0 };
|
|
stUserRob.wRobUser = wChairID;
|
|
stUserRob.bRobResult = bRob;
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_USER_ROB, &stUserRob, sizeof(stUserRob));
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_USER_ROB, &stUserRob, sizeof(stUserRob));
|
|
|
|
if (IsUserNoOperate(false)) return true;
|
|
}
|
|
|
|
//超时，放弃抢庄;
|
|
for (int i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (m_bActiveUser[i] && 0==m_cbUserResponse[i])
|
|
{
|
|
m_cbUserResponse[i] = 1;
|
|
|
|
CMD_S_UserRob stUserRob = { 0 };
|
|
stUserRob.wRobUser = i;
|
|
stUserRob.bRobResult = false;
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_USER_ROB, &stUserRob, sizeof(stUserRob));
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_USER_ROB, &stUserRob, sizeof(stUserRob));
|
|
}
|
|
}
|
|
|
|
//没有人抢庄;
|
|
if (0 == m_cbRobBankerCount)
|
|
{
|
|
for (int i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (m_bActiveUser[i])
|
|
{
|
|
ASSERT(1 == m_cbUserResponse[i]);
|
|
m_wRobBankerUser[m_cbRobBankerCount++] = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_pITableFrame->KillGameTimer(IDI_ROB_BANKER);
|
|
ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
ASSERT(m_cbRobBankerCount > 0);
|
|
m_wBankerUser = m_wRobBankerUser[rand()%m_cbRobBankerCount];
|
|
|
|
SendStartChip();
|
|
return true;
|
|
}
|
|
|
|
//加注事件;
|
|
bool CTableFrameSink::OnUserChipScore(WORD wChairID, LONG lScore)
|
|
{
|
|
const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
|
|
ASSERT(GS_NN_USER_CHIP == cbGameStatus);
|
|
if (GS_NN_USER_CHIP != cbGameStatus) return true;
|
|
|
|
//ASSERT(IsUserPlaying(wChairID));
|
|
ASSERT(wChairID != m_wBankerUser);
|
|
|
|
//玩家操作;
|
|
if (INVALID_CHAIR != wChairID)
|
|
{
|
|
ASSERT(IsUserPlaying(wChairID));
|
|
if (!IsUserPlaying(wChairID)) return true;
|
|
ASSERT(0 == m_cbUserResponse[wChairID]);
|
|
if (0 != m_cbUserResponse[wChairID]) return true;
|
|
|
|
m_cbUserResponse[wChairID] = 1;
|
|
m_lTableScore[wChairID] = lScore;
|
|
|
|
CMD_S_UserChip stUserChip = { 0 };
|
|
stUserChip.wChipUser = wChairID;
|
|
stUserChip.lChipScore = lScore;
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_USER_CHIP, &stUserChip, sizeof(stUserChip));
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_USER_CHIP, &stUserChip, sizeof(stUserChip));
|
|
|
|
if (IsUserNoOperate(true)) return true;
|
|
}
|
|
|
|
//超时,没下注处理;
|
|
for (int i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i] || i==m_wBankerUser)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (0 == m_cbUserResponse[i])
|
|
{
|
|
//完成下注;
|
|
m_cbUserResponse[i] = 1;
|
|
m_lTableScore[i] = lScore;
|
|
//发送消息;
|
|
CMD_S_UserChip stUserChip = { 0 };
|
|
stUserChip.wChipUser = i;
|
|
stUserChip.lChipScore = (GetMinFreeChip()>0?GetMaxFreeChip():1);
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_USER_CHIP, &stUserChip, sizeof(stUserChip));
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_USER_CHIP, &stUserChip, sizeof(stUserChip));
|
|
}
|
|
}
|
|
|
|
// 让各个玩家都明牌;
|
|
for (int i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
// 调用开牌把牌信息发送给客户端;
|
|
CMD_S_OpenCard stOpenCard = { 0 };
|
|
stOpenCard.wOpenUser = i;
|
|
stOpenCard.cbCardType = 0;
|
|
CopyMemory(stOpenCard.cbCardData, m_cbHandCardData[i], sizeof(m_cbHandCardData[i]));
|
|
|
|
m_pITableFrame->SendTableData(i, SUB_S_START_OPEN, &stOpenCard, sizeof(stOpenCard));
|
|
m_pITableFrame->SendLookonData(i, SUB_S_START_OPEN, &stOpenCard, sizeof(stOpenCard));
|
|
}
|
|
|
|
m_pITableFrame->KillGameTimer(IDI_USER_CHIP);
|
|
ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
|
|
//m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_START_OPEN);
|
|
//m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_START_OPEN);
|
|
|
|
m_pITableFrame->SetGameStatus(GS_NN_OPEN_CARD);
|
|
m_pITableFrame->SetGameTimer(IDI_OPEN_CARD, IDT_OPEN_CARD, 1, 0);
|
|
|
|
return true;
|
|
}
|
|
|
|
//摊牌事件;
|
|
bool CTableFrameSink::OnUserOpenCard(WORD wChairID)
|
|
{
|
|
const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
|
|
ASSERT(GS_NN_OPEN_CARD == cbGameStatus);
|
|
if (GS_NN_OPEN_CARD != cbGameStatus) return true;
|
|
|
|
//BYTE cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
|
|
BYTE cbHandCardCount = MAX_COUNT;
|
|
|
|
//玩家操作;
|
|
if (INVALID_CHAIR != wChairID)
|
|
{
|
|
ASSERT(IsUserPlaying(wChairID));
|
|
if (!IsUserPlaying(wChairID)) return true;
|
|
ASSERT(0 == m_cbUserResponse[wChairID]);
|
|
if (0 != m_cbUserResponse[wChairID]) return true;
|
|
|
|
//完成开牌;
|
|
m_cbUserResponse[wChairID] = 1;
|
|
m_stOpenCardRlt[wChairID].cbMaxCard = m_GameLogic.GetMaxCard(m_cbHandCardData[wChairID], cbHandCardCount);
|
|
m_stOpenCardRlt[wChairID].cbCardType = m_GameLogic.GetCardType(m_cbHandCardData[wChairID], cbHandCardCount, m_stOpenCardRlt[wChairID].cbSortCard,
|
|
IsHasGameRule(eNNRuleEnum_WHN), IsHasGameRule(eNNRuleEnum_BOMB), IsHasGameRule(eNNRuleEnum_WXN));
|
|
|
|
CMD_S_OpenCard stOpenCard = { 0 };
|
|
stOpenCard.wOpenUser = wChairID;
|
|
stOpenCard.cbCardType = m_stOpenCardRlt[wChairID].cbCardType;
|
|
CopyMemory(stOpenCard.cbCardData, m_stOpenCardRlt[wChairID].cbSortCard, sizeof(stOpenCard.cbCardData));
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPEN_CARD, &stOpenCard, sizeof(stOpenCard));
|
|
m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPEN_CARD, &stOpenCard, sizeof(stOpenCard));
|
|
|
|
if (IsUserNoOperate(false)) return true;
|
|
}
|
|
|
|
//超时,没开牌处理;
|
|
for (int i=0; i<m_wPlayerCount; ++i)
|
|
{
|
|
if (!m_bActiveUser[i]) continue;
|
|
if (0 == m_cbUserResponse[i])
|
|
{
|
|
m_cbUserResponse[i] = 1;
|
|
m_stOpenCardRlt[i].cbMaxCard = m_GameLogic.GetMaxCard(m_cbHandCardData[i], cbHandCardCount);
|
|
m_stOpenCardRlt[i].cbCardType = m_GameLogic.GetCardType(m_cbHandCardData[i], cbHandCardCount, m_stOpenCardRlt[i].cbSortCard,
|
|
IsHasGameRule(eNNRuleEnum_WHN), IsHasGameRule(eNNRuleEnum_BOMB), IsHasGameRule(eNNRuleEnum_WXN));
|
|
|
|
//CMD_S_OpenCard stOpenCard = { 0 };
|
|
//stOpenCard.wOpenUser = i;
|
|
//stOpenCard.cbCardType = m_stOpenCardRlt[i].cbCardType;
|
|
//CopyMemory(stOpenCard.cbCardData, m_stOpenCardRlt[i].cbSortCard, sizeof(stOpenCard.cbCardData));
|
|
//m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPEN_CARD, &stOpenCard, sizeof(stOpenCard));
|
|
//m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPEN_CARD, &stOpenCard, sizeof(stOpenCard));
|
|
}
|
|
}
|
|
|
|
// 所有人开始开牌CMD_S_AllOpenCard;
|
|
CMD_S_AllOpenCard allOpenCard;
|
|
ZeroMemory(&allOpenCard, sizeof(allOpenCard));
|
|
|
|
for (int i = 0; i < m_wPlayerCount; ++i)
|
|
{
|
|
allOpenCard.bActiveStatus[i] = m_bActiveUser[i];
|
|
|
|
if (!m_bActiveUser[i]) continue;
|
|
allOpenCard.cbCardType[i] = m_stOpenCardRlt[i].cbCardType;
|
|
CopyMemory(&allOpenCard.cbHandCardData[i][0], m_stOpenCardRlt[i].cbSortCard, sizeof(m_stOpenCardRlt[i].cbSortCard));
|
|
|
|
m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_ALL_OPEN_CARD, &allOpenCard, sizeof(allOpenCard));
|
|
}
|
|
|
|
m_pITableFrame->SetGameStatus(GS_NN_SHOW_CARD);
|
|
|
|
m_pITableFrame->KillGameTimer(IDI_OPEN_CARD);
|
|
//ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
|
|
|
|
//结束游戏;
|
|
m_pITableFrame->SetGameTimer(IDI_GAME_END, IDT_GAME_END, 1, 0);
|
|
//OnEventGameConclude(INVALID_CHAIR, nullptr, GER_NORMAL);
|
|
return true;
|
|
}
|
|
|
|
//读取服务器配置;
|
|
bool CTableFrameSink::ReadServerConfig(const tagGameServiceOption *pGameServiceOption)
|
|
{
|
|
//TCHAR szDir[MAX_PATH];
|
|
//GetModuleFileName(NULL, szDir, MAX_PATH);
|
|
//PathRemoveFileSpec(szDir);
|
|
//CString strFileName;
|
|
//strFileName.Format(_T("%s\\%sServer.ini"), szDir, EXPORT_NAME);
|
|
|
|
//TCHAR szApp[32] = _T("Config");
|
|
//try
|
|
//{
|
|
// m_stGameRuleCfg.wGameRule = GetPrivateProfileInt(szApp, _T("GameRule"), RULE_HUA_NIU, strFileName);
|
|
// m_stGameRuleCfg.wBankerRule = GetPrivateProfileInt(szApp, _T("BankerRule"), BANKER_ROB4, strFileName);
|
|
// m_stGameRuleCfg.cbMinFreeChip = GetPrivateProfileInt(szApp, _T("MinFreeChip"), 0, strFileName);
|
|
// m_stGameRuleCfg.cbMaxFreeChip = GetPrivateProfileInt(szApp, _T("MaxFreeChip"), 0, strFileName);
|
|
// return true;
|
|
//} catch (...) {
|
|
// ASSERT(0);
|
|
//}
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////// 私人场 ////////////////////////////////////////////
|
|
void CTableFrameSink::SetPrivateInfo(BYTE bGameTypeIdex, DWORD bGameRuleIdex)
|
|
{
|
|
|
|
}
|
|
|
|
void CTableFrameSink::ResetPrivateEndInfo()
|
|
{
|
|
ZeroMemory(&m_PrivateEndInfo, sizeof(CMD_S_Private_End_Info));
|
|
m_wBankerUser = INVALID_CHAIR;
|
|
}
|
|
|
|
//获得私人场结束信息流;
|
|
void CTableFrameSink::GetPrivateEndInfo(DataStream &kDataStream, bool bSend)
|
|
{
|
|
//m_PrivateEndInfo.StreamValue(kDataStream, bSend);
|
|
for (WORD i = 0; i < GAME_PLAYER; i++)
|
|
{
|
|
// 总积分
|
|
IServerUserItem* pServerUserItem = m_pITableFrame->GetTableUserItem(i);
|
|
if (pServerUserItem)
|
|
{
|
|
m_PrivateEndInfo.lAllScore[i] = pServerUserItem->GetUserScore();
|
|
}
|
|
}
|
|
|
|
tagPrivateFrameRecordInfo* pPrivateRecord = m_pITableFrame->GetPrivateFrameRecord();
|
|
m_PrivateEndInfo.cbFinishCout = pPrivateRecord->cbFinishCout;
|
|
|
|
m_PrivateEndInfo.StreamValue(kDataStream, bSend);
|
|
}
|
|
|
|
//判断私人场是否结束;
|
|
bool CTableFrameSink::IsPrivateEnd()
|
|
{
|
|
if (m_pITableFrame == nullptr) return false;
|
|
|
|
tagPrivateFrameParameter* pPrivateFrame = m_pITableFrame->GetPrivateFrameInfo();
|
|
tagPrivateFrameRecordInfo* pPrivateRecord = m_pITableFrame->GetPrivateFrameRecord();
|
|
|
|
if ((pPrivateFrame == nullptr) || (pPrivateRecord == nullptr)) return false;
|
|
|
|
if (pPrivateFrame->cbGameCout <= pPrivateRecord->cbFinishCout)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//是否有相应规则;
|
|
bool CTableFrameSink::IsHasGameRule(eNNRuleEnum eType)
|
|
{
|
|
ASSERT(m_pITableFrame != nullptr);
|
|
if (m_pITableFrame == nullptr) return false;
|
|
|
|
const tagPrivateFrameParameter* pPrivateFrame = m_pITableFrame->GetPrivateFrameInfo();
|
|
if (nullptr == pPrivateFrame) return false;
|
|
if (0 == pPrivateFrame->dwRoomNum) return false;
|
|
|
|
return ((pPrivateFrame->dwGameRule & eType) == eType);
|
|
} |