admin/wnmj
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
abed04da1b40f3c0b3f7cea26461f021972728cb
wnmj/Servers/服务器组件/私人场服务/PrivateGame.cpp
cyw f36e3f9df2 init
2026-02-13 14:34:15 +08:00

2797 lines
84 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#include "StdAfx.h"
#include "PrivateGame.h"
#include "..\游戏服务器\DataBasePacket.h"
#include <math.h>
////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//构造函数
PriaveteGame::PriaveteGame()
{
m_pGameServiceOption=NULL;
m_pGameServiceAttrib=NULL;
//内核接口
m_pTableInfo=NULL;
m_pITimerEngine=NULL;
m_pIDataBaseEngine=NULL;
m_pITCPNetworkEngineEvent=NULL;
//服务接口
m_pIGameServiceFrame=NULL;
m_pIServerUserManager=NULL;
m_pAndroidUserManager=NULL;
ZeroMemory(&m_kPrivateInfo, sizeof(CMD_GR_Private_Info));
}
PriaveteGame::~PriaveteGame(void)
{
//释放资源
SafeDeleteArray(m_pTableInfo);
//关闭定时器
m_pITimerEngine->KillTimer(IDI_DISMISS_WAITE_END);
}
//接口查询
VOID* PriaveteGame::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
{
QUERYINTERFACE(IGamePrivateItem,Guid,dwQueryVer);
QUERYINTERFACE(IPrivateEventSink,Guid,dwQueryVer);
QUERYINTERFACE(IServerUserItemSink,Guid,dwQueryVer);
QUERYINTERFACE_IUNKNOWNEX(IGamePrivateItem,Guid,dwQueryVer);
return NULL;
}
//绑定桌子
bool PriaveteGame::BindTableFrame(ITableFrame * pTableFrame,WORD wTableID)
{
if(pTableFrame==NULL || wTableID>m_pGameServiceOption->wTableCount)
{
ASSERT(false);
return false;
}
//创建钩子
CTableFramePrivate * pTableFrameHook=new CTableFramePrivate();
pTableFrameHook->InitTableFramePrivate(QUERY_OBJECT_PTR_INTERFACE(pTableFrame,IUnknownEx));
pTableFrameHook->SetPrivateEventSink(QUERY_OBJECT_PTR_INTERFACE(this,IUnknownEx));
//设置接口
pTableFrame->SetTableFramePrivate(QUERY_OBJECT_PTR_INTERFACE(pTableFrameHook,IUnknownEx));
m_pTableInfo[wTableID].pITableFrame=pTableFrame;
m_pTableInfo[wTableID].restValue();
return true;
}
//初始化接口
bool PriaveteGame::InitPrivateInterface(tagPrivateManagerParameter & MatchManagerParameter)
{
m_pGameServiceOption=MatchManagerParameter.pGameServiceOption;
m_pGameServiceAttrib=MatchManagerParameter.pGameServiceAttrib;
//内核组件
m_pITimerEngine=MatchManagerParameter.pITimerEngine;
m_pIDataBaseEngine=MatchManagerParameter.pICorrespondManager;
m_pITCPNetworkEngineEvent=MatchManagerParameter.pTCPNetworkEngine;
//服务组件
m_pIGameServiceFrame=MatchManagerParameter.pIMainServiceFrame;
m_pIServerUserManager=MatchManagerParameter.pIServerUserManager;
m_pAndroidUserManager=MatchManagerParameter.pIAndroidUserManager;
m_pIServerUserItemSink=MatchManagerParameter.pIServerUserItemSink;
//创建桌子
if (m_pTableInfo==NULL)
{
m_pTableInfo = new PrivateTableInfo[m_pGameServiceOption->wTableCount];
}
////读取初始积分 获取路径
//TCHAR szWorkDir[MAX_PATH] = TEXT("");
//CWHService::GetWorkDirectory(szWorkDir, CountArray(szWorkDir));
////构造路径
//TCHAR szIniFile[MAX_PATH] = TEXT("");
//_sntprintf_s(szIniFile, CountArray(szIniFile), TEXT("%s\\ServerParameter.ini"), szWorkDir);
////读取配置
//CWHIniData IniData;
//IniData.SetIniFilePath(szIniFile);
//CString strSubItem;
//strSubItem.Format(_T("Server%dInitScore"), m_pGameServiceOption->wServerID);
//读取配置
//m_nInitScore = IniData.ReadInt(TEXT("ServerInfo"), strSubItem, 95);
return true;
}
void PriaveteGame::OnStartService()
{
//变量定义
DBR_GR_Private_Info kPrivateInfo;
ZeroMemory(&kPrivateInfo,sizeof(kPrivateInfo));
kPrivateInfo.wKindID=m_pGameServiceOption->wKindID;
m_pIDataBaseEngine->PostDataBaseRequest(0L,DBR_GR_PRIVATE_INFO,0L,&kPrivateInfo,sizeof(kPrivateInfo));
//定时器;
m_pITimerEngine->SetTimer(IDI_DISMISS_WAITE_END,5000L,TIMES_INFINITY,0);
m_pITimerEngine->SetTimer(IDI_CREATE_UNION_ROOM, CREATE_UNION_TIME * 1000L, TIMES_INFINITY, 0);
m_pITimerEngine->SetTimer(IDI_LOAD_UNION_ROOM, 5000L, 1, 0);
}
//时间事件
bool PriaveteGame::OnEventTimer(DWORD dwTimerID, WPARAM dwBindParameter)
{
switch(dwTimerID)
{
case IDI_DISMISS_WAITE_END: //解散等待时间 10s
{
for(int i = 0;i<m_pGameServiceOption->wTableCount;i++)
{
PrivateTableInfo* pTableInfo = &m_pTableInfo[i];
if (pTableInfo->bInEnd)
{
pTableInfo->fAgainPastTime += 5.0f;
if (pTableInfo->fAgainPastTime >= AGAIN_WAITE_TIME)
{
ClearRoom(pTableInfo);
}
}
//已经创建并且没有开始的桌子
if (pTableInfo->dwCreaterUserID>0 && !pTableInfo->bStart)
{
// 自动代开房间不解散;
if ((pTableInfo->dwGameRuleIdex&ePrivateTableCommonRule_DaiKaiFang) == 0)
{
pTableInfo->fCreateTime += 5.0f;
if (pTableInfo->fCreateTime >= CREATE_PRIVATE_FREE_TIME)
{
DismissRoom(pTableInfo);
}
}
else // 自动代开房间玩家离线5分钟自动离开游戏房间;
{
ITableFrame* pTableFrame = pTableInfo->pITableFrame;
ASSERT(pTableFrame != NULL);
if (pTableFrame != NULL && pTableFrame->GetSitUserCount() > 0)
{
for (int i = 0; i < pTableFrame->GetChairCount(); i++)
{
IServerUserItem* pUserItem = pTableFrame->GetTableUserItem(i);
if (pUserItem && pUserItem->GetTableID() != INVALID_TABLE && pUserItem->GetUserStatus() == US_OFFLINE)
{
pTableInfo->fOfflineTimes[i] += 5.0f;
// 自动离开;
if (pTableInfo->fOfflineTimes[i] >= UNION_OFFLINE_LEAVE_TIME)
{
pTableFrame->PerformStandUpActionEx(pUserItem);
pTableInfo->fOfflineTimes[i] = 0;
}
}
}
}
}
}
// 申请解散超时;
if (pTableInfo->kDismissChairID.size() > 0)
{
pTableInfo->fDismissPastTime += 5.0f;
if (pTableInfo->fDismissPastTime >= DISMISS_WAITE_TIME)
{
// 无拒绝解散玩家,才进行解散;
if (pTableInfo->kNotAgreeChairID.size() < 1)
{
DismissRoom(pTableInfo);
}
pTableInfo->kNotAgreeChairID.clear();
pTableInfo->kDismissChairID.clear();
pTableInfo->fDismissPastTime = 0;
}
}
// 游戏开始时间;
if (pTableInfo->bStart)
{
//pTableInfo->fGameStartTime += 5.0f;
if (pTableInfo->IsOffLineUser())
{
pTableInfo->fGameStartTime += 5.0f;
}
else
{
pTableInfo->fGameStartTime = 0.0f;
}
}
}
return true;
}
case IDI_CREATE_UNION_ROOM:
{
if (m_UnionRoomList.kList.size() > 0)
{
// 查找是否有带开信息未开启;
for (int i = 0; i < (int)m_UnionRoomList.kList.size(); i++)
{
CMD_GR_AutoCreatePrivate& kInfo = m_UnionRoomList.kList[i];
PrivateTableInfo* pTableInfo = GetPrivateTableInfoByDaikaiIndex(kInfo.dwIndex);
if (pTableInfo == nullptr)
{
AutoCreateUnionRoom(kInfo);
}
}
}
//else
//{
// DBR_GR_UnionRoomInfo UnionRoom;
// ZeroMemory(&UnionRoom, sizeof(DBR_GR_UnionRoomInfo));
// UnionRoom.wServerID = m_pGameServiceOption->wServerID;
// UnionRoom.wKindID = m_pGameServiceOption->wKindID;
// m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_UNION_ROOM_INFO, 0L, &UnionRoom, sizeof(UnionRoom));
//}
return true;
}
case IDI_LOAD_UNION_ROOM:
{
DBR_GR_UnionRoomInfo UnionRoom;
ZeroMemory(&UnionRoom, sizeof(DBR_GR_UnionRoomInfo));
UnionRoom.wServerID = m_pGameServiceOption->wServerID;
UnionRoom.wKindID = m_pGameServiceOption->wKindID;
m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_UNION_ROOM_INFO, 0L, &UnionRoom, sizeof(UnionRoom));
return true;
}
}
// 重置自由人数场;
if (dwTimerID >= IDI_AUTO_USER_RESET && dwTimerID < (IDI_AUTO_USER_RESET + m_pGameServiceOption->wTableCount))
{
m_pITimerEngine->KillTimer(dwTimerID);
WORD wTableID = dwTimerID - IDI_AUTO_USER_RESET;
PrivateTableInfo* pTableInfo = &m_pTableInfo[wTableID];
if (pTableInfo != nullptr && pTableInfo->IsAutoUserCountRule())
{
if (pTableInfo->bInEnd || pTableInfo->bStart) return true;
pTableInfo->mReadyInfo.reset();
// 通知客户端可以重新准备;
tagAutoUserStatus autoUserStatus;
autoUserStatus.bStartGame = true;
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
}
}
return true;
}
//代开信息是否已经开启;
PrivateTableInfo* PriaveteGame::GetPrivateTableInfoByDaikaiIndex(DWORD dwDaikaiIndex)
{
for (int i = 0; i < m_pGameServiceOption->wTableCount; i++)
{
PrivateTableInfo* pTableInfo = &m_pTableInfo[i];
if (!pTableInfo->bStart && pTableInfo->m_dwDaikaiIndex == dwDaikaiIndex)
{
return pTableInfo;
}
}
return nullptr;
}
//发送数据
bool PriaveteGame::SendData(IServerUserItem * pIServerUserItem, WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
if(pIServerUserItem!=NULL)
return m_pIGameServiceFrame->SendData(pIServerUserItem,wMainCmdID,wSubCmdID,pData,wDataSize);
else
return m_pIGameServiceFrame->SendData(BG_ALL_CLIENT, wMainCmdID,wSubCmdID, pData, wDataSize);
return true;
}
bool PriaveteGame::SendTableData(ITableFrame* pITableFrame, WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
return pITableFrame->SendTableData(INVALID_CHAIR,wSubCmdID,pData,wDataSize,wMainCmdID);
}
void PriaveteGame::CreatePrivateCost(PrivateTableInfo* pTableInfo)
{
if (pTableInfo->cbRoomType == Type_Private)
{
CString strDebugInfo;
strDebugInfo.Format(_T("RoomID[%d], dwUserID[%d], dwCost[%d]"), pTableInfo->dwRoomNum, pTableInfo->dwCreaterUserID, pTableInfo->dwPlayCost);
::OutputDebugString(strDebugInfo.GetBuffer());
// 不是工会开房扣费，工会开房已经提前扣费;
if (pTableInfo->dwUnionCode == 0)
{
if (pTableInfo->IsCardAARule())
{
EveryOnePrivateCost(pTableInfo, true);
}
else
{
CreaterPlayerPrivateCost(pTableInfo);
}
}
}
else if (pTableInfo->cbRoomType == Type_Public)
{
EveryOnePrivateCost(pTableInfo, false);
}
}
PrivateTableInfo* PriaveteGame::getTableInfoByRoomID(DWORD dwRoomID)
{
for (int i = 0;i<m_pGameServiceOption->wTableCount;i++)
{
if (m_pTableInfo[i].dwRoomNum == dwRoomID)
{
return &m_pTableInfo[i];
}
}
return NULL;
}
PrivateTableInfo* PriaveteGame::getTableInfoByCreaterID(DWORD dwUserID)
{
for (int i = 0;i<m_pGameServiceOption->wTableCount;i++)
{
if (m_pTableInfo[i].dwCreaterUserID == dwUserID)
{
return &m_pTableInfo[i];
}
}
return NULL;
}
PrivateTableInfo* PriaveteGame::getTableInfoByTableID(DWORD dwRoomID)
{
for (int i = 0;i<m_pGameServiceOption->wTableCount;i++)
{
if (m_pTableInfo[i].pITableFrame && m_pTableInfo[i].pITableFrame->GetTableID() == dwRoomID)
{
return &m_pTableInfo[i];
}
}
return NULL;
}
PrivateTableInfo* PriaveteGame::getTableInfoByTableFrame(ITableFrame* pTableFrame)
{
for (int i = 0;i<m_pGameServiceOption->wTableCount;i++)
{
if (m_pTableInfo[i].pITableFrame == pTableFrame)
{
return &m_pTableInfo[i];
}
}
return NULL;
}
//数据库事件
bool PriaveteGame::OnEventDataBase(WORD wRequestID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
switch (wRequestID)
{
case DBO_GR_PRIVATE_INFO: //私人场信息
{
//参数效验
if(wDataSize>sizeof(DBO_GR_Private_Info)) return false;
//提取数据
DBO_GR_Private_Info * pPrivate = (DBO_GR_Private_Info*)pData;
m_kPrivateInfo.wKindID = pPrivate->wKindID;
m_kPrivateInfo.lCostGold = pPrivate->lCostGold;
memcpy(&m_kPrivateInfo.bPlayCout,pPrivate->bPlayCout,sizeof(m_kPrivateInfo.bPlayCout));
memcpy(&m_kPrivateInfo.lPlayCost,pPrivate->lPlayCost,sizeof(m_kPrivateInfo.lPlayCost));
break;
}
case DBO_GR_CREATE_PRIVATE: //私人场信息
{
if (pIServerUserItem == nullptr) return false;
OnEventCreatePrivate(wRequestID,pIServerUserItem,pData,wDataSize,"");
break;
}
case DBO_GR_SINGLE_RECORD:
{
//参数效验;
if (wDataSize != sizeof(DBO_GR_SingleGameRecord)) return false;
DBO_GR_SingleGameRecord* pSingleGameRecord = (DBO_GR_SingleGameRecord*)pData;
PrivateTableInfo* pTableInfo = getTableInfoByCreaterID(pSingleGameRecord->dwCreaterUserID);
if ( NULL != pTableInfo )
{
pTableInfo->kTotalRecord.iRecordID = pSingleGameRecord->dwRecordID;
}
break;
}
case DBO_GR_CREATE_UNION_ROOM:
{
//参数效验;
if (wDataSize != sizeof(DBO_GR_CreateUnionRoomResult)) return false;
DBO_GR_CreateUnionRoomResult* pUnionRoomResult = (DBO_GR_CreateUnionRoomResult*)pData;
PrivateTableInfo* pTableInfo = getTableInfoByRoomID(pUnionRoomResult->dwRoomID);
if (NULL != pTableInfo)
{
pTableInfo->dwUnionConsumerID = pUnionRoomResult->dwUnionConsumerID;
}
break;
}
case DBO_GR_JOIN_UNION_ROOM:
{
//参数效验;
if (wDataSize != sizeof(DBO_GR_JoinUnionRoomResult)) return false;
if (pIServerUserItem == nullptr) return false;
DBO_GR_JoinUnionRoomResult* pJoinUnionRoomResult = (DBO_GR_JoinUnionRoomResult*)pData;
// 可以加入;
if (pJoinUnionRoomResult->bSucess)
{
PrivateTableInfo* pTableInfo = getTableInfoByRoomID(pJoinUnionRoomResult->dwRoomID);
if (NULL != pTableInfo)
{
//joinPrivateRoom(pIServerUserItem, pTableInfo->pITableFrame);
joinPrivateRoom(pIServerUserItem, pTableInfo, pJoinUnionRoomResult->lUnionScore);
}
}
else
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, pJoinUnionRoomResult->szDescribeString, SMT_EJECT);
}
break;
}
case DBO_GR_UnionRoomInfo:
{
// 判断服务器维护;
if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true) return true;
// 确保空;
if (m_UnionRoomList.kList.size() > 0)
{
m_UnionRoomList.kList.clear();
}
DataStream kDataStream(pData, wDataSize);
m_UnionRoomList.StreamValue(kDataStream, false);
for (int i = 0; i < (int)m_UnionRoomList.kList.size(); i++)
{
CMD_GR_AutoCreatePrivate& kInfo = m_UnionRoomList.kList[i];
PrivateTableInfo* pTableInfo = GetPrivateTableInfoByDaikaiIndex(kInfo.dwIndex);
if (pTableInfo == nullptr)
{
AutoCreateUnionRoom(kInfo);
}
}
break;
}
case DBO_GR_AUTO_CREATE:
{
OnEventCreateAuto(wRequestID, pData, wDataSize, "");
break;
}
case DBO_GR_ADD_AUTO_SUCC:
{
OnEventAddAutoRoomSucc(pIServerUserItem, pData, wDataSize);
break;
}
case DBO_GR_ADD_AUTO_ERR:
{
//发送错误
DBO_GR_AutoFailure * pLogonFailure = (DBO_GR_AutoFailure *)pData;
SendAddAutoResult(pIServerUserItem, pLogonFailure->szDescribeString, pLogonFailure->lResultCode);
break;
}
case DBO_GR_DEL_AUTO_RESULTE:
{
//发送错误
DBO_GR_AutoFailure * pLogonFailure = (DBO_GR_AutoFailure *)pData;
SendAddAutoResult(pIServerUserItem, pLogonFailure->szDescribeString, pLogonFailure->lResultCode);
break;
}
}
return true;
}
//自动创建房间;
void PriaveteGame::AutoCreateUnionRoom(CMD_GR_AutoCreatePrivate &CreatePrivate)
{
if (CreatePrivate.cbGameType == Type_Private)
{
DBR_GR_Create_Private kDBRInfo;
kDBRInfo.dwUserID = INVALID_CHAIR;
kDBRInfo.dwDaikaiIndex = CreatePrivate.dwIndex;
kDBRInfo.wKindID = m_pGameServiceAttrib->wKindID;
kDBRInfo.dwUnionCode = CreatePrivate.dwUnionCode;
kDBRInfo.cbUnionGoldOpen = CreatePrivate.cbUnionGoldOpen;
kDBRInfo.cbRoomType = Type_Private;
kDBRInfo.dwCostType = Type_Private;
kDBRInfo.dwAgaginTable = INVALID_DWORD;
ASSERT(CreatePrivate.bPlayCoutIdex < 4);
ASSERT(m_kPrivateInfo.lPlayCost[CreatePrivate.bPlayCoutIdex] != 0);
kDBRInfo.dwCost = (DWORD)m_kPrivateInfo.lPlayCost[CreatePrivate.bPlayCoutIdex];
kDBRInfo.bPlayCoutIdex = CreatePrivate.bPlayCoutIdex;
kDBRInfo.bGameRuleIdex = CreatePrivate.bGameRuleIdex;
kDBRInfo.bGameTypeIdex = CreatePrivate.bGameTypeIdex;
kDBRInfo.cbEnterRoomScoreType = CreatePrivate.cbEnterRoomScoreType;
kDBRInfo.lInitEnterRoomScore = CreatePrivate.lInitEnterRoomScore;
kDBRInfo.cbBaseScore = CreatePrivate.cbBaseScore;
if ((kDBRInfo.bGameRuleIdex & ePrivateTableCommonRule_CardAA) == ePrivateTableCommonRule_CardAA)
{
if (m_pGameServiceAttrib->wChairCount > 0)
{
kDBRInfo.dwCost = kDBRInfo.dwCost / m_pGameServiceAttrib->wChairCount;
}
}
CString strDebugInfo;
strDebugInfo.Format(_T("dwUserID[%d], bPlayCoutIdex[%d], dwCost[%d], bPlayCoutIdex[%d], bGameRuleIdex[%d], bGameTypeIdex[%d]"),
kDBRInfo.dwUserID, CreatePrivate.bPlayCoutIdex, kDBRInfo.dwCost, kDBRInfo.bPlayCoutIdex, kDBRInfo.bGameRuleIdex, kDBRInfo.bGameTypeIdex);
::OutputDebugString(strDebugInfo.GetBuffer());
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_AUTO_UNION_ROOM, 0L, &kDBRInfo, sizeof(DBR_GR_Create_Private));
}
}
//自动创建房间
bool PriaveteGame::OnEventCreateAuto(WORD wRequestID, VOID * pData, WORD wDataSize, std::string kChannel)
{
//参数效验
if (wDataSize > sizeof(DBO_GR_CreatePrivateResoult)) return false;
//提取数据
DBO_GR_CreatePrivateResoult* pPrivate = (DBO_GR_CreatePrivateResoult*)pData;
DWORD dwAgaginTable = pPrivate->dwAgaginTable;
//报名失败
if (pPrivate->bSucess == false)
{
CTraceService::TraceString(pPrivate->szDescribeString, TraceLevel_Normal);
return true;
}
if (pPrivate->bPlayCoutIdex >= 4)
{
return false;
}
//寻找位置
ITableFrame * pICurrTableFrame = NULL;
PrivateTableInfo* pCurrTableInfo = NULL;
//WORD wTableID = 0;
for (WORD wTableID = 0; wTableID < m_pGameServiceOption->wTableCount; wTableID++)
{
//获取对象
ASSERT(m_pTableInfo[wTableID].pITableFrame != NULL);
ITableFrame * pITableFrame = m_pTableInfo[wTableID].pITableFrame;
if (m_pTableInfo[wTableID].bInEnd) continue;
// 代开房间;
if (m_pTableInfo[wTableID].m_dwDaikaiIndex == 0)
{
if (pITableFrame->GetNullChairCount() == pITableFrame->GetChairCount())
{
pICurrTableFrame = pITableFrame;
pCurrTableInfo = &m_pTableInfo[wTableID];
pCurrTableInfo->restValue();
break;
}
}
}
//桌子判断
if (pICurrTableFrame == NULL)
{
return true;
}
if (m_pGameServiceOption->wServerID >= 90)
{
ASSERT(false);
return true;
}
int iRandNum = m_allocationID.PopValue();
iRandNum = (m_pGameServiceOption->wServerID + 10) * 10000 + iRandNum;
pCurrTableInfo->dwPlayCout = (DWORD)m_kPrivateInfo.bPlayCout[pPrivate->bPlayCoutIdex];
if (pPrivate->cbRoomType == Type_Private)
{
pCurrTableInfo->dwPlayCost = (DWORD)m_kPrivateInfo.lPlayCost[pPrivate->bPlayCoutIdex];
}
else
{
pCurrTableInfo->dwPlayCost = (DWORD)m_kPrivateInfo.lCostGold;
}
pCurrTableInfo->setRoomNum(iRandNum);
pCurrTableInfo->dwCreaterUserID = INVALID_CHAIR;
pCurrTableInfo->dwUnionCode = pPrivate->dwUnionCode;
pCurrTableInfo->m_dwDaikaiIndex = pPrivate->dwDaikaiIndex;
pCurrTableInfo->kHttpChannel = kChannel;
pCurrTableInfo->cbRoomType = pPrivate->cbRoomType;
pCurrTableInfo->dwGameRuleIdex = pPrivate->bGameRuleIdex;
pCurrTableInfo->bGameTypeIdex = pPrivate->bGameTypeIdex;
pCurrTableInfo->bPlayCoutIdex = pPrivate->bPlayCoutIdex;
GetLocalTime(&pCurrTableInfo->kTotalRecord.kPlayTime);
pCurrTableInfo->cbEnterRoomScoreType = pPrivate->cbEnterRoomScoreType;
pCurrTableInfo->lInitEnterRoomScore = pPrivate->lInitEnterRoomScore;
pCurrTableInfo->cbBaseScore = pPrivate->cbBaseScore;
pCurrTableInfo->cbUnionGoldOpen = pPrivate->cbUnionGoldOpen;
pCurrTableInfo->lScoreMultiple = pPrivate->lScoreMultiple;
pCurrTableInfo->lGameGold = pPrivate->lGameGold;
if (pPrivate->dwAgaginTable == INVALID_DWORD)
{
pCurrTableInfo->kTotalRecord.iRecordID = pPrivate->dwRecordID;
}
tagPrivateFrameParameter PriavateFrame;
PriavateFrame.dwCreaterUserID = pCurrTableInfo->dwCreaterUserID;
PriavateFrame.dwRoomNum = pCurrTableInfo->dwRoomNum;
PriavateFrame.dwPlayCost = pCurrTableInfo->dwPlayCost;
PriavateFrame.cbGameTypeIdex = (BYTE)pCurrTableInfo->dwGameRuleIdex;
PriavateFrame.cbGameCout = (BYTE)pCurrTableInfo->dwPlayCout;
PriavateFrame.dwGameRule = pCurrTableInfo->dwGameRuleIdex;
PriavateFrame.cbEnterRoomScoreType = pCurrTableInfo->cbEnterRoomScoreType; //进房间时的分数类型;
PriavateFrame.lInitEnterRoomScore = pCurrTableInfo->lInitEnterRoomScore; //进入房间时的分数;
PriavateFrame.cbUnionGoldOpen = pCurrTableInfo->cbUnionGoldOpen;
PriavateFrame.lScoreMultiple = pCurrTableInfo->lScoreMultiple;
PriavateFrame.lGameGold = pCurrTableInfo->lGameGold;
PriavateFrame.cbBaseScore = pCurrTableInfo->cbBaseScore;
pICurrTableFrame->SetPrivateInfo(PriavateFrame);
CString strTmp;
strTmp.Format(_T("创建代开房间: %d, %d，%d"), iRandNum, pPrivate->bPlayCoutIdex, pPrivate->cbBaseScore);
CTraceService::TraceString(strTmp, TraceLevel_Normal);
sendPrivateRoomInfo(NULL, pCurrTableInfo);
// 通知数据库扣费;
if (pPrivate->dwUnionCode != 0)
{
DBR_GR_Create_UnionRoom CreateUnionRoom;
ZeroMemory(&CreateUnionRoom, sizeof(DBR_GR_Create_UnionRoom));
CreateUnionRoom.wServerID = m_pGameServiceOption->wServerID;
CreateUnionRoom.dwUnionCode = pPrivate->dwUnionCode;
CreateUnionRoom.dwRoomID = pCurrTableInfo->dwRoomNum;
CreateUnionRoom.dwCreaterUserID = pCurrTableInfo->dwCreaterUserID;
CreateUnionRoom.wKindID = m_pGameServiceAttrib->wKindID;
CreateUnionRoom.dwCost = pCurrTableInfo->dwPlayCost;
CreateUnionRoom.dwCostType = pCurrTableInfo->cbRoomType;
CreateUnionRoom.dwGameRuleIdex = pCurrTableInfo->dwGameRuleIdex;
CreateUnionRoom.bPlayCoutIdex = (BYTE)pCurrTableInfo->dwPlayCout;
CreateUnionRoom.dwRecordID = pPrivate->dwRecordID;
CreateUnionRoom.cbBaseScore = pPrivate->cbBaseScore;
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_CREATE_UNION_ROOM, 0L, (BYTE*)&CreateUnionRoom, sizeof(DBR_GR_Create_UnionRoom));
}
else
{
DataStream kDataStream;
pCurrTableInfo->kTotalRecord.StreamValue(kDataStream, true);
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_PRIVATE_GAME_RECORD, 0, &kDataStream[0], kDataStream.size());
}
//// 设置房主积分;
//PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
//if (NULL == pTableInfo) return true;
//if (pTableInfo->bInEnd) return true;
//if (pTableInfo->IsSetOneTimeRoomScoreType())
//{ //进入房间时赋值为初始积分;
// SCORE lScore = pTableInfo->lInitEnterRoomScore - pIServerUserItem->GetUserScore();
// pIServerUserItem->WriteUserScore(lScore, 0, 0, 0, SCORE_TYPE_PRESENT, 1, 0);
//}
return true;
}
//bool PriaveteGame::joinPrivateRoom(IServerUserItem * pIServerUserItem, ITableFrame * pICurrTableFrame)
bool PriaveteGame::joinPrivateRoom(IServerUserItem * pIServerUserItem, PrivateTableInfo* pTableInfo, SCORE lUnionScore)
{
WORD wChairID = INVALID_CHAIR;
ITableFrame * pICurrTableFrame = pTableInfo->pITableFrame;
//椅子搜索
for (WORD i=0;i<pICurrTableFrame->GetChairCount();i++)
{
if (pICurrTableFrame->GetTableUserItem(i)==NULL)
{
wChairID = i;
break;
}
}
//分配用户
if (wChairID!=INVALID_CHAIR)
{
//用户起立
if (pIServerUserItem->GetTableID()!=INVALID_TABLE)
{
return pIServerUserItem->GetTableID() == pICurrTableFrame->GetTableID();
}
//用户坐下
if(pICurrTableFrame->PerformSitDownAction(wChairID,pIServerUserItem)==false)
{
return false;
}
// 记录欢乐积分
pTableInfo->lScoreInfoArray[wChairID] = lUnionScore;
// 通知数据库写座位号;
DBR_GR_WriteUnionRoomChairID JoinRoomUser;
ZeroMemory(&JoinRoomUser, sizeof(JoinRoomUser));
JoinRoomUser.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
JoinRoomUser.wChairID = wChairID;
JoinRoomUser.dwUserID = pIServerUserItem->GetUserID();
m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_WRITE_UNION_CHAIRID, 0L, (BYTE*)&JoinRoomUser, sizeof(DBR_GR_WriteUnionRoomChairID));
return true;
}
return false;
}
//创建房间
bool PriaveteGame::OnEventCreatePrivate(WORD wRequestID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize,std::string kChannel)
{
//参数效验
if(pIServerUserItem==NULL) return true;
if(wDataSize>sizeof(DBO_GR_CreatePrivateResoult)) return false;
//提取数据
DBO_GR_CreatePrivateResoult* pPrivate = (DBO_GR_CreatePrivateResoult*)pData;
DWORD dwAgaginTable = pPrivate->dwAgaginTable;
//报名失败
if(pPrivate->bSucess==false)
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,pPrivate->szDescribeString,SMT_EJECT);
CTraceService::TraceString(pPrivate->szDescribeString, TraceLevel_Normal);
return true;
}
if (pPrivate->bPlayCoutIdex >= 4)
{
return false;
}
//寻找位置
ITableFrame * pICurrTableFrame=NULL;
PrivateTableInfo* pCurrTableInfo=NULL;
if (dwAgaginTable != INVALID_DWORD)
{
pCurrTableInfo = getTableInfoByTableID(dwAgaginTable);
if (!pCurrTableInfo)
{
return false;
}
pICurrTableFrame = pCurrTableInfo->pITableFrame;
if (pCurrTableInfo->bInEnd == false)
{
//joinPrivateRoom(pIServerUserItem,pICurrTableFrame);
joinPrivateRoom(pIServerUserItem, pCurrTableInfo, pPrivate->lUnionScore);
return true;
}
else
{
pCurrTableInfo->restAgainValue();
sendPrivateRoomInfo(NULL,pCurrTableInfo);
}
}
else
{
//WORD wTableID = 0;
for (WORD wTableID = 0; wTableID < m_pGameServiceOption->wTableCount; wTableID++)
{
//获取对象
ASSERT(m_pTableInfo[wTableID].pITableFrame!=NULL);
ITableFrame * pITableFrame=m_pTableInfo[wTableID].pITableFrame;
if (m_pTableInfo[wTableID].bInEnd) continue;
// 代开房间;
if (m_pTableInfo[wTableID].m_dwDaikaiIndex == 0)
{
if (pITableFrame->GetNullChairCount() == pITableFrame->GetChairCount())
{
pICurrTableFrame = pITableFrame;
pCurrTableInfo = &m_pTableInfo[wTableID];
pCurrTableInfo->restValue();
break;
}
}
}
if (getTableInfoByCreaterID(pIServerUserItem->GetUserID()))
{
return true;
}
}
//桌子判断
if(pICurrTableFrame==NULL)
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,TEXT("房间已满，创建房间失败。"),SMT_EJECT);
return true;
}
if (m_pGameServiceOption->wServerID >= 90)
{
ASSERT(false);
return true;
}
int iRandNum = m_allocationID.PopValue();
iRandNum = (m_pGameServiceOption->wServerID+10)*10000+iRandNum;
pCurrTableInfo->dwPlayCout = (DWORD)m_kPrivateInfo.bPlayCout[pPrivate->bPlayCoutIdex];
if (pPrivate->cbRoomType == Type_Private)
{
pCurrTableInfo->dwPlayCost = (DWORD)m_kPrivateInfo.lPlayCost[pPrivate->bPlayCoutIdex];
}
else
{
pCurrTableInfo->dwPlayCost = (DWORD)m_kPrivateInfo.lCostGold;
}
pCurrTableInfo->setRoomNum(iRandNum);
pCurrTableInfo->dwCreaterUserID = pIServerUserItem->GetUserID();
pCurrTableInfo->dwUnionCode = pPrivate->dwUnionCode;
pCurrTableInfo->kHttpChannel = kChannel;
pCurrTableInfo->cbRoomType = pPrivate->cbRoomType;
pCurrTableInfo->lCreateScore = pPrivate->lUnionScore;
pCurrTableInfo->dwGameRuleIdex = pPrivate->bGameRuleIdex;
pCurrTableInfo->bGameTypeIdex = pPrivate->bGameTypeIdex;
pCurrTableInfo->bPlayCoutIdex = pPrivate->bPlayCoutIdex;
GetLocalTime(&pCurrTableInfo->kTotalRecord.kPlayTime);
pCurrTableInfo->cbEnterRoomScoreType = pPrivate->cbEnterRoomScoreType;
pCurrTableInfo->lInitEnterRoomScore = pPrivate->lInitEnterRoomScore;
pCurrTableInfo->cbBaseScore = pPrivate->cbBaseScore;
pCurrTableInfo->cbUnionGoldOpen = pPrivate->cbUnionGoldOpen;
pCurrTableInfo->lScoreMultiple = pPrivate->lScoreMultiple;
pCurrTableInfo->lGameGold = pPrivate->lGameGold;
if (pPrivate->dwAgaginTable == INVALID_DWORD)
{
pCurrTableInfo->kTotalRecord.iRecordID = pPrivate->dwRecordID;
}
tagPrivateFrameParameter PriavateFrame;
PriavateFrame.dwCreaterUserID = pCurrTableInfo->dwCreaterUserID;
PriavateFrame.dwRoomNum = pCurrTableInfo->dwRoomNum;
PriavateFrame.dwPlayCost = pCurrTableInfo->dwPlayCost;
PriavateFrame.cbGameTypeIdex = (BYTE)pCurrTableInfo->dwGameRuleIdex;
PriavateFrame.cbGameCout = (BYTE)pCurrTableInfo->dwPlayCout;
PriavateFrame.dwGameRule = pCurrTableInfo->dwGameRuleIdex;
PriavateFrame.cbEnterRoomScoreType = pCurrTableInfo->cbEnterRoomScoreType; //进房间时的分数类型;
PriavateFrame.lInitEnterRoomScore = pCurrTableInfo->lInitEnterRoomScore; //进入房间时的分数;
PriavateFrame.cbBaseScore = pCurrTableInfo->cbBaseScore;
PriavateFrame.cbUnionGoldOpen = pCurrTableInfo->cbUnionGoldOpen;
PriavateFrame.lScoreMultiple = pCurrTableInfo->lScoreMultiple;
PriavateFrame.lGameGold = pCurrTableInfo->lGameGold;
pICurrTableFrame->SetPrivateInfo(PriavateFrame);
//pICurrTableFrame->SetPrivateInfo(pCurrTableInfo->bGameTypeIdex,pCurrTableInfo->bGameRuleIdex);
CMD_GF_Create_Private_Sucess kSucessInfo;
kSucessInfo.lCurSocre = pPrivate->bSucess;
kSucessInfo.dwRoomNum = pCurrTableInfo->dwRoomNum;
SendData(pIServerUserItem,MDM_GR_PRIVATE,SUB_GR_CREATE_PRIVATE_SUCESS,&kSucessInfo,sizeof(kSucessInfo));
CString strTmp;
strTmp.Format(_T("创建房间: %d, %d"), iRandNum, pPrivate->bPlayCoutIdex);
CTraceService::TraceString(strTmp, TraceLevel_Normal);
sendPrivateRoomInfo(NULL,pCurrTableInfo);
// 通知数据库扣费;
if (pPrivate->dwUnionCode != 0)
{
DBR_GR_Create_UnionRoom CreateUnionRoom;
ZeroMemory(&CreateUnionRoom, sizeof(DBR_GR_Create_UnionRoom));
CreateUnionRoom.wServerID = m_pGameServiceOption->wServerID;
CreateUnionRoom.dwUnionCode = pPrivate->dwUnionCode;
CreateUnionRoom.dwRoomID = pCurrTableInfo->dwRoomNum;
CreateUnionRoom.dwCreaterUserID = pCurrTableInfo->dwCreaterUserID;
CreateUnionRoom.wKindID = m_pGameServiceAttrib->wKindID;
CreateUnionRoom.dwCost = pCurrTableInfo->dwPlayCost;
CreateUnionRoom.dwCostType = pCurrTableInfo->cbRoomType;
CreateUnionRoom.dwGameRuleIdex = pCurrTableInfo->dwGameRuleIdex;
CreateUnionRoom.bPlayCoutIdex = (BYTE)pCurrTableInfo->dwPlayCout;
CreateUnionRoom.dwRecordID = pPrivate->dwRecordID;
CreateUnionRoom.cbBaseScore = pPrivate->cbBaseScore;
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_CREATE_UNION_ROOM, 0L, (BYTE*)&CreateUnionRoom, sizeof(DBR_GR_Create_UnionRoom));
}
else
{
DataStream kDataStream;
pCurrTableInfo->kTotalRecord.StreamValue(kDataStream, true);
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_PRIVATE_GAME_RECORD, 0, &kDataStream[0], kDataStream.size());
}
// 设置房主积分;
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (NULL == pTableInfo) return true;
if (pTableInfo->bInEnd) return true;
if (pTableInfo->IsSetOneTimeRoomScoreType())
{ //进入房间时赋值为初始积分;
SCORE lScore = pTableInfo->lInitEnterRoomScore - pIServerUserItem->GetUserScore();
pIServerUserItem->WriteUserScore(lScore, 0, 0, 0, SCORE_TYPE_PRESENT, 1, 0);
}
return true;
}
//创建私人场
bool PriaveteGame::OnTCPNetworkSubCreatePrivate(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
//参数效验
ASSERT(wDataSize==sizeof(CMD_GR_Create_Private));
if(wDataSize!=sizeof(CMD_GR_Create_Private)) return false;
// 判断服务器维护;
if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true)
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("服务器即将维护，请关注微信群通知。"), SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
return true;
}
CMD_GR_Create_Private* pCMDInfo = (CMD_GR_Create_Private*)pData;
if (pIServerUserItem->GetTableID() != INVALID_TABLE)
{
SendData(pIServerUserItem, MDM_GR_PRIVATE, SUB_GR_PRIVATE_HAS_CREATED, NULL, 0);
return true;
}
if(pCMDInfo->cbGameType == Type_Private)
{
DBR_GR_Create_Private kDBRInfo;
kDBRInfo.dwUserID = pIServerUserItem->GetUserID();
kDBRInfo.wKindID = m_pGameServiceAttrib->wKindID;
kDBRInfo.dwDaikaiIndex = 0;
kDBRInfo.dwUnionCode = pCMDInfo->dwUnionCode;
kDBRInfo.cbUnionGoldOpen = pCMDInfo->cbUnionGoldOpen;
kDBRInfo.cbRoomType = Type_Private;
kDBRInfo.dwCostType = Type_Private;
kDBRInfo.dwAgaginTable = INVALID_DWORD;
ASSERT(pCMDInfo->bPlayCoutIdex < 4);
ASSERT(m_kPrivateInfo.lPlayCost[pCMDInfo->bPlayCoutIdex] != 0);
kDBRInfo.dwCost = (DWORD)m_kPrivateInfo.lPlayCost[pCMDInfo->bPlayCoutIdex];
kDBRInfo.bPlayCoutIdex = pCMDInfo->bPlayCoutIdex;
kDBRInfo.bGameRuleIdex = pCMDInfo->bGameRuleIdex;
kDBRInfo.bGameTypeIdex = pCMDInfo->bGameTypeIdex;
kDBRInfo.cbEnterRoomScoreType = pCMDInfo->cbEnterRoomScoreType;
kDBRInfo.lInitEnterRoomScore = pCMDInfo->lInitEnterRoomScore;
kDBRInfo.cbBaseScore = pCMDInfo->cbBaseScore;
if ((kDBRInfo.bGameRuleIdex & ePrivateTableCommonRule_CardAA) == ePrivateTableCommonRule_CardAA)
{
if (m_pGameServiceAttrib->wChairCount > 0)
{
kDBRInfo.dwCost = kDBRInfo.dwCost / m_pGameServiceAttrib->wChairCount;
}
}
CString strDebugInfo;
strDebugInfo.Format(_T("dwUserID[%d], bPlayCoutIdex[%d], dwCost[%d], bPlayCoutIdex[%d], bGameRuleIdex[%d], bGameTypeIdex[%d]"),
kDBRInfo.dwUserID, pCMDInfo->bPlayCoutIdex, kDBRInfo.dwCost, kDBRInfo.bPlayCoutIdex, kDBRInfo.bGameRuleIdex, kDBRInfo.bGameTypeIdex);
::OutputDebugString(strDebugInfo.GetBuffer());
m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_CREATE_PRIVAT, dwSocketID, &kDBRInfo, sizeof(DBR_GR_Create_Private));
}
return true;
}
//创建代开信息
bool PriaveteGame::OnTCPNetworkSubAutoRoomInfo(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
//参数效验
ASSERT(wDataSize == sizeof(CMD_GR_AutoRoomInfo));
if (wDataSize != sizeof(CMD_GR_AutoRoomInfo)) return false;
// 判断服务器维护;
if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true)
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("服务器即将维护，请关注微信群通知。"), SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
return true;
}
CMD_GR_AutoRoomInfo* pCMDInfo = (CMD_GR_AutoRoomInfo*)pData;
ASSERT(pCMDInfo->dwUserID == pIServerUserItem->GetUserID());
if (pCMDInfo->cbGameType == Type_Private)
{
DBR_GR_AutoRoomInfo kDBRInfo;
kDBRInfo.dwUserID = pCMDInfo->dwUserID;
kDBRInfo.wKindID = m_pGameServiceAttrib->wKindID;
kDBRInfo.wServerID = m_pGameServiceOption->wServerID;
kDBRInfo.cbGameType = pCMDInfo->cbGameType;
ASSERT(pCMDInfo->bPlayCoutIdex < 4);
ASSERT(m_kPrivateInfo.lPlayCost[pCMDInfo->bPlayCoutIdex] != 0);
kDBRInfo.bPlayCoutIdex = pCMDInfo->bPlayCoutIdex;
kDBRInfo.bPlayCout = m_kPrivateInfo.bPlayCout[pCMDInfo->bPlayCoutIdex];
kDBRInfo.bGameRuleIdex = pCMDInfo->bGameRuleIdex;
kDBRInfo.bGameTypeIdex = pCMDInfo->bGameTypeIdex;
kDBRInfo.cbEnterRoomScoreType = pCMDInfo->cbEnterRoomScoreType;
kDBRInfo.lInitEnterRoomScore = pCMDInfo->lInitEnterRoomScore;
kDBRInfo.cbBaseScore = pCMDInfo->cbBaseScore;
m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_ADD_AUTO_ROOM_INFO, dwSocketID, &kDBRInfo, sizeof(DBR_GR_AutoRoomInfo));
}
return true;
}
//增加自动开房信息成功;
bool PriaveteGame::OnEventAddAutoRoomSucc(IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
ASSERT(wDataSize == sizeof(CMD_GR_AutoCreatePrivate));
if (pIServerUserItem == nullptr) return false;
if (wDataSize != sizeof(CMD_GR_AutoCreatePrivate)) return false;
CMD_GR_AutoCreatePrivate AutoCreate;
memcpy(&AutoCreate, pData, wDataSize);
// 查找列表中是否存在该记录;m_UnionRoomList
for (int i = 0; i < (int)m_UnionRoomList.kList.size(); i++)
{
CMD_GR_AutoCreatePrivate& kInfo = m_UnionRoomList.kList[i];
if (kInfo.dwIndex == AutoCreate.dwIndex)
{
return false;
}
}
// 不存在加入列表，然后创建房间;
AutoCreateUnionRoom(AutoCreate);
m_UnionRoomList.kList.push_back(AutoCreate);
// 通知客户端增加成功;
SendAddAutoResult(pIServerUserItem, TEXT("添加代开信息成功！"), 0);
return true;
}
//发送增加自动开房结果;
bool PriaveteGame::SendAddAutoResult(IServerUserItem * pIServerUserItem, LPCTSTR pszString, LONG lErrorCode)
{
//变量定义
CMD_GR_AutoResulte autoFailure;
ZeroMemory(&autoFailure, sizeof(autoFailure));
//构造数据
autoFailure.lErrorCode = lErrorCode;
lstrcpyn(autoFailure.szDescribeString, pszString, CountArray(autoFailure.szDescribeString));
//数据属性
WORD wDataSize = CountStringBuffer(autoFailure.szDescribeString);
WORD wHeadSize = sizeof(autoFailure) - sizeof(autoFailure.szDescribeString);
//发送数据
return SendData(pIServerUserItem, MDM_GR_PRIVATE, SUB_GR_CREATE_AUTO_RESULTE, &autoFailure, wHeadSize + wDataSize);
}
//删除代开信息
bool PriaveteGame::OnTCPNetworkSubDelAutoRoomInfo(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
//参数效验
ASSERT(wDataSize == sizeof(CMD_GP_DelAutoRoomInfo));
if (wDataSize != sizeof(CMD_GP_DelAutoRoomInfo)) return false;
CMD_GP_DelAutoRoomInfo* pDelAutoInfo = (CMD_GP_DelAutoRoomInfo*)pData;
if (pDelAutoInfo->wServerID != m_pGameServiceOption->wServerID) return false;
// 删除内存数据;
bool bHasAutoRoomInfo = false;
for (std::vector<CMD_GR_AutoCreatePrivate>::iterator iter = m_UnionRoomList.kList.begin(); iter != m_UnionRoomList.kList.end(); iter++)
{
if ((*iter).dwIndex == pDelAutoInfo->dwIndex)
{
iter = m_UnionRoomList.kList.erase(iter);
bHasAutoRoomInfo = true;
break;
}
}
if (bHasAutoRoomInfo)
{
// 解散内存房间;
for (int i = 0; i < m_pGameServiceOption->wTableCount; i++)
{
PrivateTableInfo* pTableInfo = &m_pTableInfo[i];
//已经创建并且没有开始的桌子
if (pTableInfo->dwCreaterUserID > 0 && !pTableInfo->bStart)
{
if ((pTableInfo->dwGameRuleIdex&ePrivateTableCommonRule_DaiKaiFang) == ePrivateTableCommonRule_DaiKaiFang)
{
if (pTableInfo->m_dwDaikaiIndex == pDelAutoInfo->dwIndex)
{
DismissRoom(pTableInfo);
break;
}
}
}
}
// 删除数据库数据;
DBO_GR_DelAutoRoomInfo DelAutoRoomInfo;
DelAutoRoomInfo.dwUserID = pIServerUserItem->GetUserID();
DelAutoRoomInfo.dwIndex = pDelAutoInfo->dwIndex;
DelAutoRoomInfo.wServerID = pDelAutoInfo->wServerID;
m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_DEL_AUTO_ROOM_INFO, dwSocketID, &DelAutoRoomInfo, sizeof(DelAutoRoomInfo));
//SendAddAutoResult(pIServerUserItem, TEXT("删除代开信息完成！"), 0);
}
else
{
SendAddAutoResult(pIServerUserItem, TEXT("抱歉，未找到代开信息！"), 1);
}
return true;
}
//自由人数玩家状态，玩家可以准备;
bool PriaveteGame::OnTCPNetworkSubAutoUserStatus(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
//PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
//if (!pTableInfo)
//{
// return false;
//}
//// 结束了或者已经开始了，就不处理该消息;
//if (pTableInfo->bInEnd || pTableInfo->bStart)
//{
// return true;
//}
//WORD wChairID = pIServerUserItem->GetChairID();
//if (wChairID == INVALID_CHAIR) return false;
//pTableInfo->bAutoStart[wChairID] = true;
//// 发送状态;
//SendAutoUserStatus(pTableInfo);
return true;
}
//自由人数准备状态
bool PriaveteGame::OnTCPNetworkSubAutoUserReady(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
//参数效验
ASSERT(wDataSize == sizeof(CMD_GR_Private_Ready));
if (wDataSize != sizeof(CMD_GR_Private_Ready)) return false;
CMD_GR_Private_Ready* pCMDInfo = (CMD_GR_Private_Ready*)pData;
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return false;
}
// 结束了或者已经开始了，就不处理该消息;
if (pTableInfo->bInEnd || pTableInfo->bStart)
{
return true;
}
WORD wChairID = pIServerUserItem->GetChairID();
WORD wTableID = pIServerUserItem->GetTableID();
if (wChairID == INVALID_CHAIR || wTableID == INVALID_CHAIR) return false;
// 第一个申请开始人;
if (pCMDInfo->bStart && pTableInfo->mReadyInfo.wChairID == INVALID_CHAIR)
{
pTableInfo->mReadyInfo.wChairID = wChairID;
}
// 准备;
if (pCMDInfo->bReady && pIServerUserItem->GetUserStatus()== US_SIT)
{
// 玩家准备;
pIServerUserItem->SetUserStatus(US_READY, wTableID, wChairID);
pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_READY;
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));
}
else
{
// 玩家准备;
//pIServerUserItem->SetUserStatus(US_READY, wTableID, wChairID);
ITableFrame* pITableFrame = pTableInfo->pITableFrame;
if (pTableInfo == nullptr) return true;
WORD wChairCount = pITableFrame->GetChairCount();
for (int i = 0; i < wChairCount; i++)
{
IServerUserItem * pServerItem = pITableFrame->GetTableUserItem(i);
if (pServerItem == nullptr) continue;
if (pServerItem->GetUserStatus() == US_READY)
{
pIServerUserItem->SetUserStatus(US_SIT, wTableID, i);
}
}
pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_REFUSED;
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));
}
return true;
}
//重新加入私人场
bool PriaveteGame::OnTCPNetworkSubAgainEnter(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
//参数效验
ASSERT(wDataSize==sizeof(CMD_GR_Again_Private));
if(wDataSize!=sizeof(CMD_GR_Again_Private)) return false;
CMD_GR_Again_Private* pCMDInfo = (CMD_GR_Again_Private*)pData;
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return true;
}
if (!pTableInfo->bInEnd && pTableInfo->dwRoomNum != 0)
{
//joinPrivateRoom(pIServerUserItem,pTableInfo->pITableFrame);
joinPrivateRoom(pIServerUserItem, pTableInfo, 0);
return true;
}
DBR_GR_Create_Private kDBRInfo;
ZeroMemory(&kDBRInfo,sizeof(kDBRInfo));
kDBRInfo.cbRoomType = pTableInfo->cbRoomType;
kDBRInfo.dwUserID = pIServerUserItem->GetUserID();
kDBRInfo.wKindID = m_pGameServiceAttrib->wKindID;
kDBRInfo.dwCost = (DWORD)m_kPrivateInfo.lPlayCost[pTableInfo->bPlayCoutIdex];
kDBRInfo.dwAgaginTable = pIServerUserItem->GetTableID();
m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_CREATE_PRIVAT, dwSocketID, &kDBRInfo, sizeof(DBR_GR_Create_Private));
return true;
}
//加入私人场
bool PriaveteGame::OnTCPNetworkSubJoinPrivate(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
//参数效验
ASSERT(wDataSize==sizeof(CMD_GR_Join_Private));
if(wDataSize!=sizeof(CMD_GR_Join_Private)) return false;
// 判断服务器维护;
if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true)
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("服务器即将维护，请关注微信群通知。"), SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
return true;
}
bool bRet = true;
CString strMessage;
CMD_GR_Join_Private* pCMDInfo = (CMD_GR_Join_Private*)pData;
PrivateTableInfo* pTableInfo = getTableInfoByRoomID(pCMDInfo->dwRoomNum);
do
{
if (!pTableInfo)
{
bRet = false;
strMessage = TEXT("对不起，没有找到该房间，可能房主已经退出。");
break;
}
if (pTableInfo->pITableFrame->GetNullChairCount() <= 0)
{
bRet = false;
strMessage = TEXT("对不起，游戏人数已满，无法加入。");
break;
}
if (pTableInfo->bStart || pTableInfo->bInEnd)
{
bRet = false;
strMessage = TEXT("对不起，游戏已经开始，无法加入。");
break;
}
BYTE cbStartMode = pTableInfo->GetStartMode();
if ((cbStartMode == START_MODE_FULL_READY) && (pTableInfo->bStart || pTableInfo->bInEnd))
{
bRet = false;
strMessage = TEXT("对不起，游戏已经开始，无法加入。");
break;
}
if (!pTableInfo->IsCanJoinTable(pIServerUserItem, strMessage))
{
bRet = false;
break;
}
} while (0);
if (!bRet)
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, strMessage, SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
return true;
}
// 是工会房;
if (pTableInfo->dwUnionCode != 0)
{
if (pIServerUserItem->GetUserID() == pTableInfo->dwCreaterUserID)
{
joinPrivateRoom(pIServerUserItem, pTableInfo, pTableInfo->lCreateScore);
}
else
{
DBR_GR_JoinUnionRoom JoinUnionRoom;
ZeroMemory(&JoinUnionRoom, sizeof(JoinUnionRoom));
JoinUnionRoom.dwUnionCode = pTableInfo->dwUnionCode;
JoinUnionRoom.dwUserID = pIServerUserItem->GetUserID();
JoinUnionRoom.dwRoomID = pTableInfo->dwRoomNum;
JoinUnionRoom.wKindID = m_pGameServiceAttrib->wKindID;
JoinUnionRoom.cbUnionGoldOpen = pTableInfo->cbUnionGoldOpen;
m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_JOIN_UNION_ROOM, dwSocketID, &JoinUnionRoom, sizeof(DBR_GR_JoinUnionRoom));
}
}
else
{
//joinPrivateRoom(pIServerUserItem, pTableInfo->pITableFrame);
joinPrivateRoom(pIServerUserItem, pTableInfo, 0);
}
//if (!joinPrivateRoom(pIServerUserItem,pTableInfo->pITableFrame))
//{
// //m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("加入房间失败。"), SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
//}
return true;
}
bool PriaveteGame::OnTCPNetworkSubDismissPrivate(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
//CTraceService::TraceString(TEXT("SUB_GR_PRIVATE_DISMISS"),TraceLevel_Normal);
//参数效验
ASSERT(wDataSize==sizeof(CMD_GR_Dismiss_Private));
if(wDataSize!=sizeof(CMD_GR_Dismiss_Private)) return false;
CMD_GR_Dismiss_Private* pCMDInfo = (CMD_GR_Dismiss_Private*)pData;
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return false;
}
if (!pTableInfo->bStart && pTableInfo->dwCreaterUserID != pIServerUserItem->GetUserID())
{
return true;
}
if (pTableInfo->bInEnd)
{
return true;
}
#if _DEBUG
#else
// 游戏开始不到2分钟不可以解散;
if (pTableInfo->bStart && !pTableInfo->IsDismissRoom())
{
//变量定义
CMD_GR_RequestFailure RequestFailure;
ZeroMemory(&RequestFailure, sizeof(RequestFailure));
//构造数据
RequestFailure.lErrorCode = SMT_EJECT;
lstrcpyn(RequestFailure.szDescribeString, TEXT("无离线玩家或玩家离线不足2分钟，无法解散房间！"), CountArray(RequestFailure.szDescribeString));
//发送数据
WORD wDataSize = CountStringBuffer(RequestFailure.szDescribeString);
WORD wHeadSize = sizeof(RequestFailure)-sizeof(RequestFailure.szDescribeString);
SendData(pIServerUserItem, MDM_GR_USER, SUB_GR_REQUEST_FAILURE, &RequestFailure, wHeadSize + wDataSize);
return true;
}
#endif
// 没人申请解散，不需要拒绝解散;
if (pTableInfo->kDismissChairID.size() == 0 && !pCMDInfo->bDismiss)
{
return true;
}
// 解散房间;
if(pCMDInfo->bDismiss)
{
for (int i = 0;i<(int)pTableInfo->kDismissChairID.size();i++)
{
if (pTableInfo->kDismissChairID[i] == pIServerUserItem->GetChairID())
{
return true;
}
}
pTableInfo->kDismissChairID.push_back(pIServerUserItem->GetChairID());
}
else
{
// 拒绝解散;
for (int i = 0;i<(int)pTableInfo->kNotAgreeChairID.size();i++)
{
if (pTableInfo->kNotAgreeChairID[i] == pIServerUserItem->GetChairID())
{
return true;
}
}
pTableInfo->kNotAgreeChairID.push_back(pIServerUserItem->GetChairID());
}
// 解散信息发生给客户端;
CMD_GF_Private_Dismiss_Info kNetInfo;
kNetInfo.dwDissUserCout = pTableInfo->kDismissChairID.size();
kNetInfo.dwNotAgreeUserCout = pTableInfo->kNotAgreeChairID.size();
for (int i = 0;i<(int)pTableInfo->kDismissChairID.size();i++)
{
kNetInfo.dwDissChairID[i] = pTableInfo->kDismissChairID[i];
}
for (int i = 0;i<(int)pTableInfo->kNotAgreeChairID.size();i++)
{
kNetInfo.dwNotAgreeChairID[i] = pTableInfo->kNotAgreeChairID[i];
}
SendTableData(pTableInfo->pITableFrame,MDM_GR_PRIVATE,SUB_GR_PRIVATE_DISMISS,&kNetInfo,sizeof(kNetInfo));
// 有人拒绝解散;
//if (pTableInfo->kNotAgreeChairID.size() >= 2)
if (pTableInfo->kNotAgreeChairID.size() > 0)
{
pTableInfo->kNotAgreeChairID.clear();
pTableInfo->kDismissChairID.clear();
pTableInfo->fDismissPastTime = 0;
CMD_GF_Private_Dismiss_Result mResult;
mResult.bSuccess = false;
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_PRIVATE_DISMISS_RESULT, &mResult, sizeof(mResult));
}
// 解散游戏;
if (!pTableInfo->bStart || (int)kNetInfo.dwDissUserCout >= (int)pTableInfo->pITableFrame->GetSitUserCount()-1)
{
CMD_GF_Private_Dismiss_Result mResult;
mResult.bSuccess = true;
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_PRIVATE_DISMISS_RESULT, &mResult, sizeof(mResult));
//pTableInfo->pITableFrame->SendGameMessage(TEXT("房间已被解散！"),SMT_EJECT);
DismissRoom(pTableInfo);
ClearRoom(pTableInfo);
}
return true;
}
//比赛事件
bool PriaveteGame::OnEventSocketPrivate(WORD wSubCmdID, VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
switch (wSubCmdID)
{
case SUB_GR_PRIVATE_INFO: //私人场信息
{
SendData(pIServerUserItem,MDM_GR_PRIVATE,SUB_GR_PRIVATE_INFO,&m_kPrivateInfo,sizeof(m_kPrivateInfo));
return true;
}
case SUB_GR_CREATE_PRIVATE: //创建私人场
{
return OnTCPNetworkSubCreatePrivate(pData,wDataSize,pIServerUserItem,dwSocketID);
}
case SUB_GR_RIVATE_AGAIN: //重新加入私人场
{
return OnTCPNetworkSubAgainEnter(pData,wDataSize,pIServerUserItem,dwSocketID);
}
case SUB_GR_JOIN_PRIVATE: //加入私人场
{
return OnTCPNetworkSubJoinPrivate(pData,wDataSize,pIServerUserItem,dwSocketID);
}
case SUB_GR_PRIVATE_DISMISS: //解散
{
return OnTCPNetworkSubDismissPrivate(pData,wDataSize,pIServerUserItem,dwSocketID);
}
case SUB_GR_CREATE_AUTO_ROOM:
{
return OnTCPNetworkSubAutoRoomInfo(pData, wDataSize, pIServerUserItem, dwSocketID);
}
case SUB_GR_DEL_AUTO_ROOM_INFO:
{
return OnTCPNetworkSubDelAutoRoomInfo(pData, wDataSize, pIServerUserItem, dwSocketID);
}
case SUB_GR_AUTO_USER_STATUS:
{
return OnTCPNetworkSubAutoUserStatus(pData, wDataSize, pIServerUserItem, dwSocketID);
}
case SUB_GR_AUTO_USER_READY:
{
return OnTCPNetworkSubAutoUserReady(pData, wDataSize, pIServerUserItem, dwSocketID);
}
}
return true;
}
//重置桌位
void PriaveteGame::DismissRoom(PrivateTableInfo* pTableInfo)
{
ASSERT(pTableInfo!=NULL);
if (pTableInfo==NULL) return;
ITableFrame* pTableFrame=pTableInfo->pITableFrame;
ASSERT(pTableFrame!=NULL);
if (pTableFrame==NULL) return;
//强制解散游戏
if (pTableFrame->IsGameStarted()==true)
{
bool bSuccess=pTableFrame->DismissGame();
if (bSuccess==false)
{
CTraceService::TraceString(TEXT("PriaveteGame 解散游戏 失败！"),TraceLevel_Exception);
return;
}
}
m_allocationID.PushValue(pTableInfo->dwRoomNum % 10000);
// 如果是第一局没结束就解散，需要到数据库返还工会房卡;
if (!pTableInfo->bStart || (pTableInfo->dwStartPlayCout < 1))
{
DBR_GR_DismissUnionRoom DismissUnionRoom;
ZeroMemory(&DismissUnionRoom, sizeof(DismissUnionRoom));
DismissUnionRoom.dwUnionCode = pTableInfo->dwUnionCode;
DismissUnionRoom.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
DismissUnionRoom.dwCost = pTableInfo->dwPlayCost;
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_DISMISS_UNION_ROOM, 0L, (BYTE*)&DismissUnionRoom, sizeof(DismissUnionRoom));
}
pTableInfo->bInEnd = true;
if (pTableInfo->bStart)
{
SendGamePrivateEndInfo(pTableInfo);
CalcUnionScore(pTableInfo);
pTableInfo->bInEnd = true;
pTableInfo->dwCreaterUserID = 0;
pTableInfo->dwUnionCode = 0; // 工会ID
pTableInfo->dwUnionConsumerID = 0; // 消耗记录ID
//清除每局的记录只向0.数据库记录总的记录;
pTableInfo->kTotalRecord.kRecordChild.clear();
DataStream kDataStream;
pTableInfo->kTotalRecord.StreamValue(kDataStream,true);
m_pIDataBaseEngine->PostDataBaseRequest(0,DBR_GR_PRIVATE_GAME_RECORD,0,&kDataStream[0],kDataStream.size());
pTableInfo->bStart = false;
sendPrivateRoomInfo(NULL,pTableInfo);
gameEnd(pTableInfo);
}
else
{
ClearRoom(pTableInfo);
}
CString strTmp;
strTmp.Format(_T("解散房间: %d"), pTableInfo->dwRoomNum);
CTraceService::TraceString(strTmp, TraceLevel_Normal);
return;
}
void PriaveteGame::ClearRoom(PrivateTableInfo* pTableInfo)
{
ASSERT(pTableInfo!=NULL);
if (pTableInfo==NULL) return;
ITableFrame* pTableFrame=pTableInfo->pITableFrame;
ASSERT(pTableFrame!=NULL);
if (pTableFrame==NULL) return;
//该桌用户全部离开
for (int i=0;i<pTableFrame->GetChairCount();i++)
{
IServerUserItem* pUserItem=pTableFrame->GetTableUserItem(i);
if(pUserItem&&pUserItem->GetTableID()!=INVALID_TABLE)
{
pTableFrame->PerformStandUpActionEx(pUserItem);
}
}
pTableInfo->restValue();
}
//发送私人场结束消息,结算信息来自每个游戏内部;
void PriaveteGame::SendGamePrivateEndInfo(PrivateTableInfo* pTableInfo)
{
ITableFrame* pTableFrame = pTableInfo->pITableFrame;
ASSERT(pTableFrame != NULL);
if (pTableFrame == NULL) return;
DataStream kDataStream;
pTableFrame->GetPrivateEndInfo(kDataStream, true);
if (kDataStream.size() > 0)
{
SendTableData(pTableFrame, MDM_GR_PRIVATE, SUB_GF_GM_PRIVATE_END, &kDataStream[0], kDataStream.size());
}
}
//用户积分
bool PriaveteGame::OnEventUserItemScore(IServerUserItem * pIServerUserItem, BYTE cbReason)
{
//效验参数
ASSERT(pIServerUserItem!=NULL);
if (pIServerUserItem==NULL) return false;
m_pIServerUserItemSink->OnEventUserItemScore(pIServerUserItem,cbReason);
return true;
}
//用户状态
bool PriaveteGame::OnEventUserItemStatus(IServerUserItem * pIServerUserItem, WORD wOldTableID, WORD wOldChairID)
{
if(m_pIServerUserItemSink!=NULL)
{
return m_pIServerUserItemSink->OnEventUserItemStatus(pIServerUserItem,wOldTableID,wOldChairID);
}
return true;
}
//用户权限
bool PriaveteGame::OnEventUserItemRight(IServerUserItem *pIServerUserItem, DWORD dwAddRight, DWORD dwRemoveRight,bool bGameRight)
{
if(m_pIServerUserItemSink!=NULL)
{
return m_pIServerUserItemSink->OnEventUserItemRight(pIServerUserItem,dwAddRight,dwRemoveRight,bGameRight);
}
return true;
}
//用户登录
bool PriaveteGame::OnEventUserLogon(IServerUserItem * pIServerUserItem)
{
return true;
}
//用户登出
bool PriaveteGame::OnEventUserLogout(IServerUserItem * pIServerUserItem)
{
return true;
}
//进入事件
bool PriaveteGame::OnEventEnterPrivate(DWORD dwSocketID ,VOID* pData,DWORD dwUserIP, bool bIsMobile)
{
//手机用户
if(bIsMobile == true)
{
//处理消息
CMD_GR_LogonMobile * pLogonMobile=(CMD_GR_LogonMobile *)pData;
pLogonMobile->szPassword[CountArray(pLogonMobile->szPassword)-1]=0;
pLogonMobile->szMachineID[CountArray(pLogonMobile->szMachineID)-1]=0;
//变量定义
DBR_GR_LogonMobile LogonMobile;
ZeroMemory(&LogonMobile,sizeof(LogonMobile));
//构造数据
LogonMobile.dwUserID=pLogonMobile->dwUserID;
LogonMobile.dwClientAddr=dwUserIP;
LogonMobile.cbDeviceType=pLogonMobile->cbDeviceType;
LogonMobile.wBehaviorFlags=pLogonMobile->wBehaviorFlags;
LogonMobile.wPageTableCount=pLogonMobile->wPageTableCount;
lstrcpyn(LogonMobile.szPassword,pLogonMobile->szPassword,CountArray(LogonMobile.szPassword));
lstrcpyn(LogonMobile.szMachineID,pLogonMobile->szMachineID,CountArray(LogonMobile.szMachineID));
//投递请求
m_pIDataBaseEngine->PostDataBaseRequest(LogonMobile.dwUserID,DBR_GR_LOGON_MOBILE,dwSocketID,&LogonMobile,sizeof(LogonMobile));
}
else
{
//处理消息
CMD_GR_LogonUserID * pLogonUserID=(CMD_GR_LogonUserID *)pData;
pLogonUserID->szPassword[CountArray(pLogonUserID->szPassword)-1]=0;
pLogonUserID->szMachineID[CountArray(pLogonUserID->szMachineID)-1]=0;
//变量定义
DBR_GR_LogonUserID LogonUserID;
ZeroMemory(&LogonUserID,sizeof(LogonUserID));
//构造数据
LogonUserID.dwClientAddr=dwUserIP;
LogonUserID.dwUserID=pLogonUserID->dwUserID;
lstrcpyn(LogonUserID.szPassword,pLogonUserID->szPassword,CountArray(LogonUserID.szPassword));
lstrcpyn(LogonUserID.szMachineID,pLogonUserID->szMachineID,CountArray(LogonUserID.szMachineID));
//投递请求
m_pIDataBaseEngine->PostDataBaseRequest(LogonUserID.dwUserID,DBR_GR_LOGON_USERID,dwSocketID,&LogonUserID,sizeof(LogonUserID));
}
return true;
}
bool PriaveteGame::AddPrivateAction(ITableFrame* pTbableFrame,DWORD dwChairID, BYTE bActionIdex)
{
//PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pTbableFrame);
//ASSERT(pTableInfo);
//if (!pTableInfo)
//{
// return true;
//}
//if (dwChairID >= 100 || bActionIdex >= MAX_PRIVATE_ACTION)
//{
// return true;
//}
//pTableInfo->lPlayerAction[dwChairID][bActionIdex] ++;
return true;
}
//是不是自由人数场
bool PriaveteGame::IsAutoUserCountRule(ITableFrame* pTbableFrame, bool bReal)
{
PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pTbableFrame);
ASSERT(pTableInfo);
if (!pTableInfo)
{
return false;
}
if (bReal == false)
{
if (pTableInfo->bStart || pTableInfo->bInEnd)
{
return false;
}
}
return pTableInfo->IsAutoUserCountRule();
}
bool PriaveteGame::addPrivatePlayCout(ITableFrame* pTbableFrame, WORD wCout)
{
PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pTbableFrame);
ASSERT(pTableInfo);
if (!pTableInfo)
{
return true;
}
pTableInfo->dwFinishPlayCout += wCout;
return true;
}
//用户
bool PriaveteGame::OnEventUserJoinPrivate(IServerUserItem * pIServerUserItem, BYTE cbReason,DWORD dwSocketID)
{
//参数校验
ASSERT(pIServerUserItem!=NULL);
if (pIServerUserItem == NULL) return false;
SendData(pIServerUserItem,MDM_GR_PRIVATE,SUB_GR_PRIVATE_INFO,&m_kPrivateInfo,sizeof(m_kPrivateInfo));
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
//判断状态
if(pIServerUserItem->GetTableID()!=INVALID_TABLE)
{
sendPrivateRoomInfo(pIServerUserItem,getTableInfoByTableID(pIServerUserItem->GetTableID()));
}
return true;
}
//用户退赛
bool PriaveteGame::OnEventUserQuitPrivate(IServerUserItem * pIServerUserItem, BYTE cbReason, WORD *pBestRank, DWORD dwContextID)
{
ASSERT(pIServerUserItem!=NULL);
if (pIServerUserItem==NULL) return false;
return true;
}
//游戏开始
bool PriaveteGame::OnEventGameStart(ITableFrame *pITableFrame, WORD wChairCount)
{
PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pITableFrame);
ASSERT(pTableInfo);
if (!pTableInfo) return true;
// 是工会房间通知数据库扣费;
if ((pTableInfo->dwUnionCode != 0) && !pTableInfo->bStart)
{
ITableFrame* pTableFrame = pTableInfo->pITableFrame;
if (NULL != pTableFrame)
{
DBR_GR_UnionRoomUser UnionRoomUser;
ZeroMemory(&UnionRoomUser, sizeof(DBR_GR_UnionRoomUser));
UnionRoomUser.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
UnionRoomUser.CreateUnionRoom.dwUnionCode = pTableInfo->dwUnionCode;
UnionRoomUser.CreateUnionRoom.dwRoomID = pTableInfo->dwRoomNum;
UnionRoomUser.CreateUnionRoom.dwCreaterUserID = pTableInfo->dwCreaterUserID;
UnionRoomUser.CreateUnionRoom.wKindID = m_pGameServiceAttrib->wKindID;
UnionRoomUser.CreateUnionRoom.dwCost = pTableInfo->dwPlayCost;
UnionRoomUser.CreateUnionRoom.dwCostType = pTableInfo->cbRoomType;
UnionRoomUser.CreateUnionRoom.dwGameRuleIdex = pTableInfo->dwGameRuleIdex;
WORD nUserCount = pTableFrame->GetChairCount();
for (int i = 0; i < nUserCount; i++)
{
IServerUserItem* pServerUserItem = pTableFrame->GetTableUserItem(i);
if (NULL == pServerUserItem) continue;
//if (pTableInfo->dwCreaterUserID != INVALID_TABLE && pTableInfo->dwCreaterUserID == pServerUserItem->GetUserID()) continue;
UnionRoomUser.dwUserID[UnionRoomUser.cbUserCount++] = pServerUserItem->GetUserID();
}
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_UNION_ROOM_USER, 0L, (BYTE*)&UnionRoomUser, sizeof(UnionRoomUser));
}
// 自动代开;
if ((pTableInfo->dwGameRuleIdex&ePrivateTableCommonRule_DaiKaiFang) > 0)
{
CMD_GR_AutoCreatePrivate CreatePrivate;
CreatePrivate.dwIndex = pTableInfo->m_dwDaikaiIndex;
CreatePrivate.dwUnionCode = pTableInfo->dwUnionCode; //工会ID
CreatePrivate.cbUnionGoldOpen = pTableInfo->cbUnionGoldOpen; // 1 欢乐场, 0普通;
CreatePrivate.cbGameType = pTableInfo->cbRoomType; //游戏类型
CreatePrivate.bPlayCoutIdex = pTableInfo->bPlayCoutIdex; //游戏局数
CreatePrivate.bGameTypeIdex = pTableInfo->bGameTypeIdex; //游戏类型
CreatePrivate.bGameRuleIdex = pTableInfo->dwGameRuleIdex; //游戏规则
CreatePrivate.cbEnterRoomScoreType = pTableInfo->cbEnterRoomScoreType; //进房间时的分数类型;
CreatePrivate.lInitEnterRoomScore = pTableInfo->lInitEnterRoomScore; //进入房间时的分数;
CreatePrivate.cbBaseScore = pTableInfo->cbBaseScore;
AutoCreateUnionRoom(CreatePrivate);
}
}
pTableInfo->dwStartPlayCout ++;
pTableInfo->bStart = true;
pTableInfo->newRandChild();
sendPrivateRoomInfo(NULL,pTableInfo);
// 显示游戏开始;
CString strDebugInfo = _T("");
strDebugInfo.Format("EventGameStart RoomID = %d, TableID = %d", pTableInfo->dwRoomNum, pITableFrame->GetTableID());
::OutputDebugString(strDebugInfo.GetBuffer());
return true;
}
//游戏结束
bool PriaveteGame::OnEventGameEnd(ITableFrame *pITableFrame,WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)
{
ASSERT(pITableFrame!=NULL);
if (pITableFrame==NULL) return false;
PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pITableFrame);
if (!pTableInfo)
{
return true;
}
if (pTableInfo->cbRoomType == Type_Private)
{
// 显示游戏开始;
CString strDebugInfo = _T("");
strDebugInfo.Format("EventGameEnd RoomID = %d, TableID = %d", pTableInfo->dwRoomNum, pITableFrame->GetTableID());
::OutputDebugString(strDebugInfo.GetBuffer());
// 一局没结束提前解散不扣房卡;
if ((cbReason != GER_DISMISS) && (pTableInfo->dwStartPlayCout == 1))
{
CreatePrivateCost(pTableInfo);
}
if (pITableFrame->IsPrivateEnd())
{
DismissRoom(pTableInfo);
return true;
}
sendPrivateRoomInfo(NULL, pTableInfo);
}
else if (pTableInfo->cbRoomType == Type_Public)
{
CreatePrivateCost(pTableInfo);
DismissRoom(pTableInfo);
ClearRoom(pTableInfo);
}
return true;
}
//记录游戏积分
bool PriaveteGame::WriteTableScore(ITableFrame* pITableFrame,tagScoreInfo ScoreInfoArray[], WORD wScoreCount,DataStream& kData)
{
PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pITableFrame);
if (!pTableInfo)
{
return true;
}
// 插入私人场信息;
tagGameRecord gameRecord;
gameRecord.StreamValue(kData, false);
gameRecord.roomInfo.cbRoomType = pTableInfo->cbRoomType;
gameRecord.roomInfo.bStartGame = pTableInfo->bStart;
gameRecord.roomInfo.dwRoomNum = pTableInfo->dwRoomNum;
gameRecord.roomInfo.dwPlayCout = pTableInfo->dwFinishPlayCout - 1; // 减去当局的局数;
gameRecord.roomInfo.dwCreateUserID = pTableInfo->dwCreaterUserID;
gameRecord.roomInfo.bGameRuleIdex = pTableInfo->dwGameRuleIdex;
gameRecord.roomInfo.bGameTypeIdex = pTableInfo->bGameTypeIdex;
gameRecord.roomInfo.bPlayCoutIdex = pTableInfo->bPlayCoutIdex;
gameRecord.roomInfo.dwPlayTotal = pTableInfo->dwPlayCout;
DataStream tmpGameRecord;
gameRecord.StreamValue(tmpGameRecord, true);
pTableInfo->writeSocre(ScoreInfoArray, wScoreCount, tmpGameRecord);
//写入单一一场数据到数据库;
std::vector<tagPrivateRandRecordChild>& refkRecordChild = pTableInfo->kTotalRecord.kRecordChild;
if (refkRecordChild.size() > 0)
{
tagPrivateRandRecordChild& refkSingleRecord = refkRecordChild.back();
refkSingleRecord.iRecordID = pTableInfo->kTotalRecord.iRecordID;
// 玩家ID;
CString strUserIDs = "";
WORD nUserCount = pITableFrame->GetChairCount();
for (int i = 0; i < nUserCount; i++)
{
IServerUserItem* pServerUserItem = pITableFrame->GetTableUserItem(i);
if (NULL == pServerUserItem) continue;
CString strTmp = "";
if (!strUserIDs.IsEmpty())
{
strTmp.Format(",%d", pServerUserItem->GetUserID());
}
else
{
strTmp.Format("%d", pServerUserItem->GetUserID());
}
strUserIDs += strTmp;
}
refkSingleRecord.kUserDefine = strUserIDs;
DataStream singleGameRecordData;
refkSingleRecord.StreamValue(singleGameRecordData, true);
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_SINGLE_PRIVATE_RECORD, 0L, (BYTE*)&singleGameRecordData[0], singleGameRecordData.size());
}
return true;
}
//发送房间信息;
void PriaveteGame::sendPrivateRoomInfo(IServerUserItem * pIServerUserItem,PrivateTableInfo* pTableInfo)
{
ASSERT(pTableInfo);
if (!pTableInfo)
{
return;
}
CMD_GF_Private_Room_Info kNetInfo;
kNetInfo.cbRoomType = pTableInfo->cbRoomType;
kNetInfo.bStartGame = pTableInfo->bStart;
kNetInfo.dwRoomNum = pTableInfo->dwRoomNum;
//kNetInfo.dwPlayCout = pTableInfo->dwStartPlayCout;
kNetInfo.dwPlayCout = pTableInfo->dwFinishPlayCout;
kNetInfo.dwCreateUserID = pTableInfo->dwCreaterUserID;
kNetInfo.dwUnionCode = pTableInfo->dwUnionCode;
kNetInfo.bGameRuleIdex = pTableInfo->dwGameRuleIdex;
kNetInfo.bGameTypeIdex = pTableInfo->bGameTypeIdex;
kNetInfo.bPlayCoutIdex = pTableInfo->bPlayCoutIdex;
kNetInfo.dwPlayTotal = pTableInfo->dwPlayCout;
kNetInfo.dwPlayCost = pTableInfo->dwPlayCost;
kNetInfo.cbUnionGoldOpen = pTableInfo->cbUnionGoldOpen;
kNetInfo.lScoreMultiple = pTableInfo->lScoreMultiple;
kNetInfo.lGameGold = pTableInfo->lGameGold;
kNetInfo.cbBaseScore = pTableInfo->cbBaseScore;
kNetInfo.kWinLoseScore.resize(pTableInfo->pITableFrame->GetChairCount());
//kNetInfo.kScoreInfoArray.resize(pTableInfo->pITableFrame->GetChairCount());
for (WORD i = 0;i<pTableInfo->pITableFrame->GetChairCount();i++)
{
kNetInfo.kWinLoseScore[i] = (int)pTableInfo->lPlayerWinLose[i];
//kNetInfo.kScoreInfoArray[i] = pTableInfo->lScoreInfoArray[i];
}
DataStream kDataStream;
kNetInfo.StreamValue(kDataStream,true);
if (pIServerUserItem)
{
SendData(pIServerUserItem,MDM_GR_PRIVATE,SUB_GF_PRIVATE_ROOM_INFO,&kDataStream[0],kDataStream.size());
}
else
{
SendTableData(pTableInfo->pITableFrame,MDM_GR_PRIVATE,SUB_GF_PRIVATE_ROOM_INFO,&kDataStream[0],kDataStream.size());
}
// 发生欢乐积分
if (1 == pTableInfo->cbUnionGoldOpen)
{
CMD_GF_Private_Score_Info kScoreInfo;
kScoreInfo.kScoreInfoArray.resize(pTableInfo->pITableFrame->GetChairCount());
for (WORD i = 0; i < pTableInfo->pITableFrame->GetChairCount(); i++)
{
kScoreInfo.kScoreInfoArray[i] = pTableInfo->lScoreInfoArray[i];
}
DataStream kSocreStream;
kScoreInfo.StreamValue(kSocreStream, true);
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GF_PRIVATE_SCORE_INFO, &kSocreStream[0], kSocreStream.size());
}
}
//断线
bool PriaveteGame::OnActionUserOffLine(WORD wChairID, IServerUserItem * pIServerUserItem)
{
ASSERT(pIServerUserItem);
if (!pIServerUserItem)
{
return false;
}
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return false;
}
if (pTableInfo->dwCreaterUserID == pIServerUserItem->GetUserID() && !pTableInfo->bInEnd)
{
return true;
}
if (pTableInfo->bInEnd)
{
pTableInfo->pITableFrame->PerformStandUpActionEx(pIServerUserItem);
}
else
{
// 离线时间;
WORD wOfflineChairID = pIServerUserItem->GetChairID();
if (wOfflineChairID != INVALID_CHAIR)
{
pTableInfo->fOfflineTimes[wOfflineChairID] = 0;
}
//// 是不是自由场;
//if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
//{
// // 可以准备清空;
// pTableInfo->bAutoStart[wChairID] = false;
//}
}
return true;
}
//用户坐下
bool PriaveteGame::OnActionUserSitDown(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)
{
ASSERT(pIServerUserItem);
if (NULL == pIServerUserItem) return true;
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (NULL == pTableInfo) return true;
if (pTableInfo->bInEnd) return false;
if (pTableInfo->IsSetOneTimeRoomScoreType())
{
//进入房间时赋值为初始积分;
SCORE lScore = pTableInfo->lInitEnterRoomScore - pIServerUserItem->GetUserScore();
pIServerUserItem->WriteUserScore(lScore, 0, 0, 0, SCORE_TYPE_PRESENT, 1, 0);
}
// 是不是自由场;
if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
{
// 可以准备清空;
pTableInfo->mReadyInfo.reset();
tagAutoUserStatus autoUserStatus;
autoUserStatus.bStartGame = false;
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
}
return true;
}
//用户起立
bool PriaveteGame::OnActionUserStandUp(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)
{
ASSERT(pIServerUserItem);
if (!pIServerUserItem)
{
return true;
}
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return true;
}
if (pTableInfo->bInEnd)
{
return false;
}
// 是不是自由场;
if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
{
// 可以准备清空;
pTableInfo->mReadyInfo.reset();
tagAutoUserStatus autoUserStatus;
autoUserStatus.bStartGame = false;
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
}
return true;
}
//随机空位
WORD PriaveteGame::GetNullChairID(ITableFrame * pTableFrame)
{
//椅子搜索
for (WORD i = 0; i < pTableFrame->GetChairCount(); i++)
{
if (pTableFrame->GetTableUserItem(i) == NULL)
{
return i;
}
}
return INVALID_CHAIR;
}
//用户同意
bool PriaveteGame::OnActionUserOnReady(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
ASSERT(pIServerUserItem);
if (!pIServerUserItem)
{
return true;
}
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return true;
}
if (pTableInfo->bInEnd)
{
return false;
}
if ( pTableInfo->IsEveryTimeRoomScoreType() )
{
//每局重新赋值为初始积分;
SCORE lScore = pTableInfo->lInitEnterRoomScore - pIServerUserItem->GetUserScore();
pIServerUserItem->WriteUserScore(lScore, 0, 0, 0, SCORE_TYPE_PRESENT, 1, 0);
}
//// 自由人数，通知客户端玩家准备情况;
//if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
//{
// //变量定义
// bool bReady = *(bool *)pData;
// // 第一个准备的人为申请人;
// if (pTableInfo->mReadyInfo.wChairID == INVALID_CHAIR)
// {
// pTableInfo->mReadyInfo.wChairID = wChairID;
// }
// if (bReady)
// {
// pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_READY;
// }
// else
// {
// pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_REFUSED;
// }
//
// SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));
//}
return true;
}
//判断房卡是否够
bool PriaveteGame::OnActionUserFangKaCheck(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, SCORE lUserInsure)
{
ASSERT(pIServerUserItem);
if (NULL == pIServerUserItem) return true;
PrivateTableInfo* pTableInfo = getTableInfoByTableID(wTableID);
if (NULL == pTableInfo) return true;
if (pTableInfo->bInEnd) return false;
if (pTableInfo->IsCardAARule())
{
ASSERT((pTableInfo->dwPlayCost / pTableInfo->pITableFrame->GetChairCount())>0);
// AA 情况下判断房卡数量;
if (lUserInsure < (pTableInfo->dwPlayCost / pTableInfo->pITableFrame->GetChairCount()))
{
return false;
}
}
return true;
}
//用户可以开始
bool PriaveteGame::OnActionUserOnStart(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
//效验参数
ASSERT(wDataSize == sizeof(tagAutoUserStatus));
if (wDataSize != sizeof(tagAutoUserStatus)) return false;
if (pData == nullptr) return false;
ASSERT(pIServerUserItem);
if (!pIServerUserItem)
{
return true;
}
PrivateTableInfo* pTableInfo = getTableInfoByTableID(wTableID);;
if (pIServerUserItem->GetTableID() != INVALID_TABLE)
{
ASSERT(pIServerUserItem->GetTableID() == wTableID);
}
if (!pTableInfo)
{
return true;
}
if (pTableInfo->bInEnd)
{
return false;
}
// 是不是自由场;
if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
{
// 断线重连;
if (pTableInfo->mReadyInfo.wChairID != INVALID_CHAIR)
{
//SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));
if (pTableInfo->bInEnd || pTableInfo->bStart) return true;
pTableInfo->mReadyInfo.reset();
// 通知客户端可以重新准备;
tagAutoUserStatus autoUserStatus;
autoUserStatus.bStartGame = true;
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
}
else
{
tagAutoUserStatus autoUserStatus;
CopyMemory(&autoUserStatus, pData, sizeof(tagAutoUserStatus));
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
}
}
return true;
}
//用户开始游戏
bool PriaveteGame::OnActionUserStartGame(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
//效验参数
ASSERT(wDataSize == sizeof(bool));
if (wDataSize != sizeof(bool)) return false;
if (pData == nullptr) return false;
ASSERT(pIServerUserItem);
if (!pIServerUserItem)
{
return true;
}
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return true;
}
if (pTableInfo->bInEnd || pTableInfo->bStart)
{
return false;
}
ITableFrame* pTableFrame = pTableInfo->pITableFrame;
ASSERT(pTableFrame != NULL);
if (pTableFrame == NULL) return false;
// 自由人数，通知客户端玩家准备情况;
if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
{
//变量定义
bool bReady = *(bool *)pData;
// 判断是否可以开始游戏
if (bReady && EfficacyStartGame(pTableInfo, wChairID))
{
if (!pTableFrame->IsGameStarted())
{
bool bSuccess = pTableFrame->StartGame();
if (bSuccess == false)
{
CTraceService::TraceString(TEXT("PriaveteGame 开始游戏失败！"), TraceLevel_Exception);
return false;
}
}
return true;
}
else
{
// 第一个准备的人为申请人;
if (pTableInfo->mReadyInfo.wChairID == INVALID_CHAIR)
{
pTableInfo->mReadyInfo.wChairID = wChairID;
}
if (bReady)
{
pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_READY;
}
else
{
pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_REFUSED;
}
SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));
// 一个人拒绝之后就要重新开始;
if (!bReady)
{
//pTableInfo->mReadyInfo.reset();
m_pITimerEngine->SetTimer(IDI_AUTO_USER_RESET + pTableFrame->GetTableID(), NOT_AUTO_USER_TIME*1000L, 1, 0);
}
}
}
return true;
}
//开始效验
bool PriaveteGame::EfficacyStartGame(PrivateTableInfo* pTableInfo, WORD wReadyChairID)
{
//状态判断
if (!pTableInfo) return true;
if (pTableInfo->bInEnd || pTableInfo->bStart) return false;
ITableFrame* pTableFrame = pTableInfo->pITableFrame;
ASSERT(pTableFrame != NULL);
if (pTableFrame == NULL) return false;
WORD wChairCount = pTableInfo->getChairCout();
//准备人数
WORD wReadyUserCount = 0;
for (WORD i = 0; i < wChairCount; i++)
{
//获取用户
IServerUserItem * pITableUserItem = pTableFrame->GetTableUserItem(i);
if (pITableUserItem == NULL) continue;
//用户统计
if (pITableUserItem != NULL)
{
//状态判断(离线前的状态如果是准备状态)
if (pITableUserItem->IsClientReady() == false) return false;
BYTE cbReady = pTableInfo->mReadyInfo.cbReady[i];
if ((wReadyChairID != i) && (cbReady != RIT_READY)) return false;
//用户计数
wReadyUserCount++;
}
}
// 自由人数场;
if (pTableInfo->IsAutoUserCountRule())
{
//数目判断
if (wReadyUserCount >= 2L) return true;
return false;
}
return false;
}
bool PriaveteGame::OnEventReqStandUP(IServerUserItem * pIServerUserItem)
{
ASSERT(pIServerUserItem);
if (!pIServerUserItem)
{
return true;
}
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
ASSERT(pTableInfo);
if (!pTableInfo)
{
return true;
}
if (pTableInfo->bStart && !pTableInfo->bInEnd)
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,TEXT("游戏已经开始，无法退出。"),SMT_EJECT);
return true;
}
if (getTableInfoByCreaterID(pIServerUserItem->GetUserID()) && !pTableInfo->bInEnd)
{
m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,TEXT("您已返回大厅,房间将会继续保留。"),SMT_CLOSE_GAME);
return true;
}
// 如果是工会房间，去数据库离开桌子;
DBR_GR_WriteUnionRoomChairID JoinRoomUser;
ZeroMemory(&JoinRoomUser, sizeof(JoinRoomUser));
JoinRoomUser.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
JoinRoomUser.wChairID = pIServerUserItem->GetChairID();
JoinRoomUser.dwUserID = 0;
m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_WRITE_UNION_CHAIRID, 0L, (BYTE*)&JoinRoomUser, sizeof(DBR_GR_WriteUnionRoomChairID));
pTableInfo->pITableFrame->PerformStandUpActionEx(pIServerUserItem);
//// 是不是自由场;
//if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
//{
// // 可以准备清空;
// pTableInfo->bAutoStart[pIServerUserItem->GetChairID()] = false;
// // 发送状态;
// SendAutoUserStatus(pTableInfo);
//}
return true;
}
bool PriaveteGame::OnEventClientReady(WORD wChairID,IServerUserItem * pIServerUserItem)
{
ASSERT(pIServerUserItem);
if (!pIServerUserItem)
{
return true;
}
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return true;
}
//sendPrivateRoomInfo(pIServerUserItem,pTableInfo);
//if (pTableInfo->pITableFrame->GetGameStatus() == GAME_STATUS_FREE)
//{
// pIServerUserItem->SetUserStatus(US_READY,
// pTableInfo->pITableFrame->GetTableID(),wChairID);
//}
if (pTableInfo->kDismissChairID.size())
{
CMD_GF_Private_Dismiss_Info kNetInfo;
kNetInfo.dwDissUserCout = pTableInfo->kDismissChairID.size();
kNetInfo.dwNotAgreeUserCout = pTableInfo->kNotAgreeChairID.size();
for (int i = 0;i<(int)pTableInfo->kDismissChairID.size();i++)
{
kNetInfo.dwDissChairID[i] = pTableInfo->kDismissChairID[i];
}
for (int i = 0;i<(int)pTableInfo->kNotAgreeChairID.size();i++)
{
kNetInfo.dwNotAgreeChairID[i] = pTableInfo->kNotAgreeChairID[i];
}
SendTableData(pTableInfo->pITableFrame,MDM_GR_PRIVATE,SUB_GR_PRIVATE_DISMISS,&kNetInfo,sizeof(kNetInfo));
}
//// 是不是自由场;
//if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
//{
// // 发送状态;
// SendAutoUserStatus(pTableInfo);
//}
return true;
}
//同步私人场信息
bool PriaveteGame::OnEventPrivateRoomInfo(WORD wChairID, IServerUserItem * pIServerUserItem)
{
ASSERT(pIServerUserItem);
if (!pIServerUserItem)
{
return true;
}
PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
if (!pTableInfo)
{
return true;
}
sendPrivateRoomInfo(pIServerUserItem, pTableInfo);
}
void PriaveteGame::CreaterPlayerPrivateCost(PrivateTableInfo* pTableInfo)
{
DBR_GR_Create_Private_Cost kNetInfo;
kNetInfo.dwUserID = pTableInfo->dwCreaterUserID;
kNetInfo.wKindID = m_pGameServiceOption->wKindID;
kNetInfo.dwRoomID = pTableInfo->dwRoomNum;
kNetInfo.dwCost = pTableInfo->dwPlayCost;
kNetInfo.dwCostType = pTableInfo->cbRoomType;
kNetInfo.dwGameRuleIdex = pTableInfo->dwGameRuleIdex;
m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_CREATE_PRIVAT_COST, 0L, &kNetInfo, sizeof(kNetInfo));
}
void PriaveteGame::EveryOnePrivateCost(PrivateTableInfo* pTableInfo, bool bDivideCost)
{
if (NULL == pTableInfo) return;
ITableFrame* pTableFrame = pTableInfo->pITableFrame;
if ( NULL == pTableFrame) return;
WORD nUserCount = pTableFrame->GetChairCount();
DWORD dwCost = pTableInfo->dwPlayCost;
if (bDivideCost && nUserCount!=0)
{
dwCost = (dwCost / nUserCount);
}
for (int i = 0; i < nUserCount; i++)
{
IServerUserItem* pServerUserItem = pTableFrame->GetTableUserItem(i);
if (NULL == pServerUserItem) continue;
DBR_GR_Create_Private_Cost kNetInfo;
kNetInfo.dwUserID = pServerUserItem->GetUserID();
kNetInfo.wKindID = m_pGameServiceOption->wKindID;
kNetInfo.dwRoomID = pTableInfo->dwRoomNum;
kNetInfo.dwCost = dwCost;
kNetInfo.dwCostType = pTableInfo->cbRoomType;
kNetInfo.dwGameRuleIdex = pTableInfo->dwGameRuleIdex;
m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_CREATE_PRIVAT_COST, 0L, &kNetInfo, sizeof(kNetInfo));
}
}
void PriaveteGame::gameEnd(PrivateTableInfo* pTableInfo)
{
ASSERT(pTableInfo != nullptr);
ITableFrame* pITableFrame = pTableInfo->pITableFrame;
ASSERT(pITableFrame != nullptr);
if (nullptr == pITableFrame) return;
DBO_GR_PrivateGameEnd mGameEnd;
mGameEnd.wKindID = m_pGameServiceOption->wKindID;
mGameEnd.wServerID = m_pGameServiceOption->wServerID;
mGameEnd.wPlayCount = (WORD)pTableInfo->dwFinishPlayCout;
WORD wChairCount = pITableFrame->GetChairCount();
for (WORD i = 0; i < wChairCount; i++)
{
IServerUserItem * pServerItem = pITableFrame->GetTableUserItem(i);
if (pServerItem == nullptr)
{
continue;
}
mGameEnd.dwUserID = pServerItem->GetUserID();
mGameEnd.lScore = pServerItem->GetUserScore();
mGameEnd.dwCardLibIndex = pServerItem->getCardLibIndex();
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_PRIVATE_GAME_END, 0, &mGameEnd, sizeof(DBO_GR_PrivateGameEnd));
}
}
void PriaveteGame::CalcUnionScore(PrivateTableInfo* pTableInfo)
{
if (NULL == pTableInfo) return;
ITableFrame* pTableFrame = pTableInfo->pITableFrame;
if (NULL == pTableFrame) return;
// 通知数据库操作;
DBR_GR_UnionRoomEnd UnionRoomEnd;
ZeroMemory(&UnionRoomEnd, sizeof(DBR_GR_UnionRoomEnd));
UnionRoomEnd.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
UnionRoomEnd.dwUnionCode = pTableInfo->dwUnionCode;
UnionRoomEnd.cbUserCount = (BYTE)pTableInfo->getChairCout();
// 积分场才去处理;
if (1 != pTableInfo->cbUnionGoldOpen)
{
for (int i = 0; i < UnionRoomEnd.cbUserCount; i++)
{
IServerUserItem * pServerItem = pTableFrame->GetTableUserItem(i);
if (pServerItem == nullptr)
{
continue;
}
UnionRoomEnd.dwUserID[i] = pServerItem->GetUserID();
UnionRoomEnd.lUserScore[i] = pTableInfo->lPlayerWinLose[i];
}
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_UNION_ROOM_END, 0L, (BYTE*)&UnionRoomEnd, sizeof(UnionRoomEnd));
return;
}
// 计算积分，找到大赢家分数;
SCORE lMaxScore = 0;
for (int i = 0; i < UnionRoomEnd.cbUserCount; i++)
{
IServerUserItem * pServerItem = pTableFrame->GetTableUserItem(i);
if (pServerItem == nullptr)
{
continue;
}
UnionRoomEnd.dwUserID[i] = pServerItem->GetUserID();
/*UnionRoomEnd.lUserScore[i] = pTableInfo->lPlayerWinLose[i] * pTableInfo->lScoreMultiple * pTableInfo->cbBaseScore;*/
UnionRoomEnd.lUserScore[i] = pTableInfo->lPlayerWinLose[i] * pTableInfo->cbBaseScore;
if (UnionRoomEnd.lUserScore[i] > lMaxScore)
{
lMaxScore = UnionRoomEnd.lUserScore[i];
}
}
// 统计大赢家数量;
int iMaxScoreCount = 0;
for (int j = 0; j < UnionRoomEnd.cbUserCount; j++)
{
if ((lMaxScore > 0) && (UnionRoomEnd.lUserScore[j] == lMaxScore))
{
iMaxScoreCount++;
}
}
if (iMaxScoreCount > 0)
{
// 佣金
SCORE lGameGold = pTableInfo->lGameGold * pTableInfo->dwPlayCost;
// 计算玩家积分;
SCORE lRevenue = floor(lGameGold / iMaxScoreCount);
// 重新计算积分, 统计扣税;
for (int k = 0; k < UnionRoomEnd.cbUserCount; k++)
{
if ((lMaxScore > 0) && (UnionRoomEnd.lUserScore[k] == lMaxScore))
{
if (UnionRoomEnd.lUserScore[k] > lRevenue)
{
UnionRoomEnd.lUserScore[k] -= lRevenue;
UnionRoomEnd.lRevenue += lRevenue;
}
else
{
UnionRoomEnd.lRevenue += UnionRoomEnd.lUserScore[k];
UnionRoomEnd.lUserScore[k] = 0;
}
}
}
}
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_UNION_ROOM_END, 0L, (BYTE*)&UnionRoomEnd, sizeof(UnionRoomEnd));
// 写每个玩家积分;
for (int i = 0; i < UnionRoomEnd.cbUserCount; i++)
{
IServerUserItem* pServerUserItem = pTableFrame->GetTableUserItem(i);
if (NULL == pServerUserItem) continue;
// 有输赢才写数据库;
if (UnionRoomEnd.lUserScore[i] != 0)
{
DBR_GR_UnionScore unionScore;
ZeroMemory(&unionScore, sizeof(DBR_GR_UnionScore));
unionScore.dwUserID = pServerUserItem->GetUserID();
unionScore.dwUnoinCode = pTableInfo->dwUnionCode;
unionScore.lUserScore = UnionRoomEnd.lUserScore[i];
m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_WRITE_UNION_SCORE, 0L, (BYTE*)&unionScore, sizeof(unionScore));
}
}
}
////发送自由人数玩家状态
//void PriaveteGame::SendAutoUserStatus(PrivateTableInfo* pTableInfo)
//{
// if (pTableInfo == nullptr) return;
//
// // 结束了或者已经开始了，就不处理该消息;
// if (pTableInfo->bInEnd || pTableInfo->bStart)return;
//
// // 不是自由人数场;
// if (!pTableInfo->IsAutoUserCountRule()) return;
//
// // 通知客户端可以开始游戏了;
// tagAutoUserStatus autoUserStatus;
// ZeroMemory(&autoUserStatus, sizeof(tagAutoUserStatus));
//
// autoUserStatus.wChairCount = pTableInfo->pITableFrame->GetChairCount();
// CopyMemory(autoUserStatus.bAutoUserStatus, pTableInfo->bAutoStart, sizeof(bool)*autoUserStatus.wChairCount);
//
// SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
//
//}
Reference in New Issue View Git Blame Copy Permalink