usermanager.cpp

网络游戏魔域的服务端与客户端完整源代码 包括详细的说明文档与开发日志

{
	CHECKF(idSocket >= 0 && idSocket < m_setUser.size());

	CUserPtr pUser = GetUserBySocketID(idSocket);
	if (pUser)
	{
		pUser->SaveInfo();		// SaveAllInfo
		if(szReason)
			LOGWARNING("KickOutSocket()踢出SOCKET_ID[%d], 玩家[%s]。理由：%s", idSocket, pUser->GetName(), szReason);
	}
	else
	{
		if(szReason)
			LOGWARNING("KickOutSocket()踢出SOCKET_ID[%d]。理由：%s", idSocket, szReason);
	}

	MapGroup(PID)->QueryIntraMsg()->CloseSocket(idSocket);
	return true;
}

//////////////////////////////////////////////////////////////////////
void CUserManager::LogoutAllUser()
{
	CUserManager::Iterator pUser = UserManager()->NewEnum();
	while(pUser.Next())
	{
		if(!pUser->IsAgent())
			LogoutUser(pUser->GetSocketID());
		else
			LogoutAgent(pUser);
	}
}

//////////////////////////////////////////////////////////////////////
CUser* CUserManager::GetUser(OBJID idUser)
{
	if(idUser == ID_NONE)
		return NULL;

	IRole* pRole = RoleManager()->QueryRole(idUser);
	CUser* pUser;
	if(pRole && pRole->QueryObj(OBJ_USER, IPP_OF(pUser)))
		return pUser;

	return NULL;
}

//////////////////////////////////////////////////////////////////////
CUser* CUserManager::GetUser(LPCTSTR szName)
{
	ASSERT(szName);

	CUserManager::Iterator pUser = this->NewEnum();
	while(pUser.Next())
	{
		if(strcmp(pUser->GetName(), szName) == 0)
			return pUser;
	}

	return NULL;
}

//////////////////////////////////////////////////////////////////////
CUser* CUserManager::GetUser(CNetMsg* pMsg)			// for agent
{
	ASSERT(pMsg);

	if(pMsg->IsNpcMsg())
	{
		IRole* pRole = RoleManager()->QuerySet()->GetObj(pMsg->GetNpcID());
		if(!pRole)
			return NULL;
		CUser* pUser = NULL;
		pRole->QueryObj(OBJ_USER, IPP_OF(pUser));
		return pUser;
	}
	else
		return GetUserBySocketID(pMsg->GetSocketID());
}

//////////////////////////////////////////////////////////////////////
bool CUserManager::FindNextSynMember(OBJID idSyn, int& nIter)
{
	CHECKF(idSyn != ID_NONE);

	OBJID	idLastUser	= nIter;
	CUser*	pTarget		= NULL;
	bool	bFindNext	= true;
	CUserManager::Iterator pUser = UserManager()->NewEnum();
	while(pUser.Next())
	{
		if(pUser && pUser->GetSynID() == idSyn)
		{
			if(bFindNext)
			{
				pTarget		= pUser;
				bFindNext	= false;
			}

			if(pUser->GetID() == idLastUser)
			{
				pTarget		= NULL;
				bFindNext	= true;
				continue;
			}
		}
	}

	if(pTarget)
	{
		nIter = pTarget->GetID();
		return true;
	}
	return false;
}

//////////////////////////////////////////////////////////////////////
void CUserManager::BroadcastMsg(CNetMsg* pMsg, CUser* pExcludeSender/*=NULL*/)
{
	CHECK(pMsg);

	BroadcastMapGroupMsg(pMsg, pExcludeSender);

	MapGroup(PID)->QueryIntraMsg()->SendBroadcastMsg(pMsg);
}

//////////////////////////////////////////////////////////////////////
void CUserManager::BroadcastMsg(LPCTSTR szMsg, CUser* pExcludeSender/*=NULL*/, LPCTSTR pszEmotion, DWORD dwColor, int nAttribute)
{
	CHECK(szMsg);

	CMsgTalk	msg;
	if(msg.Create(SYSTEM_NAME, ALLUSERS_NAME, szMsg, pszEmotion, dwColor, nAttribute))
		BroadcastMsg(&msg, pExcludeSender);
}

