void NFCLoginNet_ServerModule::OnSelectWorldProcess(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFGUID nPlayerID;
NFMsg::ReqConnectWorld xMsg;
if (!m_pNetModule->ReceivePB(nSockIndex, nMsgID, msg, nLen, xMsg, nPlayerID))
{
return;
}
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (!pNetObject)
{
return;
}
//没登录过
if (pNetObject->GetConnectKeyState() <= 0)
{
return;
}
NFMsg::ReqConnectWorld xData;
xData.set_world_id(xMsg.world_id());
xData.set_login_id(pPluginManager->AppID());
xData.mutable_sender()->CopyFrom(NFINetModule::NFToPB(pNetObject->GetClientID()));
xData.set_account(pNetObject->GetAccount());
m_pLoginToMasterModule->GetClusterModule()->SendSuitByPB(pNetObject->GetAccount(), NFMsg::EGameMsgID::EGMI_REQ_CONNECT_WORLD, xData);//here has a problem to be solve
}
void NFCProxyServerNet_ServerModule::OnConnectKeyProcess(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFGUID nPlayerID;
NFMsg::ReqAccountLogin xMsg;
if (!m_pNetModule->ReceivePB(nSockIndex, nMsgID, msg, nLen, xMsg, nPlayerID))
{
return;
}
bool bRet = m_pProxyToWorldModule->VerifyConnectData(xMsg.account(), xMsg.security_code());
if (bRet)
{
//可以进入,设置标志，选单服,心跳延迟,进入gs创建角色和删除角色,这里只是转发
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (pNetObject)
{
pNetObject->SetConnectKeyState(1);
pNetObject->SetAccount(xMsg.account());
NFMsg::AckEventResult xSendMsg;
xSendMsg.set_event_code(NFMsg::EGEC_VERIFY_KEY_SUCCESS);
*xSendMsg.mutable_event_client() = NFINetModule::NFToPB(pNetObject->GetClientID());//让前端记得自己的fd，后面有一些验证
m_pNetModule->SendMsgPB(NFMsg::EGameMsgID::EGMI_ACK_CONNECT_KEY, xSendMsg, nSockIndex);
}
}
else
{
m_pNetModule->GetNet()->CloseNetObject(nSockIndex);
}
}
int NFCLoginNet_ServerModule::OnSelectWorldProcess( const NFIPacket& msg )
{
NFIDENTID nPlayerID;
NFMsg::ReqConnectWorld xMsg;
if (!RecivePB(msg, xMsg, nPlayerID))
{
return 0;
}
NetObject* pNetObject = GetNet()->GetNetObject(msg.GetFd());
if (!pNetObject)
{
return 0;
}
//没登录过
if (pNetObject->GetConnectKeyState() <= 0)
{
return 0;
}
NFCDataList val;
val << xMsg.world_id() << pNetObject->GetClientID() << pPluginManager->AppID() << pNetObject->GetAccount();
m_pEventProcessModule->DoEvent(NFIDENTID(), NFED_ON_CLIENT_SELECT_SERVER, val);
return 0;
}
bool NFCNet::SendMsg(const char* msg, const uint32_t nLen, const int nSockIndex)
{
if (nLen <= 0)
{
return false;
}
std::map<int, NetObject*>::iterator it = mmObject.find(nSockIndex);
if (it != mmObject.end())
{
NetObject* pNetObject = (NetObject*)it->second;
if (pNetObject)
{
bufferevent* bev = pNetObject->GetBuffEvent();
if (NULL != bev)
{
bufferevent_write(bev, msg, nLen);
return true;
}
}
}
return false;
}
void NFCProxyServerNet_ServerModule::OnSelectServerProcess(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFGUID nPlayerID;
NFMsg::ReqSelectServer xMsg;
if (!m_pNetModule->ReceivePB(nSockIndex, nMsgID, msg, nLen, xMsg, nPlayerID))
{
return;
}
NF_SHARE_PTR<ConnectData> pServerData = m_pProxyServerToGameModule->GetClusterModule()->GetServerNetInfo(xMsg.world_id());
if (pServerData && ConnectDataState::NORMAL == pServerData->eState)
{
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (pNetObject)
{
//now this client bind a game server, after this time, all message will be sent to this game server who bind with client
pNetObject->SetGameID(xMsg.world_id());
NFMsg::AckEventResult xMsg;
xMsg.set_event_code(NFMsg::EGameEventCode::EGEC_SELECTSERVER_SUCCESS);
m_pNetModule->SendMsgPB(NFMsg::EGameMsgID::EGMI_ACK_SELECT_SERVER, xMsg, nSockIndex);
return;
}
}
NFMsg::AckEventResult xSendMsg;
xSendMsg.set_event_code(NFMsg::EGameEventCode::EGEC_SELECTSERVER_FAIL);
m_pNetModule->SendMsgPB(NFMsg::EGameMsgID::EGMI_ACK_SELECT_SERVER, xMsg, nSockIndex);
}
void RPGBase::unpackUpdate( NetConnection* con, BitStream* stream )
{
Parent::unpackUpdate(con, stream);
if (stream->readFlag())
{
S32 nIndex;
if (stream->readFlag())
{
stream->read(&nIndex);
NetObject* pObject = NULL;
if( con->isGhostingTo())
pObject = con->resolveGhost(nIndex);
else if( con->isGhostingFrom())
pObject = con->resolveObjectFromGhostIndex(nIndex);
if (pObject)
{
setCasterSimID(pObject->getId());
}
}
if (stream->readFlag())
{
stream->read(&nIndex);
NetObject* pObject = NULL;
if( con->isGhostingTo())
pObject = con->resolveGhost(nIndex);
else if( con->isGhostingFrom())
pObject = con->resolveObjectFromGhostIndex(nIndex);
if (pObject)
{
setCasterSimID(pObject->getId());
}
}
}
}
void NFCLoginNet_ServerModule::OnClientDisconnect(const int nAddress)
{
NetObject* pObject = GetNet()->GetNetObject(nAddress);
if (pObject)
{
NFIDENTID xIdent = pObject->GetClientID();
mxClientIdent.RemoveElement(xIdent);
}
}
void NFCLoginNet_ServerModule::OnClientConnected(const int nAddress)
{
NetObject* pObject = GetNet()->GetNetObject(nAddress);
if (pObject)
{
NFIDENTID xIdent =m_pUUIDModule->CreateGUID();
pObject->SetClientID(xIdent);
mxClientIdent.AddElement(xIdent, NF_SHARE_PTR<int> (NF_NEW int(nAddress)) );
}
}
void IController::ReadEntityUpdate(SnapshotEntList& frame, ENetPeer* owner)
{
NetObject* target = nullptr;
uint32_t queryID = frame.get_netid();
for (auto it = m_Instances.begin(); it != m_Instances.end(); ++it)
{
target = it->second->FindObject(queryID);
if (target != nullptr)
{
break;
}
}
if (target == nullptr)
return;
// If owner is set, check the permissions for updating this entity.
// This will happen when clients resync entities that aren't theirs, but
// this could also be called by a malicious peer.
if (owner != nullptr)
{
if (target->m_pPeer != owner)
{
return;
}
}
NetObject::VariableList_t& vars = target->GetVariables();
NetVar* pVar = nullptr;
for (auto it = vars.begin(); it != vars.end(); ++it)
{
if (strcmp((*it)->GetName(), frame.get_name()) == 0)
{
pVar = (*it);
break;
}
}
if (pVar == nullptr)
{
GetQueue().Add(kMessageType_Warn, "Tried to update NULL variable name " + std::string(frame.get_name()) + " for ID: " + std::to_string(queryID));
return;
}
if (target->m_Controller == NET_CONTROLLER_LOCAL && frame.get_forced() == false)
{
}
else
{
pVar->Set(const_cast<unsigned char*>(frame.get_data()), 0, owner);
}
}
void NFCProxyServerNet_ServerModule::OnClientConnected(const int nAddress)
{
NFGUID xClientIdent = m_pUUIDModule->CreateGUID();
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nAddress);
if (pNetObject)
{
pNetObject->SetClientID(xClientIdent);
}
mxClientIdent.AddElement(xClientIdent, NF_SHARE_PTR<int>(new int(nAddress)));
}
int NFCProxyServerNet_ServerModule::Transpond(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFMsg::MsgBase xMsg;
if (!xMsg.ParseFromArray(msg, nLen))
{
char szData[MAX_PATH] = { 0 };
sprintf(szData, "Parse Message Failed from Packet to MsgBase, MessageID: %d\n", nMsgID);
return false;
}
//broadcast many palyer
for (int i = 0; i < xMsg.player_client_list_size(); ++i)
{
NF_SHARE_PTR<int> pFD = mxClientIdent.GetElement(NFINetModule::PBToNF(xMsg.player_client_list(i)));
if (pFD)
{
if (xMsg.has_hash_ident())
{
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(*pFD);
if (pNetObject)
{
pNetObject->SetHashIdentID(NFINetModule::PBToNF(xMsg.hash_ident()));
}
}
m_pNetModule->GetNet()->SendMsgWithOutHead(nMsgID, msg, nLen, *pFD);
}
}
//send message to one player
if (xMsg.player_client_list_size() <= 0)
{
//playerid==ClientID;
NF_SHARE_PTR<int> pFD = mxClientIdent.GetElement(NFINetModule::PBToNF(xMsg.player_id()));
if (pFD)
{
if (xMsg.has_hash_ident())
{
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(*pFD);
if (pNetObject)
{
pNetObject->SetHashIdentID(NFINetModule::PBToNF(xMsg.hash_ident()));
}
}
m_pNetModule->GetNet()->SendMsgWithOutHead(nMsgID, msg, nLen, *pFD);
}
}
return true;
}
int NFCProxyServerNet_ServerModule::EnterGameSuccessEvent(const NFGUID xClientID, const NFGUID xPlayerID)
{
NF_SHARE_PTR<int> pFD = mxClientIdent.GetElement(xClientID);
if (pFD)
{
NetObject* pNetObeject = m_pNetModule->GetNet()->GetNetObject(*pFD);
if (pNetObeject)
{
pNetObeject->SetUserID(xPlayerID);
}
}
return 0;
}
int NFCLoginNet_ServerModule::OnLoginResultsEvent(const NFIDENTID& object, const int nEventID, const NFIDataList& var)
{
if (3 != var.GetCount()
|| !var.TypeEx(TDATA_TYPE::TDATA_INT, TDATA_TYPE::TDATA_OBJECT, TDATA_TYPE::TDATA_STRING, TDATA_TYPE::TDATA_UNKNOWN))
{
return -1;
}
const int nState = var.Int(0);
const NFIDENTID xIdent = var.Object(1);
const std::string& strAccount = var.String(2);
NF_SHARE_PTR<int> xFD = mxClientIdent.GetElement(xIdent);
if (xFD)
{
if (0 != nState)
{
//此帐号密码错误或者被封号
//登录失败
NFMsg::AckEventResult xMsg;
xMsg.set_event_code(NFMsg::EGEC_ACCOUNTPWD_INVALID);
SendMsgPB(NFMsg::EGameMsgID::EGMI_ACK_LOGIN, xMsg, *xFD);
return 0;
}
NetObject* pNetObject = GetNet()->GetNetObject(*xFD);
if (pNetObject)
{
//记录他登录过
pNetObject->SetConnectKeyState(1);
pNetObject->SetAccount(strAccount);
}
//把服务器列表广播下去
NFMsg::AckEventResult xData;
xData.set_event_code(NFMsg::EGEC_ACCOUNT_SUCCESS);
SendMsgPB(NFMsg::EGameMsgID::EGMI_ACK_LOGIN, xData, *xFD);
//SynWorldToClient(unAddress);
m_pLogModule->LogNormal(NFILogModule::NLL_INFO_NORMAL, NFIDENTID(0, *xFD), "Login successed :", strAccount.c_str());
}
return 0;
}
void NFCNet::listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data)
{
//怕你们重了
NFCNet* pNet = (NFCNet*)user_data;
bool bClose = pNet->CloseNetObject(fd);
if (bClose)
{
//error
return;
}
if (pNet->mmObject.size() >= pNet->mnMaxConnect)
{
//应该T掉，拒绝
return;
}
struct event_base *base = pNet->base;
//创建一个基于socket的bufferevent
struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
if (!bev)
{
//应该T掉，拒绝
fprintf(stderr, "Error constructing bufferevent!");
//event_base_loopbreak(base);
return;
}
//我获得一个新连接。为其创建一个bufferevent--FD需要管理
struct sockaddr_in* pSin = (sockaddr_in*)sa;
NetObject* pObject = new NetObject(pNet, fd, *pSin, bev);
pObject->GetNet()->AddNetObject(fd, pObject);
//为bufferevent设置各种回调
bufferevent_setcb(bev, conn_readcb, conn_writecb, conn_eventcb, (void*)pObject);
//开启bufferevent的读写
bufferevent_enable(bev, EV_READ|EV_WRITE);
//模拟客户端已连接事件
conn_eventcb(bev, BEV_EVENT_CONNECTED, (void*)pObject);
//////////////////////////////////////////////////////////////////////////
struct timeval tv;
/* 设置读超时120秒, 可做为心跳机制, 120秒没收到消息就T */
tv.tv_sec = 120;
tv.tv_usec = 0;
bufferevent_set_timeouts(bev, &tv, NULL);
}
bool NFCNet::CloseNetObject( const int nSockIndex )
{
std::map<int, NetObject*>::iterator it = mmObject.find(nSockIndex);
if (it != mmObject.end())
{
NetObject* pObject = it->second;
pObject->SetRemoveState(true);
mvRemoveObject.push_back(nSockIndex);
return true;
}
return false;
}
void write(NetConnection *ps, BitStream *bstream)
{
bstream->writeInt(ghostIndex, NetConnection::GhostIdBitSize);
if(bstream->writeFlag(validObject))
{
S32 classId = object->getClassId(ps->getNetClassGroup());
bstream->writeClassId(classId, NetClassTypeObject, ps->getNetClassGroup());
#ifdef TORQUE_NET_STATS
U32 beginSize = bstream->getBitPosition();
#endif
U32 retMask = object->packUpdate(ps, 0xFFFFFFFF, bstream);
if ( retMask != 0 ) object->setMaskBits( retMask );
#ifdef TORQUE_NET_STATS
object->getClassRep()->updateNetStatPack(0xFFFFFFFF, bstream->getBitPosition() - beginSize);
#endif
}
}
void NFCLoginLogicModule::OnLoginProcess(const NFSOCK nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFGUID nPlayerID;
NFMsg::ReqAccountLogin xMsg;
if (!m_pNetModule->ReceivePB( nMsgID, msg, nLen, xMsg, nPlayerID))
{
return;
}
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (pNetObject)
{
if (pNetObject->GetConnectKeyState() == 0)
{
if (!m_pAccountRedisModule->ExistAccount(xMsg.account()))
{
m_pAccountRedisModule->AddAccount(xMsg.account(), xMsg.password());
}
int nState = m_pAccountRedisModule->VerifyAccount(xMsg.account(), xMsg.password());
if (0 != nState)
{
std::ostringstream strLog;
strLog << "Check password failed, Account = " << xMsg.account() << " Password = "******"Login successed :", xMsg.account().c_str());
}
}
}
bool NFCNet::SendMsgToAllClient( const NFIPacket& msg )
{
std::map<int, NetObject*>::iterator it = mmObject.begin();
for (; it != mmObject.end(); ++it)
{
NetObject* pNetObject = (NetObject*)it->second;
if (pNetObject && !pNetObject->GetRemoveState())
{
bufferevent* bev = pNetObject->GetBuffEvent();
if (NULL != bev)
{
bufferevent_write(bev, msg.GetPacketData(), msg.GetPacketLen());
}
}
}
return true;
}
void NFCNet::CloseObject( const int nSockIndex )
{
std::map<int, NetObject*>::iterator it = mmObject.find(nSockIndex);
if (it != mmObject.end())
{
NetObject* pObject = it->second;
struct bufferevent* bev = pObject->GetBuffEvent();
//bev->cbarg = NULL;
bufferevent_free(bev);
evutil_closesocket(nSockIndex);
mmObject.erase(it);
delete pObject;
pObject = NULL;
}
}
void NetObject::collapseDirtyList()
{
#ifdef TORQUE_DEBUG
Vector<NetObject *> tempV;
for(NetObject *t = mDirtyList; t; t = t->mNextDirtyList)
tempV.push_back(t);
#endif
for(NetObject *obj = mDirtyList; obj; )
{
NetObject *next = obj->mNextDirtyList;
U32 dirtyMask = obj->mDirtyMaskBits;
obj->mNextDirtyList = NULL;
obj->mPrevDirtyList = NULL;
obj->mDirtyMaskBits = 0;
if(!obj->isDeleted() && dirtyMask)
{
for(GhostInfo *walk = obj->mFirstObjectRef; walk; walk = walk->nextObjectRef)
{
U32 orMask = obj->filterMaskBits(dirtyMask,walk->connection);
if(!walk->updateMask && orMask)
{
walk->updateMask = orMask;
walk->connection->ghostPushNonZero(walk);
}
else
walk->updateMask |= orMask;
}
}
obj = next;
}
mDirtyList = NULL;
#ifdef TORQUE_DEBUG
for(U32 i = 0; i < tempV.size(); i++)
{
AssertFatal(tempV[i]->mNextDirtyList == NULL && tempV[i]->mPrevDirtyList == NULL && tempV[i]->mDirtyMaskBits == 0, "Error in collapse");
}
#endif
}
void NFCProxyServerNet_ServerModule::OnReqServerListProcess(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
NFGUID nPlayerID;
NFMsg::ReqServerList xMsg;
if (!m_pNetModule->ReceivePB(nSockIndex, nMsgID, msg, nLen, xMsg, nPlayerID))
{
return;
}
if (xMsg.type() != NFMsg::RSLT_GAMES_ERVER)
{
return;
}
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (pNetObject && pNetObject->GetConnectKeyState() > 0)
{
//ack all gameserver data
NFMsg::AckServerList xData;
xData.set_type(NFMsg::RSLT_GAMES_ERVER);
NFMapEx<int, ConnectData>& xServerList = m_pProxyServerToGameModule->GetClusterModule()->GetServerList();
ConnectData* pGameData = xServerList.FirstNude();
while (NULL != pGameData)
{
if (ConnectDataState::NORMAL == pGameData->eState)
{
NFMsg::ServerInfo* pServerInfo = xData.add_info();
pServerInfo->set_name(pGameData->strName);
pServerInfo->set_status(NFMsg::EServerState::EST_NARMAL);
pServerInfo->set_server_id(pGameData->nGameID);
pServerInfo->set_wait_count(0);
}
pGameData = xServerList.NextNude();
}
m_pNetModule->SendMsgPB(NFMsg::EGameMsgID::EGMI_ACK_WORLD_LIST, xData, nSockIndex);
}
}
bool NFCNet::SendMsgToAllClient( const char* msg, const uint32_t nLen )
{
if (nLen <= 0)
{
return false;
}
std::map<int, NetObject*>::iterator it = mmObject.begin();
for (; it != mmObject.end(); ++it)
{
NetObject* pNetObject = (NetObject*)it->second;
if (pNetObject && !pNetObject->GetRemoveState())
{
bufferevent* bev = pNetObject->GetBuffEvent();
if (NULL != bev)
{
bufferevent_write(bev, msg, nLen);
}
}
}
return true;
}
int NFCLoginNet_ServerModule::OnLoginProcess( const NFIPacket& msg )
{
NFIDENTID nPlayerID;
NFMsg::ReqAccountLogin xMsg;
if (!RecivePB(msg, xMsg, nPlayerID))
{
return 0;
}
NetObject* pNetObject = GetNet()->GetNetObject(msg.GetFd());
if (pNetObject)
{
//还没有登录过
if (pNetObject->GetConnectKeyState() == 0)
{
NFCDataList val;
val << pNetObject->GetClientID()<< xMsg.account() << xMsg.password();
m_pEventProcessModule->DoEvent(NFIDENTID(), NFED_ON_CLIENT_LOGIN, val);
}
}
return 0;
}
void NFCProxyServerNet_ServerModule::OnReqDelRoleProcess(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
//在没有正式进入游戏之前，nPlayerID都是FD
NFGUID nPlayerID;
NFMsg::ReqDeleteRole xData;
if (!m_pNetModule->ReceivePB(nSockIndex, nMsgID, msg, nLen, xData, nPlayerID))
{
return;
}
NF_SHARE_PTR<ConnectData> pServerData = m_pProxyServerToGameModule->GetClusterModule()->GetServerNetInfo(xData.game_id());
if (pServerData && ConnectDataState::NORMAL == pServerData->eState)
{
//数据匹配
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (pNetObject
&& pNetObject->GetConnectKeyState() > 0
&& pNetObject->GetGameID() == xData.game_id()
&& pNetObject->GetAccount() == xData.account())
{
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(pNetObject->GetGameID(), nMsgID, std::string(msg, nLen));
}
}
}
void NFCProxyServerNet_ServerModule::OnClientDisconnect(const int nAddress)
{
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nAddress);
if (pNetObject)
{
int nGameID = pNetObject->GetGameID();
if (nGameID > 0)
{
if (!pNetObject->GetUserID().IsNull())
{
//掉线
NFMsg::ReqLeaveGameServer xData;
NFMsg::MsgBase xMsg;
//playerid主要是网关转发消息的时候做识别使用，其他使用不使用
*xMsg.mutable_player_id() = NFINetModule::NFToPB(pNetObject->GetUserID());
if (!xData.SerializeToString(xMsg.mutable_msg_data()))
{
return;
}
std::string strMsg;
if (!xMsg.SerializeToString(&strMsg))
{
return;
}
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(nGameID, NFMsg::EGameMsgID::EGMI_REQ_LEAVE_GAME, strMsg);
}
}
NFGUID xClientIdent = pNetObject->GetClientID();
mxClientIdent.RemoveElement(xClientIdent);
}
}
void unpack(NetConnection *ps, BitStream *bstream)
{
ghostIndex = bstream->readInt(NetConnection::GhostIdBitSize);
if(bstream->readFlag())
{
S32 classId = bstream->readClassId(NetClassTypeObject, ps->getNetClassGroup());
if(classId == -1)
{
ps->setLastError("Invalid packet. (invalid ghost class id)");
return;
}
object = (NetObject *) ConsoleObject::create(ps->getNetClassGroup(), NetClassTypeObject, classId);
if(!object)
{
ps->setLastError("Invalid packet. (failed to created from class id)");
return;
}
object->mNetFlags = NetObject::IsGhost;
object->mNetIndex = ghostIndex;
#ifdef TORQUE_NET_STATS
U32 beginSize = bstream->getBitPosition();
#endif
object->unpackUpdate(ps, bstream);
#ifdef TORQUE_NET_STATS
object->getClassRep()->updateNetStatUnpack(bstream->getBitPosition() - beginSize);
#endif
validObject = true;
}
else
{
object = new NetObject;
validObject = false;
}
}
void NFCNet::conn_eventcb(struct bufferevent *bev, short events, void *user_data)
{
NetObject* pObject = (NetObject*)user_data;
NFCNet* pNet = (NFCNet*)pObject->GetNet();
if(pNet->mEventCB)
{
pNet->mEventCB(pObject->GetFd(), NF_NET_EVENT(events), pNet);
}
if (events & BEV_EVENT_EOF)
{
//printf("%d Connection closed.\n", pObject->GetFd());
pNet->CloseNetObject(pObject->GetFd());
if (!pNet->mbServer)
{
//客户端断线重连
pNet->ReqReset();
}
}
else if (events & BEV_EVENT_ERROR)
{
//printf("%d Got an error on the connection: %d\n", pObject->GetFd(), errno);/*XXX win32*/
pNet->CloseNetObject(pObject->GetFd());
if (!pNet->mbServer)
{
//客户端断线重连
pNet->ReqReset();
}
}
else if (events & BEV_EVENT_TIMEOUT)
{
//printf("%d read timeout: %d\n", pObject->GetFd(), errno);/*XXX win32*/
pNet->CloseNetObject(pObject->GetFd());
if (!pNet->mbServer)
{
//客户端断线重连
pNet->ReqReset();
}
}
else if (events & BEV_EVENT_CONNECTED)
{
pNet->mfRunTimeReseTime = 0.0f;
//printf("%d Connection successed\n", pObject->GetFd());/*XXX win32*/
}
}
void NFCProxyServerNet_ServerModule::OnOtherMessage(const int nSockIndex, const int nMsgID, const char * msg, const uint32_t nLen)
{
NFMsg::MsgBase xMsg;
if (!xMsg.ParseFromArray(msg, nLen))
{
char szData[MAX_PATH] = { 0 };
sprintf(szData, "Parse Message Failed from Packet to MsgBase, MessageID: %d\n", nMsgID);
return;
}
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (!pNetObject || pNetObject->GetConnectKeyState() <= 0 || pNetObject->GetGameID() <= 0)
{
//state error
return;
}
if (xMsg.has_hash_ident())
{
//special for distributed
if (!pNetObject->GetHashIdentID().IsNull())
{
NFCMachineNode xNode;
if (mxConsistentHash.GetSuitNode(pNetObject->GetHashIdentID().ToString(), xNode))
{
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(xNode.GetDataID(), nMsgID, msg, nLen);
}
}
else
{
NFGUID xHashIdent = NFINetModule::PBToNF(xMsg.hash_ident());
NFCMachineNode xNode;
if (mxConsistentHash.GetSuitNode(xHashIdent.ToString(), xNode))
{
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(xNode.GetDataID(), nMsgID, msg, nLen);
}
}
}
else
{
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(pNetObject->GetGameID(), nMsgID, msg, nLen);
}
}
void NFCProxyServerNet_ServerModule::OnReqEnterGameServer(const int nSockIndex, const int nMsgID, const char* msg, const uint32_t nLen)
{
//在没有正式进入游戏之前，nPlayerID都是FD
NFGUID nPlayerID;
NFMsg::ReqEnterGameServer xData;
if (!m_pNetModule->ReceivePB(nSockIndex, nMsgID, msg, nLen, xData, nPlayerID))
{
return;
}
NF_SHARE_PTR<ConnectData> pServerData = m_pProxyServerToGameModule->GetClusterModule()->GetServerNetInfo(xData.game_id());
if (pServerData && ConnectDataState::NORMAL == pServerData->eState)
{
//数据匹配
NetObject* pNetObject = m_pNetModule->GetNet()->GetNetObject(nSockIndex);
if (pNetObject
&& pNetObject->GetConnectKeyState() > 0
&& pNetObject->GetGameID() == xData.game_id()
&& pNetObject->GetAccount() == xData.account()
&& !xData.name().empty()
&& !xData.account().empty())
{
NFMsg::MsgBase xMsg;
if (!xData.SerializeToString(xMsg.mutable_msg_data()))
{
return;
}
//playerid在进入游戏之前都是FD，其他时候是真实的ID
xMsg.mutable_player_id()->CopyFrom(NFINetModule::NFToPB(pNetObject->GetClientID()));
std::string strMsg;
if (!xMsg.SerializeToString(&strMsg))
{
return;
}
m_pProxyServerToGameModule->GetClusterModule()->SendByServerID(pNetObject->GetGameID(), NFMsg::EGameMsgID::EGMI_REQ_ENTER_GAME, strMsg);
}
}
}
void GhostConnection::readPacket(BitStream *bstream)
{
Parent::readPacket(bstream);
if(mConnectionParameters.mDebugObjectSizes)
{
U32 sum = bstream->readInt(32);
TNLAssert(sum == DebugChecksum, "Invalid checksum.");
}
if(!doesGhostTo())
return;
if(!bstream->readFlag())
return;
S32 idSize;
idSize = bstream->readInt( 3 );
idSize += 3;
// while there's an object waiting...
while(bstream->readFlag())
{
U32 index;
//S32 startPos = bstream->getCurPos();
index = (U32) bstream->readInt(idSize);
if(bstream->readFlag()) // is this ghost being deleted?
{
TNLAssert(mLocalGhosts[index] != NULL, "Error, NULL ghost encountered.");
if(mLocalGhosts[index])
{
mLocalGhosts[index]->onGhostRemove();
delete mLocalGhosts[index];
mLocalGhosts[index] = NULL;
}
}
else
{
U32 endPosition = 0;
if(mConnectionParameters.mDebugObjectSizes)
endPosition = bstream->readInt(BitStreamPosBitSize);
if(!mLocalGhosts[index]) // it's a new ghost... cool
{
S32 classId = bstream->readClassId(NetClassTypeObject, getNetClassGroup());
if(classId == -1)
{
setLastError("Invalid packet.");
return;
}
NetObject *obj = (NetObject *) Object::create(getNetClassGroup(), NetClassTypeObject, classId);
if(!obj)
{
setLastError("Invalid packet.");
return;
}
obj->mOwningConnection = this;
obj->mNetFlags = NetObject::IsGhost;
// object gets initial update before adding to the manager
obj->mNetIndex = index;
mLocalGhosts[index] = obj;
NetObject::mIsInitialUpdate = true;
mLocalGhosts[index]->unpackUpdate(this, bstream);
NetObject::mIsInitialUpdate = false;
if(!obj->onGhostAdd(this))
{
if(!mErrorBuffer[0])
setLastError("Invalid packet.");
return;
}
if(mRemoteConnection)
{
GhostConnection *gc = static_cast<GhostConnection *>(mRemoteConnection.getPointer());
obj->mServerObject = gc->resolveGhostParent(index);
}
}
else
{
mLocalGhosts[index]->unpackUpdate(this, bstream);
}
if(mConnectionParameters.mDebugObjectSizes)
{
TNLAssert(bstream->getBitPosition() == endPosition,
avar("unpackUpdate did not match packUpdate for object of class %s. Expected %d bits, got %d bits.",
mLocalGhosts[index]->getClassName(), endPosition, bstream->getBitPosition()) );
}
if(mErrorBuffer[0])
return;
}
}
}