VOID KRankHandler::OnSwapRankRequest(BYTE* pbyData, size_t uDataLen, int nConnIndex)
{
BOOL bRetCode = FALSE;
BOOL bSucceed = FALSE;
DWORD dwId = 0;
S2R_SWAP_RANK_REQUEST* pRequest = (S2R_SWAP_RANK_REQUEST*)pbyData;
KRankPool* pRankPool = NULL;
KRole* pRole = NULL;
pRankPool = g_pGameCenter->m_RankManager.GetRankPool(pRequest->byRankId);
LOG_PROCESS_ERROR(pRankPool);
bSucceed = pRankPool->SwapRank(pRequest->dwSrcId, pRequest->dwDstId);
LOG_PROCESS_ERROR(bSucceed);
// 交换双方都发下
bRetCode = DoSwapRankRespond(nConnIndex, pRequest->byRankId, pRequest->dwSrcId, pRankPool->GetIdxById(pRequest->dwSrcId), pRequest->dwDstId, pRankPool->GetIdxById(pRequest->dwDstId), bSucceed);
LOG_PROCESS_ERROR(bRetCode);
pRole = g_pGameCenter->m_RoleManager.GetRole(pRequest->dwDstId);
if (pRole != NULL && pRole->m_nConnIndex != nConnIndex) // 在目标玩家和源玩家不在同一个gs的情况下，给目标玩家也发一次，以便更新目标玩家的竞技场信息
{
bRetCode = DoSwapRankRespond(pRole->m_nConnIndex, pRequest->byRankId, pRequest->dwSrcId, pRankPool->GetIdxById(pRequest->dwSrcId), pRequest->dwDstId, pRankPool->GetIdxById(pRequest->dwDstId), bSucceed);
LOG_PROCESS_ERROR(bRetCode);
}
EXIT0:
return;
}
BOOL KRankHandler::DoGetRankIdxRespond(INT nConnIndex, INT nRankId, DWORD dwSrcId, DWORD dwId, INT nRankIdx)
{
BOOL bRetCode = FALSE;
BOOL bResult = FALSE;
R2S_GET_RANK_IDX_RESPOND* pRespond = NULL;
IMemBlock* piPackage = NULL;
piPackage = QCreateMemBlock(sizeof(R2S_GET_RANK_IDX_RESPOND));
pRespond = (R2S_GET_RANK_IDX_RESPOND*)piPackage->GetData();
LOG_PROCESS_ERROR(pRespond);
pRespond->wProtocolID = r2s_get_rank_idx_respond;
pRespond->nRankId = nRankId;
pRespond->nRankIdx = nRankIdx;
pRespond->dwSrcId = dwSrcId;
pRespond->dwId = dwId;
bRetCode = Send(nConnIndex, piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = TRUE;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
BOOL KRankHandler::DoSwapRankRespond(INT nConnIndex, INT nRankId, DWORD dwSrcId, INT nSrcRank, DWORD dwDestId, INT nDestRank, BOOL bSucceed)
{
BOOL bRetCode = FALSE;
BOOL bResult = FALSE;
R2S_SWAP_RANK_RESPOND* pRespond = NULL;
IMemBlock* piPackage = NULL;
KRole* pRole = g_pGameCenter->m_RoleManager.GetRole(dwSrcId);
PROCESS_ERROR(pRole);
piPackage = QCreateMemBlock(sizeof(R2S_SWAP_RANK_RESPOND));
pRespond = (R2S_SWAP_RANK_RESPOND*)piPackage->GetData();
LOG_PROCESS_ERROR(pRespond);
pRespond->wProtocolID = r2s_swap_rank_respond;
pRespond->nRankId = nRankId;
strcpy(pRespond->szSrcPlayerName, pRole->getName()); ;
pRespond->nSrcRank = nSrcRank;
pRespond->dwDestId = dwDestId;
pRespond->nDestRank = nDestRank;
pRespond->bSucceed = bSucceed;
bRetCode = Send(nConnIndex, piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = TRUE;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
BOOL KSndaAgency::DoTokenVerifyRequest(KPlayerAgency* pPlayer)
{
BOOL bResult = false;
#ifdef USE_SDOA
int nRetCode = 0;
const char* pszIP = NULL;
struct in_addr RemoteIP;
u_short uRemotePort;
assert(pPlayer);
LOG_PROCESS_ERROR(m_piUserInfoAuthen);
LOG_PROCESS_ERROR(pPlayer->piSocket);
nRetCode = pPlayer->piSocket->GetRemoteAddress(&RemoteIP, &uRemotePort);
LOG_PROCESS_ERROR(nRetCode);
pszIP = inet_ntoa(RemoteIP);
LOG_PROCESS_ERROR(pszIP);
nRetCode = m_piUserInfoAuthen->AsyncGetUserInfo(pPlayer->szSndaToken, pszIP, (unsigned long)pPlayer->nIndex);
if (nRetCode != 0)
{
QLogPrintf(LOG_DEBUG, "[SDOA] AsyncGetUserInfo failed! RetCode = %d", nRetCode);
goto EXIT0;
}
bResult = true;
EXIT0:
#endif // USE_SDOA
return bResult;
}
BOOL KPurseModule::ProcessProtocol(INT nPlayerIndex, LPCBYTE pbData, UINT uDataLen)
{
QCONFIRM_RET_FALSE(nPlayerIndex > 0);
QCONFIRM_RET_FALSE(pbData != NULL && uDataLen > 0);
KPlayer* pPlayer = g_cPlayerMgr.GetByIndex(nPlayerIndex);
QCONFIRM_RET_FALSE(NULL != pPlayer);
KPlayerPurse* pPlayerPurse = pPlayer->GetCtrl<KPlayerPurse>();
QCONFIRM_RET_FALSE(NULL != pPlayerPurse);
KPTC_HEADER_BASE *pData = (KPTC_HEADER_BASE*)pbData;
switch (pData->byProtocol)
{
case emPURSE_PTC_C2S_SYNC_AL_CHEMY:
KPlayer* pPlayer = g_cPlayerMgr.GetByIndex(nPlayerIndex);
LOG_PROCESS_ERROR(pPlayer);
KPlayerPurse* pPlayerPurse = pPlayer->GetCtrl<KPlayerPurse>();
LOG_PROCESS_ERROR(pPlayerPurse);
// ×ö³ö´ðÌâÑ¡Ôñ
C2S_PURSE_SYNC_AL_CHEMY* ptcAward = (C2S_PURSE_SYNC_AL_CHEMY*)pData;
pPlayerPurse->SyncBowlData(ptcAward->nRefresh);
break;
}
EXIT0:
return TRUE;
}
BOOL KSndaAgency::LoadConfig()
{
BOOL bResult = false;
BOOL bRetCode = false;
IIniFile* piIniFile = NULL;
piIniFile = g_OpenIniFile(GATEWAY_CONFIG_FILE);
LOG_PROCESS_ERROR(piIniFile);
m_bOpen = true;
bRetCode = piIniFile->IsSectionExist("SDOA");
if (!bRetCode)
{
m_bOpen = false;
goto EXIT1;
}
bRetCode = piIniFile->GetString("SDOA", "AdultIDCard", "not configed", m_szAdultIDCard, sizeof(m_szAdultIDCard));
LOG_PROCESS_ERROR(bRetCode);
EXIT1:
bResult = true;
EXIT0:
SAFE_RELEASE(piIniFile);
return bResult;
}
BOOL KQueueSlave::DoCreateOverallTeamRequest(INT nPlayerId, LPCTSTR szPlayerName, BYTE byPlayerLevel, BYTE byPlayerSex, INT nFightScore, INT nMapId, INT nRequireFightScore)
{
BOOL bResult = false;
BOOL bRetCode = false;
IMemBlock* piPackage = NULL;
R2M_OVERALL_CREATE_TEAM_REQUEST* pRequest = NULL;
INT nConnIndex = 0;
piPackage = QCreateMemBlock(sizeof(R2M_OVERALL_CREATE_TEAM_REQUEST));
LOG_PROCESS_ERROR(piPackage);
pRequest = (R2M_OVERALL_CREATE_TEAM_REQUEST*)piPackage->GetData();
LOG_PROCESS_ERROR(pRequest);
pRequest->wProtocolID = r2m_overall_create_team_request;
pRequest->nCreaterId = nPlayerId;
pRequest->nInstanceMapId = nMapId;
pRequest->nServerId = 1; // 先暂定为1，以后每个服一个编号
pRequest->nRequireFightScore = nRequireFightScore;
strncpy(pRequest->szPlayerName, szPlayerName, MAX_NAME_LEN);
pRequest->byCreaterLevel = byPlayerLevel;
pRequest->byCreaterSex = byPlayerSex;
pRequest->nCreaterFightScore = nFightScore;
bRetCode = Send(piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = true;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
void CMainFrame::OnCreateItemOnListView(wxCommandEvent& event)
{
wxString btnString = event.GetString();
/*if (btnString.Find(m_leftWindow->getSkillRootID().GetID()) == "")
{
}*/
wxString selText = wxT("");
LOG_PROCESS_ERROR (m_leftWindow && m_rightWindow);
wxTreeItemId selItem = m_leftWindow->GetSelection();
LOG_PROCESS_ERROR (selItem.IsOk());
if (selItem == m_leftWindow->getSkillRootID())
{
m_rightWindow->showGridPage(ECreateItemType_Skill, true);
}else if (selItem == m_leftWindow->getAuraRootID())
{
m_rightWindow->showGridPage(ECreateItemType_Aura);
}else if (selItem == m_leftWindow->getEotRootID())
{
m_rightWindow->showGridPage(ECreateItemType_Eot);
}
selText = m_leftWindow->GetItemText(selItem);
wxLogMessage(selText);
return;
Exit0:
return;
}
BOOL KQueueSlave::DoGetPlayerOverallTeamRequest(INT nPlayerId, DWORD dwLeaderCombinedIdx)
{
BOOL bResult = false;
BOOL bRetCode = false;
IMemBlock* piPackage = NULL;
R2M_GET_PLAYER_OVERALLTEAM_REQUEST* pRequest = NULL;
piPackage = QCreateMemBlock(sizeof(R2M_GET_PLAYER_OVERALLTEAM_REQUEST));
LOG_PROCESS_ERROR(piPackage);
pRequest = (R2M_GET_PLAYER_OVERALLTEAM_REQUEST*)piPackage->GetData();
LOG_PROCESS_ERROR(pRequest);
pRequest->wProtocolID = r2m_get_player_overallteam_request;
pRequest->nPlayerId = nPlayerId;
pRequest->dwLeaderCombinedIdx = dwLeaderCombinedIdx;
bRetCode = Send(piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = true;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
BOOL KQueueSlave::DoKickOverallPlayerRequest(DWORD dwLeaderCombinedIdx, DWORD dwMemberCombinedIdx)
{
BOOL bResult = false;
BOOL bRetCode = false;
IMemBlock* piPackage = NULL;
R2M_KICK_OVERALL_PLAYER_REQUEST* pRequest = NULL;
piPackage = QCreateMemBlock(sizeof(R2M_KICK_OVERALL_PLAYER_REQUEST));
LOG_PROCESS_ERROR(piPackage);
pRequest = (R2M_KICK_OVERALL_PLAYER_REQUEST*)piPackage->GetData();
LOG_PROCESS_ERROR(pRequest);
pRequest->wProtocolID = r2m_kick_player_request;
pRequest->dwLeaderCombinedIdx = dwLeaderCombinedIdx;
pRequest->dwMemberCombinedIdx = dwMemberCombinedIdx;
bRetCode = Send(piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = true;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
BOOL KQueueSlave::DoLeaveOverallTeamRequest(DWORD dwMemberCombinedIdx, DWORD dwLeaderCombinedIdx, BYTE byIsKick)
{
BOOL bResult = false;
BOOL bRetCode = false;
IMemBlock* piPackage = NULL;
R2M_OVERALL_LEAVE_TEAM_REQUEST* pRequest = NULL;
piPackage = QCreateMemBlock(sizeof(R2M_OVERALL_LEAVE_TEAM_REQUEST));
LOG_PROCESS_ERROR(piPackage);
pRequest = (R2M_OVERALL_LEAVE_TEAM_REQUEST*)piPackage->GetData();
LOG_PROCESS_ERROR(pRequest);
pRequest->wProtocolID = r2m_overall_leave_team_request;
pRequest->dwMemberCombinedIdx = dwMemberCombinedIdx;
pRequest->dwLeaderCombinedIdx = dwLeaderCombinedIdx;
pRequest->byIsKick = byIsKick;
bRetCode = Send(piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = true;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
BOOL KQueueSlave::DoMemberPrepareRequest(INT nMemberId, DWORD dwLeaderCombinedIdx, BYTE byPrepare)
{
BOOL bResult = false;
BOOL bRetCode = false;
IMemBlock* piPackage = NULL;
R2M_OVERALL_PREPARE_REQUEST* pRequest = NULL;
piPackage = QCreateMemBlock(sizeof(R2M_OVERALL_PREPARE_REQUEST));
LOG_PROCESS_ERROR(piPackage);
pRequest = (R2M_OVERALL_PREPARE_REQUEST*)piPackage->GetData();
LOG_PROCESS_ERROR(pRequest);
pRequest->wProtocolID = r2m_overall_team_prepare_request;
pRequest->nMemberId = nMemberId;
pRequest->dwLeaderCombinedIdx = dwLeaderCombinedIdx;
pRequest->byPrepare = byPrepare;
bRetCode = Send(piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = true;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
BOOL KQueueSlave::DoJoinOverallTeamRequest(INT nMemberId, LPCTSTR szMemberName, BYTE byMemberLevel, BYTE byMemberSex, INT nFightScore, INT nInstanceMapId, DWORD dwCombinedIdx)
{
BOOL bResult = false;
BOOL bRetCode = false;
IMemBlock* piPackage = NULL;
R2M_OVERALL_JOIN_TEAM_REQUEST* pRequest = NULL;
piPackage = QCreateMemBlock(sizeof(R2M_OVERALL_JOIN_TEAM_REQUEST));
LOG_PROCESS_ERROR(piPackage);
pRequest = (R2M_OVERALL_JOIN_TEAM_REQUEST*)piPackage->GetData();
LOG_PROCESS_ERROR(pRequest);
pRequest->wProtocolID = r2m_overall_join_team_request;
pRequest->nMemberId = nMemberId;
strncpy(pRequest->szMemberName, szMemberName, MAX_NAME_LEN);
pRequest->byMemberLevel = byMemberLevel;
pRequest->byMemberSex = byMemberSex;
pRequest->nMemberFightScore = nFightScore;
pRequest->nInstanceMapId = nInstanceMapId;
pRequest->dwCombinedIdx = dwCombinedIdx;
bRetCode = Send(piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = true;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
BOOL KRecordHandler::DoGetAllPurchaseRespond(INT nConnIndex, INT nShopId, INT nCategoryId, INT nGoodsId, INT nCount, INT nBuycount, DWORD dwRoleId)
{
BOOL bRetCode = FALSE;
BOOL bResult = FALSE;
R2S_BUY_ALL_PURCHASE_REQUEST* pRespond = NULL;
IMemBlock* piPackage = NULL;
piPackage = QCreateMemBlock(sizeof(R2S_BUY_ALL_PURCHASE_REQUEST));
pRespond = (R2S_BUY_ALL_PURCHASE_REQUEST*)piPackage->GetData();
LOG_PROCESS_ERROR(pRespond);
pRespond->wProtocolID = r2s_get_all_purchase_buy_respond;
pRespond->nShopId = nShopId;
pRespond->nCategoryId = nCategoryId;
pRespond->nGoodsId = nGoodsId;
pRespond->nCount = nCount;
pRespond->dwRoleId = dwRoleId;
pRespond->nBuyCount = nBuycount;
bRetCode = Send(nConnIndex, piPackage);
LOG_PROCESS_ERROR(bRetCode);
bResult = TRUE;
EXIT0:
SAFE_RELEASE(piPackage);
return bResult;
}
INT KNetConnectPlayer::OnClientLogin2( DWORD dwRoleId, const GUID& rConnGuid, INT nConnectId, BOOL bHidden /*= FALSE*/,BOOL bTinyTerminal)
{
INT nRetCode = FALSE;
KPlayer* pPlayer = NULL;
INT nPlayerIndex = 0;
pPlayer = g_cPlayerMgr.GetById(dwRoleId);
LOG_PROCESS_ERROR(pPlayer);
LOG_PROCESS_ERROR(pPlayer->GetGameState() == gsWaitForConnect);
LOG_PROCESS_ERROR(pPlayer->m_cPlayerServer.m_Guid == rConnGuid);
pPlayer->SetTinyTerminal(bTinyTerminal);
nPlayerIndex = pPlayer->GetPlayerIndex();
m_pnConnId2PlayerIndex[nConnectId] = nPlayerIndex;
m_pnPlayerIndex2ConnId[nPlayerIndex] = nConnectId;
m_mpAccount2Player[pPlayer->m_cPlayerServer.m_strAccount] = nPlayerIndex;
g_RelayClient.DoConfirmPlayerLoginRequest(dwRoleId);
pPlayer->SetGameState(gsWaitForPermit);
pPlayer->m_nTimer = 0;
nRetCode = TRUE;
EXIT0:
if (!nRetCode)
{
QLogPrintf(LOG_INFO, "Invalid Client: %d\n", nConnectId);
if (pPlayer)
QLogPrintf(LOG_INFO, "Player %d state %d\n", dwRoleId, pPlayer->GetGameState());
}
return nRetCode;
}
void QMailModule::OnQueryMailContent(KPlayer* pPlayer, char* pData, size_t uDataLen)
{
BOOL bRetCode = false;
KNpc* pNpc = NULL;
C2S_QUERY_MAIL_CONTENT* pPak = (C2S_QUERY_MAIL_CONTENT*)pData;
LOG_PROCESS_ERROR(pPlayer);
LOG_PROCESS_ERROR(pData);
LOG_PROCESS_ERROR(uDataLen == sizeof(C2S_QUERY_MAIL_CONTENT));
LOG_PROCESS_ERROR(pPak->dwMailID);
// if (pPak->byMailType != eMailType_GmMessage && pPak->byMailType != eMailType_PlayerMessage)
// {
// pNpc = 0; // TODO get by id(pPak->dwNpcID);
// LOG_PROCESS_ERROR(pNpc);
// //LOG_PROCESS_ERROR(pNpc is Mailbox);
//
// bRetCode = g_InRange(pPlayer, pNpc, COMMON_PLAYER_OPERATION_DISTANCE);
// LOG_PROCESS_ERROR(bRetCode);
// }
//
// PROCESS_ERROR(pPlayer->m_eMoveState == cmsOnStand);
bRetCode = MailRelayClient::DoQueryMailContent(pPlayer->m_dwId, pPak->dwMailID, pPak->byMailType);
LOG_PROCESS_ERROR(bRetCode);
EXIT0:
return;
}
BOOL QMailModule::DoGetMailListRespond( KPlayer* pPlayer, KMailListInfo* pMailListInfo, int nMailCount )
{
BOOL bRetCode = FALSE;
INT nMailListDataLen = 0;
S2C_GET_MAIL_LIST_RESPOND* pRespond = (S2C_GET_MAIL_LIST_RESPOND*)m_byTempData;
LOG_PROCESS_ERROR(pPlayer);
LOG_PROCESS_ERROR(pMailListInfo);
pRespond->byProtocol = s2c_get_mail_list_respond;
pRespond->byMailCount = nMailCount;
nMailListDataLen = sizeof(KMailListInfo) * nMailCount;
if (nMailListDataLen > 0)
{
memcpy(pRespond->MailListInfo, pMailListInfo, nMailListDataLen);
}
bRetCode = SendLenData(pPlayer->GetPlayerIndex(), *pRespond, sizeof(S2C_GET_MAIL_LIST_RESPOND) + nMailListDataLen);
LOG_PROCESS_ERROR(bRetCode);
bRetCode = TRUE;
EXIT0:
return bRetCode;
}
BOOL FactionManager::SetLevel( KCharacter& rcCharacter, WORD wOldValue, WORD wNewValue )
{
//QLogPrintf(LOG_INFO,"..FactionManager::SetLevel..");
BOOL bRetCode = FALSE;
PlayerFaction* playerFaction = NULL;
PROCESS_ERROR(rcCharacter.GetLevel() && wOldValue != wNewValue);
playerFaction = rcCharacter.GetCtrl<PlayerFaction>();
LOG_PROCESS_ERROR(playerFaction);
playerFaction->OnFactionRouteChange(rcCharacter.GetLevel(), rcCharacter.GetPrimaryFaction(), rcCharacter.GetCurrentRoute());
playerFaction->OnLevelChange(wOldValue, wNewValue);
if (wOldValue != 0 && wOldValue != wNewValue && wNewValue == ARENA_OPEN_LEVEL)
{
// 按战斗力加入竞技场排行榜
PlayerArena* pPlayerArena = rcCharacter.GetCtrl<PlayerArena>();
LOG_PROCESS_ERROR(pPlayerArena);
pPlayerArena->AddArenaRank();
}
g_cCharacterHelper.CalcFightScore(rcCharacter); // 这句话和上面的AddArenaRank顺序不能变，涉及到排名顺序问题
bRetCode = TRUE;
EXIT0:
return bRetCode;
}
BOOL TargetModule::ProcessProtocol(INT nPlayerIndex, LPCBYTE pbData, UINT uDataLen)
{
QCONFIRM_RET_FALSE(pbData);
KPTC_HEADER_BASE *pData = (KPTC_HEADER_BASE*)pbData;
PlayerTarget* pPlayerTarget = NULL;
KPlayer* pPlayer = g_cPlayerMgr.GetByIndex(nPlayerIndex);
LOG_PROCESS_ERROR(pPlayer);
pPlayerTarget = pPlayer->GetCtrl<PlayerTarget>();
LOG_PROCESS_ERROR(pPlayerTarget);
switch (pData->byProtocol)
{
case emTARGET_PTC_C2S_SYNC:
pPlayerTarget->SyncTarget();
break;
case emTARGET_PTC_C2S_GETAWARD:
TARGET_C2S_GETAWARD* ptcAward = (TARGET_C2S_GETAWARD*)pData;
pPlayerTarget->GetAward(ptcAward->nDay, ptcAward->nId);
break;
}
return TRUE;
EXIT0:
return FALSE;
}
INT KGC_CoordinatorClient::Send( IMemBlock* piBuffer )
{
INT nRet = FALSE;
LOG_PROCESS_ERROR(m_piSocket);
nRet = m_piSocket->Send(piBuffer);
LOG_PROCESS_ERROR(nRet);
EXIT0:
return nRet;
}
BOOL KSndaAgency::Init()
{
BOOL bResult = false;
int nRetCode = false;
#ifdef USE_SDOA
KSdoaCreateUserInfoAuthenFunc SdoaCreateUserInfoAuthen = NULL;
nRetCode = LoadConfig();
LOG_PROCESS_ERROR(nRetCode);
PROCESS_SUCCESS(!m_bOpen);
m_hSDOALibrary = KG_LoadLibrary(SDOA_DLL_FILE);
LOG_PROCESS_ERROR(m_hSDOALibrary);
SdoaCreateUserInfoAuthen = (KSdoaCreateUserInfoAuthenFunc)KG_GetProcessAddress(m_hSDOALibrary, "sdoaCreateUserInfoAuthen");
LOG_PROCESS_ERROR(SdoaCreateUserInfoAuthen);
m_piUserInfoAuthen = SdoaCreateUserInfoAuthen();
LOG_PROCESS_ERROR(m_piUserInfoAuthen);
nRetCode = m_piUserInfoAuthen->Initialize(SDOA_CONFIG_FILE, &SdoaUserInfoCallBackFunc);
if (nRetCode != 0)
{
QLogPrintf(LOG_DEBUG, "[SDOA] Initialize failed! RetCode = %d", nRetCode);
goto EXIT0;
}
#endif // USE_SDOA
EXIT1:
bResult = true;
EXIT0:
if (!bResult)
{
QThread_Sleep(10000);
#ifdef USE_SDOA
SAFE_RELEASE(m_piUserInfoAuthen);
if (m_hSDOALibrary)
{
KG_FreeLibrary(m_hSDOALibrary);
m_hSDOALibrary = NULL;
}
#endif // USE_SDOA
}
if (m_bOpen)
{
QLogPrintf(LOG_INFO, "[SDOA] Initialize %s!", bResult ? "succeed" : "failed");
}
return bResult;
}
BOOL KStageCtrl::OnTakeAward()
{
BOOL bResult = FALSE;
LOG_PROCESS_ERROR(sMopInfo.nState == emMopStateDone);
ResetMopInfo();
LOG_PROCESS_ERROR(SyncStageInfo());
bResult = TRUE;
EXIT0:
return bResult;
}
VOID KRecordHandler::OnSetBuyAllPurcaseRequest(BYTE* pbyData, size_t uDataLen, int nConnIndex)
{
S2R_BUY_ALL_PURCHASE_REQUEST* pRequest = (S2R_BUY_ALL_PURCHASE_REQUEST*)pbyData;
BOOL bResult = FALSE;
LOG_PROCESS_ERROR(pRequest);
bResult = g_pGameCenter->m_RecordManager.SetBuyAllPurchaseRequest(*pRequest);
LOG_PROCESS_ERROR(bResult);
g_pGameCenter->m_RecordManager.OnAllPurchaseRespond(nConnIndex, pRequest->nShopId, pRequest->nCategoryId, pRequest->nGoodsId, pRequest->nCount, pRequest->dwRoleId);
g_pGameCenter->m_RecordManager.OnBuyAllPurchaseRecordBroadcast();
EXIT0:
return;
}
void KRoleServerEyes::SendCustomInfo()
{
l2e_update_custom_info* pInfo = NULL;
size_t uStrLen = 0;
IMemBlock* piBuffer = NULL;
int nTotalAccounts = 0;
std::string strClusterStatics;
std::string strNameDbStatics;
time_t timeClock = m_nNextPingTime;
struct tm tmClock = *localtime(&timeClock);
nTotalAccounts = g_cAccountIndexing.TotalAccounts();
piBuffer = QCreateMemBlock(MAX_CUSTOM_INFO_PAK);
LOG_PROCESS_ERROR(piBuffer);
pInfo = (l2e_update_custom_info*)piBuffer->GetData();
LOG_PROCESS_ERROR(pInfo);
pInfo->wProtocol = l2e_header_def;
pInfo->wServer = 0;
pInfo->wSubProtocol = l2e_update_custom_info_def;
g_cDbClusterMgr.GetWorkStat(strClusterStatics);
g_cNameServerMgr.GetWorkStat(strNameDbStatics);
uStrLen = snprintf(
(char*)pInfo->byData, MAX_CUSTOM_INFO_PAK - sizeof(l2e_update_custom_info),
"-------------------------------------\n"
"Total Accounts .... ... ... %d\n"
"Last Ping .... ... ... .... %s"
"-------------------------------------\n"
"%s"
"-------------------------------------\n"
"%s",
nTotalAccounts,
asctime(&tmClock),
strClusterStatics.c_str(),
strNameDbStatics.c_str()
);
LOG_PROCESS_ERROR(uStrLen > 0);
LOG_PROCESS_ERROR(uStrLen < MAX_CUSTOM_INFO_PAK - sizeof(l2e_update_custom_info));
pInfo->uDataLen = uStrLen;
m_Stream.PutPack(pInfo, sizeof(l2e_update_custom_info) + uStrLen);
EXIT0:
SAFE_RELEASE(piBuffer);
return;
}
BOOL KStageCtrl::OnSpeedUp()
{
BOOL bResult = FALSE;
LOG_PROCESS_ERROR(sMopInfo.nState == emMopStateDoing);
sMopInfo.nLeftTime = sMopInfo.nLeftTime / 2;
sMopInfo.bSpeedUp = TRUE;
LOG_PROCESS_ERROR(SyncStageInfo());
bResult = TRUE;
EXIT0:
return bResult;
}
INT KAwardSetting::GetExpAwardPercent(INT nExpAwardId, INT nLevel)
{
INT nPercent = 0;
MAP_EXP_AWARD::iterator it_exp;
std::map<INT, MAP_EXP_AWARD>::iterator it = m_mapExpAwards.find(nExpAwardId);
LOG_PROCESS_ERROR(it != m_mapExpAwards.end());
it_exp = (it->second).find(nLevel);
LOG_PROCESS_ERROR(it_exp != (it->second).end());
nPercent = it_exp->second.nPercent;
EXIT0:
return nPercent;
}
BOOL KStageCtrl::StartMopStage(INT nMopTime)
{
BOOL bResult = FALSE;
LOG_PROCESS_ERROR(sMopInfo.nState == emMopStateNone);
sMopInfo.nState = emMopStateDoing;
sMopInfo.nLeftTime = nMopTime;
LOG_PROCESS_ERROR(SyncStageInfo());
bResult = TRUE;
EXIT0:
return bResult;
}
void QMailModule::OnReturnMail(KPlayer* pPlayer, char* pData, size_t uDataLen)
{
BOOL bRetCode = false;
C2S_RETURN_MAIL* pPak = (C2S_RETURN_MAIL*)pData;
LOG_PROCESS_ERROR(pPlayer);
LOG_PROCESS_ERROR(pData);
LOG_PROCESS_ERROR(uDataLen == sizeof(C2S_RETURN_MAIL));
bRetCode = MailRelayClient::DoReturnMail(pPlayer->m_dwId, pPak->dwMailID);
PROCESS_ERROR(bRetCode);
EXIT0:
return;
}
void QMailModule::OnSetMailRead(KPlayer* pPlayer, char* pData, size_t uDataLen)
{
BOOL bRetCode = false;
C2S_SET_MAIL_READ* pPak = (C2S_SET_MAIL_READ*)pData;
LOG_PROCESS_ERROR(pPlayer);
LOG_PROCESS_ERROR(pData);
LOG_PROCESS_ERROR(uDataLen == sizeof(C2S_SET_MAIL_READ));
bRetCode = MailRelayClient::DoSetMailRead(pPlayer->m_dwId, pPak->dwMailID);
LOG_PROCESS_ERROR(bRetCode);
EXIT0:
return;
}
BOOL AwardLobbyModule::c2sOnSignedInRequest(KPlayer* pPlayer, LPCBYTE pProtocol, UINT uDataLen)
{
BOOL bResult = FALSE;
PlayerAwardLobby* pAwardLobby = NULL;
KC2S_SIGNED_IN_REQUEST* pRequest = (KC2S_SIGNED_IN_REQUEST*)pProtocol;
pAwardLobby = pPlayer->GetCtrl<PlayerAwardLobby>();
LOG_PROCESS_ERROR(pAwardLobby);
LOG_PROCESS_ERROR(pAwardLobby->PlayerSignedIn(pRequest->nDay));
bResult = TRUE;
EXIT0:
return bResult;
}