//////////////////////////////////////////////////////////////////////
void CUserManager::BroadcastMapMsg(OBJID idMap, CNetMsg* pMsg, CUser* pExcludeSender)
{
	ASSERT(pMsg);

	bool	bSendAiServer = true;
	CUserManager::Iterator pUser = UserManager()->NewEnum();
	while(pUser.Next())
	{
		if(!pUser->IsAgent())
		{
			if(pUser->GetMap()->GetID() == idMap && (!pExcludeSender || pExcludeSender->GetID() != pUser->GetID()))
			{
				MapGroup(PID)->QueryIntraMsg()->SendClientMsg(pUser->GetSocketID(), pMsg);
			}
		}
		else if(bSendAiServer)
		{
			if(pUser->GetMap()->GetID() == idMap && (!pExcludeSender || pExcludeSender->GetID() != pUser->GetID()))
			{
				MapGroup(PID)->QueryIntraMsg()->SendNpcMsg(pUser->GetID(), pMsg);
				bSendAiServer = false;	// only one npc msg
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////
// for mapgroup
//////////////////////////////////////////////////////////////////////
void CUserManager::BroadcastMapGroupMsg(CNetMsg* pMsg, CUser* pExcludeSender)
{
	ASSERT(pMsg);

	bool	bSendAiServer = true;
	CUserManager::Iterator pUser = UserManager()->NewEnum();
	while(pUser.Next())
	{
		if(!pUser->IsAgent())
		{
			if(!pExcludeSender || pExcludeSender->GetID() != pUser->GetID())
			{
				MapGroup(PID)->QueryIntraMsg()->SendClientMsg(pUser->GetSocketID(), pMsg);
			}
		}
		else if(bSendAiServer)
		{
			if(!pExcludeSender || pExcludeSender->GetSocketID() != pUser->GetID())
			{
				MapGroup(PID)->QueryIntraMsg()->SendNpcMsg(pUser->GetID(), pMsg);
				bSendAiServer = false;	// only one npc msg
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////
void CUserManager::JoinMapGroup(SOCKET_ID idSocket, UserInfoStruct* pInfo)
{
	CHECK(idSocket != SOCKET_NONE && pInfo);

	if(idSocket >= m_setUser.size())
		m_setUser.resize(idSocket + 1, NULL);			// 保证idSocket索引有效
	CHECK(m_setUser[idSocket] == NULL);

	CUser* pUser = CUser::CreateNewUser(m_idProcess, idSocket, pInfo);
	if(!pUser)
		return;

	ASSERT(!m_setUser[idSocket]);
	m_setUser[idSocket]	= pUser;
	RoleManager()->QuerySet()->AddObj(pUser->QueryRole());
}

//////////////////////////////////////////////////////////////////////
DWORD CUserManager::GetUserAmount()
{
	DWORD dwUsers = 0;
	for(int i = 0; i < m_setUser.size(); i++)
	{
		if(m_setUser[i])
			dwUsers++;
	}

	return dwUsers;
}

//////////////////////////////////////////////////////////////////////
DWORD CUserManager::GetMapUserAmount(OBJID idMap)
{
	DWORD dwUsers = 0;
	for(int i = 0; i < m_setUser.size(); i++)
	{
		CUser* pUser = m_setUser[i];
		if (pUser && pUser->GetMapID() == idMap)
			dwUsers++;
	}

	return dwUsers;
}

//////////////////////////////////////////////////////////////////////
int CUserManager::GetTeamAmount()
{
	CHECKF(m_pTeamSet);

	return m_pTeamSet->GetAmount();
}

//////////////////////////////////////////////////////////////////////
CTeam* CUserManager::GetTeamByIndex(int nIndex)
{
	CHECKF(m_pTeamSet);

	CTeam* pTeam	= m_pTeamSet->GetObjByIndex(nIndex);
	return pTeam;
}

//////////////////////////////////////////////////////////////////////
CTeam* CUserManager::GetTeamByLeaderId(OBJID idLeader)
{
	for (int i=0; i<this->GetTeamAmount(); i++)
	{
		CTeam* pTeam	= this->GetTeamByIndex(i);
		if (pTeam && pTeam->GetLeader() == idLeader)
			return pTeam;
	}

	return NULL;
}

//////////////////////////////////////////////////////////////////////
BOOL CUserManager::IsValidTeam(CTeam* pTeam)
{
	if (!pTeam)
		return false;

	for (int i=0; i<this->GetTeamAmount(); i++)
	{
		CTeam* pNowTeam	= this->GetTeamByIndex(i);
		if (pNowTeam && pNowTeam->GetLeader() == pTeam->GetLeader() &&
			pNowTeam->GetMemberAmount() == pTeam->GetMemberAmount())
			return true;
	}

	return false;
}

//////////////////////////////////////////////////////////////////////
BOOL CUserManager::AddTeam(CTeam* pTeam)
{
	if (!pTeam)
		return false;

	m_pTeamSet->AddObj(pTeam);
	return true;
}

//////////////////////////////////////////////////////////////////////
void CUserManager::DelTeam(CTeam* pTeam)
{
	if (!pTeam)
		return;

	for (int i=0; i<this->GetTeamAmount(); i++)
	{
		CTeam* pNowTeam	= this->GetTeamByIndex(i);
		if (pNowTeam && pNowTeam->GetID() == pTeam->GetID())
		{
			m_pTeamSet->DelObj(pTeam->GetID());
			return;
		}
	}
}

//////////////////////////////////////////////////////////////////////
OBJID CUserManager::SpawnNewTeamID()
{
	m_idLastTeam += MapGroup(PID)->GetMapGroupAmount();					//? 保证每个进程组的TEAM_ID不冲突。
	ASSERT(m_idLastTeam < 4012345678);
	return m_idLastTeam;
}

CUserManager::Iterator CUserManager::NewEnum()						{ return Iterator(RoleManager()->QuerySet()); }

//////////////////////////////////////////////////////////////////////
bool CUserManager::AddCheat(OBJID idUser, int *pnAmount, int *pnTimes)
{
	CHECKF(pnAmount && pnTimes);

	int	nAmount = m_setCheatIDTimes.Size();
	int	nTimes = 1;
	if(m_setCheatIDTimes.IsIn(idUser))
		nTimes = m_setCheatIDTimes.At(idUser) + 1;
	else
		nAmount++;

	m_setCheatIDTimes.Add(idUser, nTimes);

	*pnAmount	= nAmount;
	*pnTimes	= nTimes;
	return true;
}