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

3171 lines
83 KiB
C++
Raw Permalink 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 "TableFrame.h"
#include "StockManager.h"
#include "AttemperEngineSink.h"
#include "DataBasePacket.h"
//////////////////////////////////////////////////////////////////////////////////
//断线定义
#define IDI_OFF_LINE (TIME_TABLE_SINK_RANGE+1) //断线标识
#define MAX_OFF_LINE 3 //断线次数
#define TIME_OFF_LINE 60000L //断线时间
void ConvertUtf8ToGBK(CString &strUtf8)
{
int len = MultiByteToWideChar(CP_UTF8, 0, (LPCTSTR)strUtf8, -1, NULL, 0);
wchar_t * wszGBK = new wchar_t[len];
memset(wszGBK, 0, len);
MultiByteToWideChar(CP_UTF8, 0, (LPCTSTR)strUtf8, -1, wszGBK, len);
len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
char *szGBK = new char[len + 1];
memset(szGBK, 0, len + 1);
WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
strUtf8 = szGBK;
delete[] szGBK;
delete[] wszGBK;
}
void ConvertUtf8ToGBK(char* pChar, int iLen)
{
CString kString(pChar);
ConvertUtf8ToGBK(kString);
strncpy(pChar, kString.GetString(), iLen);
}
//////////////////////////////////////////////////////////////////////////////////
//组件变量
CStockManager g_StockManager; //库存管理
//游戏记录
CGameScoreRecordArray CTableFrame::m_GameScoreRecordBuffer;
CGameCardLibraryArray CTableFrame::m_GameCardLibraryBuffer;
//////////////////////////////////////////////////////////////////////////////////
//构造函数
CTableFrame::CTableFrame()
{
//固有属性
m_wUserCount = 0;
m_wTableID=0;
m_wChairCount=0;
m_cbStartMode=START_MODE_ALL_READY;
//标志变量
m_bGameStarted=false;
m_bDrawStarted=false;
m_bTableStarted=false;
ZeroMemory(m_bAllowLookon,sizeof(m_bAllowLookon));
ZeroMemory(m_lFrozenedScore,sizeof(m_lFrozenedScore));
//游戏变量
m_lCellScore=0L;
m_wDrawCount = 0; // 构造函数初始化;
m_cbGameStatus=GAME_STATUS_FREE;
//时间变量
m_dwDrawStartTime=0L;
ZeroMemory(&m_SystemTimeStart,sizeof(m_SystemTimeStart));
//动态属性
m_dwTableOwnerID=0L;
ZeroMemory(m_szEnterPassword,sizeof(m_szEnterPassword));
//断线变量
ZeroMemory(m_wOffLineCount,sizeof(m_wOffLineCount));
ZeroMemory(m_dwOffLineTime,sizeof(m_dwOffLineTime));
//配置信息
m_pGameParameter=NULL;
m_pGameServiceAttrib=NULL;
m_pGameServiceOption=NULL;
m_pGameMatchOption = NULL;
//组件接口
m_pITimerEngine=NULL;
m_pITableFrameSink=NULL;
m_pIMainServiceFrame=NULL;
m_pIAndroidUserManager=NULL;
//扩张接口
m_pITableUserAction=NULL;
m_pITableUserRequest=NULL;
m_pIMatchTableAction=NULL;
m_pITableFramePrivate=NULL;
m_pIPrivateTableAction=NULL;
//数据接口
m_pIKernelDataBaseEngine=NULL;
m_pIRecordDataBaseEngine=NULL;
//比赛接口
m_pITableFrameHook=NULL;
//用户数组
ZeroMemory(m_TableUserItemArray,sizeof(m_TableUserItemArray));
//私人场配置;
ZeroMemory(&m_PrivateFramePrarameter, sizeof(m_PrivateFramePrarameter));
return;
}
//析构函数
CTableFrame::~CTableFrame()
{
//释放对象
SafeRelease(m_pITableFrameSink);
SafeRelease(m_pITableFrameHook);
SafeRelease(m_pITableFramePrivate);
ClearGameCardLibrary();
return;
}
//接口查询
VOID * CTableFrame::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
{
QUERYINTERFACE(ITableFrame,Guid,dwQueryVer);
QUERYINTERFACE_IUNKNOWNEX(ITableFrame,Guid,dwQueryVer);
return NULL;
}
//开始游戏
bool CTableFrame::StartGame()
{
//游戏状态
ASSERT(m_bDrawStarted==false);
if (m_bDrawStarted==true) return false;
//保存变量
bool bGameStarted=m_bGameStarted;
bool bTableStarted=m_bTableStarted;
//设置状态
m_bGameStarted=true;
m_bDrawStarted=true;
m_bTableStarted=true;
//开始时间
GetLocalTime(&m_SystemTimeStart);
m_dwDrawStartTime=(DWORD)time(NULL);
//开始设置
if (bGameStarted==false)
{
//状态变量
ZeroMemory(m_wOffLineCount,sizeof(m_wOffLineCount));
ZeroMemory(m_dwOffLineTime,sizeof(m_dwOffLineTime));
//设置用户
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(i);
//设置用户
if (pIServerUserItem!=NULL)
{
//锁定游戏币
if (m_pGameServiceOption->lServiceScore>0L)
{
m_lFrozenedScore[i]=m_pGameServiceOption->lServiceScore;
pIServerUserItem->FrozenedUserScore(m_pGameServiceOption->lServiceScore);
}
//设置状态
BYTE cbUserStatus=pIServerUserItem->GetUserStatus();
if ((cbUserStatus!=US_OFFLINE)&&(cbUserStatus!=US_PLAYING)) pIServerUserItem->SetUserStatus(US_PLAYING,m_wTableID,i);
}
}
//发送状态
if (bTableStarted!=m_bTableStarted) SendTableStatus();
}
//通知事件
ASSERT(m_pITableFrameSink!=NULL);
if (m_pITableFrameSink!=NULL) m_pITableFrameSink->OnEventGameStart();
//比赛通知
bool bStart=true;
if(m_pITableFrameHook!=NULL) bStart=m_pITableFrameHook->OnEventGameStart(this, m_wChairCount);
//私人场通知
if(m_pITableFramePrivate!=NULL) bStart=m_pITableFramePrivate->OnEventGameStart(this, m_wChairCount);
////通知事件
//ASSERT(m_pITableFrameSink!=NULL);
//if (m_pITableFrameSink!=NULL&&bStart) m_pITableFrameSink->OnEventGameStart();
return true;
}
//解散游戏
bool CTableFrame::DismissGame()
{
//状态判断
ASSERT(m_bTableStarted==true);
if (m_bTableStarted==false) return false;
//结束游戏
if ((m_bGameStarted==true)&&(m_pITableFrameSink->OnEventGameConclude(INVALID_CHAIR,NULL,GER_DISMISS)==false))
{
ASSERT(FALSE);
return false;
}
//设置状态
if ((m_bGameStarted==false)&&(m_bTableStarted==true))
{
//设置变量
m_bTableStarted=false;
//发送状态
SendTableStatus();
}
return true;
}
//结束游戏
bool CTableFrame::ConcludeGame(BYTE cbGameStatus, BYTE cbReason/* = GER_NORMAL*/)
{
//效验状态
ASSERT(m_bGameStarted==true);
if (m_bGameStarted==false) return false;
//保存变量
bool bDrawStarted=m_bDrawStarted;
//设置状态
m_bDrawStarted=false;
m_cbGameStatus=cbGameStatus;
m_bGameStarted=(cbGameStatus>=GAME_STATUS_PLAY)?true:false;
m_wDrawCount++; // 一局结束统计;
//游戏记录
if (bDrawStarted==true)
{
////写入记录
//if (CServerRule::IsRecordGameScore(m_pGameServiceOption->dwServerRule)==true)
//{
// //变量定义
// DBR_GR_GameScoreRecord GameScoreRecord;
// //设置变量
// GameScoreRecord.wTableID=m_wTableID;
// GameScoreRecord.dwPlayTimeCount=(bDrawStarted==true)?(DWORD)time(NULL)-m_dwDrawStartTime:0;
// //游戏时间
// GameScoreRecord.SystemTimeStart=m_SystemTimeStart;
// GetLocalTime(&GameScoreRecord.SystemTimeConclude);
// //用户积分
// for (INT_PTR i=0;i<m_GameScoreRecordActive.GetCount();i++)
// {
// //获取对象
// ASSERT(m_GameScoreRecordActive[i]!=NULL);
// tagGameScoreRecord * pGameScoreRecord=m_GameScoreRecordActive[i];
// //用户数目
// if (pGameScoreRecord->cbAndroid==FALSE)
// {
// GameScoreRecord.wUserCount++;
// }
// else
// {
// GameScoreRecord.wAndroidCount++;
// }
// //奖牌统计
// GameScoreRecord.dwUserMemal+=pGameScoreRecord->dwUserMemal;
// //统计信息
// if (pGameScoreRecord->cbAndroid==FALSE)
// {
// GameScoreRecord.lWasteCount-=(pGameScoreRecord->lScore+pGameScoreRecord->lRevenue);
// GameScoreRecord.lRevenueCount+=pGameScoreRecord->lRevenue;
// }
// WORD wIndex=GameScoreRecord.wRecordCount++;
// GameScoreRecord.GameScoreRecord.push_back(*pGameScoreRecord);
// }
// //投递数据
// if(GameScoreRecord.wUserCount > 0)
// {
// //GameScoreRecord.dataGameDefine = m_UserDefine;
// DataStream kDataStream;
// GameScoreRecord.StreamValue(kDataStream,true);
// m_pIRecordDataBaseEngine->PostDataBaseRequest(DBR_GR_GAME_SCORE_RECORD,0,&kDataStream[0],kDataStream.size());
// }
//}
//清理记录
if (m_GameScoreRecordActive.GetCount()>0L)
{
m_GameScoreRecordBuffer.Append(m_GameScoreRecordActive);
m_GameScoreRecordActive.RemoveAll();
}
}
//结束设置
if (m_bGameStarted==false)
{
//变量定义
bool bOffLineWait=false;
//设置用户
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(i);
//用户处理
if (pIServerUserItem!=NULL)
{
tagTimeInfo* TimeInfo=pIServerUserItem->GetTimeInfo();
//游戏时间
DWORD dwCurrentTime=(DWORD)time(NULL);
TimeInfo->dwEndGameTimer=dwCurrentTime;
//解锁游戏币
if (m_lFrozenedScore[i]!=0L)
{
pIServerUserItem->UnFrozenedUserScore(m_lFrozenedScore[i]);
m_lFrozenedScore[i]=0L;
}
//设置状态
if (pIServerUserItem->GetUserStatus() == US_OFFLINE)
{
//断线处理
bOffLineWait = true;
if (m_pGameServiceOption->wServerType != GAME_GENRE_MATCH)
{
PerformStandUpAction(pIServerUserItem);
// 私人场重置还原状态
if (m_pGameServiceOption->wServerType == GAME_GENRE_EDUCATE)
{
pIServerUserItem->SetReUserStatus(US_SIT);
}
}
else
{
pIServerUserItem->SetClientReady(true);
pIServerUserItem->SetUserStatus(US_SIT, m_wTableID, i);
}
}
else
{
//设置状态
pIServerUserItem->SetUserStatus(US_SIT, m_wTableID, i);
}
}
}
//删除时间
if (bOffLineWait==true) KillGameTimer(IDI_OFF_LINE);
}
//通知比赛
if(m_pITableFrameHook!=NULL) m_pITableFrameHook->OnEventGameEnd(this,0, NULL, cbGameStatus);
//通知私人场;
if (m_pITableFramePrivate != NULL) m_pITableFramePrivate->OnEventGameEnd(this, 0, NULL, cbReason);
//重置桌子
ASSERT(m_pITableFrameSink!=NULL);
if (m_pITableFrameSink!=NULL) m_pITableFrameSink->RepositionSink();
//踢出检测
if (m_bGameStarted==false)
{
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
if (m_TableUserItemArray[i]==NULL) continue;
IServerUserItem * pIServerUserItem=m_TableUserItemArray[i];
//积分限制
if ((m_pGameServiceOption->lMinTableScore!=0L)&&(pIServerUserItem->GetUserScore()<m_pGameServiceOption->lMinTableScore))
{
//构造提示
TCHAR szDescribe[128]=TEXT("");
if (m_pGameServiceOption->wServerType&GAME_GENRE_GOLD)
{
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("您的游戏币少于 ") SCORE_STRING TEXT("，不能继续游戏！"),m_pGameServiceOption->lMinTableScore);
}
else
{
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("您的游戏积分少于 ") SCORE_STRING TEXT("，不能继续游戏！"),m_pGameServiceOption->lMinTableScore);
}
//发送消息
if (pIServerUserItem->IsAndroidUser()==true)
SendGameMessage(pIServerUserItem,szDescribe,SMT_CHAT|SMT_CLOSE_GAME|SMT_CLOSE_ROOM|SMT_EJECT);
else
SendGameMessage(pIServerUserItem,szDescribe,SMT_CHAT|SMT_CLOSE_GAME|SMT_EJECT);
//用户起立
PerformStandUpAction(pIServerUserItem);
continue;
}
//关闭判断
if ((CServerRule::IsForfendGameEnter(m_pGameServiceOption->dwServerRule)==true)&&(pIServerUserItem->GetMasterOrder()==0))
{
//发送消息
LPCTSTR pszMessage=TEXT("由于系统维护，当前游戏桌子禁止用户继续游戏！");
SendGameMessage(pIServerUserItem,pszMessage,SMT_EJECT|SMT_CHAT|SMT_CLOSE_GAME);
//用户起立
PerformStandUpAction(pIServerUserItem);
continue;
}
}
}
//结束桌子
ConcludeTable();
//发送状态
SendTableStatus();
return true;
}
//结束桌子
bool CTableFrame::ConcludeTable()
{
//结束桌子
if ((m_bGameStarted==false)&&(m_bTableStarted==true))
{
//人数判断
WORD wTableUserCount=GetSitUserCount();
if (wTableUserCount==0) m_bTableStarted=false;
if (m_pGameServiceAttrib->wChairCount==MAX_CHAIR) m_bTableStarted=false;
//模式判断
if (m_cbStartMode==START_MODE_FULL_READY) m_bTableStarted=false;
if (m_cbStartMode==START_MODE_PAIR_READY) m_bTableStarted=false;
if (m_cbStartMode==START_MODE_ALL_READY) m_bTableStarted=false;
}
return true;
}
//写入积分
bool CTableFrame::WriteUserScore(WORD wChairID, tagScoreInfo & ScoreInfo)
{
//效验参数
ASSERT((wChairID<m_wChairCount)&&(ScoreInfo.cbType!=SCORE_TYPE_NULL));
if ((wChairID>=m_wChairCount)&&(ScoreInfo.cbType==SCORE_TYPE_NULL)) return false;
//获取用户
ASSERT(GetTableUserItem(wChairID)!=NULL);
IServerUserItem * pIServerUserItem=GetTableUserItem(wChairID);
TCHAR szMessage[128]=TEXT("");
//写入积分
if (pIServerUserItem!=NULL)
{
//变量定义
DWORD dwUserMemal=0L;
SCORE lRevenueScore=__min(m_lFrozenedScore[wChairID],m_pGameServiceOption->lServiceScore);
//扣服务费
if (m_pGameServiceOption->lServiceScore>0L
&& m_pGameServiceOption->wServerType == GAME_GENRE_GOLD
&& m_pITableFrameSink->QueryBuckleServiceCharge(wChairID))
{
//扣服务费
ScoreInfo.lScore-=lRevenueScore;
ScoreInfo.lRevenue+=lRevenueScore;
//解锁游戏币
pIServerUserItem->UnFrozenedUserScore(m_lFrozenedScore[wChairID]);
m_lFrozenedScore[wChairID]=0L;
}
//奖牌计算
if (ScoreInfo.lRevenue>0L)
{
WORD wMedalRate=m_pGameParameter->wMedalRate;
dwUserMemal=(DWORD)(ScoreInfo.lRevenue*wMedalRate/1000L);
}
//游戏时间
DWORD dwCurrentTime=(DWORD)time(NULL);
DWORD dwPlayTimeCount=(m_bDrawStarted==true)?dwCurrentTime-m_dwDrawStartTime:0L;
//变量定义
tagUserProperty * pUserProperty=pIServerUserItem->GetUserProperty();
//道具判断
if(m_pGameServiceOption->wServerType == GAME_GENRE_SCORE)
{
if (ScoreInfo.lScore>0L)
{
//四倍积分
if ((pUserProperty->wPropertyUseMark&PT_USE_MARK_FOURE_SCORE)!=0)
{
//变量定义
DWORD dwValidTime=pUserProperty->PropertyInfo[1].wPropertyCount*pUserProperty->PropertyInfo[1].dwValidNum;
if(pUserProperty->PropertyInfo[1].dwEffectTime+dwValidTime>dwCurrentTime)
{
//积分翻倍
ScoreInfo.lScore *= 4;
_sntprintf_s(szMessage,CountArray(szMessage),TEXT("[ %s ] 使用了[ 四倍积分卡 ]，得分翻四倍！)"),pIServerUserItem->GetNickName());
}
else
{
pUserProperty->wPropertyUseMark&=~PT_USE_MARK_FOURE_SCORE;
}
} //双倍积分
else if ((pUserProperty->wPropertyUseMark&PT_USE_MARK_DOUBLE_SCORE)!=0)
{
//变量定义
DWORD dwValidTime=pUserProperty->PropertyInfo[0].wPropertyCount*pUserProperty->PropertyInfo[0].dwValidNum;
if (pUserProperty->PropertyInfo[0].dwEffectTime+dwValidTime>dwCurrentTime)
{
//积分翻倍
ScoreInfo.lScore*=2L;
_sntprintf_s(szMessage,CountArray(szMessage),TEXT("[ %s ] 使用了[ 双倍积分卡 ]，得分翻倍！"), pIServerUserItem->GetNickName());
}
else
{
pUserProperty->wPropertyUseMark&=~PT_USE_MARK_DOUBLE_SCORE;
}
}
}
else
{
//附身符
if ((pUserProperty->wPropertyUseMark&PT_USE_MARK_POSSESS)!=0)
{
//变量定义
DWORD dwValidTime=pUserProperty->PropertyInfo[3].wPropertyCount*pUserProperty->PropertyInfo[3].dwValidNum;
if(pUserProperty->PropertyInfo[3].dwEffectTime+dwValidTime>dwCurrentTime)
{
//积分翻倍
ScoreInfo.lScore = 0;
_sntprintf_s(szMessage,CountArray(szMessage),TEXT("[ %s ] 使用了[ 护身符卡 ]，积分不变！"),pIServerUserItem->GetNickName());
}
else
{
pUserProperty->wPropertyUseMark &= ~PT_USE_MARK_POSSESS;
}
}
}
}
SCORE lScore = ScoreInfo.lScore;
//if (lScore + pIServerUserItem->GetUserScore() < 0)
//{
// lScore = -pIServerUserItem->GetUserScore();
//}
//写入积分
//if (m_pGameServiceOption->wServerType != GAME_GENRE_EDUCATE)
//{
// if (lScore + pIServerUserItem->GetUserScore() < 0)
// {
// lScore = -pIServerUserItem->GetUserScore();
// }
//}
//写入积分
pIServerUserItem->WriteUserScore(lScore, ScoreInfo.lGrade, ScoreInfo.lRevenue, dwUserMemal, ScoreInfo.cbType, ScoreInfo.cbLastScoreMultiple, dwPlayTimeCount);
//游戏记录
if (pIServerUserItem->IsAndroidUser()==false && CServerRule::IsRecordGameScore(m_pGameServiceOption->dwServerRule)==true)
{
//变量定义
tagGameScoreRecord * pGameScoreRecord=NULL;
//查询库存
if (m_GameScoreRecordBuffer.GetCount()>0L)
{
//获取对象
INT_PTR nCount=m_GameScoreRecordBuffer.GetCount();
pGameScoreRecord=m_GameScoreRecordBuffer[nCount-1];
//删除对象
m_GameScoreRecordBuffer.RemoveAt(nCount-1);
}
//创建对象
if (pGameScoreRecord==NULL)
{
try
{
//创建对象
pGameScoreRecord=new tagGameScoreRecord;
if (pGameScoreRecord==NULL) throw TEXT("游戏记录对象创建失败");
}
catch (...)
{
ASSERT(FALSE);
}
}
//记录数据
if (pGameScoreRecord!=NULL)
{
//用户信息
pGameScoreRecord->wChairID=wChairID;
pGameScoreRecord->dwUserID=pIServerUserItem->GetUserID();
pGameScoreRecord->cbAndroid=(pIServerUserItem->IsAndroidUser()?TRUE:FALSE);
//用户信息
pGameScoreRecord->dwDBQuestID=pIServerUserItem->GetDBQuestID();
pGameScoreRecord->dwInoutIndex=pIServerUserItem->GetInoutIndex();
//成绩信息
pGameScoreRecord->lScore=ScoreInfo.lScore;
pGameScoreRecord->lGrade=ScoreInfo.lGrade;
pGameScoreRecord->lRevenue=ScoreInfo.lRevenue;
//附加信息
pGameScoreRecord->dwUserMemal=dwUserMemal;
pGameScoreRecord->dwPlayTimeCount=dwPlayTimeCount;
//机器人免税
if(pIServerUserItem->IsAndroidUser())
{
pGameScoreRecord->lScore += pGameScoreRecord->lRevenue;
pGameScoreRecord->lRevenue = 0L;
}
//插入数据
m_GameScoreRecordActive.Add(pGameScoreRecord);
}
}
}
else
{
//离开用户
CTraceService::TraceString(TEXT("系统暂时未支持离开用户的补分操作处理！"),TraceLevel_Exception);
return false;
}
//广播消息
if (szMessage[0]!=0)
{
//变量定义
IServerUserItem * pISendUserItem = NULL;
WORD wEnumIndex=0;
//游戏玩家
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
pISendUserItem=GetTableUserItem(i);
if(pISendUserItem==NULL) continue;
//发送消息
SendGameMessage(pISendUserItem, szMessage, SMT_CHAT);
}
//旁观用户
do
{
pISendUserItem=EnumLookonUserItem(wEnumIndex++);
if(pISendUserItem!=NULL)
{
//发送消息
SendGameMessage(pISendUserItem, szMessage, SMT_CHAT);
}
} while (pISendUserItem!=NULL);
}
return true;
}
//写入积分
bool CTableFrame::WriteTableScore(tagScoreInfo ScoreInfoArray[], WORD wScoreCount,DataStream kDataStream)
{
//效验参数
ASSERT(wScoreCount==m_wChairCount);
if (wScoreCount!=m_wChairCount) return false;
//写入分数
for (WORD i=0;i<m_wChairCount;i++)
{
if (ScoreInfoArray[i].cbType!=SCORE_TYPE_NULL)
{
WriteUserScore(i,ScoreInfoArray[i]);
}
}
if (m_pITableFramePrivate)
{
m_pITableFramePrivate->WriteTableScore(this,ScoreInfoArray,wScoreCount,kDataStream);
}
return true;
}
////积分倍数
//bool CTableFrame::WriteScoreMultiple(WORD wChairID, BYTE cbScoreMultiple)
//{
// //效验参数
// ASSERT((wChairID < m_wChairCount) && (cbScoreMultiple >= 1));
// if ((wChairID >= m_wChairCount) && (cbScoreMultiple < 1)) return false;
//
//
//}
//计算税收
SCORE CTableFrame::CalculateRevenue(WORD wChairID, SCORE lScore)
{
//效验参数
ASSERT(wChairID<m_wChairCount);
if (wChairID>=m_wChairCount) return 0L;
//计算税收
if ((m_pGameServiceOption->wRevenueRatio>0)&&(lScore>=REVENUE_BENCHMARK))
{
//获取用户
ASSERT(GetTableUserItem(wChairID)!=NULL);
IServerUserItem * pIServerUserItem=GetTableUserItem(wChairID);
//计算税收
SCORE lRevenue=lScore*m_pGameServiceOption->wRevenueRatio/REVENUE_DENOMINATOR;
return lRevenue;
}
return 0L;
}
//消费限额
SCORE CTableFrame::QueryConsumeQuota(IServerUserItem * pIServerUserItem)
{
//用户效验
ASSERT(pIServerUserItem->GetTableID()==m_wTableID);
if (pIServerUserItem->GetTableID()!=m_wTableID) return 0L;
//查询额度
SCORE lTrusteeScore=pIServerUserItem->GetTrusteeScore();
SCORE lMinEnterScore=m_pGameServiceOption->lMinTableScore;
SCORE lUserConsumeQuota=m_pITableFrameSink->QueryConsumeQuota(pIServerUserItem);
//效验额度
ASSERT((lUserConsumeQuota>=0L)&&(lUserConsumeQuota<=pIServerUserItem->GetUserScore()-lMinEnterScore));
if ((lUserConsumeQuota<0L)||(lUserConsumeQuota>pIServerUserItem->GetUserScore()-lMinEnterScore)) return 0L;
return lUserConsumeQuota+lTrusteeScore;
}
//寻找用户
IServerUserItem * CTableFrame::SearchUserItem(DWORD dwUserID)
{
//变量定义
WORD wEnumIndex=0;
IServerUserItem * pIServerUserItem=NULL;
//桌子用户
for (WORD i=0;i<m_wChairCount;i++)
{
pIServerUserItem=GetTableUserItem(i);
if ((pIServerUserItem!=NULL)&&(pIServerUserItem->GetUserID()==dwUserID)) return pIServerUserItem;
}
//旁观用户
do
{
pIServerUserItem=EnumLookonUserItem(wEnumIndex++);
if ((pIServerUserItem!=NULL)&&(pIServerUserItem->GetUserID()==dwUserID)) return pIServerUserItem;
} while (pIServerUserItem!=NULL);
return NULL;
}
//游戏用户
IServerUserItem * CTableFrame::GetTableUserItem(WORD wChairID)
{
//效验参数
ASSERT(wChairID<m_wChairCount);
if (wChairID>=m_wChairCount) return NULL;
//获取用户
return m_TableUserItemArray[wChairID];
}
//旁观用户
IServerUserItem * CTableFrame::EnumLookonUserItem(WORD wEnumIndex)
{
if (wEnumIndex>=m_LookonUserItemArray.GetCount()) return NULL;
return m_LookonUserItemArray[wEnumIndex];
}
//设置时间
bool CTableFrame::SetGameTimer(DWORD dwTimerID, DWORD dwElapse, DWORD dwRepeat, WPARAM dwBindParameter)
{
//效验参数
ASSERT((dwTimerID>0)&&(dwTimerID<TIME_TABLE_MODULE_RANGE));
if ((dwTimerID<=0)||(dwTimerID>=TIME_TABLE_MODULE_RANGE)) return false;
//设置时间
DWORD dwEngineTimerID=IDI_TABLE_MODULE_START+m_wTableID*TIME_TABLE_MODULE_RANGE;
if (m_pITimerEngine!=NULL) m_pITimerEngine->SetTimer(dwEngineTimerID+dwTimerID,dwElapse,dwRepeat,dwBindParameter);
return true;
}
//删除时间
bool CTableFrame::KillGameTimer(DWORD dwTimerID)
{
//效验参数
ASSERT((dwTimerID>0)&&(dwTimerID<=TIME_TABLE_MODULE_RANGE));
if ((dwTimerID<=0)||(dwTimerID>TIME_TABLE_MODULE_RANGE)) return false;
//删除时间
DWORD dwEngineTimerID=IDI_TABLE_MODULE_START+m_wTableID*TIME_TABLE_MODULE_RANGE;
if (m_pITimerEngine!=NULL) m_pITimerEngine->KillTimer(dwEngineTimerID+dwTimerID);
return true;
}
//发送数据
bool CTableFrame::SendUserItemData(IServerUserItem * pIServerUserItem, WORD wSubCmdID)
{
//状态效验
ASSERT((pIServerUserItem!=NULL)&&(pIServerUserItem->IsClientReady()==true));
if ((pIServerUserItem==NULL)&&(pIServerUserItem->IsClientReady()==false)) return false;
//发送数据
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_GAME,wSubCmdID,NULL,0);
return true;
}
//发送数据
bool CTableFrame::SendUserItemData(IServerUserItem * pIServerUserItem, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
//状态效验
ASSERT((pIServerUserItem!=NULL)&&(pIServerUserItem->IsClientReady()==true));
if ((pIServerUserItem==NULL)&&(pIServerUserItem->IsClientReady()==false)) return false;
//发送数据
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_GAME,wSubCmdID,pData,wDataSize);
return true;
}
//发送数据
bool CTableFrame::SendTableData(WORD wChairID, WORD wSubCmdID)
{
//用户群发
if (wChairID==INVALID_CHAIR)
{
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(i);
if (pIServerUserItem==NULL) continue;
//效验状态
ASSERT(pIServerUserItem->IsClientReady()==true);
if (pIServerUserItem->IsClientReady()==false) continue;
//发送数据
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_GAME,wSubCmdID,NULL,0);
}
return true;
}
else
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(wChairID);
if (pIServerUserItem==NULL) return false;
//效验状态
ASSERT(pIServerUserItem->IsClientReady()==true);
if (pIServerUserItem->IsClientReady()==false) return false;
//发送数据
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_GAME,wSubCmdID,NULL,0);
return true;
}
return false;
}
//发送数据
bool CTableFrame::SendTableData(WORD wChairID, WORD wSubCmdID, VOID * pData, WORD wDataSize,WORD wMainCmdID)
{
//用户群发
if (wChairID==INVALID_CHAIR)
{
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(i);
if ((pIServerUserItem==NULL)||(pIServerUserItem->IsClientReady()==false)) continue;
if ((pIServerUserItem==NULL)) continue;
//发送数据
m_pIMainServiceFrame->SendData(pIServerUserItem,wMainCmdID,wSubCmdID,pData,wDataSize);
}
return true;
}
else
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(wChairID);
if ((pIServerUserItem==NULL)||(pIServerUserItem->IsClientReady()==false)) return false;
//发送数据
m_pIMainServiceFrame->SendData(pIServerUserItem,wMainCmdID,wSubCmdID,pData,wDataSize);
return true;
}
return false;
}
//发送数据
bool CTableFrame::SendLookonData(WORD wChairID, WORD wSubCmdID)
{
//变量定义
WORD wEnumIndex=0;
IServerUserItem * pIServerUserItem=NULL;
//枚举用户
do
{
//获取用户
pIServerUserItem=EnumLookonUserItem(wEnumIndex++);
if (pIServerUserItem==NULL) break;
//效验状态
ASSERT(pIServerUserItem->IsClientReady()==true);
if (pIServerUserItem->IsClientReady()==false) return false;
//发送数据
if ((wChairID==INVALID_CHAIR)||(pIServerUserItem->GetChairID()==wChairID))
{
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_GAME,wSubCmdID,NULL,0);
}
} while (true);
return true;
}
//发送数据
bool CTableFrame::SendLookonData(WORD wChairID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
//变量定义
WORD wEnumIndex=0;
IServerUserItem * pIServerUserItem=NULL;
//枚举用户
do
{
//获取用户
pIServerUserItem=EnumLookonUserItem(wEnumIndex++);
if (pIServerUserItem==NULL) break;
//效验状态
//ASSERT(pIServerUserItem->IsClientReady()==true);
if (pIServerUserItem->IsClientReady()==false) return false;
//发送数据
if ((wChairID==INVALID_CHAIR)||(pIServerUserItem->GetChairID()==wChairID))
{
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_GAME,wSubCmdID,pData,wDataSize);
}
} while (true);
return true;
}
//发送消息
bool CTableFrame::SendGameMessage(LPCTSTR lpszMessage, WORD wType)
{
//变量定义
WORD wEnumIndex=0;
//发送消息
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(i);
if ((pIServerUserItem==NULL)||(pIServerUserItem->IsClientReady()==false)) continue;
//发送消息
m_pIMainServiceFrame->SendGameMessage(pIServerUserItem,lpszMessage,wType);
}
//枚举用户
do
{
//获取用户
IServerUserItem * pIServerUserItem=EnumLookonUserItem(wEnumIndex++);
if (pIServerUserItem==NULL) break;
//效验状态
ASSERT(pIServerUserItem->IsClientReady()==true);
if (pIServerUserItem->IsClientReady()==false) return false;
//发送消息
m_pIMainServiceFrame->SendGameMessage(pIServerUserItem,lpszMessage,wType);
} while (true);
return true;
}
//房间消息
bool CTableFrame::SendRoomMessage(IServerUserItem * pIServerUserItem, LPCTSTR lpszMessage, WORD wType)
{
//用户效验
ASSERT(pIServerUserItem!=NULL);
if (pIServerUserItem==NULL) return false;
//发送消息
m_pIMainServiceFrame->SendRoomMessage(pIServerUserItem,lpszMessage,wType);
return true;
}
//游戏消息
bool CTableFrame::SendGameMessage(IServerUserItem * pIServerUserItem, LPCTSTR lpszMessage, WORD wType)
{
//用户效验
ASSERT(pIServerUserItem!=NULL);
if (pIServerUserItem==NULL) return false;
//发送消息
return m_pIMainServiceFrame->SendGameMessage(pIServerUserItem,lpszMessage,wType);
}
//发送场景
bool CTableFrame::SendGameScene(IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
//用户效验
ASSERT((pIServerUserItem!=NULL)&&(pIServerUserItem->IsClientReady()==true));
if ((pIServerUserItem==NULL)||(pIServerUserItem->IsClientReady()==false)) return false;
//发送场景
ASSERT(m_pIMainServiceFrame!=NULL);
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_FRAME,SUB_GF_GAME_SCENE,pData,wDataSize);
return true;
}
//设置接口
bool CTableFrame::SetTableFrameHook(IUnknownEx * pIUnknownEx)
{
ASSERT(pIUnknownEx!=NULL);
if(pIUnknownEx==NULL) return false;
//类型判断
if((m_pGameServiceOption->wServerType&GAME_GENRE_MATCH)==0) return false;
//查询接口
m_pITableFrameHook=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,ITableFrameHook);
m_pIMatchTableAction=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,ITableUserAction);
return true;
}
bool CTableFrame::SetTableFramePrivate(IUnknownEx * pIUnknownEx)
{
ASSERT(pIUnknownEx!=NULL);
if(pIUnknownEx==NULL) return false;
//类型判断
if((m_pGameServiceOption->wServerType&GAME_GENRE_EDUCATE)==0) return false;
//查询接口
m_pITableFramePrivate=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,ITableFramePrivate);
m_pIPrivateTableAction=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,ITableUserAction);
return true;
}
//添加事件
void CTableFrame::AddPrivateAction(DWORD dwChairID,BYTE bActionIdex)
{
if (m_pITableFramePrivate)
{
m_pITableFramePrivate->AddPrivateAction(this,dwChairID,bActionIdex);
}
}
//设置私人场信息
void CTableFrame::SetPrivateInfo(tagPrivateFrameParameter &PriavateFrame)
{
CopyMemory(&m_PrivateFramePrarameter, &PriavateFrame, sizeof(tagPrivateFrameParameter));
}
//获取私人场配置
tagPrivateFrameParameter* CTableFrame::GetPrivateFrameInfo()
{
return &m_PrivateFramePrarameter;
}
bool CTableFrame::IsAutoUserCountRule(ITableFrame* pTbableFrame, bool bReal /*= false*/)
{
if (m_pITableFramePrivate)
{
return m_pITableFramePrivate->IsAutoUserCountRule(pTbableFrame, bReal);
}
return false;
}
//统计私人场玩家局数
VOID CTableFrame::addPrivatePlayCout(WORD wCout)
{
m_PrivateFrameRecord.cbFinishCout += wCout;
if (m_pITableFramePrivate)
{
m_pITableFramePrivate->addPrivatePlayCout(this, wCout);
}
}
//重置私人场结束信息
void CTableFrame::ResetPrivateEndInfo()
{
ZeroMemory(&m_PrivateFrameRecord, sizeof(m_PrivateFrameRecord));
//私人场配置;
ZeroMemory(&m_PrivateFramePrarameter, sizeof(m_PrivateFramePrarameter));
if (m_pITableFrameSink)
{
m_pITableFrameSink->ResetPrivateEndInfo();
}
}
//获取当前完成数据
tagPrivateFrameRecordInfo* CTableFrame::GetPrivateFrameRecord()
{
return &m_PrivateFrameRecord;
}
//获得私人场结束信息流
void CTableFrame::GetPrivateEndInfo(DataStream &kDataStream, bool bSend)
{
if (m_pITableFrameSink)
{
m_pITableFrameSink->GetPrivateEndInfo(kDataStream, bSend);
}
}
//判断私人场是否结束
bool CTableFrame::IsPrivateEnd()
{
// 判断服务器维护;
if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true)
{
return true;
}
// 游戏是否结束;
if (m_pITableFrameSink)
{
return m_pITableFrameSink->IsPrivateEnd();
}
return false;
}
//真实椅子数量
WORD CTableFrame::GetRealChairCount()
{
if (m_pITableFrameSink)
{
return m_pITableFrameSink->GetRealChairCount();
}
return 0;
}
//获取牌库
tagGameCardLibrary* CTableFrame::GetGameCardLibrary(DWORD dwCustomID/* = 0xFFFFFFFF*/)
{
INT_PTR nLibCount = m_GameCardLibraryBuffer.GetCount();
if (0xFFFFFFFF == dwCustomID)
{
if (nLibCount > 0L)
{
INT_PTR nIndex = rand() % nLibCount;
return m_GameCardLibraryBuffer[nIndex];
}
}
else
{
if (nLibCount > 0L && dwCustomID <= CServerUserItem::g_dwCardLibCount)
{
//return m_GameCardLibraryBuffer[dwIndex];
for (INT_PTR i = 0; i < nLibCount; i++)
{
tagGameCardLibrary* pCardLib = m_GameCardLibraryBuffer[i];
if (pCardLib->dwCustomID == dwCustomID)
{
return pCardLib;
}
}
}
}
return NULL;
}
//增加牌库
void CTableFrame::AddGameCardLibrary(tagGameCardLibrary* pGameCard)
{
m_GameCardLibraryBuffer.Add(pGameCard);
}
//修改牌库
void CTableFrame::UpdateGameCardLibrary(DWORD dwLibID, DWORD dwCustomID, BYTE cbCardCount, BYTE* pCardData)
{
ASSERT(pCardData != NULL);
INT_PTR nCount = m_GameCardLibraryBuffer.GetCount();
for (INT_PTR i = 0; i < nCount; i++)
{
tagGameCardLibrary* pCardLib = m_GameCardLibraryBuffer[i];
if (pCardLib->dwLibID == dwLibID)
{
pCardLib->cbCount = cbCardCount;
pCardLib->dwCustomID = dwCustomID;
ZeroMemory(pCardLib->cbData, sizeof(pCardLib->cbData));
memcpy(pCardLib->cbData, pCardData, cbCardCount*sizeof(BYTE));
break;
}
}
}
//删除牌库
void CTableFrame::ClearGameCardLibrary()
{
for (INT_PTR i = 0; i < m_GameCardLibraryBuffer.GetCount(); i++)
{
tagGameCardLibrary* pCardLib = m_GameCardLibraryBuffer[i];
SafeDelete(pCardLib);
}
m_GameCardLibraryBuffer.RemoveAll();
}
//断线事件
bool CTableFrame::OnEventUserOffLine(IServerUserItem * pIServerUserItem)
{
//参数效验
ASSERT(pIServerUserItem!=NULL);
if (pIServerUserItem==NULL) return false;
//用户变量
tagUserInfo * pUserInfo=pIServerUserItem->GetUserInfo();
IServerUserItem * pITableUserItem=m_TableUserItemArray[pUserInfo->wChairID];
//用户属性
WORD wChairID=pIServerUserItem->GetChairID();
BYTE cbUserStatus=pIServerUserItem->GetUserStatus();
//游戏用户
if (cbUserStatus!=US_LOOKON)
{
//效验用户
ASSERT(pIServerUserItem==GetTableUserItem(wChairID));
if (pIServerUserItem!=GetTableUserItem(wChairID)) return false;
//私人类型
if(m_pGameServiceOption->wServerType==GAME_GENRE_EDUCATE)
{
pIServerUserItem->SetReUserStatus(pIServerUserItem->GetUserStatus());
pIServerUserItem->SetUserStatus(US_OFFLINE,m_wTableID,wChairID);
//掉线通知
if(m_pIPrivateTableAction!=NULL) m_pIPrivateTableAction->OnActionUserOffLine(wChairID,pIServerUserItem);
//掉线通知
if (m_pITableUserAction != NULL) m_pITableUserAction->OnActionUserOffLine(wChairID, pIServerUserItem);
return true;
}
//比赛类型
if (m_pGameServiceOption->wServerType == GAME_GENRE_MATCH)
{
if (pIServerUserItem->GetChairID() != INVALID_CHAIR && pIServerUserItem->GetTableID() != INVALID_TABLE)
{
pIServerUserItem->SetReUserStatus(pIServerUserItem->GetUserStatus());
pIServerUserItem->SetUserStatus(US_OFFLINE, m_wTableID, wChairID);
//掉线通知
if (m_pIPrivateTableAction != NULL) m_pIPrivateTableAction->OnActionUserOffLine(wChairID, pIServerUserItem);
return true;
}
}
//断线处理
if ((cbUserStatus==US_PLAYING)&&(m_wOffLineCount[wChairID]<MAX_OFF_LINE))
{
//用户设置
pIServerUserItem->SetClientReady(false);
pIServerUserItem->SetUserStatus(US_OFFLINE,m_wTableID,wChairID);
//比赛类型
if(m_pGameServiceOption->wServerType==GAME_GENRE_MATCH)
{
//if(pIServerUserItem->IsTrusteeUser()==false)
{
//设置托管
//pIServerUserItem->SetTrusteeUser(true);
//掉线通知
if(m_pITableUserAction!=NULL) m_pITableUserAction->OnActionUserOffLine(wChairID,pIServerUserItem);
}
return true;
}
//掉线通知
if(m_pITableUserAction!=NULL) m_pITableUserAction->OnActionUserOffLine(wChairID,pIServerUserItem);
//断线处理
if (m_dwOffLineTime[wChairID]==0L)
{
//设置变量
m_wOffLineCount[wChairID]++;
m_dwOffLineTime[wChairID]=(DWORD)time(NULL);
//时间设置
WORD wOffLineCount=GetOffLineUserCount();
if (wOffLineCount==1) SetGameTimer(IDI_OFF_LINE,TIME_OFF_LINE,1,wChairID);
}
return true;
}
}
//用户起立
PerformStandUpAction(pIServerUserItem);
//删除用户
ASSERT(pIServerUserItem->GetUserStatus()==US_FREE);
pIServerUserItem->SetUserStatus(US_NULL,INVALID_TABLE,INVALID_CHAIR);
return true;
}
//积分事件
bool CTableFrame::OnUserScroeNotify(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)
{
//通知游戏
return m_pITableFrameSink->OnUserScroeNotify(wChairID,pIServerUserItem,cbReason);
}
//时间事件
bool CTableFrame::OnEventTimer(DWORD dwTimerID, WPARAM dwBindParameter)
{
//回调事件
if ((dwTimerID>=0)&&(dwTimerID<TIME_TABLE_SINK_RANGE))
{
ASSERT(m_pITableFrameSink!=NULL);
return m_pITableFrameSink->OnTimerMessage(dwTimerID,dwBindParameter);
}
//事件处理
switch (dwTimerID)
{
case IDI_OFF_LINE: //断线事件
{
//效验状态
ASSERT(m_bGameStarted==true);
if (m_bGameStarted==false) return false;
//变量定义
DWORD dwOffLineTime=0L;
WORD wOffLineChair=INVALID_CHAIR;
//寻找用户
for (WORD i=0;i<m_wChairCount;i++)
{
if ((m_dwOffLineTime[i]!=0L)&&((m_dwOffLineTime[i]<dwOffLineTime)||(wOffLineChair==INVALID_CHAIR)))
{
wOffLineChair=i;
dwOffLineTime=m_dwOffLineTime[i];
}
}
//位置判断
ASSERT(wOffLineChair!=INVALID_CHAIR);
if (wOffLineChair==INVALID_CHAIR) return false;
//用户判断
ASSERT(dwBindParameter<m_wChairCount);
if (wOffLineChair!=(WORD)dwBindParameter)
{
//时间计算
DWORD dwCurrentTime=(DWORD)time(NULL);
DWORD dwLapseTime=dwCurrentTime-m_dwOffLineTime[wOffLineChair];
//设置时间
dwLapseTime=__min(dwLapseTime,TIME_OFF_LINE-2000L);
SetGameTimer(IDI_OFF_LINE,TIME_OFF_LINE-dwLapseTime,1,wOffLineChair);
return true;
}
//获取用户
ASSERT(GetTableUserItem(wOffLineChair)!=NULL);
IServerUserItem * pIServerUserItem=GetTableUserItem(wOffLineChair);
//结束游戏
if (pIServerUserItem!=NULL)
{
//设置变量
m_dwOffLineTime[wOffLineChair]=0L;
//用户起立
PerformStandUpAction(pIServerUserItem);
}
//继续时间
if (m_bGameStarted==true)
{
//变量定义
DWORD dwOffLineTime=0L;
WORD wOffLineChair=INVALID_CHAIR;
//寻找用户
for (WORD i=0;i<m_wChairCount;i++)
{
if ((m_dwOffLineTime[i]!=0L)&&((m_dwOffLineTime[i]<dwOffLineTime)||(wOffLineChair==INVALID_CHAIR)))
{
wOffLineChair=i;
dwOffLineTime=m_dwOffLineTime[i];
}
}
//设置时间
if (wOffLineChair!=INVALID_CHAIR)
{
//时间计算
DWORD dwCurrentTime=(DWORD)time(NULL);
DWORD dwLapseTime=dwCurrentTime-m_dwOffLineTime[wOffLineChair];
//设置时间
dwLapseTime=__min(dwLapseTime,TIME_OFF_LINE-2000L);
SetGameTimer(IDI_OFF_LINE,TIME_OFF_LINE-dwLapseTime,1,wOffLineChair);
}
}
return true;
}
}
//错误断言
ASSERT(FALSE);
return false;
}
//游戏事件
bool CTableFrame::OnEventSocketGame(WORD wSubCmdID, VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem)
{
//效验参数
ASSERT(pIServerUserItem!=NULL);
ASSERT(m_pITableFrameSink!=NULL);
//消息处理
return m_pITableFrameSink->OnGameMessage(wSubCmdID,pData,wDataSize,pIServerUserItem);
}
//框架事件
bool CTableFrame::OnEventSocketFrame(WORD wSubCmdID, VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem)
{
//游戏处理
if (m_pITableFrameSink->OnFrameMessage(wSubCmdID,pData,wDataSize,pIServerUserItem)==true) return true;
//默认处理
switch (wSubCmdID)
{
case SUB_GF_GAME_OPTION: //游戏配置
{
//效验参数
ASSERT(wDataSize==sizeof(CMD_GF_GameOption));
if (wDataSize!=sizeof(CMD_GF_GameOption)) return false;
//变量定义
CMD_GF_GameOption * pGameOption=(CMD_GF_GameOption *)pData;
//获取属性
WORD wChairID=pIServerUserItem->GetChairID();
BYTE cbUserStatus=pIServerUserItem->GetUserStatus();
//断线清理
if ((cbUserStatus!=US_LOOKON)&&((m_dwOffLineTime[wChairID]!=0L)))
{
//设置变量
m_dwOffLineTime[wChairID]=0L;
//删除时间
WORD wOffLineCount=GetOffLineUserCount();
if (wOffLineCount==0) KillGameTimer(IDI_OFF_LINE);
}
//设置状态
pIServerUserItem->SetClientReady(true);
if (cbUserStatus!=US_LOOKON) m_bAllowLookon[wChairID]=pGameOption->cbAllowLookon?true:false;
//发送状态
CMD_GF_GameStatus GameStatus;
GameStatus.cbGameStatus=m_cbGameStatus;
GameStatus.cbAllowLookon=m_bAllowLookon[wChairID]?TRUE:FALSE;
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_FRAME,SUB_GF_GAME_STATUS,&GameStatus,sizeof(GameStatus));
// 先发送私人场信息，在发送场景信息
if (m_pITableFramePrivate != NULL) m_pITableFramePrivate->OnEventPrivateRoomInfo(wChairID, pIServerUserItem);
////发送消息
//TCHAR szMessage[128]=TEXT("");
//_sntprintf_s(szMessage,CountArray(szMessage),TEXT("欢迎您进入“%s”游戏，祝您游戏愉快！"),m_pGameServiceAttrib->szGameName);
//m_pIMainServiceFrame->SendGameMessage(pIServerUserItem,szMessage,SMT_CHAT);
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
if (m_TableUserItemArray[i]==NULL) continue;
if (pIServerUserItem==NULL) continue;
if (pIServerUserItem == m_TableUserItemArray[i]) continue;
IServerUserItem * pSendIServerUserItem=m_TableUserItemArray[i];
m_pIMainServiceFrame->SendUserInfoPacket(pSendIServerUserItem,pIServerUserItem);
m_pIMainServiceFrame->SendUserInfoPacket(pIServerUserItem,pSendIServerUserItem);
}
if (pIServerUserItem->IsAndroidUser())
{
//构造提示;
TCHAR szDescribe[256] = TEXT("");
_sntprintf_s(szDescribe, CountArray(szDescribe), TEXT("recv player [%s] SUB_GF_GAME_OPTION message, SendUserInfoPacket, GetUserStatus:[%d].GetTableID:[%d],GetChairID:[%d]."),
pIServerUserItem->GetNickName(), pIServerUserItem->GetUserStatus(), pIServerUserItem->GetTableID(), pIServerUserItem->GetChairID());
//提示消息;
CTraceService::TraceString(szDescribe, TraceLevel_Warning);
}
// 玩家全部同步完成同步;
if (m_pITableFramePrivate != NULL) m_pITableFramePrivate->OnEventClientReady(wChairID, pIServerUserItem);
//发送场景
bool bSendSecret=((cbUserStatus!=US_LOOKON)||(m_bAllowLookon[wChairID]==true));
m_pITableFrameSink->OnEventSendGameScene(wChairID,pIServerUserItem,m_cbGameStatus,bSendSecret);
//// 如果当前桌上是空闲状态设置断线玩家为坐下状态
//if ((this->GetGameStatus() == GAME_STATUS_FREE) && (cbUserStatus == US_PLAYING))
//{
// pIServerUserItem->SetUserStatus(US_SIT, GetTableID(), wChairID);
//}
//开始判断
if (cbUserStatus == US_READY)
{
if (EfficacyStartGame(wChairID) == true)
{
//StartGame();
// 自由人数场，通知客户端开始准备;
if (IsAutoUserCountRule(this))
{
tagAutoUserStatus userStatus;
userStatus.bStartGame = true;
m_pIPrivateTableAction->OnActionUserOnStart(wChairID, pIServerUserItem, &userStatus, sizeof(userStatus));
}
else
{
StartGame();
}
}
}
return true;
}
case SUB_GF_USER_READY: //用户准备
{
//获取属性
WORD wChairID=pIServerUserItem->GetChairID();
BYTE cbUserStatus=pIServerUserItem->GetUserStatus();
//效验状态
ASSERT(GetTableUserItem(wChairID)==pIServerUserItem);
if (GetTableUserItem(wChairID)!=pIServerUserItem) return false;
//效验状态
ASSERT(cbUserStatus==US_SIT || cbUserStatus == US_CAN_READY);
if (cbUserStatus!=US_SIT && cbUserStatus != US_CAN_READY) return true;
////分组判断(不是私人场)
//if (m_pGameServiceOption->wServerType != GAME_GENRE_EDUCATE)
//{
// if ((m_pGameServiceOption->cbDistributeRule&DISTRIBUTE_ALLOW) != 0)
// {
// m_pIMainServiceFrame->InsertDistribute(pIServerUserItem);
// return true;
// }
//}
//防作弊分组判断
if ((CServerRule::IsAllowAvertCheatMode(m_pGameServiceOption->dwServerRule) && (m_pGameServiceAttrib->wChairCount < MAX_CHAIR))
&& (m_wDrawCount >= m_pGameServiceOption->wDistributeDrawCount || CheckDistribute()))
{
//发送消息
LPCTSTR pszMessage = TEXT("系统重新分配桌子，请稍后！");
SendGameMessage(pIServerUserItem, pszMessage, SMT_CHAT);
//发送消息
m_pIMainServiceFrame->InsertDistribute(pIServerUserItem);
return true;
}
//事件通知
if (m_pITableUserAction!=NULL)
{
m_pITableUserAction->OnActionUserOnReady(wChairID,pIServerUserItem,pData,wDataSize);
}
//事件通知
if(m_pIMatchTableAction!=NULL && !m_pIMatchTableAction->OnActionUserOnReady(wChairID,pIServerUserItem, pData,wDataSize))
{
return true;
}
//事件通知
bool bReady = true;
if (m_pIPrivateTableAction != NULL && !m_pIPrivateTableAction->OnActionUserOnReady(wChairID, pIServerUserItem, &bReady, sizeof(bReady)))
{
return true;
}
//开始判断
if (EfficacyStartGame(wChairID)==false)
{
pIServerUserItem->SetUserStatus(US_READY,m_wTableID,wChairID);
}
else
{
// 自由人数场，通知客户端开始准备;
if (IsAutoUserCountRule(this))
{
pIServerUserItem->SetUserStatus(US_READY, m_wTableID, wChairID);
tagAutoUserStatus userStatus;
userStatus.bStartGame = true;
m_pIPrivateTableAction->OnActionUserOnStart(wChairID, pIServerUserItem, &userStatus, sizeof(userStatus));
}
else
{
StartGame();
}
}
return true;
}
case SUB_GF_USER_START_READY:
{
//分组判断(不是私人场)
if (m_pGameServiceOption->wServerType != GAME_GENRE_EDUCATE)
{
return false;
}
//获取属性
WORD wChairID = pIServerUserItem->GetChairID();
BYTE cbUserStatus = pIServerUserItem->GetUserStatus();
//效验状态
ASSERT(GetTableUserItem(wChairID) == pIServerUserItem);
if (GetTableUserItem(wChairID) != pIServerUserItem) return false;
//效验状态
ASSERT((cbUserStatus == US_READY));
if ((cbUserStatus != US_READY)) return true;
//事件通知
if (m_pIPrivateTableAction != NULL && !m_pIPrivateTableAction->OnActionUserStartGame(wChairID, pIServerUserItem, pData, wDataSize))
{
//开始判断
return false;
}
return true;
}
case SUB_GF_CHANGE_TABLE:
{
//获取属性
WORD wChairID = pIServerUserItem->GetChairID();
BYTE cbUserStatus = pIServerUserItem->GetUserStatus();
//效验状态
ASSERT(GetTableUserItem(wChairID) == pIServerUserItem);
if (GetTableUserItem(wChairID) != pIServerUserItem) return false;
//效验状态
ASSERT(cbUserStatus == US_SIT);
if (cbUserStatus != US_SIT) return true;
//防作弊分组判断
if (CServerRule::IsAllowAvertCheatMode(m_pGameServiceOption->dwServerRule) && (m_pGameServiceAttrib->wChairCount < MAX_CHAIR))
{
//发送消息
LPCTSTR pszMessage = TEXT("系统重新分配桌子，请稍后！");
SendGameMessage(pIServerUserItem, pszMessage, SMT_CHAT);
//发送消息
m_pIMainServiceFrame->InsertDistribute(pIServerUserItem);
}
return true;
}
case SUB_GF_USER_CHAT: //用户聊天
{
//变量定义
CMD_GF_C_UserChat * pUserChat=(CMD_GF_C_UserChat *)pData;
//效验参数
ASSERT(wDataSize<=sizeof(CMD_GF_C_UserChat));
ASSERT(wDataSize>=(sizeof(CMD_GF_C_UserChat)-sizeof(pUserChat->szChatString)));
ASSERT(wDataSize==(sizeof(CMD_GF_C_UserChat)-sizeof(pUserChat->szChatString)+pUserChat->wChatLength*sizeof(pUserChat->szChatString[0])));
//效验参数
if (wDataSize>sizeof(CMD_GF_C_UserChat)) return false;
if (wDataSize<(sizeof(CMD_GF_C_UserChat)-sizeof(pUserChat->szChatString))) return false;
if (wDataSize!=(sizeof(CMD_GF_C_UserChat)-sizeof(pUserChat->szChatString)+pUserChat->wChatLength*sizeof(pUserChat->szChatString[0]))) return false;
pUserChat->szChatString[pUserChat->wChatLength] = _T('\0');
ConvertUtf8ToGBK(pUserChat->szChatString, LEN_USER_CHAT);
//目标用户
if ((pUserChat->dwTargetUserID!=0)&&(SearchUserItem(pUserChat->dwTargetUserID)==NULL))
{
ASSERT(FALSE);
return true;
}
//状态判断
if ((CServerRule::IsForfendGameChat(m_pGameServiceOption->dwServerRule)==true)&&(pIServerUserItem->GetMasterOrder()==0L))
{
SendGameMessage(pIServerUserItem,TEXT("抱歉，当前游戏房间禁止游戏聊天！"),SMT_CHAT);
return true;
}
//权限判断
if (CUserRight::CanRoomChat(pIServerUserItem->GetUserRight())==false)
{
SendGameMessage(pIServerUserItem,TEXT("抱歉，您没有游戏聊天的权限，若需要帮助，请联系游戏客服咨询！"),SMT_EJECT|SMT_CHAT);
return true;
}
//构造消息
CMD_GF_S_UserChat UserChat;
ZeroMemory(&UserChat,sizeof(UserChat));
//字符过滤
m_pIMainServiceFrame->SensitiveWordFilter(pUserChat->szChatString,UserChat.szChatString,CountArray(UserChat.szChatString));
//构造数据
UserChat.dwChatColor=pUserChat->dwChatColor;
UserChat.wChatLength=pUserChat->wChatLength;
UserChat.dwTargetUserID=pUserChat->dwTargetUserID;
UserChat.dwSendUserID=pIServerUserItem->GetUserID();
UserChat.wChatLength=CountStringBuffer(UserChat.szChatString);
//发送数据
WORD wHeadSize=sizeof(UserChat)-sizeof(UserChat.szChatString);
WORD wSendSize=wHeadSize+UserChat.wChatLength*sizeof(UserChat.szChatString[0]);
//游戏用户
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(i);
if ((pIServerUserItem==NULL)||(pIServerUserItem->IsClientReady()==false)) continue;
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_FRAME,SUB_GF_USER_CHAT,&UserChat,wSendSize);
}
//旁观用户
WORD wEnumIndex=0;
IServerUserItem * pIServerUserItem=NULL;
//枚举用户
do
{
//获取用户
pIServerUserItem=EnumLookonUserItem(wEnumIndex++);
if (pIServerUserItem==NULL) break;
//发送数据
if (pIServerUserItem->IsClientReady()==true)
{
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_FRAME,SUB_GF_USER_CHAT,&UserChat,wSendSize);
}
} while (true);
return true;
}
case SUB_GF_USER_EXPRESSION: //用户表情
{
//效验参数
ASSERT(wDataSize==sizeof(CMD_GF_C_UserExpression));
if (wDataSize!=sizeof(CMD_GF_C_UserExpression)) return false;
//变量定义
CMD_GF_C_UserExpression * pUserExpression=(CMD_GF_C_UserExpression *)pData;
//目标用户
if ((pUserExpression->dwTargetUserID!=0)&&(SearchUserItem(pUserExpression->dwTargetUserID)==NULL))
{
ASSERT(FALSE);
return true;
}
//状态判断
if ((CServerRule::IsForfendGameChat(m_pGameServiceOption->dwServerRule)==true)&&(pIServerUserItem->GetMasterOrder()==0L))
{
SendGameMessage(pIServerUserItem,TEXT("抱歉，当前游戏房间禁止游戏聊天！"),SMT_CHAT);
return true;
}
//权限判断
if (CUserRight::CanRoomChat(pIServerUserItem->GetUserRight())==false)
{
SendGameMessage(pIServerUserItem,TEXT("抱歉，您没有游戏聊天的权限，若需要帮助，请联系游戏客服咨询！"),SMT_EJECT|SMT_CHAT);
return true;
}
//构造消息
CMD_GF_S_UserExpression UserExpression;
ZeroMemory(&UserExpression,sizeof(UserExpression));
//构造数据
UserExpression.isExpression = pUserExpression->isExpression;
UserExpression.wItemIndex=pUserExpression->wItemIndex;
UserExpression.dwSendUserID=pIServerUserItem->GetUserID();
UserExpression.dwTargetUserID=pUserExpression->dwTargetUserID;
//游戏用户
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(i);
if ((pIServerUserItem==NULL)||(pIServerUserItem->IsClientReady()==false)) continue;
//发送数据
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_FRAME,SUB_GF_USER_EXPRESSION,&UserExpression,sizeof(UserExpression));
}
//旁观用户
WORD wEnumIndex=0;
IServerUserItem * pIServerUserItem=NULL;
//枚举用户
do
{
//获取用户
pIServerUserItem=EnumLookonUserItem(wEnumIndex++);
if (pIServerUserItem==NULL) break;
//发送数据
if (pIServerUserItem->IsClientReady()==true)
{
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GF_FRAME,SUB_GF_USER_EXPRESSION,&UserExpression,sizeof(UserExpression));
}
} while (true);
return true;
}
case SUB_GR_TABLE_TALK: //游戏聊天
{
SendTableData(INVALID_CHAIR,SUB_GR_TABLE_TALK,pData,wDataSize,MDM_GF_FRAME);
return true;
}
case SUB_GF_LOOKON_CONFIG: //旁观配置
{
//效验参数
ASSERT(wDataSize==sizeof(CMD_GF_LookonConfig));
if (wDataSize<sizeof(CMD_GF_LookonConfig)) return false;
//变量定义
CMD_GF_LookonConfig * pLookonConfig=(CMD_GF_LookonConfig *)pData;
//目标用户
if ((pLookonConfig->dwUserID!=0)&&(SearchUserItem(pLookonConfig->dwUserID)==NULL))
{
ASSERT(FALSE);
return true;
}
//用户效验
ASSERT(pIServerUserItem->GetUserStatus()!=US_LOOKON);
if (pIServerUserItem->GetUserStatus()==US_LOOKON) return false;
//旁观处理
if (pLookonConfig->dwUserID!=0L)
{
for (INT_PTR i=0;i<m_LookonUserItemArray.GetCount();i++)
{
//获取用户
IServerUserItem * pILookonUserItem=m_LookonUserItemArray[i];
if (pILookonUserItem->GetUserID()!=pLookonConfig->dwUserID) continue;
if (pILookonUserItem->GetChairID()!=pIServerUserItem->GetChairID()) continue;
//构造消息
CMD_GF_LookonStatus LookonStatus;
LookonStatus.cbAllowLookon=pLookonConfig->cbAllowLookon;
//发送消息
ASSERT(m_pIMainServiceFrame!=NULL);
m_pIMainServiceFrame->SendData(pILookonUserItem,MDM_GF_FRAME,SUB_GF_LOOKON_STATUS,&LookonStatus,sizeof(LookonStatus));
break;
}
}
else
{
//设置判断
bool bAllowLookon=(pLookonConfig->cbAllowLookon==TRUE)?true:false;
if (bAllowLookon==m_bAllowLookon[pIServerUserItem->GetChairID()]) return true;
//设置变量
m_bAllowLookon[pIServerUserItem->GetChairID()]=bAllowLookon;
//构造消息
CMD_GF_LookonStatus LookonStatus;
LookonStatus.cbAllowLookon=pLookonConfig->cbAllowLookon;
//发送消息
for (INT_PTR i=0;i<m_LookonUserItemArray.GetCount();i++)
{
//获取用户
IServerUserItem * pILookonUserItem=m_LookonUserItemArray[i];
if (pILookonUserItem->GetChairID()!=pIServerUserItem->GetChairID()) continue;
//发送消息
ASSERT(m_pIMainServiceFrame!=NULL);
m_pIMainServiceFrame->SendData(pILookonUserItem,MDM_GF_FRAME,SUB_GF_LOOKON_STATUS,&LookonStatus,sizeof(LookonStatus));
}
}
return true;
}
case SUB_GF_USER_LOCATION: //用户地理位置信息;
{
//效验参数;
ASSERT(wDataSize == sizeof(CMD_GF_C_UserLocation));
if (wDataSize < sizeof(CMD_GF_C_UserLocation)) return false;
//变量定义;
CMD_GF_C_UserLocation * pCUserLocation = (CMD_GF_C_UserLocation *)pData;
pCUserLocation->szAddress[LEN_DWELLING_PLACE - 1] = '\0';
//获取属性;
WORD wChairID = pIServerUserItem->GetChairID();
BYTE cbUserStatus = pIServerUserItem->GetUserStatus();
//效验状态;
ASSERT(GetTableUserItem(wChairID) == pIServerUserItem);
if (GetTableUserItem(wChairID) != pIServerUserItem) return false;
tagUserInfo* pTagUserInfo = pIServerUserItem->GetUserInfo();
if (NULL == pTagUserInfo) return false;
if ((pTagUserInfo->lLatitude != pCUserLocation->lLatitude) || (pTagUserInfo->lLongitude != pCUserLocation->lLongitude))
{
pTagUserInfo->lAccuracy = pCUserLocation->lAccuracy;
pTagUserInfo->lLatitude = pCUserLocation->lLatitude;
pTagUserInfo->lLongitude = pCUserLocation->lLongitude;
memcpy(pTagUserInfo->szAddress, pCUserLocation->szAddress, sizeof(pCUserLocation->szAddress));
// 同步地理位置信息;
CMD_GF_S_UserLocation newLocation = { 0 };
newLocation.dwTargetUserID = pIServerUserItem->GetUserID();
newLocation.lAccuracy = pCUserLocation->lAccuracy;
newLocation.lLatitude = pCUserLocation->lLatitude;
newLocation.lLongitude = pCUserLocation->lLongitude;
memcpy(newLocation.szAddress, pCUserLocation->szAddress, sizeof(pCUserLocation->szAddress));
SendTableData(INVALID_CHAIR, SUB_GR_USER_LOCATION, &newLocation, sizeof(CMD_GF_S_UserLocation), MDM_GR_USER);
//游戏用户;
//for (WORD i = 0; i < m_wChairCount; i++)
//{
// if (i != wChairID)
// {
// SendTableData(i, SUB_GR_USER_LOCATION, &newLocation, sizeof(CMD_GF_S_UserLocation), MDM_GR_USER);
// }
//}
}
return true;
}
case SUB_GF_PING_TIME:
{
//效验参数;
ASSERT(wDataSize == sizeof(CMD_GF_C_PingTime));
if (wDataSize < sizeof(CMD_GF_C_PingTime)) return false;
//变量定义;
CMD_GF_C_PingTime * pPingTime = (CMD_GF_C_PingTime *)pData;
//发送状态
CMD_GF_C_PingTime pingTimeResponse;
pingTimeResponse.dwPingCount = pPingTime->dwPingCount;
m_pIMainServiceFrame->SendData(pIServerUserItem, MDM_GF_FRAME, SUB_GF_PING_TIME, &pingTimeResponse, sizeof(pingTimeResponse));
return true;
}
}
return false;
}
//游戏局数
WORD CTableFrame::GetDrawCount()
{
return m_wDrawCount;
}
//获取空位
WORD CTableFrame::GetNullChairID()
{
//椅子搜索
for (WORD i=0;i<m_wChairCount;i++)
{
if (m_TableUserItemArray[i]==NULL)
{
return i;
}
}
return INVALID_CHAIR;
}
//随机空位
WORD CTableFrame::GetRandNullChairID()
{
//椅子搜索
WORD wIndex = rand()%m_wChairCount;
for (WORD i=wIndex;i<m_wChairCount+wIndex;i++)
{
if (m_TableUserItemArray[i%m_wChairCount]==NULL)
{
return i%m_wChairCount;
}
}
return INVALID_CHAIR;
}
//用户数目
WORD CTableFrame::GetSitUserCount()
{
//变量定义
WORD wUserCount=0;
//数目统计
for (WORD i=0;i<m_wChairCount;i++)
{
if (GetTableUserItem(i)!=NULL)
{
wUserCount++;
}
}
return wUserCount;
}
void CTableFrame::SetCellScore(LONG lCellScore)
{
m_lCellScore=lCellScore;
if (m_pITableFrameSink)
{
m_pITableFrameSink->SetGameBaseScore(lCellScore);
}
}
//旁观数目
WORD CTableFrame::GetLookonUserCount()
{
//获取数目
INT_PTR nLookonCount=m_LookonUserItemArray.GetCount();
return (WORD)(nLookonCount);
}
//断线数目
WORD CTableFrame::GetOffLineUserCount()
{
//变量定义
WORD wOffLineCount=0;
//断线人数
for (WORD i=0;i<m_wChairCount;i++)
{
if (m_dwOffLineTime[i]!=0L)
{
wOffLineCount++;
}
}
return wOffLineCount;
}
//桌子状况
WORD CTableFrame::GetTableUserInfo(tagTableUserInfo & TableUserInfo)
{
//设置变量
ZeroMemory(&TableUserInfo,sizeof(TableUserInfo));
//用户分析
for (WORD i=0;i<m_pGameServiceAttrib->wChairCount;i++)
{
//获取用户
IServerUserItem * pIServerUserItem=GetTableUserItem(i);
if (pIServerUserItem==NULL) continue;
//用户类型
if (pIServerUserItem->IsAndroidUser()==false)
{
TableUserInfo.wTableUserCount++;
}
else
{
TableUserInfo.wTableAndroidCount++;
}
//准备判断
if (pIServerUserItem->GetUserStatus()==US_READY)
{
TableUserInfo.wTableReadyCount++;
}
}
//最少数目
switch (m_cbStartMode)
{
case START_MODE_ALL_READY: //所有准备
{
TableUserInfo.wMinUserCount=2;
break;
}
case START_MODE_PAIR_READY: //配对开始
{
TableUserInfo.wMinUserCount=2;
break;
}
case START_MODE_TIME_CONTROL: //时间控制
{
TableUserInfo.wMinUserCount=1;
break;
}
default: //默认模式
{
TableUserInfo.wMinUserCount=m_pGameServiceAttrib->wChairCount;
break;
}
}
return TableUserInfo.wTableAndroidCount+TableUserInfo.wTableUserCount;
}
//配置桌子
bool CTableFrame::InitializationFrame(WORD wTableID, tagTableFrameParameter & TableFrameParameter)
{
//设置变量
m_wTableID=wTableID;
m_wChairCount=TableFrameParameter.pGameServiceAttrib->wChairCount;
//配置参数
m_pGameParameter=TableFrameParameter.pGameParameter;
m_pGameServiceAttrib=TableFrameParameter.pGameServiceAttrib;
m_pGameServiceOption=TableFrameParameter.pGameServiceOption;
m_pGameMatchOption = TableFrameParameter.pGameMatchOption;
//组件接口
m_pITimerEngine=TableFrameParameter.pITimerEngine;
m_pIMainServiceFrame=TableFrameParameter.pIMainServiceFrame;
m_pIAndroidUserManager=TableFrameParameter.pIAndroidUserManager;
m_pIKernelDataBaseEngine=TableFrameParameter.pIKernelDataBaseEngine;
m_pIRecordDataBaseEngine=TableFrameParameter.pIRecordDataBaseEngine;
//创建桌子
IGameServiceManager * pIGameServiceManager=TableFrameParameter.pIGameServiceManager;
m_pITableFrameSink=(ITableFrameSink *)pIGameServiceManager->CreateTableFrameSink(IID_ITableFrameSink,VER_ITableFrameSink);
//错误判断
if (m_pITableFrameSink==NULL)
{
ASSERT(FALSE);
return false;
}
//设置桌子
IUnknownEx * pITableFrame=QUERY_ME_INTERFACE(IUnknownEx);
if (m_pITableFrameSink->Initialization(pITableFrame)==false) return false;
//设置变量
m_lCellScore=m_pGameServiceOption->lCellScore;
//扩展接口
m_pITableUserAction=QUERY_OBJECT_PTR_INTERFACE(m_pITableFrameSink,ITableUserAction);
m_pITableUserRequest=QUERY_OBJECT_PTR_INTERFACE(m_pITableFrameSink,ITableUserRequest);
return true;
}
//起立动作
bool CTableFrame::PerformStandUpAction(IServerUserItem * pIServerUserItem)
{
WORD wChairID=pIServerUserItem->GetChairID();
//私人场类型
if(m_pGameServiceOption->wServerType==GAME_GENRE_EDUCATE)
{
//掉线通知
if(m_pIPrivateTableAction!=NULL && m_pIPrivateTableAction->OnActionUserOffLine(wChairID,pIServerUserItem))
{
return true;
}
}
return PerformStandUpActionEx(pIServerUserItem);
}
//起立动作
bool CTableFrame::PerformStandUpActionEx(IServerUserItem * pIServerUserItem)
{
//效验参数
ASSERT(pIServerUserItem!=NULL);
ASSERT(pIServerUserItem->GetTableID()==m_wTableID);
ASSERT(pIServerUserItem->GetChairID()<=m_wChairCount);
//用户属性
WORD wChairID=pIServerUserItem->GetChairID();
BYTE cbUserStatus=pIServerUserItem->GetUserStatus();
IServerUserItem * pITableUserItem=GetTableUserItem(wChairID);
//游戏用户
if ((m_bGameStarted==true)&&((cbUserStatus==US_PLAYING)||(cbUserStatus==US_OFFLINE)))
{
//比赛类型
if(m_pGameServiceOption->wServerType==GAME_GENRE_MATCH)
{
//掉线通知
if(m_pITableUserAction!=NULL) m_pITableUserAction->OnActionUserOffLine(wChairID,pIServerUserItem);
return true;
}
if (m_pGameServiceOption->wServerType == GAME_GENRE_EDUCATE)
{
m_pITableFrameSink->OnEventGameConclude(wChairID, pIServerUserItem, GER_DISMISS);
}
else if (m_pGameServiceOption->wServerType == GAME_GENRE_GOLD || m_pGameServiceOption->wServerType == GAME_GENRE_SCORE)
{
BYTE cbConcludeReason = (cbUserStatus == US_OFFLINE) ? GER_NETWORK_ERROR : GER_USER_LEAVE;
m_pITableFrameSink->OnEventGameConclude(wChairID, pIServerUserItem, cbConcludeReason);
}
//离开判断
if (m_TableUserItemArray[wChairID]!=pIServerUserItem) return true;
}
//设置变量
if (pIServerUserItem==pITableUserItem)
{
//解锁游戏币
if (m_lFrozenedScore[wChairID]!=0L)
{
pIServerUserItem->UnFrozenedUserScore(m_lFrozenedScore[wChairID]);
m_lFrozenedScore[wChairID]=0L;
}
//事件通知
if (m_pITableUserAction!=NULL)
{
m_pITableUserAction->OnActionUserStandUp(wChairID,pIServerUserItem,false);
}
//事件通知
if(m_pIMatchTableAction!=NULL) m_pIMatchTableAction->OnActionUserStandUp(wChairID,pIServerUserItem,false);
//事件通知
if(m_pIPrivateTableAction!=NULL) m_pIPrivateTableAction->OnActionUserStandUp(wChairID,pIServerUserItem,false);
//设置变量
m_TableUserItemArray[wChairID]=NULL;
//用户状态
pIServerUserItem->SetClientReady(false);
pIServerUserItem->SetUserStatus((cbUserStatus==US_OFFLINE)?US_NULL:US_FREE,INVALID_TABLE,INVALID_CHAIR);
//变量定义
bool bTableLocked=IsTableLocked();
bool bTableStarted=IsTableStarted();
WORD wTableUserCount=GetSitUserCount();
//设置变量
m_wUserCount=wTableUserCount;
//桌子信息
if (wTableUserCount==0)
{
m_dwTableOwnerID=0L;
m_szEnterPassword[0]=0;
}
//踢走旁观
if (wTableUserCount==0)
{
for (INT_PTR i=0;i<m_LookonUserItemArray.GetCount();i++)
{
SendGameMessage(m_LookonUserItemArray[i],TEXT("此游戏桌的所有玩家已经离开了！"),SMT_CLOSE_GAME|SMT_EJECT);
}
}
//结束桌子
ConcludeTable();
//开始判断
if (EfficacyStartGame(wChairID) == true)
{
//StartGame();
// 自由人数场，通知客户端开始准备;
if (IsAutoUserCountRule(this))
{
tagAutoUserStatus userStatus;
userStatus.bStartGame = true;
m_pIPrivateTableAction->OnActionUserOnStart(wChairID, pIServerUserItem, &userStatus, sizeof(userStatus));
}
else
{
StartGame();
}
}
////开始判断
//if (EfficacyStartGame(INVALID_CHAIR)==true)
//{
// StartGame();
//}
//发送状态
if ((bTableLocked!=IsTableLocked())||(bTableStarted!=IsTableStarted()))
{
SendTableStatus();
}
//防作弊分组判断
if (CServerRule::IsAllowAvertCheatMode(m_pGameServiceOption->dwServerRule) && (m_pGameServiceAttrib->wChairCount < MAX_CHAIR))
{
//防作弊分组判断
if (IsTableStarted() == false && CheckDistribute())
{
for (int i = 0; i < m_wChairCount; i++)
{
if (m_TableUserItemArray[i] != NULL && m_TableUserItemArray[i]->GetUserStatus() == US_READY)
{
//发送消息
LPCTSTR pszMessage = TEXT("由玩家离开，系统重新分配桌子，请稍后！");
SendGameMessage(m_TableUserItemArray[i], pszMessage, SMT_CHAT);
//发送消息
m_pIMainServiceFrame->InsertDistribute(m_TableUserItemArray[i]);
}
}
}
}
return true;
}
else
{
//起立处理
for (INT_PTR i=0;i<m_LookonUserItemArray.GetCount();i++)
{
if (pIServerUserItem==m_LookonUserItemArray[i])
{
//删除子项
m_LookonUserItemArray.RemoveAt(i);
//事件通知
if (m_pITableUserAction!=NULL)
{
m_pITableUserAction->OnActionUserStandUp(wChairID,pIServerUserItem,true);
}
//事件通知
if(m_pIMatchTableAction!=NULL) m_pIMatchTableAction->OnActionUserStandUp(wChairID,pIServerUserItem,true);
//事件通知
if(m_pIPrivateTableAction!=NULL) m_pIPrivateTableAction->OnActionUserStandUp(wChairID,pIServerUserItem,true);
//用户状态
pIServerUserItem->SetClientReady(false);
pIServerUserItem->SetUserStatus(US_FREE,INVALID_TABLE,INVALID_CHAIR);
return true;
}
}
//错误断言
ASSERT(FALSE);
}
return true;
}
//旁观动作
bool CTableFrame::PerformLookonAction(WORD wChairID, IServerUserItem * pIServerUserItem)
{
//效验参数
ASSERT((pIServerUserItem!=NULL)&&(wChairID<m_wChairCount));
ASSERT((pIServerUserItem->GetTableID()==INVALID_TABLE)&&(pIServerUserItem->GetChairID()==INVALID_CHAIR));
//变量定义
tagUserInfo * pUserInfo=pIServerUserItem->GetUserInfo();
tagUserRule * pUserRule=pIServerUserItem->GetUserRule();
IServerUserItem * pITableUserItem=GetTableUserItem(wChairID);
//游戏状态
if ((m_bGameStarted==false)&&(pIServerUserItem->GetMasterOrder()==0L))
{
SendRequestFailure(pIServerUserItem,TEXT("游戏还没有开始，不能旁观此游戏桌！"),REQUEST_FAILURE_NORMAL);
return false;
}
//模拟处理
if (m_pGameServiceAttrib->wChairCount < MAX_CHAIR && pIServerUserItem->IsAndroidUser()==false)
{
//定义变量
CAttemperEngineSink * pAttemperEngineSink=(CAttemperEngineSink *)m_pIMainServiceFrame;
//查找机器
for (WORD i=0; i<m_pGameServiceAttrib->wChairCount; i++)
{
//获取用户
IServerUserItem *pIUserItem=m_TableUserItemArray[i];
if(pIUserItem==NULL) continue;
if(pIUserItem->IsAndroidUser()==false)break;
//获取参数
tagBindParameter * pBindParameter=pAttemperEngineSink->GetBindParameter(pIUserItem->GetBindIndex());
IAndroidUserItem * pIAndroidUserItem=m_pIAndroidUserManager->SearchAndroidUserItem(pIUserItem->GetUserID(),pBindParameter->dwSocketID);
tagAndroidParameter * pAndroidParameter=pIAndroidUserItem->GetAndroidParameter();
//模拟判断
if ((pAndroidParameter->dwServiceMode&ANDROID_SIMULATE) != 0
&& (pAndroidParameter->dwServiceMode&ANDROID_PASSIVITY) == 0
&& (pAndroidParameter->dwServiceMode&ANDROID_INITIATIVE) == 0)
{
SendRequestFailure(pIServerUserItem,TEXT("抱歉，当前游戏桌子禁止用户旁观！"),REQUEST_FAILURE_NORMAL);
return false;
}
break;
}
}
//旁观判断
if (CServerRule::IsAllowAndroidSimulate(m_pGameServiceOption->dwServerRule)==true
&& (CServerRule::IsAllowAndroidAttend(m_pGameServiceOption->dwServerRule)==false))
{
if ((pITableUserItem!=NULL)&&(pITableUserItem->IsAndroidUser()==true))
{
SendRequestFailure(pIServerUserItem,TEXT("抱歉，当前游戏房间禁止用户旁观！"),REQUEST_FAILURE_NORMAL);
return false;
}
}
//状态判断
if ((CServerRule::IsForfendGameLookon(m_pGameServiceOption->dwServerRule)==true)&&(pIServerUserItem->GetMasterOrder()==0))
{
SendRequestFailure(pIServerUserItem,TEXT("抱歉，当前游戏房间禁止用户旁观！"),REQUEST_FAILURE_NORMAL);
return false;
}
//椅子判断
if ((pITableUserItem==NULL)&&(pIServerUserItem->GetMasterOrder()==0L))
{
SendRequestFailure(pIServerUserItem,TEXT("您所请求的位置没有游戏玩家，无法旁观此游戏桌"),REQUEST_FAILURE_NORMAL);
return false;
}
//密码效验
if ((IsTableLocked()==true)&&(pIServerUserItem->GetMasterOrder()==0L)&&(lstrcmp(pUserRule->szPassword,m_szEnterPassword)!=0))
{
SendRequestFailure(pIServerUserItem,TEXT("游戏桌进入密码不正确，不能旁观游戏！"),REQUEST_FAILURE_PASSWORD);
return false;
}
//扩展效验
if (m_pITableUserRequest!=NULL)
{
//变量定义
tagRequestResult RequestResult;
ZeroMemory(&RequestResult,sizeof(RequestResult));
//坐下效验
if (m_pITableUserRequest->OnUserRequestLookon(wChairID,pIServerUserItem,RequestResult)==false)
{
//发送信息
SendRequestFailure(pIServerUserItem,RequestResult.szFailureReason,RequestResult.cbFailureCode);
return false;
}
}
//设置用户
m_LookonUserItemArray.Add(pIServerUserItem);
//用户状态
pIServerUserItem->SetClientReady(false);
pIServerUserItem->SetUserStatus(US_LOOKON,m_wTableID,wChairID);
//事件通知
if (m_pITableUserAction!=NULL)
{
m_pITableUserAction->OnActionUserSitDown(wChairID,pIServerUserItem,true);
}
//事件通知
if(m_pIMatchTableAction!=NULL) m_pIMatchTableAction->OnActionUserSitDown(wChairID,pIServerUserItem,true);
//事件通知
if(m_pIPrivateTableAction!=NULL) m_pIPrivateTableAction->OnActionUserSitDown(wChairID,pIServerUserItem,true);
return true;
}
//坐下动作
bool CTableFrame::PerformSitDownAction(WORD wChairID, IServerUserItem * pIServerUserItem, LPCTSTR lpszPassword)
{
//效验参数
ASSERT((pIServerUserItem!=NULL)&&(wChairID<m_wChairCount));
ASSERT((pIServerUserItem->GetTableID()==INVALID_TABLE)&&(pIServerUserItem->GetChairID()==INVALID_CHAIR));
//变量定义
tagUserInfo * pUserInfo=pIServerUserItem->GetUserInfo();
tagUserRule * pUserRule=pIServerUserItem->GetUserRule();
IServerUserItem * pITableUserItem=GetTableUserItem(wChairID);
//状态判断
if ((CServerRule::IsForfendGameEnter(m_pGameServiceOption->dwServerRule)==true)&&(pIServerUserItem->GetMasterOrder()==0))
{
SendRequestFailure(pIServerUserItem,TEXT("抱歉，当前游戏桌子禁止用户进入！"),REQUEST_FAILURE_NORMAL);
return false;
}
//椅子调整
if (m_pIPrivateTableAction != NULL)
{
WORD wRealChairCount = GetRealChairCount();
if (wChairID >= wRealChairCount)
{
SendRequestFailure(pIServerUserItem, TEXT("由于此游戏桌暂时没有可以让您加入的位置了，请选择另外的游戏桌！"), 0);
return false;
}
}
//模拟处理
if (m_pGameServiceAttrib->wChairCount < MAX_CHAIR && pIServerUserItem->IsAndroidUser()==false)
{
//定义变量
CAttemperEngineSink * pAttemperEngineSink=(CAttemperEngineSink *)m_pIMainServiceFrame;
//查找机器
for (WORD i=0; i<m_pGameServiceAttrib->wChairCount; i++)
{
//获取用户
IServerUserItem *pIUserItem=m_TableUserItemArray[i];
if(pIUserItem==NULL) continue;
if(pIUserItem->IsAndroidUser()==false)break;
//获取参数
tagBindParameter * pBindParameter=pAttemperEngineSink->GetBindParameter(pIUserItem->GetBindIndex());
IAndroidUserItem * pIAndroidUserItem=m_pIAndroidUserManager->SearchAndroidUserItem(pIUserItem->GetUserID(),pBindParameter->dwSocketID);
tagAndroidParameter * pAndroidParameter=pIAndroidUserItem->GetAndroidParameter();
//模拟判断
if ((pAndroidParameter->dwServiceMode&ANDROID_SIMULATE) != 0
&& (pAndroidParameter->dwServiceMode&ANDROID_PASSIVITY) == 0
&& (pAndroidParameter->dwServiceMode&ANDROID_INITIATIVE) == 0)
{
SendRequestFailure(pIServerUserItem,TEXT("抱歉，当前游戏桌子禁止用户进入！"),REQUEST_FAILURE_NORMAL);
return false;
}
break;
}
}
//动态加入
bool bDynamicJoin=true;
if (m_pGameServiceAttrib->cbDynamicJoin==FALSE) bDynamicJoin=false;
if (CServerRule::IsAllowDynamicJoin(m_pGameServiceOption->dwServerRule)==false) bDynamicJoin=false;
//游戏状态
if ((m_bGameStarted==true)&&(bDynamicJoin==false))
{
SendRequestFailure(pIServerUserItem, TEXT("游戏已经开始了，现在不能进入游戏桌！"), SMT_EJECT);
return false;
}
//椅子判断
if (pITableUserItem!=NULL)
{
for (int i = 0;i<m_wChairCount;i++)
{
if (!GetTableUserItem(i))
{
wChairID = i;
pITableUserItem = NULL;
break;
}
}
if (pITableUserItem)
{
//构造信息
TCHAR szDescribe[128]=TEXT("");
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("椅子已经被 [ %s ] 捷足先登了，下次动作要快点了！"),pITableUserItem->GetNickName());
//发送信息
SendRequestFailure(pIServerUserItem,szDescribe,REQUEST_FAILURE_NORMAL);
return false;
}
}
//积分变量
SCORE lUserScore=pIServerUserItem->GetUserScore();
SCORE lMinTableScore=m_pGameServiceOption->lMinTableScore;
SCORE lLessEnterScore=m_pITableFrameSink->QueryLessEnterScore(wChairID,pIServerUserItem);
//密码效验
if(((IsTableLocked()==true)&&(pIServerUserItem->GetMasterOrder()==0L))
&&((lpszPassword==NULL)||(lstrcmp(lpszPassword,m_szEnterPassword)!=0)))
{
SendRequestFailure(pIServerUserItem, TEXT("游戏桌进入密码不正确，不能加入游戏！"), SMT_EJECT);
return false;
}
//积分限制
if (((lMinTableScore!=0L)&&(lUserScore<lMinTableScore))||((lLessEnterScore!=0L)&&(lUserScore<lLessEnterScore)))
{
//构造信息
TCHAR szDescribe[128]=TEXT("");
if(m_pGameServiceOption->wServerType==GAME_GENRE_GOLD)
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("加入游戏至少需要 ") SCORE_STRING TEXT(" 的游戏币，您的游戏币不够，不能加入！"),__max(lMinTableScore,lLessEnterScore));
else if(m_pGameServiceOption->wServerType==GAME_GENRE_MATCH)
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("加入游戏至少需要 ") SCORE_STRING TEXT(" 的比赛币，您的比赛币不够，不能加入！"),__max(lMinTableScore,lLessEnterScore));
else
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("加入游戏至少需要 ") SCORE_STRING TEXT(" 的游戏积分，您的积分不够，不能加入！"),__max(lMinTableScore,lLessEnterScore));
//发送信息
SendRequestFailure(pIServerUserItem, szDescribe, SMT_EJECT);
return false;
}
//事件通知
if (m_pIPrivateTableAction != NULL)
{
// 房卡交验
SCORE lUserInsure = pIServerUserItem->GetUserInsure();
if (!m_pIPrivateTableAction->OnActionUserFangKaCheck(wChairID, pIServerUserItem, lUserInsure))
{
//构造信息
TCHAR szDescribe[128] = TEXT("");
_sntprintf_s(szDescribe, CountArray(szDescribe), TEXT("本房间为AA制房间，您的房卡数量不足，无法加入游戏！ "));
//发送信息
SendRoomMessage(pIServerUserItem, szDescribe, SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
return false;
}
}
//规则效验
if (EfficacyIPAddress(pIServerUserItem)==false) return false;
if (EfficacyScoreRule(pIServerUserItem)==false) return false;
//扩展效验
if (m_pITableUserRequest!=NULL)
{
//变量定义
tagRequestResult RequestResult;
ZeroMemory(&RequestResult,sizeof(RequestResult));
//坐下效验
if (m_pITableUserRequest->OnUserRequestSitDown(wChairID,pIServerUserItem,RequestResult)==false)
{
//发送信息
SendRequestFailure(pIServerUserItem,RequestResult.szFailureReason,RequestResult.cbFailureCode);
return false;
}
}
//设置变量
m_TableUserItemArray[wChairID]=pIServerUserItem;
m_wDrawCount = 0; // 玩家坐下重置;
//用户状态
if ((IsGameStarted()==false)||(m_cbStartMode!=START_MODE_TIME_CONTROL))
{
if (CServerRule::IsAllowAvertCheatMode(m_pGameServiceOption->dwServerRule)==false && (m_pGameServiceOption->wServerType&GAME_GENRE_MATCH)==0)
{
pIServerUserItem->SetClientReady(false); //QY 2016 05 10 如果已经在游戏中再次调用会永远无法开始游戏
pIServerUserItem->SetUserStatus(US_SIT,m_wTableID,wChairID);
}
else
{
pIServerUserItem->SetClientReady(false);
pIServerUserItem->SetUserStatus(US_READY,m_wTableID,wChairID);
}
}
else
{
//设置变量
m_wOffLineCount[wChairID]=0L;
m_dwOffLineTime[wChairID]=0L;
//锁定游戏币
if (m_pGameServiceOption->lServiceScore>0L)
{
m_lFrozenedScore[wChairID]=m_pGameServiceOption->lServiceScore;
pIServerUserItem->FrozenedUserScore(m_pGameServiceOption->lServiceScore);
}
//设置状态
pIServerUserItem->SetClientReady(false);
pIServerUserItem->SetUserStatus(US_PLAYING,m_wTableID,wChairID);
}
m_wUserCount=GetSitUserCount();
//桌子信息
if (GetSitUserCount()==1)
{
//状态变量
bool bTableLocked=IsTableLocked();
//设置变量
m_dwTableOwnerID=pIServerUserItem->GetUserID();
lstrcpyn(m_szEnterPassword,pUserRule->szPassword,CountArray(m_szEnterPassword));
//发送状态
if (bTableLocked!=IsTableLocked()) SendTableStatus();
}
//事件通知
if (m_pITableUserAction!=NULL)
{
m_pITableUserAction->OnActionUserSitDown(wChairID,pIServerUserItem,false);
}
//事件通知
if(m_pIMatchTableAction!=NULL) m_pIMatchTableAction->OnActionUserSitDown(wChairID,pIServerUserItem,false);
//事件通知
if(m_pIPrivateTableAction!=NULL) m_pIPrivateTableAction->OnActionUserSitDown(wChairID,pIServerUserItem,false);
return true;
}
//桌子状态
bool CTableFrame::SendTableStatus()
{
//变量定义
CMD_GR_TableStatus TableStatus;
ZeroMemory(&TableStatus,sizeof(TableStatus));
//构造数据
TableStatus.wTableID=m_wTableID;
TableStatus.TableStatus.cbTableLock=IsTableLocked()?TRUE:FALSE;
TableStatus.TableStatus.cbPlayStatus=IsTableStarted()?TRUE:FALSE;
//电脑数据
m_pIMainServiceFrame->SendData(BG_COMPUTER,MDM_GR_STATUS,SUB_GR_TABLE_STATUS,&TableStatus,sizeof(TableStatus));
//手机数据
return true;
}
//请求失败
bool CTableFrame::SendRequestFailure(IServerUserItem * pIServerUserItem, LPCTSTR pszDescribe, LONG lErrorCode)
{
//变量定义
CMD_GR_RequestFailure RequestFailure;
ZeroMemory(&RequestFailure,sizeof(RequestFailure));
//构造数据
RequestFailure.lErrorCode=lErrorCode;
lstrcpyn(RequestFailure.szDescribeString,pszDescribe,CountArray(RequestFailure.szDescribeString));
//发送数据
WORD wDataSize=CountStringBuffer(RequestFailure.szDescribeString);
WORD wHeadSize=sizeof(RequestFailure)-sizeof(RequestFailure.szDescribeString);
m_pIMainServiceFrame->SendData(pIServerUserItem,MDM_GR_USER,SUB_GR_REQUEST_FAILURE,&RequestFailure,wHeadSize+wDataSize);
return true;
}
//开始效验
bool CTableFrame::EfficacyStartGame(WORD wReadyChairID)
{
//状态判断
if (m_bGameStarted==true) return false;
//模式过滤
if (m_cbStartMode==START_MODE_TIME_CONTROL) return false;
if (m_cbStartMode==START_MODE_MASTER_CONTROL) return false;
//准备人数
WORD wReadyUserCount=0;
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pITableUserItem=GetTableUserItem(i);
if (pITableUserItem==NULL) continue;
//用户统计
if (pITableUserItem!=NULL)
{
//状态判断(离线前的状态如果是准备状态)
if (pITableUserItem->IsClientReady() == false) return false;
if ((wReadyChairID != i) && (pITableUserItem->GetUserStatus() != US_READY)) return false;
//用户计数
wReadyUserCount++;
}
}
// 自由人数场;
if (IsAutoUserCountRule(this, true))
{
//数目判断
if (wReadyUserCount >= 2L) return true;
return false;
}
//开始处理
switch (m_cbStartMode)
{
case START_MODE_ALL_READY: //所有准备
{
//数目判断
if (wReadyUserCount>=2L) return true;
return false;
}
case START_MODE_FULL_READY: //满人开始
{
WORD wRealChairCount = GetRealChairCount();
//人数判断
if (wReadyUserCount == wRealChairCount) return true;
return false;
}
case START_MODE_PAIR_READY: //配对开始
{
//数目判断
if (wReadyUserCount==m_wChairCount) return true;
if ((wReadyUserCount<2L)||(wReadyUserCount%2)!=0) return false;
//位置判断
for (WORD i=0;i<m_wChairCount/2;i++)
{
//获取用户
IServerUserItem * pICurrentUserItem=GetTableUserItem(i);
IServerUserItem * pITowardsUserItem=GetTableUserItem(i+m_wChairCount/2);
//位置过滤
if ((pICurrentUserItem==NULL)&&(pITowardsUserItem!=NULL)) return false;
if ((pICurrentUserItem!=NULL)&&(pITowardsUserItem==NULL)) return false;
}
return true;
}
default:
{
ASSERT(FALSE);
return false;
}
}
return false;
}
//开始准备校验
bool CTableFrame::EfficacyStartReady(WORD wStartChairID)
{
//状态判断
if (m_bGameStarted == true) return false;
//准备人数
WORD wReadyUserCount = 0;
for (WORD i = 0; i < m_wChairCount; i++)
{
//获取用户
IServerUserItem * pITableUserItem = GetTableUserItem(i);
if (pITableUserItem == NULL) continue;
//用户统计
if (pITableUserItem != NULL)
{
//状态判断(离线前的状态如果是准备状态)
if (pITableUserItem->IsClientReady() == false) return false;
if ((wStartChairID != i) && (pITableUserItem->GetUserStatus() != US_CAN_READY)) return false;
//用户计数
wReadyUserCount++;
}
}
//数目判断
if (wReadyUserCount >= 2L) return true;
return false;
}
//地址效验
bool CTableFrame::EfficacyIPAddress(IServerUserItem * pIServerUserItem)
{
//管理员不受限制
if(pIServerUserItem->GetMasterOrder()!=0) return true;
//规则判断
if (CServerRule::IsForfendGameRule(m_pGameServiceOption->dwServerRule)==true) return true;
//地址效验
const tagUserRule * pUserRule=pIServerUserItem->GetUserRule(),*pTableUserRule=NULL;
bool bCheckSameIP=pUserRule->bLimitSameIP;
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pITableUserItem=GetTableUserItem(i);
if (pITableUserItem!=NULL && (!pITableUserItem->IsAndroidUser()) && (pITableUserItem->GetMasterOrder()==0))
{
pTableUserRule=pITableUserItem->GetUserRule();
if (pTableUserRule->bLimitSameIP==true)
{
bCheckSameIP=true;
break;
}
}
}
//地址效验
if (bCheckSameIP==true)
{
DWORD dwUserIP=pIServerUserItem->GetClientAddr();
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pITableUserItem=GetTableUserItem(i);
if ((pITableUserItem!=NULL)&&(pITableUserItem != pIServerUserItem)&&(!pITableUserItem->IsAndroidUser())&&(pITableUserItem->GetMasterOrder()==0)&&(pITableUserItem->GetClientAddr()==dwUserIP))
{
if (!pUserRule->bLimitSameIP)
{
//发送信息
LPCTSTR pszDescribe=TEXT("此游戏桌玩家设置了不跟相同 IP 地址的玩家游戏，您 IP 地址与此玩家的 IP 地址相同，不能加入游戏！");
SendRequestFailure(pIServerUserItem,pszDescribe,REQUEST_FAILURE_NORMAL);
return false;
}
else
{
//发送信息
LPCTSTR pszDescribe=TEXT("您设置了不跟相同 IP 地址的玩家游戏，此游戏桌存在与您 IP 地址相同的玩家，不能加入游戏！");
SendRequestFailure(pIServerUserItem,pszDescribe,REQUEST_FAILURE_NORMAL);
return false;
}
}
}
for (WORD i=0;i<m_wChairCount-1;i++)
{
//获取用户
IServerUserItem * pITableUserItem=GetTableUserItem(i);
if (pITableUserItem!=NULL && (!pITableUserItem->IsAndroidUser()) && (pITableUserItem->GetMasterOrder()==0))
{
for (WORD j=i+1;j<m_wChairCount;j++)
{
//获取用户
IServerUserItem * pITableNextUserItem=GetTableUserItem(j);
if ((pITableNextUserItem!=NULL) && (!pITableNextUserItem->IsAndroidUser()) && (pITableNextUserItem->GetMasterOrder()==0)&&(pITableUserItem->GetClientAddr()==pITableNextUserItem->GetClientAddr()))
{
LPCTSTR pszDescribe=TEXT("您设置了不跟相同 IP 地址的玩家游戏，此游戏桌存在 IP 地址相同的玩家，不能加入游戏！");
SendRequestFailure(pIServerUserItem,pszDescribe,REQUEST_FAILURE_NORMAL);
return false;
}
}
}
}
}
return true;
}
//积分效验
bool CTableFrame::EfficacyScoreRule(IServerUserItem * pIServerUserItem)
{
//管理员不受限制
if(pIServerUserItem->GetMasterOrder()!=0) return true;
//规则判断
if (CServerRule::IsForfendGameRule(m_pGameServiceOption->dwServerRule)==true) return true;
//变量定义
WORD wWinRate=pIServerUserItem->GetUserWinRate();
WORD wFleeRate=pIServerUserItem->GetUserFleeRate();
//积分范围
for (WORD i=0;i<m_wChairCount;i++)
{
//获取用户
IServerUserItem * pITableUserItem=GetTableUserItem(i);
//规则效验
if (pITableUserItem!=NULL)
{
//获取规则
tagUserRule * pTableUserRule=pITableUserItem->GetUserRule();
//逃率效验
if ((pTableUserRule->bLimitFleeRate)&&(wFleeRate>pTableUserRule->wMaxFleeRate))
{
//构造信息
TCHAR szDescribe[128]=TEXT("");
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("您的逃跑率太高，与 %s 设置的设置不符，不能加入游戏！"),pITableUserItem->GetNickName());
//发送信息
SendRequestFailure(pIServerUserItem,szDescribe,REQUEST_FAILURE_NORMAL);
return false;
}
//胜率效验
if ((pTableUserRule->bLimitWinRate)&&(wWinRate<pTableUserRule->wMinWinRate))
{
//构造信息
TCHAR szDescribe[128]=TEXT("");
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("您的胜率太低，与 %s 设置的设置不符，不能加入游戏！"),pITableUserItem->GetNickName());
//发送信息
SendRequestFailure(pIServerUserItem,szDescribe,REQUEST_FAILURE_NORMAL);
return false;
}
//积分效验
if (pTableUserRule->bLimitGameScore==true)
{
//最高积分
if (pIServerUserItem->GetUserScore()>pTableUserRule->lMaxGameScore)
{
//构造信息
TCHAR szDescribe[128]=TEXT("");
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("您的积分太高，与 %s 设置的设置不符，不能加入游戏！"),pITableUserItem->GetNickName());
//发送信息
SendRequestFailure(pIServerUserItem,szDescribe,REQUEST_FAILURE_NORMAL);
return false;
}
//最低积分
if (pIServerUserItem->GetUserScore()<pTableUserRule->lMinGameScore)
{
//构造信息
TCHAR szDescribe[128]=TEXT("");
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("您的积分太低，与 %s 设置的设置不符，不能加入游戏！"),pITableUserItem->GetNickName());
//发送信息
SendRequestFailure(pIServerUserItem,szDescribe,REQUEST_FAILURE_NORMAL);
return false;
}
}
}
}
return true;
}
//检查分配
bool CTableFrame::CheckDistribute()
{
//防作弊
if (CServerRule::IsAllowAvertCheatMode(m_pGameServiceOption->dwServerRule))
{
//桌子状况
tagTableUserInfo TableUserInfo;
WORD wUserSitCount = GetTableUserInfo(TableUserInfo);
//用户起立
if (wUserSitCount < TableUserInfo.wMinUserCount)
{
return true;
}
}
return false;
}
bool CTableFrame::ImitateGameOption(IServerUserItem * pIServerUserItem)
{
//参数校验
ASSERT(pIServerUserItem != NULL);
if (pIServerUserItem == NULL)
{
return false;
}
//状态判断;
if (m_bGameStarted == true)
{
return true;
}
//if (pIServerUserItem->GetUserMatchStatus() != MUS_PLAYING)
//{
// return false;
//}
//类型判断;
if ((m_pGameServiceOption->wServerType&GAME_GENRE_MATCH) == 0)
{
return false;
}
//设置状态;
pIServerUserItem->SetClientReady(true);
//开始判断;
if ((pIServerUserItem->GetUserStatus() == US_READY) && (EfficacyStartGame(pIServerUserItem->GetChairID()) == true))
{
StartGame();
}
return true;
}
//////////////////////////////////////////////////////////////////////////////////
Reference in New Issue View Git Blame Copy Permalink