bool CPlayerManager::onCrossServerRequestRet(stMsgCrossServerRequestRet* pResult,Json::Value* vJsValue)
{
if ( eCrossSvrReq_SelectTakeIn == pResult->nRequestType && eCrossSvrReqSub_SelectPlayerData == pResult->nRequestSubType )
{
stMsgRequestPlayerDataRet msgBack ;
msgBack.nRet = 0 ;
msgBack.isDetail = pResult->vArg[3] ;
CPlayer* pPlayer = GetPlayerByUserUID(pResult->vArg[0]);
if ( pPlayer == nullptr )
{
CLogMgr::SharedLogMgr()->ErrorLog("why this player is null , can not , funck!") ;
return true ;
}
stPlayerDetailDataClient stData ;
stData.nCurrentRoomID = 0 ;
CAutoBuffer auB (sizeof(msgBack) + sizeof(stPlayerDetailDataClient));
if ( pPlayer )
{
CPlayerTaxas* pTaxasData = (CPlayerTaxas*)pPlayer->GetComponent(ePlayerComponent_PlayerTaxas);
stData.nCurrentRoomID = pResult->nReqOrigID;
if ( msgBack.isDetail )
{
pPlayer->GetBaseData()->GetPlayerDetailData(&stData);
pTaxasData->getTaxasData(&stData.tTaxasData);
if ( vJsValue )
{
stData.tTaxasData.nPlayTimes += (*vJsValue)["playTimes"].asUInt();
stData.tTaxasData.nWinTimes += (*vJsValue)["winTimes"].asUInt();
stData.tTaxasData.nSingleWinMost = (*vJsValue)["singleMost"].asUInt() < stData.tTaxasData.nSingleWinMost ? stData.tTaxasData.nSingleWinMost : (*vJsValue)["singleMost"].asUInt();
}
else
{
CLogMgr::SharedLogMgr()->PrintLog("targe player not sit down uid = %llu",pResult->vArg[0]);
}
}
else
{
pPlayer->GetBaseData()->GetPlayerBrifData(&stData) ;
}
if ( pResult->vArg[1] )
{
stData.nCoin += pResult->vArg[2] ;
}
else
{
stData.nDiamoned += pResult->vArg[2] ;
}
stData.nCurrentRoomID = pResult->nReqOrigID;
auB.addContent(&msgBack,sizeof(msgBack));
auB.addContent(&stData,msgBack.isDetail ? sizeof(stPlayerDetailDataClient) : sizeof(stPlayerBrifData) ) ;
CGameServerApp::SharedGameServerApp()->sendMsg(pResult->nTargetID,auB.getBufferPtr(),auB.getContentSize()) ;
CLogMgr::SharedLogMgr()->PrintLog("select take in ret , send player data");
return true ;
}
return true ;
}
return false ;
}
bool CPlayerFriend::OnMessage(stMsg* pMsg, eMsgPort eSenderPort )
{
switch ( pMsg->usMsgType )
{
case MSG_READ_FRIEND_LIST:
{
stMsgReadFriendListRet* pRet = (stMsgReadFriendListRet*)pMsg ;
char* pBuffer = (char*)&pRet;
pBuffer += sizeof(stMsgReadFriendListRet);
if ( pRet->nFriendCountLen )
{
Json::Reader reader ;
Json::Value arrayValue ;
reader.parse(pBuffer,pBuffer + pRet->nFriendCountLen,arrayValue,false);
for ( uint16_t nIdx = 0 ; nIdx < arrayValue.size(); ++nIdx )
{
m_vAllFriends.insert(arrayValue[nIdx].asUInt());
}
}
LOGFMTD("read friend list ok uid = %d",GetPlayer()->GetUserUID());
}
break;
case MSG_REQUEST_FRIEND_LIST:
{
SendListToClient();
}
break;
case MSG_PLAYER_ADD_FRIEND:
{
stMsgPlayerAddFriend* pMsgRet = (stMsgPlayerAddFriend*)pMsg ;
CPlayer* pTargetPlayer = CGameServerApp::SharedGameServerApp()->GetPlayerMgr()->GetPlayerByUserUID(pMsgRet->nTargetUID,false) ;
stMsgPlayerAddFriendRet msg ;
msg.nRet = 0 ;
msg.nTaregtUID = pMsgRet->nTargetUID ;
memset(msg.pReplayerName,0,sizeof(msg.pReplayerName));
if ( pTargetPlayer )
{
sprintf_s(msg.pReplayerName,sizeof(msg.pReplayerName),"%s",pTargetPlayer->GetBaseData()->GetPlayerName()) ;
}
if ( IsFriendListFull() )
{
msg.nRet = 2 ;
LOGFMTD("friend list is full, can not add");
}
else if ( isPlayerUIDFriend(pMsgRet->nTargetUID) )
{
msg.nRet = 5 ;
LOGFMTD("already your friend , can not add");
}
else if ( pTargetPlayer == nullptr )
{
msg.nRet = 4 ;
}
else
{
CPlayerFriend* pTaretFriendModule = (CPlayerFriend*)pTargetPlayer->GetComponent(ePlayerComponent_Friend);
if ( pTaretFriendModule->IsFriendListFull() )
{
msg.nRet = 3 ;
}
else
{
pTaretFriendModule->OnPlayerWantAddMe(this);
}
}
if ( msg.nRet )
{
SendMsg(&msg,sizeof(msg)) ;
}
}
break;
case MSG_PLAYER_BE_ADDED_FRIEND_REPLY:
{
stMsgPlayerBeAddedFriendReply* pMsgRet = (stMsgPlayerBeAddedFriendReply*)pMsg ;
CPlayer* pReplyToPlayer = CGameServerApp::SharedGameServerApp()->GetPlayerMgr()->GetPlayerByUserUID(pMsgRet->nReplayToPlayerUserUID) ;
CPlayerFriend* pReplyToFriendComponed = NULL;
stMsgPlayerBeAddedFriendReplyRet msgBack ;
msgBack.nNewFriendUserUID = pMsgRet->nReplayToPlayerUserUID ;
msgBack.nRet = 0 ;
if ( pReplyToPlayer )
{
pReplyToFriendComponed = (CPlayerFriend*)pReplyToPlayer->GetComponent(ePlayerComponent_Friend) ;
}
if ( pReplyToFriendComponed )
{
if ( IsFriendListFull() )
{
msgBack.nRet = 2 ;
}
if ( msgBack.nRet == 0 && pReplyToFriendComponed->IsFriendListFull() )
{
msgBack.nRet = 1 ;
}
if ( pMsgRet->bAgree && msgBack.nRet == 0 )
{
AddFriend(pMsgRet->nReplayToPlayerUserUID) ;
}
pReplyToFriendComponed->OnOtherReplayMeAboutAddItbeFriend(pMsgRet->bAgree,this);
}
else
{
LOGFMTE("%d uid offline can not reply add friend ",pMsgRet->nReplayToPlayerUserUID);
msgBack.nRet = 3 ;
}
if ( pMsgRet->bAgree )
{
SendMsg(&msgBack,sizeof(msgBack)) ;
LOGFMTD("uid = %u msg type = stMsgPlayerBeAddedFriendReplyRet, typeid = %s",GetPlayer()->GetUserUID(),typeid(stMsgPlayerBeAddedFriendReplyRet)) ;
}
}
break;
case MSG_PLAYER_DELETE_FRIEND:
{
stMsgPlayerDelteFriendRet msgBack ;
msgBack.nRet = 0 ;
stMsgPlayerDelteFriend* pMsgRet = (stMsgPlayerDelteFriend*)pMsg ;
msgBack.nDeleteUID = pMsgRet->nDelteFriendUserUID ;
if ( isPlayerUIDFriend(pMsgRet->nDelteFriendUserUID) == false )
{
msgBack.nRet = 1 ;
}
else
{
RemoveFriendByUID(pMsgRet->nDelteFriendUserUID) ;
}
SendMsg(&msgBack,sizeof(msgBack));
CPlayer* pReplyToPlayer = CGameServerApp::SharedGameServerApp()->GetPlayerMgr()->GetPlayerByUserUID(msgBack.nDeleteUID) ;
CPlayerFriend* pReplyToFriendComponed = NULL;
if ( pReplyToPlayer )
{
pReplyToFriendComponed = (CPlayerFriend*)pReplyToPlayer->GetComponent(ePlayerComponent_Friend) ;
pReplyToFriendComponed->RemoveFriendByUID(GetPlayer()->GetUserUID()) ;
}
else
{
LOGFMTE("no online tell mail to delete friend");
}
}
break;
default:
return false ;
}
return true ;
}
bool CPlayerManager::ProcessTaxasServerMsg( stMsg* prealMsg , eMsgPort eSenderPort , uint32_t nRoomID )
{
if ( eSenderPort != ID_MSG_PORT_TAXAS )
{
return false ;
}
switch ( prealMsg->usMsgType )
{
case MSG_TP_REQUEST_PLAYER_DATA:
{
stMsgRequestTaxasPlayerData* pData = (stMsgRequestTaxasPlayerData*)prealMsg;
stMsgRequestTaxasPlayerDataRet msgBack ;
msgBack.nRoomID = nRoomID ;
msgBack.nRet = 0 ;
CPlayer* pPlayer = GetPlayerBySessionID(pData->nSessionID) ;
if ( pPlayer == NULL )
{
msgBack.nRet = 1 ;
CGameServerApp::SharedGameServerApp()->SendMsg(pData->nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
CLogMgr::SharedLogMgr()->ErrorLog("why can not find player session from taxas server session id = %d",pData->nSessionID ) ;
return true ;
}
if ( pPlayer->GetTaxasRoomID() )
{
msgBack.nRet = 2 ;
CGameServerApp::SharedGameServerApp()->SendMsg(pData->nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
CLogMgr::SharedLogMgr()->ErrorLog("can not enter room already in other room id = %d session id = %d",pPlayer->GetTaxasRoomID(),pData->nSessionID ) ;
// may have error order leave
stMsgOrderTaxasPlayerLeave msg ;
msg.nRoomID = pPlayer->GetTaxasRoomID() ;
CGameServerApp::SharedGameServerApp()->SendMsg(pPlayer->GetSessionID(),(char*)&msg,sizeof(msg)) ;
return true ;
}
msgBack.tData.nPhotoID = pPlayer->GetBaseData()->GetPhotoID();
memset(msgBack.tData.cName,0,sizeof(msgBack.tData.cName) );
sprintf_s(msgBack.tData.cName,sizeof(msgBack.tData.cName),"%s",pPlayer->GetBaseData()->GetPlayerName()) ;
msgBack.tData.nSessionID = pData->nSessionID ;
msgBack.tData.nSex = pPlayer->GetBaseData()->GetSex();
msgBack.tData.nUserUID = pPlayer->GetUserUID();
msgBack.tData.nVipLevel = pPlayer->GetBaseData()->GetVipLevel() ;
CGameServerApp::SharedGameServerApp()->SendMsg(pData->nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
pPlayer->SetStayInTaxasRoomID(nRoomID) ;
}
break;
case MSG_TP_REQUEST_TAKE_IN_MONEY:
{
stMsgRequestTaxasPlayerTakeInCoin* pRet = (stMsgRequestTaxasPlayerTakeInCoin*)prealMsg ;
stMsgRequestTaxasPlayerTakeInCoinRet msgBack ;
CPlayer* pPlayer = GetPlayerBySessionID(pRet->nPlayerSessionID ) ;
if ( pPlayer == NULL )
{
msgBack.nRet = 2 ;
CGameServerApp::SharedGameServerApp()->SendMsg(pRet->nPlayerSessionID,(char*)&msgBack,sizeof(msgBack)) ;
CLogMgr::SharedLogMgr()->ErrorLog("MSG_TP_REQUEST_TAKE_IN_MONEY why can not find player session from taxas server session id = %d",pRet->nPlayerSessionID ) ;
return true ;
}
if ( pPlayer->GetBaseData()->SetTakeInCoin(pRet->nMoneyToTakeIn,pRet->bIsDiamond) )
{
msgBack.nRet = 0 ;
msgBack.nMoneyToTakeIn = pRet->nMoneyToTakeIn ;
msgBack.nRoomID = nRoomID ;
msgBack.nSeatIdx = pRet->nSeatIdx ;
msgBack.bIsDiamond = pRet->bIsDiamond ;
CGameServerApp::SharedGameServerApp()->SendMsg(pRet->nPlayerSessionID,(char*)&msgBack,sizeof(msgBack)) ;
}
else
{
msgBack.nRet = 1 ;
CGameServerApp::SharedGameServerApp()->SendMsg(pRet->nPlayerSessionID,(char*)&msgBack,sizeof(msgBack)) ;
}
}
break;
case MSG_TP_INFORM_STAND_UP:
{
stMsgInformTaxasPlayerStandUp* pRet = (stMsgInformTaxasPlayerStandUp*)prealMsg ;
CPlayer* pPlayer = NULL ;
if ( pRet->nUserUID )
{
pPlayer = GetPlayerByUserUID(pRet->nUserUID ) ;
}
else
{
pPlayer = GetPlayerBySessionID(pRet->nSessionID ) ;
}
if ( pPlayer == NULL )
{
CLogMgr::SharedLogMgr()->ErrorLog("MSG_TP_INFORM_STAND_UP why can not find player uid from taxas server uid = %d",pRet->nSessionID ) ;
return true ;
}
if ( pPlayer )
{
pPlayer->GetBaseData()->CacluateTaxasRoomMoney(pRet->nTakeInMoney,pRet->bIsDiamond) ;
}
}
break;
case MSG_TP_INFORM_LEAVE:
{
stMsgInformTaxasPlayerLeave* pRet = (stMsgInformTaxasPlayerLeave*)prealMsg ;
CPlayer* pPlayer = GetPlayerByUserUID(pRet->nUserUID) ;
if ( pPlayer == NULL )
{
CLogMgr::SharedLogMgr()->ErrorLog("MSG_TP_INFORM_LEAVE why can not find player uid from taxas server uid = %d",pRet->nUserUID ) ;
return true ;
}
pPlayer->SetStayInTaxasRoomID(0) ;
}
break;
default:
return false ;
}
return true ;
}
bool CPokerCircle::onMessage(stMsg* prealMsg , eMsgPort eSenderPort , uint32_t nSessionID)
{
switch ( prealMsg->usMsgType )
{
case MSG_CIRCLE_READ_TOPICS:
{
stMsgReadCircleTopicsRet* pRet = (stMsgReadCircleTopicsRet*)prealMsg ;
stCircleTopicItem* pItem = (stCircleTopicItem*)(((char*)prealMsg) + sizeof(stMsgReadCircleTopicsRet));
while ( pRet->nCnt-- )
{
stTopicDetail* pDetail = new stTopicDetail ;
pDetail->nAuthorUID = pItem->nAuthorUID ;
pDetail->nPublishTime = pItem->nPublishTime ;
pDetail->nTopicID = pItem->nTopicID ;
char* pContent = (char*)pItem;
pContent = pContent + sizeof(stCircleTopicItem);
pDetail->strContent.append(pContent,pItem->nContentLen) ;
m_vListTopics.push_back(pDetail);
pContent = pContent + pItem->nContentLen ;
pItem = (stCircleTopicItem*)pContent ;
if ( pDetail->nTopicID > m_nMaxTopicUID )
{
m_nMaxTopicUID = pDetail->nTopicID ;
}
//LOGFMTI("read topic id = %d , content: %s",pDetail->nTopicID,pDetail->strContent.c_str()) ;
std::sort(m_vListTopics.begin(),m_vListTopics.end(),TopicSort);
}
}
break;
case MSG_CIRCLE_PUBLISH_TOPIC:
{
stMsgPublishTopicRet msgBack ;
stMsgPublishTopic* pRet = (stMsgPublishTopic*)prealMsg ;
CPlayer* pPlayer = CGameServerApp::SharedGameServerApp()->GetPlayerMgr()->GetPlayerBySessionID(nSessionID);
if ( pRet->nContentLen >= MAX_CIRCLE_CONTENT_LEN || pRet->nContentLen < 8 )
{
msgBack.nRet = 2 ;
msgBack.nTopicID = 0 ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
return true ;
}
//if ( pPlayer->GetBaseData()->GetData()->isRegister == 0 )
//{
// msgBack.nRet = 3 ;
// msgBack.nTopicID = 0 ;
// CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
// return true ;
//}
if ( pPlayer->GetBaseData()->GetAllCoin() < 200 )
{
msgBack.nRet = 1 ;
msgBack.nTopicID = 0 ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
return true ;
}
pPlayer->GetBaseData()->decressMoney(200);
stTopicDetail* pDetail = new stTopicDetail ;
pDetail->nAuthorUID = pPlayer->GetUserUID() ;
pDetail->nPublishTime = time(nullptr) ;
pDetail->nTopicID = ++m_nMaxTopicUID ;
pDetail->strContent.append(((char*)prealMsg) + sizeof(stMsgPublishTopic),pRet->nContentLen) ;
LOGFMTD("recive content = %s",pDetail->strContent.c_str()) ;
m_vListTopics.push_back(pDetail);
msgBack.nRet = 0 ;
msgBack.nTopicID = pDetail->nTopicID ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
stMsgSaveAddCircleTopic msgAdd ;
msgAdd.item.nAuthorUID = pDetail->nAuthorUID ;
msgAdd.item.nPublishTime = pDetail->nPublishTime ;
msgAdd.item.nTopicID = pDetail->nTopicID ;
msgAdd.item.nContentLen = pDetail->strContent.size() ;
CAutoBuffer auAddTopic(sizeof(msgAdd) + msgAdd.item.nContentLen );
auAddTopic.addContent(&msgAdd,sizeof(msgAdd)) ;
auAddTopic.addContent(pDetail->strContent.c_str(),msgAdd.item.nContentLen) ;
CGameServerApp::SharedGameServerApp()->sendMsg(0,auAddTopic.getBufferPtr(),auAddTopic.getContentSize()) ;
}
break;
case MSG_CIRCLE_DELETE_TOPIC:
{
stMsgDeleteTopic* pDelete = (stMsgDeleteTopic*)prealMsg ;
CPlayer* pPlayer = CGameServerApp::SharedGameServerApp()->GetPlayerMgr()->GetPlayerBySessionID(nSessionID);
if ( pPlayer->GetUserUID() != MATCH_MGR_UID )
{
return true ;
}
auto iter = m_vListTopics.begin() ;
for ( ; iter != m_vListTopics.end() ; ++iter )
{
if ( (*iter)->nTopicID == pDelete->nDelTopicID )
{
delete (*iter) ;
(*iter) = nullptr ;
m_vListTopics.erase(iter) ;
stMsgSaveDeleteCircleTopic msgDel ;
msgDel.nTopicID = pDelete->nDelTopicID ;
CGameServerApp::SharedGameServerApp()->sendMsg(0,(char*)&msgDel,sizeof(msgDel)) ;
return true ;
}
}
}
break;
case MSG_CIRCLE_REQUEST_TOPIC_LIST:
{
stMsgRequestTopicList* pRet = (stMsgRequestTopicList*)prealMsg ;
stMsgRequestTopicListRet msgBack ;
msgBack.nRet = 0 ;
msgBack.nPageIdx = pRet->nPageIdx ;
msgBack.nTotalPageCnt = ( m_vListTopics.size() + CIRCLE_TOPIC_CNT_PER_PAGE - 1 ) / CIRCLE_TOPIC_CNT_PER_PAGE ;
memset(msgBack.vTopicIDs,0,sizeof(msgBack.vTopicIDs)) ;
if ( pRet->nPageIdx >= msgBack.nTotalPageCnt )
{
msgBack.nRet = 1 ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
return true ;
}
LOGFMTI("page idx = %d",pRet->nPageIdx);
uint64_t nStartIdx = pRet->nPageIdx * CIRCLE_TOPIC_CNT_PER_PAGE ;
for ( uint8_t nIdx =0 ; nStartIdx < m_vListTopics.size() && nIdx < CIRCLE_TOPIC_CNT_PER_PAGE ; ++nStartIdx, ++nIdx )
{
uint64_t nReverIdx = m_vListTopics.size() - 1 - nStartIdx ;
msgBack.vTopicIDs[nIdx] = m_vListTopics[nReverIdx]->nTopicID ;
LOGFMTI("topic array idx = %d ,id = %I64d",nIdx,msgBack.vTopicIDs[nIdx]) ;
}
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
}
break;
case MSG_CIRCLE_REQUEST_TOPIC_DETAIL:
{
stMsgRequestTopicDetail* pRet = (stMsgRequestTopicDetail*)prealMsg ;
auto topic = getTopicByID(pRet->nTopicID) ;
stMsgRequestTopicDetailRet msgBack ;
msgBack.nRet = 0 ;
if ( topic == nullptr )
{
msgBack.nRet = 1 ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgBack,sizeof(msgBack)) ;
return true ;
}
msgBack.nAuthorUID = topic->nAuthorUID ;
msgBack.nPublishTime = topic->nPublishTime ;
msgBack.nTopicID = topic->nTopicID ;
msgBack.nContentLen = topic->strContent.size() ;
CAutoBuffer aubuff(sizeof(msgBack) + msgBack.nContentLen );
aubuff.addContent(&msgBack,sizeof(msgBack)) ;
aubuff.addContent(topic->strContent.c_str(),msgBack.nContentLen) ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,aubuff.getBufferPtr(),aubuff.getContentSize()) ;
LOGFMTD("send content = %s",topic->strContent.c_str()) ;
}
break;
default:
return false;
}
return true ;
}
void CRobotManager::OrderRobotToRoom()
{
if ( m_vRoomsRequestRobots.empty() || m_vIdleRobotPlayers.empty() )
{
return ;
}
LIST_ROOMS::iterator iter = m_vRoomsRequestRobots.begin() ;
while ( iter != m_vRoomsRequestRobots.end() && m_vIdleRobotPlayers.empty() == false )
{
stRequestRobotRoom* stR = &(*iter);
CRoomBaseNew* pRoom = CGameServerApp::SharedGameServerApp()->GetRoomMgr()->GetRoom(stR->nRoomType,stR->cLevel,stR->nRoomID) ;
if ( pRoom == NULL )
{
CLogMgr::SharedLogMgr()->ErrorLog("why room is NULL , reclyed ?") ;
}
// check if need robot ;
if ( pRoom == NULL || (MIN_PEERS_IN_ROOM_ROBOT - pRoom->GetData()->GetPlayingSeatCnt()) <= 0 )
{
m_vRoomsRequestRobots.erase(iter) ;
iter = m_vRoomsRequestRobots.begin();
continue;
}
// avoid more than once add robot to room ;
// real put robot in that room ;
LIST_ROBOT_PLAYERS::iterator iter_Robot = m_vIdleRobotPlayers.begin() ;
for ( ; iter_Robot != m_vIdleRobotPlayers.end() ; )
{
CPlayer* pRobot = *iter_Robot ;
if ( pRobot && pRobot->GetState() == CPlayer::ePlayerState_Free && (pRoom->CheckCanJoinThisRoom(pRobot) == 0) && pRobot->GetBaseData()->GetAllCoin() >= pRoom->GetAntesCoin() )
{
// send msg tell to enter this room ;
stMsgRobotOrderToEnterRoom msgEnter ;
msgEnter.cLevel = stR->cLevel;
msgEnter.nRoomID = stR->nRoomID ;
msgEnter.nRoomType = stR->nRoomType ;
pRobot->SendMsgToClient((char*)&msgEnter,sizeof(msgEnter)) ;
stR->nLackRobotCnt-- ;
m_vIdleRobotPlayers.erase(iter_Robot) ;
iter_Robot = m_vIdleRobotPlayers.begin() ;
if ( stR->nLackRobotCnt <= 0 )
{
break;;
}
continue;
}
++iter_Robot ;
}
// go to next room ;
if ( stR->nLackRobotCnt <= 0 )
{
m_vRoomsRequestRobots.erase(iter) ;
iter = m_vRoomsRequestRobots.begin();
continue;
}
++iter ;
}
}
bool CPlayerManager::ProcessPublicMessage( stMsg* prealMsg , eMsgPort eSenderPort , uint32_t nSessionID )
{
switch ( prealMsg->usMsgType )
{
case MSG_CROSS_SERVER_REQUEST:
{
stMsgCrossServerRequest* pRet = (stMsgCrossServerRequest*)prealMsg ;
Json::Value* pJsValue = nullptr ;
Json::Value rootValue ;
if ( pRet->nJsonsLen )
{
Json::Reader reader;
char* pstr = ((char*)&pRet->nJsonsLen) + sizeof(pRet->nJsonsLen) ;
reader.parse(pstr,pstr + pRet->nJsonsLen,rootValue,false);
pJsValue = &rootValue ;
}
if ( onCrossServerRequest(pRet,eSenderPort,pJsValue) == false )
{
CPlayer* pPlayer = GetPlayerByUserUID(pRet->nTargetID);
assert(pPlayer&&"this request no one to process or target id error");
if ( pPlayer && pPlayer->onCrossServerRequest(pRet,eSenderPort,pJsValue) )
{
return true ;
}
CLogMgr::SharedLogMgr()->ErrorLog("cross request type = %d , subType = %d ,unprocessed",pRet->nRequestType,pRet->nRequestSubType);
return false;
}
return true ;
}
break;
case MSG_CROSS_SERVER_REQUEST_RET:
{
stMsgCrossServerRequestRet* pRet = (stMsgCrossServerRequestRet*)prealMsg ;
Json::Value* pJsValue = nullptr ;
Json::Value rootValue ;
if ( pRet->nJsonsLen )
{
Json::Reader reader;
char* pstr = ((char*)&pRet->nJsonsLen) + sizeof(pRet->nJsonsLen) ;
reader.parse(pstr,pstr + pRet->nJsonsLen,rootValue,false);
pJsValue = &rootValue ;
}
if ( onCrossServerRequestRet(pRet,pJsValue) == false )
{
CPlayer* pPlayer = GetPlayerByUserUID(pRet->nTargetID);
assert(pPlayer&&"this request no one to process or target id error");
if ( pPlayer && pPlayer->onCrossServerRequestRet(pRet,pJsValue) )
{
return true ;
}
CLogMgr::SharedLogMgr()->ErrorLog("cross request result type = %d , subType = %d ,unprocessed",pRet->nRequestType,pRet->nRequestSubType);
return false;
}
return true ;
}
break;
case MSG_REQUEST_PLAYER_DATA:
{
stMsgRequestPlayerData* pRet = (stMsgRequestPlayerData*)prealMsg ;
stMsgRequestPlayerDataRet msgBack ;
msgBack.nRet = 0 ;
msgBack.isDetail = pRet->isDetail ;
CPlayer* pPlayer = GetPlayerByUserUID(pRet->nPlayerUID);
stPlayerDetailDataClient stData ;
stData.nCurrentRoomID = 0 ;
CAutoBuffer auB (sizeof(msgBack) + sizeof(stPlayerDetailData));
if ( pPlayer )
{
CPlayerTaxas* pTaxasData = (CPlayerTaxas*)pPlayer->GetComponent(ePlayerComponent_PlayerTaxas);
stData.nCurrentRoomID = pTaxasData->getCurRoomID() ;
if ( stData.nCurrentRoomID ) // select take in
{
stMsgCrossServerRequest msgReq ;
msgReq.nJsonsLen = 0 ;
msgReq.nReqOrigID = nSessionID ;
msgReq.nRequestSubType = eCrossSvrReqSub_SelectPlayerData ;
msgReq.nRequestType = eCrossSvrReq_SelectTakeIn ;
msgReq.nTargetID = stData.nCurrentRoomID ;
msgReq.cSysIdentifer = ID_MSG_PORT_TAXAS ;
msgReq.vArg[0] = pRet->nPlayerUID;
msgReq.vArg[1] = pRet->isDetail ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgReq,sizeof(msgReq)) ;
CLogMgr::SharedLogMgr()->PrintLog("select take in for player detail") ;
return true ;
}
if ( pRet->isDetail )
{
pPlayer->GetBaseData()->GetPlayerDetailData(&stData);
pTaxasData->getTaxasData(&stData.tTaxasData);
}
else
{
pPlayer->GetBaseData()->GetPlayerBrifData(&stData) ;
}
auB.addContent(&msgBack,sizeof(msgBack));
auB.addContent(&stData,pRet->isDetail ? sizeof(stPlayerDetailDataClient) : sizeof(stPlayerBrifData) ) ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,auB.getBufferPtr(),auB.getContentSize()) ;
return true ;
}
if ( m_tPlayerDataCaher.getPlayerData(pRet->nPlayerUID,&stData,pRet->isDetail) )
{
auB.addContent(&msgBack,sizeof(msgBack));
auB.addContent(&stData,pRet->isDetail ? sizeof(stPlayerDetailDataClient) : sizeof(stPlayerBrifData) ) ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,auB.getBufferPtr(),auB.getContentSize()) ;
CLogMgr::SharedLogMgr()->PrintLog("get player data from cahe") ;
return true ;
}
CLogMgr::SharedLogMgr()->PrintLog("req detail player not online , req from db target uid = %u",pRet->nPlayerUID) ;
stMsgSelectPlayerData msgReq ;
msgReq.isDetail = pRet->isDetail ;
msgReq.nReqPlayerSessionID = nSessionID ;
msgReq.nTargetPlayerUID = pRet->nPlayerUID ;
CGameServerApp::SharedGameServerApp()->sendMsg(nSessionID,(char*)&msgReq,sizeof(msgReq)) ;
}
break;
case MSG_SELECT_DB_PLAYER_DATA:
{
stMsgSelectPlayerDataRet* pRet = (stMsgSelectPlayerDataRet*)prealMsg ;
stMsgRequestPlayerDataRet msgBack ;
msgBack.nRet = pRet->nRet ;
msgBack.isDetail = pRet->isDetail ;
if ( pRet->nRet )
{
CGameServerApp::SharedGameServerApp()->sendMsg(pRet->nReqPlayerSessionID,(char*)&msgBack,sizeof(msgBack)) ;
}
else
{
m_tPlayerDataCaher.cachePlayerData(pRet);
CAutoBuffer auB (sizeof(msgBack) + sizeof(stPlayerDetailDataClient));
auB.addContent(&msgBack,sizeof(msgBack));
uint16_t nLen = pRet->isDetail ? sizeof(stPlayerDetailDataClient) : sizeof(stPlayerBrifData) ;
auB.addContent((char*)prealMsg + sizeof(stMsgSelectPlayerDataRet),nLen );
CGameServerApp::SharedGameServerApp()->sendMsg(pRet->nReqPlayerSessionID,auB.getBufferPtr(),auB.getContentSize()) ;
}
CLogMgr::SharedLogMgr()->PrintLog("session id = %d req play data ret = %d",pRet->nReqPlayerSessionID,pRet->nRet ) ;
}
break;
case MSG_PLAYER_LOGIN:
{
stMsgOnPlayerLogin* pmsgenter = (stMsgOnPlayerLogin*)prealMsg ;
CPlayer* pPlayer = GetPlayerBySessionID(nSessionID) ;
if ( pPlayer != NULL && pPlayer->GetUserUID() == pmsgenter->nUserUID )
{
CLogMgr::SharedLogMgr()->ErrorLog("double nSession, this nSessionID already have player, already login , do not login again id = %d? ",nSessionID) ;
return true ;
}
if ( pPlayer != NULL && pPlayer->GetUserUID() != pmsgenter->nUserUID ) // switch account in main scene
{
// disconnect pre player
OnPlayerOffline(pPlayer);
}
if ( ProcessIsAlreadyLogin(pmsgenter->nUserUID,nSessionID) )
{
return true ;
}
// is offline peer
MAP_UID_PLAYERS::iterator iterOfflien = m_vOfflinePlayers.begin();
for ( ; iterOfflien != m_vOfflinePlayers.end(); ++iterOfflien )
{
if ( iterOfflien->second && iterOfflien->first == pmsgenter->nUserUID )
{
iterOfflien->second->OnReactive(nSessionID) ;
AddPlayer(iterOfflien->second) ;
m_vOfflinePlayers.erase(iterOfflien) ;
return true ;
}
}
CPlayer* pNew = new CPlayer ;
pNew->Init(pmsgenter->nUserUID,nSessionID ) ;
AddPlayer(pNew) ;
}
break;
case MSG_DISCONNECT_CLIENT:
case MSG_PLAYER_LOGOUT:
{
CPlayer* pPlayer = GetPlayerBySessionID(nSessionID) ;
if ( pPlayer )
{
// post online event ;
CLogMgr::SharedLogMgr()->PrintLog("player disconnect session id = %d",nSessionID);
OnPlayerOffline(pPlayer) ;
}
else
{
CLogMgr::SharedLogMgr()->ErrorLog("client disconnect ! client is NULL session id = %d",nSessionID) ;
}
//#ifdef _DEBUG
LogState();
//#endif
}
break;
case MSG_TP_ORDER_LEAVE:
{
stMsgOrderTaxasPlayerLeaveRet* pRet = (stMsgOrderTaxasPlayerLeaveRet*)prealMsg ;
CPlayer* pp = GetPlayerByUserUID(pRet->nUserUID) ;
if (!pp)
{
CLogMgr::SharedLogMgr()->ErrorLog("uid = %d not find , so can not inform leave",pRet->nUserUID);
}
else
{
pp->OnMessage(prealMsg,eSenderPort);
}
}
break;
case MSG_TP_INFORM_LEAVE:
{
stMsgInformTaxasPlayerLeave* pRet = (stMsgInformTaxasPlayerLeave*)prealMsg ;
CPlayer* pp = GetPlayerByUserUID(pRet->nUserUID) ;
if (!pp)
{
CLogMgr::SharedLogMgr()->ErrorLog("uid = %d not find , so can not inform leave",pRet->nUserUID);
}
else
{
pp->OnMessage(prealMsg,eSenderPort);
}
}
break;
case MSG_TP_SYNC_PLAYER_DATA:
{
stMsgSyncTaxasPlayerData* pRet = (stMsgSyncTaxasPlayerData*)prealMsg ;
CPlayer* pp = GetPlayerByUserUID(pRet->nUserUID) ;
if (!pp)
{
CLogMgr::SharedLogMgr()->ErrorLog("uid = %d not find , so can not sys data",pRet->nUserUID);
}
else
{
pp->OnMessage(prealMsg,eSenderPort);
}
}
break;
default:
return false;
}
return true ;
}
