1278 lines
32 KiB
C++
1278 lines
32 KiB
C++
#include "StdAfx.h"
|
||
#include "AndroidUserManager.h"
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////
|
||
|
||
//常量定义
|
||
#define ANDROID_LOGON_COUNT 32 //登录数目
|
||
#define ADNDROID_PLAY_DRAW 10 //游戏局数
|
||
#define ANDROID_UNLOAD_TIME 30*60 //不加载时间
|
||
#define ANDROID_UNIN_TIME 10*60 //不进入时间
|
||
|
||
//时间标识
|
||
#define IDI_ANDROID_IN (IDI_REBOT_MODULE_START+0) //进入时间
|
||
#define IDI_ANDROID_OUT (IDI_REBOT_MODULE_START+MAX_BATCH) //退出时间
|
||
#define IDI_ANDROID_PULSE (IDI_REBOT_MODULE_START+2*MAX_BATCH)//脉冲时间
|
||
|
||
//机器时间
|
||
#define TIME_ANDROID_INOUT 15L //登录时间
|
||
#define TIME_ANDROID_PULSE 1L //脉冲时间
|
||
#define TIME_LOAD_ANDROID_INFO 900L //加载用户
|
||
#define TIME_ANDROID_REPOSE_TIME 1800L //服务时间
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////
|
||
|
||
//构造函数
|
||
CAndroidUserManager::CAndroidUserManager()
|
||
{
|
||
//系统参数
|
||
m_pGameParameter=NULL;
|
||
m_pGameServiceAttrib=NULL;
|
||
m_pGameServiceOption=NULL;
|
||
m_pGameMatchOption=NULL;
|
||
|
||
//组件接口
|
||
m_pITimerEngine=NULL;
|
||
m_pIServerUserManager=NULL;
|
||
m_pIGameServiceManager=NULL;
|
||
m_pIGameServiceSustomTime=NULL;
|
||
m_pITCPNetworkEngineEvent=NULL;
|
||
m_pIMainServiceFrame=NULL;
|
||
|
||
//配置变量
|
||
m_dwMinSitInterval=0;
|
||
m_dwMaxSitInterval=0;
|
||
m_bServiceContinue=false;
|
||
m_wAutoAndroidCount=ANDROID_LOGON_COUNT;
|
||
|
||
//库存变量
|
||
m_wStockCount=0;
|
||
ZeroMemory(&m_AndroidItemConfig,sizeof(m_AndroidItemConfig));
|
||
|
||
//设置索引
|
||
m_AndroidUserItemMap.InitHashTable(PRIME_ANDROID_USER);
|
||
m_AndroidUserItemMap.RemoveAll();
|
||
|
||
return;
|
||
}
|
||
|
||
//析构函数
|
||
CAndroidUserManager::~CAndroidUserManager()
|
||
{
|
||
//清理断言
|
||
ASSERT(m_AndroidUserItemMap.GetCount()==0L);
|
||
ASSERT(m_AndroidParameterArray.GetCount()==0L);
|
||
ASSERT(m_AndroidUserItemArray.GetCount()==0L);
|
||
ASSERT(m_AndroidUserItemBuffer.GetCount()==0L);
|
||
|
||
return;
|
||
}
|
||
|
||
//接口查询
|
||
VOID * CAndroidUserManager::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
|
||
{
|
||
QUERYINTERFACE(IAndroidUserManager,Guid,dwQueryVer);
|
||
QUERYINTERFACE_IUNKNOWNEX(IAndroidUserManager,Guid,dwQueryVer);
|
||
return NULL;
|
||
}
|
||
|
||
//启动服务
|
||
bool CAndroidUserManager::StartService()
|
||
{
|
||
//时间间隔
|
||
DWORD dwTimeCell=TIME_CELL;
|
||
DWORD dwElapse=TIME_ANDROID_PULSE*1000L;
|
||
|
||
//调整时间
|
||
if (m_pIGameServiceSustomTime!=NULL)
|
||
{
|
||
dwTimeCell=m_pIGameServiceSustomTime->GetTimerEngineTimeCell();
|
||
if (dwTimeCell>TIME_CELL) dwTimeCell=TIME_CELL;
|
||
|
||
dwElapse=m_pIGameServiceSustomTime->GetAndroidTimerPulse();
|
||
if (dwElapse<dwTimeCell) dwElapse=dwTimeCell;
|
||
}
|
||
|
||
//启动时间
|
||
m_pITimerEngine->SetTimer(IDI_ANDROID_PULSE,dwElapse,TIMES_INFINITY,0);
|
||
|
||
return true;
|
||
}
|
||
|
||
//停止服务
|
||
bool CAndroidUserManager::ConcludeService()
|
||
{
|
||
//删除存储
|
||
for (INT_PTR i=0;i<m_AndroidUserItemArray.GetCount();i++)
|
||
{
|
||
SafeRelease(m_AndroidUserItemArray[i]);
|
||
}
|
||
|
||
//删除存储
|
||
for (INT_PTR i=0;i<m_AndroidParameterArray.GetCount();i++)
|
||
{
|
||
SafeDelete(m_AndroidParameterArray[i]);
|
||
}
|
||
|
||
//清理数组
|
||
m_AndroidUserItemMap.RemoveAll();
|
||
m_AndroidParameterArray.RemoveAll();
|
||
m_AndroidUserItemArray.RemoveAll();
|
||
m_AndroidUserItemBuffer.RemoveAll();
|
||
|
||
//库存用户
|
||
m_wStockCount=0;
|
||
ZeroMemory(&m_AndroidItemConfig,sizeof(m_AndroidItemConfig));
|
||
|
||
return true;
|
||
}
|
||
|
||
//配置组件
|
||
bool CAndroidUserManager::InitAndroidUser(tagAndroidUserParameter & AndroidUserParameter)
|
||
{
|
||
//服务配置
|
||
m_bServiceContinue=AndroidUserParameter.bServiceContinue;
|
||
m_dwMinSitInterval=AndroidUserParameter.dwMinSitInterval;
|
||
m_dwMaxSitInterval=AndroidUserParameter.dwMaxSitInterval;
|
||
|
||
//设置变量
|
||
m_pGameParameter=AndroidUserParameter.pGameParameter;
|
||
m_pGameServiceAttrib=AndroidUserParameter.pGameServiceAttrib;
|
||
m_pGameServiceOption=AndroidUserParameter.pGameServiceOption;
|
||
m_pGameMatchOption=AndroidUserParameter.pGameMatchOption;
|
||
|
||
//组件接口
|
||
m_pITimerEngine=AndroidUserParameter.pITimerEngine;
|
||
m_pIServerUserManager=AndroidUserParameter.pIServerUserManager;
|
||
m_pIGameServiceManager=AndroidUserParameter.pIGameServiceManager;
|
||
m_pIGameServiceSustomTime=AndroidUserParameter.pIGameServiceSustomTime;
|
||
m_pITCPNetworkEngineEvent=AndroidUserParameter.pITCPNetworkEngineEvent;
|
||
|
||
return true;
|
||
}
|
||
|
||
//移除参数
|
||
bool CAndroidUserManager::RemoveAndroidParameter(DWORD dwBatchID)
|
||
{
|
||
//获取参数
|
||
tagAndroidParameterEx * pAndroidParameter = GetAndroidParameter(dwBatchID);
|
||
if(pAndroidParameter==NULL) return false;
|
||
|
||
//获取时间
|
||
SYSTEMTIME SystemTime;
|
||
GetLocalTime(&SystemTime);
|
||
DWORD dwTodayTickCount= GetTodayTickCount(SystemTime);
|
||
|
||
//调整参数
|
||
pAndroidParameter->bIsValided=false;
|
||
pAndroidParameter->AndroidParameter.dwLeaveTime=dwTodayTickCount;
|
||
|
||
//获取索引
|
||
WORD wParameterIndex=GetAndroidParameterIndex(pAndroidParameter);
|
||
if(wParameterIndex==INVALID_WORD) return true;
|
||
|
||
//关闭定时器
|
||
m_pITimerEngine->KillTimer(IDI_ANDROID_IN+wParameterIndex);
|
||
|
||
//删掉库存
|
||
for (int i=m_wStockCount-1;i>=0;i--)
|
||
{
|
||
//批次判断
|
||
if(m_AndroidItemConfig[i].pAndroidParameter!=&pAndroidParameter->AndroidParameter) continue;
|
||
|
||
//删除存存
|
||
m_wStockCount--;
|
||
m_AndroidItemConfig[i]=m_AndroidItemConfig[m_wStockCount];
|
||
}
|
||
|
||
//加载判断
|
||
if(pAndroidParameter->bIsLoadAndroid==false)
|
||
{
|
||
//释放资源
|
||
SafeDelete(pAndroidParameter);
|
||
m_AndroidParameterArray[wParameterIndex]=NULL;
|
||
|
||
return true;
|
||
}
|
||
|
||
//开启定时器
|
||
m_pITimerEngine->SetTimer(IDI_ANDROID_OUT+wParameterIndex,TIME_ANDROID_INOUT*1000L,TIMES_INFINITY,(WPARAM)pAndroidParameter);
|
||
|
||
return true;
|
||
}
|
||
|
||
//设置参数
|
||
bool CAndroidUserManager::AddAndroidParameter(tagAndroidParameter AndroidParameter[], WORD wParameterCount)
|
||
{
|
||
//变量定义
|
||
tagAndroidParameterEx * pAndroidParameter=NULL;
|
||
|
||
for(WORD wIndex=0;wIndex<wParameterCount;wIndex++)
|
||
{
|
||
//数目限制
|
||
if(m_AndroidParameterArray.GetCount()>=MAX_BATCH) break;
|
||
|
||
//设置资源
|
||
pAndroidParameter = GetAndroidParameter(AndroidParameter[wIndex].dwBatchID);
|
||
if(pAndroidParameter==NULL)
|
||
{
|
||
//申请资源
|
||
pAndroidParameter = new tagAndroidParameterEx();
|
||
if(pAndroidParameter==NULL) return false;
|
||
|
||
//设置变量
|
||
pAndroidParameter->bIsValided=true;
|
||
pAndroidParameter->bIsLoadAndroid=false;
|
||
|
||
//变量定义
|
||
bool bVacancyExist=false;
|
||
|
||
//查找空缺
|
||
for(INT_PTR nIndex=0;nIndex<m_AndroidParameterArray.GetCount();nIndex++)
|
||
{
|
||
if(m_AndroidParameterArray[nIndex]==NULL)
|
||
{
|
||
bVacancyExist=true;
|
||
m_AndroidParameterArray[nIndex]=pAndroidParameter;
|
||
break;
|
||
}
|
||
}
|
||
|
||
//不存在空缺
|
||
if(bVacancyExist==false)
|
||
{
|
||
m_AndroidParameterArray.Add(pAndroidParameter);
|
||
}
|
||
}
|
||
|
||
//拷贝数据
|
||
CopyMemory(pAndroidParameter,&AndroidParameter[wIndex],sizeof(tagAndroidParameter));
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//插入机器
|
||
bool CAndroidUserManager::InsertAndroidInfo(tagAndroidAccountsInfo AndroidAccountsInfo[],WORD wAndroidCount,DWORD dwBatchID)
|
||
{
|
||
//获取参数
|
||
tagAndroidParameterEx * pAndroidParameter = GetAndroidParameter(dwBatchID);
|
||
if(pAndroidParameter==NULL) return false;
|
||
|
||
//记录库存
|
||
CAndroidUserItem * pAndroidUserItem=NULL;
|
||
WORD wStockCount=m_wStockCount;
|
||
bool bAndroidExist=false;
|
||
|
||
//添加新机器
|
||
for(WORD wIndex=0;wIndex<wAndroidCount;wIndex++)
|
||
{
|
||
//设置变量
|
||
bAndroidExist=false;
|
||
|
||
//从库存中查找
|
||
for(WORD wItem=0;wItem<wStockCount;wItem++)
|
||
{
|
||
if(m_AndroidItemConfig[wItem].AndroidAccountsInfo.dwUserID==AndroidAccountsInfo[wIndex].dwUserID)
|
||
{
|
||
bAndroidExist=true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
//存在判断
|
||
if(bAndroidExist==true) continue;
|
||
|
||
//从映射中查找
|
||
if(m_AndroidUserItemMap.Lookup(AndroidAccountsInfo[wIndex].dwUserID,pAndroidUserItem)==TRUE)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//添加机器
|
||
m_AndroidItemConfig[m_wStockCount].AndroidAccountsInfo=AndroidAccountsInfo[wIndex];
|
||
m_AndroidItemConfig[m_wStockCount].pAndroidParameter=&pAndroidParameter->AndroidParameter;
|
||
|
||
//增加库存
|
||
m_wStockCount++;
|
||
}
|
||
|
||
//获取索引
|
||
WORD wParameterIndex=GetAndroidParameterIndex(pAndroidParameter);
|
||
if(wParameterIndex==INVALID_WORD) return true;
|
||
|
||
//开启定时器
|
||
m_pITimerEngine->KillTimer(IDI_ANDROID_IN+wParameterIndex);
|
||
m_pITimerEngine->SetTimer(IDI_ANDROID_IN+wParameterIndex,TIME_ANDROID_INOUT*1000L,TIMES_INFINITY,(WPARAM)pAndroidParameter);
|
||
|
||
return true;
|
||
}
|
||
|
||
//删除机器
|
||
bool CAndroidUserManager::DeleteAndroidUserItem(DWORD dwAndroidID,bool bStockRetrieve)
|
||
{
|
||
//获取对象
|
||
WORD wIndex=LOWORD(dwAndroidID);
|
||
CAndroidUserItem * pAndroidUserItem=GetAndroidUserItem(wIndex);
|
||
|
||
//对象效验
|
||
//ASSERT((pAndroidUserItem!=NULL)&&(pAndroidUserItem->m_wRoundID==HIWORD(dwAndroidID)));
|
||
if ((pAndroidUserItem==NULL)||(pAndroidUserItem->m_wRoundID!=HIWORD(dwAndroidID))) return false;
|
||
|
||
//关闭事件
|
||
try
|
||
{
|
||
m_pITCPNetworkEngineEvent->OnEventTCPNetworkShut(dwAndroidID,0,0L);
|
||
}
|
||
catch (...)
|
||
{
|
||
//错误断言
|
||
ASSERT(FALSE);
|
||
}
|
||
|
||
//机器配置
|
||
tagAndroidItemConfig AndroidItemConfig = pAndroidUserItem->m_AndroidItemConfig;
|
||
|
||
//删除对象
|
||
FreeAndroidUserItem(pAndroidUserItem->GetUserID());
|
||
|
||
////库存回收
|
||
//if(bStockRetrieve==true)
|
||
//{
|
||
// InsertAndroidInfo(&AndroidItemConfig.AndroidAccountsInfo,1,AndroidItemConfig.pAndroidParameter->dwBatchID);
|
||
//}
|
||
|
||
return true;
|
||
}
|
||
|
||
//查找机器
|
||
IAndroidUserItem * CAndroidUserManager::SearchAndroidUserItem(DWORD dwUserID, DWORD dwContextID)
|
||
{
|
||
//查找机器
|
||
CAndroidUserItem * pAndroidUserItem=NULL;
|
||
m_AndroidUserItemMap.Lookup(dwUserID,pAndroidUserItem);
|
||
|
||
//机器判断
|
||
if (pAndroidUserItem!=NULL)
|
||
{
|
||
WORD wRoundID=pAndroidUserItem->m_wRoundID;
|
||
WORD wAndroidIndex=pAndroidUserItem->m_wAndroidIndex;
|
||
if (MAKELONG(wAndroidIndex,wRoundID)==dwContextID) return pAndroidUserItem;
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//创建机器
|
||
IAndroidUserItem * CAndroidUserManager::CreateAndroidUserItem(tagAndroidItemConfig & AndroidItemConfig)
|
||
{
|
||
//效验参数
|
||
ASSERT(AndroidItemConfig.AndroidAccountsInfo.dwUserID!=0L);
|
||
if (AndroidItemConfig.AndroidAccountsInfo.dwUserID==0L) return NULL;
|
||
|
||
//创建对象
|
||
CAndroidUserItem * pAndroidUserItem=ActiveAndroidUserItem(AndroidItemConfig);
|
||
if (pAndroidUserItem==NULL) return NULL;
|
||
|
||
//属性变量
|
||
WORD wRoundID=pAndroidUserItem->m_wRoundID;
|
||
WORD wAndroidIndex=pAndroidUserItem->m_wAndroidIndex;
|
||
|
||
//连接模拟
|
||
try
|
||
{
|
||
if (m_pITCPNetworkEngineEvent->OnEventTCPNetworkBind(MAKELONG(wAndroidIndex,wRoundID),0L)==false)
|
||
{
|
||
throw 0;
|
||
}
|
||
}
|
||
catch (...)
|
||
{
|
||
//错误断言
|
||
ASSERT(FALSE);
|
||
|
||
//释放用户
|
||
FreeAndroidUserItem(AndroidItemConfig.AndroidAccountsInfo.dwUserID);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//变量定义
|
||
CMD_GR_LogonUserID LogonUserID;
|
||
ZeroMemory(&LogonUserID,sizeof(LogonUserID));
|
||
|
||
//版本信息
|
||
LogonUserID.dwPlazaVersion=VERSION_PLAZA;
|
||
LogonUserID.dwFrameVersion=VERSION_FRAME;
|
||
LogonUserID.dwProcessVersion=m_pGameServiceAttrib->dwClientVersion;
|
||
|
||
//用户信息
|
||
LogonUserID.dwUserID=AndroidItemConfig.AndroidAccountsInfo.dwUserID;
|
||
lstrcpyn(LogonUserID.szPassword,AndroidItemConfig.AndroidAccountsInfo.szPassword,CountArray(LogonUserID.szPassword));
|
||
LogonUserID.wKindID=m_pGameServiceOption->wKindID;
|
||
|
||
//构造数据
|
||
TCP_Command Command;
|
||
Command.wMainCmdID=MDM_GR_LOGON;
|
||
Command.wSubCmdID=SUB_GR_LOGON_USERID;
|
||
|
||
//消息处理
|
||
try
|
||
{
|
||
//发送数据
|
||
if (m_pITCPNetworkEngineEvent->OnEventTCPNetworkRead(MAKELONG(wAndroidIndex,wRoundID),Command,&LogonUserID,sizeof(LogonUserID))==false)
|
||
{
|
||
throw 0;
|
||
}
|
||
}
|
||
catch (...)
|
||
{
|
||
//错误断言
|
||
ASSERT(FALSE);
|
||
|
||
//删除机器
|
||
DeleteAndroidUserItem(MAKELONG(wAndroidIndex,wRoundID),false);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
return pAndroidUserItem;
|
||
}
|
||
|
||
//设置接口
|
||
VOID CAndroidUserManager::SetMainServiceFrame(IMainServiceFrame *pIMainServiceFrame)
|
||
{
|
||
m_pIMainServiceFrame=pIMainServiceFrame;
|
||
|
||
return;
|
||
}
|
||
|
||
//脉冲事件
|
||
bool CAndroidUserManager::OnEventTimerPulse(DWORD dwTimerID, WPARAM dwBindParameter)
|
||
{
|
||
//进入处理
|
||
if(dwTimerID>=IDI_ANDROID_IN && dwTimerID<IDI_ANDROID_IN+MAX_BATCH)
|
||
{
|
||
//获取时间
|
||
SYSTEMTIME SystemTime;
|
||
GetLocalTime(&SystemTime);
|
||
DWORD dwTodayTickCount= GetTodayTickCount(SystemTime);
|
||
|
||
//获取参数
|
||
tagAndroidParameter * pAndroidParameter=(tagAndroidParameter *)dwBindParameter;
|
||
if(pAndroidParameter==NULL)
|
||
{
|
||
//关闭定时器
|
||
m_pITimerEngine->KillTimer(dwTimerID);
|
||
|
||
return true;
|
||
}
|
||
|
||
//变量定义
|
||
bool bAllowAndroidAttend=CServerRule::IsAllowAndroidAttend(m_pGameServiceOption->dwServerRule);
|
||
bool bAllowAndroidSimulate=CServerRule::IsAllowAndroidSimulate(m_pGameServiceOption->dwServerRule);
|
||
|
||
//成功标识
|
||
bool bLogonSuccessed=false;
|
||
|
||
//登录处理
|
||
if ((bAllowAndroidAttend==true)||(bAllowAndroidSimulate==true))
|
||
{
|
||
//寻找机器
|
||
for (WORD i=0;i<m_wStockCount;i++)
|
||
{
|
||
//批次判断
|
||
if(m_AndroidItemConfig[i].pAndroidParameter!=pAndroidParameter) continue;
|
||
|
||
//模拟判断
|
||
if((m_pGameServiceOption->wServerType&GAME_GENRE_MATCH)
|
||
&& (pAndroidParameter->dwServiceMode&ANDROID_SIMULATE)!=0
|
||
&& (pAndroidParameter->dwServiceMode&ANDROID_PASSIVITY)==0
|
||
&& (pAndroidParameter->dwServiceMode&ANDROID_INITIATIVE)==0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//创建机器
|
||
if (CreateAndroidUserItem(m_AndroidItemConfig[i])!=NULL)
|
||
{
|
||
//删除存存
|
||
m_wStockCount--;
|
||
bLogonSuccessed=true;
|
||
m_AndroidItemConfig[i]=m_AndroidItemConfig[m_wStockCount];
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//关闭定时器
|
||
m_pITimerEngine->KillTimer(dwTimerID);
|
||
|
||
//定时器处理
|
||
if(bLogonSuccessed==true)
|
||
{
|
||
//计算流逝时间
|
||
DWORD dwElapse = pAndroidParameter->dwEnterMinInterval+rand()%(pAndroidParameter->dwEnterMaxInterval-pAndroidParameter->dwEnterMinInterval+1);
|
||
if(dwElapse==0) dwElapse=TIME_ANDROID_INOUT;
|
||
|
||
//设置定时器
|
||
m_pITimerEngine->SetTimer(dwTimerID,dwElapse*1000L,TIMES_INFINITY,dwBindParameter);
|
||
}
|
||
else
|
||
{
|
||
//剩余时间
|
||
DWORD dwRemaindTime = BatchServiceRemaindTime(pAndroidParameter,dwTodayTickCount);
|
||
if(dwRemaindTime<=ANDROID_UNIN_TIME)
|
||
{
|
||
//设置定时器
|
||
m_pITimerEngine->SetTimer(IDI_ANDROID_OUT+(dwTimerID-IDI_ANDROID_IN),TIME_ANDROID_INOUT*1000L,TIMES_INFINITY,dwBindParameter);
|
||
|
||
CString str;
|
||
str.Format(TEXT("本批次机器人开始退出, 批次ID=%d"),pAndroidParameter->dwBatchID);
|
||
CTraceService::TraceString(str,TraceLevel_Info);
|
||
}
|
||
else
|
||
{
|
||
//设置定时器
|
||
m_pITimerEngine->SetTimer(dwTimerID,TIME_ANDROID_INOUT*1000L,TIMES_INFINITY,dwBindParameter);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//退出处理
|
||
if(dwTimerID>=IDI_ANDROID_OUT && dwTimerID<IDI_ANDROID_OUT+MAX_BATCH)
|
||
{
|
||
//变量定义
|
||
DWORD dwUserID=0L;
|
||
INT_PTR nActiveCount=m_AndroidUserItemMap.GetCount();
|
||
POSITION Position=m_AndroidUserItemMap.GetStartPosition();
|
||
|
||
//获取时间
|
||
SYSTEMTIME SystemTime;
|
||
GetLocalTime(&SystemTime);
|
||
DWORD dwTodayTickCount= GetTodayTickCount(SystemTime);
|
||
|
||
//获取参数
|
||
tagAndroidParameterEx * pAndroidParameter=(tagAndroidParameterEx *)dwBindParameter;
|
||
if(pAndroidParameter==NULL)
|
||
{
|
||
//关闭定时器
|
||
m_pITimerEngine->KillTimer(dwTimerID);
|
||
|
||
return true;
|
||
}
|
||
|
||
//时间判断
|
||
if (BatchServiceRemaindTime(&pAndroidParameter->AndroidParameter,dwTodayTickCount)>0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
//变量定义
|
||
bool bLogoutMarked=false;
|
||
bool bLogoutFinished=true;
|
||
|
||
//退出处理
|
||
while (Position!=NULL)
|
||
{
|
||
//获取对象
|
||
CAndroidUserItem * pAndroidUserItem=NULL;
|
||
m_AndroidUserItemMap.GetNextAssoc(Position,dwUserID,pAndroidUserItem);
|
||
|
||
//退出判断
|
||
if (pAndroidUserItem->GetAndroidParameter()==&pAndroidParameter->AndroidParameter)
|
||
{
|
||
//设置变量
|
||
bLogoutFinished=false;
|
||
|
||
//变量定义
|
||
IServerUserItem * pIServerUserItem=pAndroidUserItem->m_pIServerUserItem;
|
||
if(pIServerUserItem!=NULL)
|
||
{
|
||
//服务状态
|
||
BYTE cbUserStatus=pIServerUserItem->GetUserStatus();
|
||
BYTE cbSignUpStatus=pIServerUserItem->GetUserMatchStatus();
|
||
if ((cbUserStatus!=US_FREE)&&(cbUserStatus!=US_SIT))
|
||
{
|
||
if (m_pGameServiceOption->wServerType==GAME_GENRE_MATCH && m_pGameMatchOption->cbMatchType==MATCH_TYPE_IMMEDIATE)
|
||
{
|
||
//防止中途换桌时UserStatus变为US_FREE导致卡赛，此时使用SignUpStatus判断可否被踢出
|
||
if(cbSignUpStatus!=MUS_NULL && pAndroidUserItem->m_bWaitLeave==false)
|
||
{
|
||
pAndroidUserItem->m_bWaitLeave=true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//标记动作
|
||
if(bLogoutMarked==false && pAndroidUserItem->m_wAndroidAction==0)
|
||
{
|
||
bLogoutMarked=true;
|
||
pAndroidUserItem->m_wAndroidAction|=ANDROID_WAITLEAVE;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
if (m_pGameServiceOption->wServerType==GAME_GENRE_MATCH && m_pGameMatchOption->cbMatchType==MATCH_TYPE_IMMEDIATE)
|
||
{
|
||
WORD wTableID = pIServerUserItem->GetTableID();
|
||
if((cbSignUpStatus!=MUS_NULL || pAndroidUserItem->m_bWaitLeave==false) && wTableID != INVALID_TABLE)
|
||
{
|
||
pAndroidUserItem->m_bWaitLeave=true;
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//删除用户
|
||
WORD wRoundID=pAndroidUserItem->m_wRoundID;
|
||
WORD wAndroidIndex=pAndroidUserItem->m_wAndroidIndex;
|
||
DeleteAndroidUserItem(MAKELONG(wAndroidIndex,wRoundID),false);
|
||
|
||
//设置标识
|
||
if(pIServerUserItem!=NULL) break;
|
||
}
|
||
}
|
||
|
||
//关闭定时器
|
||
m_pITimerEngine->KillTimer(dwTimerID);
|
||
|
||
//定时器处理
|
||
if(bLogoutFinished==false)
|
||
{
|
||
//计算流逝时间
|
||
DWORD dwElapse = pAndroidParameter->AndroidParameter.dwLeaveMinInterval+rand()%(pAndroidParameter->AndroidParameter.dwLeaveMaxInterval-pAndroidParameter->AndroidParameter.dwLeaveMinInterval+1);
|
||
if(dwElapse==0) dwElapse=TIME_ANDROID_INOUT;
|
||
|
||
//设置定时器
|
||
m_pITimerEngine->SetTimer(dwTimerID,dwElapse*1000L,TIMES_INFINITY,dwBindParameter);
|
||
}
|
||
else
|
||
{
|
||
if(pAndroidParameter->bIsValided==false)
|
||
{
|
||
//计算索引
|
||
WORD wParameterIndex=(WORD)(dwTimerID-IDI_ANDROID_OUT);
|
||
if(wParameterIndex==GetAndroidParameterIndex(pAndroidParameter))
|
||
{
|
||
//释放资源
|
||
SafeDelete(m_AndroidParameterArray[wParameterIndex]);
|
||
m_AndroidParameterArray[wParameterIndex]=NULL;
|
||
|
||
CString str;
|
||
str.Format(TEXT("本批次机器人全部退出,该批次将被删除, 批次ID=%d"),pAndroidParameter->AndroidParameter.dwBatchID);
|
||
CTraceService::TraceString(str,TraceLevel_Info);
|
||
|
||
//解锁机器人
|
||
if (m_pIMainServiceFrame!=NULL)
|
||
{
|
||
m_pIMainServiceFrame->UnLockAndroidUser(m_pGameServiceOption->wServerID,pAndroidParameter->AndroidParameter.dwBatchID);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//恢复标识
|
||
pAndroidParameter->bIsLoadAndroid=false;
|
||
|
||
CString str;
|
||
str.Format(TEXT("本批次机器人全部退出, 批次ID=%d"),pAndroidParameter->AndroidParameter.dwBatchID);
|
||
CTraceService::TraceString(str,TraceLevel_Info);
|
||
|
||
//解锁机器人
|
||
if (m_pIMainServiceFrame!=NULL)
|
||
{
|
||
m_pIMainServiceFrame->UnLockAndroidUser(m_pGameServiceOption->wServerID,pAndroidParameter->AndroidParameter.dwBatchID);
|
||
}
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//用户脉冲
|
||
if(dwTimerID==IDI_ANDROID_PULSE)
|
||
{
|
||
//变量定义
|
||
DWORD dwUserID=0L;
|
||
CAndroidUserItem * pAndroidUserItem=NULL;
|
||
POSITION Position=m_AndroidUserItemMap.GetStartPosition();
|
||
|
||
//用户处理
|
||
while (Position!=NULL)
|
||
{
|
||
//获取对象
|
||
m_AndroidUserItemMap.GetNextAssoc(Position,dwUserID,pAndroidUserItem);
|
||
|
||
//时间处理
|
||
try
|
||
{
|
||
//ASSERT(pAndroidUserItem!=NULL);
|
||
if (pAndroidUserItem->m_pIServerUserItem!=NULL) pAndroidUserItem->OnTimerPulse(dwTimerID,dwBindParameter);
|
||
}
|
||
catch (...)
|
||
{
|
||
ASSERT(FALSE);
|
||
DeleteAndroidUserItem(MAKELONG(pAndroidUserItem->m_wAndroidIndex,pAndroidUserItem->m_wRoundID),true);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//加载机器
|
||
bool CAndroidUserManager::GetAndroidLoadInfo(DWORD & dwBatchID,DWORD & dwLoadCount)
|
||
{
|
||
//数目判断
|
||
if(m_AndroidParameterArray.GetCount()==0) return false;
|
||
|
||
//获取时间
|
||
SYSTEMTIME SystemTime;
|
||
GetLocalTime(&SystemTime);
|
||
DWORD dwTodayTickCount= GetTodayTickCount(SystemTime);
|
||
|
||
//变量定义
|
||
tagAndroidParameterEx * pAndroidParameter=NULL;
|
||
DWORD dwRemaindTime;
|
||
|
||
//退出处理
|
||
for(INT_PTR nIndex=0;nIndex<m_AndroidParameterArray.GetCount();nIndex++)
|
||
{
|
||
//获取对象
|
||
pAndroidParameter = m_AndroidParameterArray[nIndex];
|
||
if(pAndroidParameter==NULL) continue;
|
||
|
||
//加载判断
|
||
if(pAndroidParameter->bIsLoadAndroid==true) continue;
|
||
|
||
//剩余时间
|
||
dwRemaindTime=BatchServiceRemaindTime(&pAndroidParameter->AndroidParameter,dwTodayTickCount);
|
||
|
||
//加载机器
|
||
if(dwRemaindTime>ANDROID_UNLOAD_TIME)
|
||
{
|
||
//设置标识
|
||
pAndroidParameter->bIsLoadAndroid=true;
|
||
|
||
//设置参数
|
||
dwBatchID = pAndroidParameter->AndroidParameter.dwBatchID;
|
||
dwLoadCount = __min(pAndroidParameter->AndroidParameter.dwAndroidCount,dwRemaindTime/pAndroidParameter->AndroidParameter.dwEnterMaxInterval);
|
||
if (dwLoadCount==0) continue;
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//用户状况
|
||
WORD CAndroidUserManager::GetAndroidUserInfo(tagAndroidUserInfo & AndroidUserInfo, DWORD dwServiceMode)
|
||
{
|
||
//获取时间
|
||
SYSTEMTIME SystemTime;
|
||
GetLocalTime(&SystemTime);
|
||
DWORD dwTodayTickCount= GetTodayTickCount(SystemTime);
|
||
|
||
//设置变量
|
||
ZeroMemory(&AndroidUserInfo,sizeof(AndroidUserInfo));
|
||
|
||
//变量定义
|
||
DWORD dwTimeMask=(1L<<SystemTime.wHour);
|
||
POSITION Position=m_AndroidUserItemMap.GetStartPosition();
|
||
|
||
//枚举对象
|
||
while (Position!=NULL)
|
||
{
|
||
//获取对象
|
||
DWORD dwUserID=0L;
|
||
CAndroidUserItem * pAndroidUserItem=NULL;
|
||
m_AndroidUserItemMap.GetNextAssoc(Position,dwUserID,pAndroidUserItem);
|
||
|
||
//效验参数
|
||
ASSERT((dwUserID!=0L)&&(pAndroidUserItem!=NULL));
|
||
if ((dwUserID==0L)||(pAndroidUserItem==NULL)) break;
|
||
|
||
//绑定判断
|
||
if(pAndroidUserItem->m_pIServerUserItem==NULL) continue;
|
||
|
||
//变量定义
|
||
IServerUserItem * pIServerUserItem=pAndroidUserItem->m_pIServerUserItem;
|
||
tagAndroidParameter * pAndroidParameter=pAndroidUserItem->GetAndroidParameter();
|
||
|
||
//离开判断
|
||
if (pAndroidUserItem->m_bWaitLeave==true) continue;
|
||
|
||
//模式判断
|
||
if ((pAndroidParameter->dwServiceMode&dwServiceMode)==0L) continue;
|
||
|
||
//离开判断
|
||
if (!m_bServiceContinue && BatchServiceRemaindTime(pAndroidParameter,dwTodayTickCount)==0) continue;
|
||
|
||
//休息时间
|
||
DWORD dwCurrTime=(DWORD)time(NULL);
|
||
if((pAndroidUserItem->m_dwStandupTickCount+pAndroidUserItem->m_dwReposeTickCount)>dwCurrTime) continue;
|
||
|
||
//状态判断
|
||
switch (pIServerUserItem->GetUserStatus())
|
||
{
|
||
case US_FREE:
|
||
{
|
||
ASSERT(AndroidUserInfo.wFreeUserCount<CountArray(AndroidUserInfo.pIAndroidUserFree));
|
||
AndroidUserInfo.pIAndroidUserFree[AndroidUserInfo.wFreeUserCount++]=pAndroidUserItem;
|
||
break;
|
||
}
|
||
case US_SIT:
|
||
case US_READY:
|
||
{
|
||
ASSERT(AndroidUserInfo.wSitdownUserCount<CountArray(AndroidUserInfo.pIAndroidUserSitdown));
|
||
AndroidUserInfo.pIAndroidUserSitdown[AndroidUserInfo.wSitdownUserCount++]=pAndroidUserItem;
|
||
break;
|
||
}
|
||
case US_PLAYING:
|
||
case US_OFFLINE:
|
||
{
|
||
ASSERT(AndroidUserInfo.wPlayUserCount<CountArray(AndroidUserInfo.pIAndroidUserPlay));
|
||
AndroidUserInfo.pIAndroidUserPlay[AndroidUserInfo.wPlayUserCount++]=pAndroidUserItem;
|
||
break;
|
||
}
|
||
case US_WAITDISTRIBUTE:
|
||
{
|
||
ASSERT(AndroidUserInfo.wWaitUserCount < CountArray(AndroidUserInfo.pIAndroidUserWait));
|
||
AndroidUserInfo.pIAndroidUserWait[AndroidUserInfo.wWaitUserCount++] = pAndroidUserItem;
|
||
break;
|
||
}
|
||
}
|
||
};
|
||
|
||
return AndroidUserInfo.wFreeUserCount + AndroidUserInfo.wPlayUserCount + AndroidUserInfo.wSitdownUserCount + AndroidUserInfo.wWaitUserCount;
|
||
}
|
||
|
||
//发送数据
|
||
bool CAndroidUserManager::SendDataToClient(WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//发送数据
|
||
for (INT_PTR i=0;i<m_AndroidUserItemArray.GetCount();i++)
|
||
{
|
||
//获取对象
|
||
CAndroidUserItem * pAndroidUserItem=m_AndroidUserItemArray[i];
|
||
|
||
//状态判断
|
||
if (pAndroidUserItem->m_pIServerUserItem==NULL) continue;
|
||
if (pAndroidUserItem->m_AndroidItemConfig.AndroidAccountsInfo.dwUserID==0L) continue;
|
||
|
||
//消息处理
|
||
try
|
||
{
|
||
if (pAndroidUserItem->OnSocketRead(wMainCmdID,wSubCmdID,pData,wDataSize)==false)
|
||
{
|
||
throw 0;
|
||
}
|
||
}
|
||
catch (...)
|
||
{
|
||
//错误断言
|
||
ASSERT(FALSE);
|
||
|
||
//断开用户
|
||
WORD wRoundID=pAndroidUserItem->m_wRoundID;
|
||
WORD wAndroidIndex=pAndroidUserItem->m_wAndroidIndex;
|
||
DeleteAndroidUserItem(MAKELONG(wAndroidIndex,wRoundID),true);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//发送数据
|
||
bool CAndroidUserManager::SendDataToClient(DWORD dwAndroidID, WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//获取对象
|
||
WORD wIndex=LOWORD(dwAndroidID);
|
||
CAndroidUserItem * pAndroidUserItem=GetAndroidUserItem(wIndex);
|
||
|
||
//对象效验
|
||
//ASSERT((pAndroidUserItem!=NULL)&&(pAndroidUserItem->m_wRoundID==HIWORD(dwAndroidID)));
|
||
if ((pAndroidUserItem==NULL)||(pAndroidUserItem->m_wRoundID!=HIWORD(dwAndroidID))) return false;
|
||
|
||
//消息处理
|
||
try
|
||
{
|
||
if (pAndroidUserItem->OnSocketRead(wMainCmdID,wSubCmdID,pData,wDataSize)==false)
|
||
{
|
||
ASSERT(FALSE);
|
||
throw 0;
|
||
}
|
||
}
|
||
catch (...)
|
||
{
|
||
ASSERT(FALSE);
|
||
DeleteAndroidUserItem(dwAndroidID,true);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//发送数据
|
||
bool CAndroidUserManager::SendDataToServer(DWORD dwAndroidID, WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//构造数据
|
||
TCP_Command Command;
|
||
Command.wSubCmdID=wSubCmdID;
|
||
Command.wMainCmdID=wMainCmdID;
|
||
|
||
//消息处理
|
||
try
|
||
{
|
||
if (m_pITCPNetworkEngineEvent->OnEventTCPNetworkRead(dwAndroidID,Command,pData,wDataSize)==false)
|
||
{
|
||
throw 0;
|
||
}
|
||
}
|
||
catch (...)
|
||
{
|
||
CString str;
|
||
str.Format(TEXT("SendDataToServer: MainID=%d,SubID=%d"),Command.wMainCmdID,Command.wSubCmdID);
|
||
CTraceService::TraceString(str,TraceLevel_Exception);
|
||
|
||
ASSERT(FALSE);
|
||
DeleteAndroidUserItem(dwAndroidID,true);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//获取对象
|
||
CAndroidUserItem * CAndroidUserManager::GetAndroidUserItem(WORD wIndex)
|
||
{
|
||
//效验索引
|
||
ASSERT(wIndex>=INDEX_ANDROID);
|
||
if (wIndex<INDEX_ANDROID) return NULL;
|
||
|
||
//效验索引
|
||
ASSERT((wIndex-INDEX_ANDROID)<m_AndroidUserItemArray.GetCount());
|
||
if (((wIndex-INDEX_ANDROID)>=m_AndroidUserItemArray.GetCount())) return NULL;
|
||
|
||
//获取对象
|
||
WORD wBufferIndex=wIndex-INDEX_ANDROID;
|
||
CAndroidUserItem * pAndroidUserItem=m_AndroidUserItemArray[wBufferIndex];
|
||
|
||
return pAndroidUserItem;
|
||
}
|
||
|
||
//释放对象
|
||
VOID CAndroidUserManager::FreeAndroidUserItem(DWORD dwUserID)
|
||
{
|
||
//效验参数
|
||
ASSERT(dwUserID!=0);
|
||
if (dwUserID==0) return;
|
||
|
||
//变量定义
|
||
CAndroidUserItem * pAndroidUserItem=NULL;
|
||
m_AndroidUserItemMap.Lookup(dwUserID,pAndroidUserItem);
|
||
|
||
//对象判断
|
||
if (pAndroidUserItem==NULL)
|
||
{
|
||
ASSERT(FALSE);
|
||
return;
|
||
}
|
||
|
||
//复位对象
|
||
pAndroidUserItem->RepositUserItem();
|
||
|
||
//设置索引
|
||
m_AndroidUserItemMap.RemoveKey(dwUserID);
|
||
m_AndroidUserItemBuffer.Add(pAndroidUserItem);
|
||
|
||
return;
|
||
}
|
||
|
||
//获取参数
|
||
tagAndroidParameterEx * CAndroidUserManager::GetAndroidParameter(DWORD dwBatchID)
|
||
{
|
||
//查找数组
|
||
for(INT_PTR nIndex=0;nIndex<m_AndroidParameterArray.GetCount();nIndex++)
|
||
{
|
||
if(m_AndroidParameterArray[nIndex]==NULL) continue;
|
||
if(m_AndroidParameterArray[nIndex]->AndroidParameter.dwBatchID==dwBatchID)
|
||
{
|
||
return m_AndroidParameterArray[nIndex];
|
||
}
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//获取索引
|
||
WORD CAndroidUserManager::GetAndroidParameterIndex(tagAndroidParameterEx * pAndroidParameter)
|
||
{
|
||
//参数校验
|
||
if(pAndroidParameter==NULL) return INVALID_WORD;
|
||
|
||
//查找数组
|
||
for(INT_PTR nIndex=0;nIndex<m_AndroidParameterArray.GetCount();nIndex++)
|
||
{
|
||
if(m_AndroidParameterArray[nIndex]==pAndroidParameter)
|
||
{
|
||
return (WORD)nIndex;
|
||
}
|
||
}
|
||
|
||
return INVALID_WORD;
|
||
}
|
||
|
||
//转换时间
|
||
DWORD CAndroidUserManager::GetTodayTickCount(SYSTEMTIME & SystemTime)
|
||
{
|
||
return SystemTime.wHour*3600+SystemTime.wMinute*60+SystemTime.wSecond;
|
||
}
|
||
|
||
//剩余时间
|
||
DWORD CAndroidUserManager::BatchServiceRemaindTime(tagAndroidParameter * pAndroidParameter,DWORD dwTodayTickCount)
|
||
{
|
||
//参数校验
|
||
ASSERT(pAndroidParameter!=NULL);
|
||
if(pAndroidParameter==NULL) return 0;
|
||
|
||
//变量定义
|
||
DWORD dwEnterTime,dwLeaveTime;
|
||
DWORD dwRemaindTime=0;
|
||
|
||
//设置变量
|
||
dwEnterTime=pAndroidParameter->dwEnterTime;
|
||
dwLeaveTime=pAndroidParameter->dwLeaveTime;
|
||
|
||
// 计算时间
|
||
// 进入时间和离开时间在同一天
|
||
// 进入时间，离开时间都在同一天的 00:00:00 ~ 23:59:59 (0~86399)
|
||
if(dwLeaveTime>dwEnterTime)
|
||
{
|
||
if(dwTodayTickCount>=dwEnterTime && dwTodayTickCount<=dwLeaveTime)
|
||
{
|
||
dwRemaindTime=dwLeaveTime-dwTodayTickCount;
|
||
}
|
||
}
|
||
// 进入时间和离开时间不在同一天
|
||
// 进入时间在第一天12:00:01 ~ 23:59:59 (43201~86399)
|
||
// 离开时间在第二天 00:00:00 ~ 12:00:00 (0~43200)
|
||
else if(dwLeaveTime<dwEnterTime)
|
||
{
|
||
//第一天
|
||
if(dwTodayTickCount>=dwEnterTime)
|
||
{
|
||
dwRemaindTime = dwLeaveTime+24*3600-dwTodayTickCount;
|
||
}
|
||
|
||
//第二天
|
||
if(dwTodayTickCount< dwLeaveTime)
|
||
{
|
||
dwRemaindTime = dwLeaveTime-dwTodayTickCount;
|
||
}
|
||
}
|
||
|
||
return dwRemaindTime;
|
||
}
|
||
|
||
//等待时间
|
||
DWORD CAndroidUserManager::BatchServiceAwaitTime(tagAndroidParameter * pAndroidParameter,DWORD dwTodayTickCount)
|
||
{
|
||
//参数校验
|
||
ASSERT(pAndroidParameter!=NULL);
|
||
if(pAndroidParameter==NULL) return 0;
|
||
if(((tagAndroidParameterEx *)pAndroidParameter)->bIsLoadAndroid==false) return -1;
|
||
|
||
//变量定义
|
||
DWORD dwEnterTime,dwLeaveTime;
|
||
|
||
//设置变量
|
||
dwEnterTime=pAndroidParameter->dwEnterTime;
|
||
dwLeaveTime=pAndroidParameter->dwLeaveTime;
|
||
|
||
//计算时间
|
||
if(dwEnterTime<dwLeaveTime)
|
||
{
|
||
if(dwTodayTickCount<dwEnterTime)
|
||
{
|
||
return dwEnterTime-dwTodayTickCount;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(dwTodayTickCount<dwEnterTime && dwTodayTickCount>dwLeaveTime)
|
||
{
|
||
return dwEnterTime-dwTodayTickCount;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
//激活对象
|
||
CAndroidUserItem * CAndroidUserManager::ActiveAndroidUserItem(tagAndroidItemConfig & AndroidItemConfig)
|
||
{
|
||
//变量定义
|
||
CAndroidUserItem * pAndroidUserItem=NULL;
|
||
INT_PTR nFreeItemCount=m_AndroidUserItemBuffer.GetCount();
|
||
|
||
//获取对象
|
||
if (nFreeItemCount>0)
|
||
{
|
||
//获取对象
|
||
INT_PTR nItemPostion=nFreeItemCount-1;
|
||
pAndroidUserItem=m_AndroidUserItemBuffer[nItemPostion];
|
||
|
||
//删除数组
|
||
m_AndroidUserItemBuffer.RemoveAt(nItemPostion);
|
||
}
|
||
|
||
//创建对象
|
||
if (pAndroidUserItem==NULL)
|
||
{
|
||
//数目判断
|
||
if (m_AndroidUserItemArray.GetCount()>=MAX_ANDROID)
|
||
{
|
||
ASSERT(FALSE);
|
||
return NULL;
|
||
}
|
||
|
||
try
|
||
{
|
||
//变量定义
|
||
IAndroidUserItemSink * pIAndroidUserItemSink=NULL;
|
||
|
||
//创建陪玩
|
||
if (CServerRule::IsAllowAndroidAttend(m_pGameServiceOption->dwServerRule)==true)
|
||
{
|
||
pIAndroidUserItemSink=(IAndroidUserItemSink *)m_pIGameServiceManager->CreateAndroidUserItemSink(IID_IAndroidUserItemSink,VER_IAndroidUserItemSink);
|
||
}
|
||
|
||
//创建对象
|
||
try
|
||
{
|
||
pAndroidUserItem=new CAndroidUserItem;
|
||
}
|
||
catch (...)
|
||
{
|
||
//错误断言
|
||
ASSERT(FALSE);
|
||
//提示消息;
|
||
CTraceService::TraceString(TEXT("release pIAndroidUserItemSink 1."), TraceLevel_Warning);
|
||
//删除对象
|
||
SafeRelease(pIAndroidUserItemSink);
|
||
}
|
||
|
||
//错误判断
|
||
if (pAndroidUserItem==NULL)
|
||
{
|
||
//错误断言
|
||
ASSERT(FALSE);
|
||
|
||
//提示消息;
|
||
CTraceService::TraceString(TEXT("release pIAndroidUserItemSink 2."), TraceLevel_Warning);
|
||
//删除对象
|
||
SafeRelease(pIAndroidUserItemSink);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//设置用户
|
||
if ((pIAndroidUserItemSink!=NULL)&&(pIAndroidUserItemSink->Initialization(pAndroidUserItem)==false))
|
||
{
|
||
//错误断言
|
||
ASSERT(FALSE);
|
||
|
||
//提示消息;
|
||
CTraceService::TraceString(TEXT("release pIAndroidUserItemSink 3."), TraceLevel_Warning);
|
||
|
||
//删除对象
|
||
SafeRelease(pAndroidUserItem);
|
||
SafeRelease(pIAndroidUserItemSink);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//设置数组
|
||
WORD wCurrentIndex=(WORD)m_AndroidUserItemArray.Add(pAndroidUserItem);
|
||
|
||
//配置变量
|
||
pAndroidUserItem->m_dwMinSitInterval=m_dwMinSitInterval;
|
||
pAndroidUserItem->m_dwMaxSitInterval=m_dwMaxSitInterval;
|
||
|
||
//设置接口
|
||
pAndroidUserItem->m_wAndroidIndex=wCurrentIndex+INDEX_ANDROID;
|
||
pAndroidUserItem->m_pIServerUserManager=m_pIServerUserManager;
|
||
pAndroidUserItem->m_pIAndroidUserItemSink=pIAndroidUserItemSink;
|
||
pAndroidUserItem->m_pIAndroidUserManager=QUERY_ME_INTERFACE(IAndroidUserManager);
|
||
}
|
||
catch (...)
|
||
{
|
||
ASSERT(FALSE);
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
//游戏局数
|
||
if((AndroidItemConfig.pAndroidParameter->dwSwitchMinInnings!=0L)&&(AndroidItemConfig.pAndroidParameter->dwSwitchMaxInnings!=0L))
|
||
{
|
||
//变量定义
|
||
DWORD dwSwitchMinInnings=AndroidItemConfig.pAndroidParameter->dwSwitchMinInnings;
|
||
DWORD dwSwitchMaxInnings=AndroidItemConfig.pAndroidParameter->dwSwitchMaxInnings;
|
||
|
||
//调整局数
|
||
if ((dwSwitchMaxInnings-dwSwitchMinInnings)>0L)
|
||
pAndroidUserItem->m_AndroidService.dwSwitchTableInnings=dwSwitchMinInnings+rand()%(dwSwitchMaxInnings-dwSwitchMinInnings);
|
||
else
|
||
pAndroidUserItem->m_AndroidService.dwSwitchTableInnings=dwSwitchMinInnings;
|
||
}
|
||
else
|
||
pAndroidUserItem->m_AndroidService.dwSwitchTableInnings=0;
|
||
|
||
//服务类型
|
||
if(pAndroidUserItem->m_pIAndroidUserItemSink==NULL && (AndroidItemConfig.pAndroidParameter->dwServiceMode&ANDROID_SIMULATE)!=0)
|
||
AndroidItemConfig.pAndroidParameter->dwServiceMode=ANDROID_SIMULATE;
|
||
|
||
//设置变量
|
||
pAndroidUserItem->m_AndroidItemConfig=AndroidItemConfig;
|
||
|
||
//设置索引
|
||
m_AndroidUserItemMap[AndroidItemConfig.AndroidAccountsInfo.dwUserID]=pAndroidUserItem;
|
||
|
||
return pAndroidUserItem;
|
||
}
|
||
|
||
//强制起立
|
||
VOID CAndroidUserManager::ForceAndroidUserItemStandup(CAndroidUserItem * pAndroidUserItem)
|
||
{
|
||
//校验参数
|
||
ASSERT(pAndroidUserItem!=NULL);
|
||
if(pAndroidUserItem==NULL) return;
|
||
|
||
//属性变量
|
||
WORD wRoundID=pAndroidUserItem->m_wRoundID;
|
||
WORD wAndroidIndex=pAndroidUserItem->m_wAndroidIndex;
|
||
|
||
//构造结构
|
||
CMD_GR_UserStandUp UserStandUp;
|
||
UserStandUp.cbForceLeave=true;
|
||
UserStandUp.wTableID=pAndroidUserItem->m_pIServerUserItem->GetTableID();
|
||
UserStandUp.wChairID=pAndroidUserItem->m_pIServerUserItem->GetChairID();
|
||
|
||
//发送数据
|
||
SendDataToServer(MAKELONG(wAndroidIndex,wRoundID),MDM_GR_USER,SUB_GR_USER_STANDUP,&UserStandUp,sizeof(UserStandUp));
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////
|