basearena.cpp

国内著名网络游戏dragon的服务端完整源码 内附完整数据库结构

	CArenaTeam* pTeam2 = pTarget->GetJoinArenaTeam();
	
	if (pTeam2 == NULL) 
	{
		return;
	}

	t_packet packet;
	packet.h.header.size = sizeof(t_arena_game_message2);
	packet.h.header.type = CMD_ARENA_GAME_MESSAGE2;
	packet.u.arena.arena_game_message2.nTeamNumber1 = pTeam1->GetTeamNumber();
	packet.u.arena.arena_game_message2.nTeamNumber2 = pTeam2->GetTeamNumber();
	strcpy(packet.u.arena.arena_game_message2.szTeamMember1, pCaster->Name);
	strcpy(packet.u.arena.arena_game_message2.szTeamMember2, pTarget->Name);
	pTeam1->SendPacket(&packet);
	pTeam2->SendPacket(&packet);
}

void CBaseArena::SendGameMessage(CHARLIST* pTarget, int nType, int nData)
{
	CArenaTeam* pTeam = pTarget->GetJoinArenaTeam();
	
	if (pTeam == NULL) 
	{
		return;
	}

	t_packet packet;
	packet.h.header.size = sizeof(t_arena_game_message3);
	packet.h.header.type = CMD_ARENA_GAME_MESSAGE3;
	packet.u.arena.arena_game_message3.nTeamNumber = pTeam->GetTeamNumber();
	packet.u.arena.arena_game_message3.nMsgType = nType;
	packet.u.arena.arena_game_message3.nStoneNumber = nData;
	strcpy(packet.u.arena.arena_game_message3.szTeamMember, pTarget->Name);
	pTeam->SendPacket(&packet);
}

void CBaseArena::SendPacketAll(t_packet* pPacket)
{
	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		(*i)->SendPacket(pPacket);
	}

	m_pLobby->SendPacket(pPacket);
}

void CBaseArena::RequestArenaMember(CHARLIST* pMember)
{	//< CSD-030522
	CArenaLobby::LIST_MEMBER ltLobby = m_pLobby->GetMemberSet();

	for (CArenaLobby::ITOR_MEMBER i = ltLobby.begin(); i != ltLobby.end(); ++i)
	{
		CHARLIST* pTemp = *i;

		if (pMember == pTemp)
		{
			continue;
		}

		t_packet packet;
		packet.h.header.type = CMD_ARENA_ADD_LOBBY;
		packet.h.header.size = sizeof(t_arena_add_lobby);
		packet.u.arena.arena_add_lobby.idMember = pTemp->GetServerID();
		::QueuePacket(connections, pMember->GetServerID(), &packet, 1);
	}

	for (ITOR_TEAM j = m_ltTeam.begin(); j != m_ltTeam.end(); ++j)
	{
		const int nTeam = (*j)->GetTeamNumber();

		CArenaTeam::LIST_MEMBER ltMember = (*j)->GetMemberSet();

		for (CArenaTeam::ITOR_MEMBER k = ltMember.begin(); k != ltMember.end(); ++k)
		{
			CHARLIST* pTemp = *k;

			if (pMember == pTemp)
			{
				continue;
			}

			if (pTemp == m_pLeader)
			{	// 府歹烙阑 舅覆
				t_packet packet;
				packet.h.header.type = CMD_ARENA_LEADER_INFO;
				packet.h.header.size = sizeof(t_arena_leader_info);
				packet.u.arena.arena_leader_info.idLeader = pTemp->GetServerID();
				::QueuePacket(connections, pMember->GetServerID(), &packet, 1);
			}

			t_packet packet;
			packet.h.header.type = CMD_ARENA_ADD_TEAM;
			packet.h.header.size = sizeof(t_arena_add_team);
			packet.u.arena.arena_add_team.idMember = pTemp->GetServerID();
			packet.u.arena.arena_add_team.nTeam = nTeam;
			::QueuePacket(connections, pMember->GetServerID(), &packet, 1);
		}

		CArenaTeam::LIST_MEMBER ltObserve = (*j)->GetObserveSet();

		for (CArenaTeam::ITOR_MEMBER l = ltObserve.begin(); l != ltObserve.end(); ++l)
		{
			CHARLIST* pTemp = *l;

			if (pMember == pTemp)
			{
				continue;
			}

			t_packet packet;
			packet.h.header.type = CMD_ARENA_ADD_OBSERVE;
			packet.h.header.size = sizeof(t_arena_add_team);
			packet.u.arena.arena_add_observe.idObserve = pTemp->GetServerID();
			packet.u.arena.arena_add_observe.nTeam = nTeam;
			::QueuePacket(connections, pMember->GetServerID(), &packet, 1);
		}

		CArenaTeam::HASH_GAMBLER mpGambler = (*j)->GetGamblerSet();

		for (CArenaTeam::ITOR_GAMBLER m = mpGambler.begin(); m != mpGambler.end(); ++m)
		{
			CHARLIST* pTemp = m->first;

			if (pMember == pTemp)
			{
				continue;
			}

			t_packet packet;
			packet.h.header.type = CMD_ARENA_ADD_GAMBLING;
			packet.h.header.size = sizeof(t_arena_add_gambling);
			packet.u.arena.arena_add_gambling.idGambler = pTemp->GetServerID();
			packet.u.arena.arena_add_gambling.nTeam = nTeam;
			::QueuePacket(connections, pMember->GetServerID(), &packet, 1);
		}
	}

	::CallClient(pMember->GetServerID(), CMD_TEAMBATTLE_INFO);
}	//> CSD-030522

void CBaseArena::RequestRegisterLeader(CHARLIST* pMember)
{
	int nTotal = 0;

	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		nTotal += (*i)->GetMemberCount();
	}

	if (nTotal == 1)
	{
		SendLeaderInfo(pMember);
	}
}

void CBaseArena::RequestChangeLeader(CHARLIST* pMember)
{
	if (m_pLeader != pMember)
	{
		return;
	}

	CArenaTeam* pTeam = pMember->GetJoinArenaTeam();

	if (pTeam == NULL)
	{
		return;
	}

	if (!pTeam->ChanageLeader(pMember))
	{
		m_pLeader = NULL;
		return;
	}

	SendLeaderInfo(pMember);
}

void CBaseArena::RequestGambling(CHARLIST* pGambler)
{
	t_packet packet;
	packet.h.header.type = CMD_ARENA_GAMBLING_INFO;
	packet.h.header.size = sizeof(t_arena_gambling_info);

	CArenaTeam* pTeam = NULL;
	
	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		if ((*i)->IsExistGambler(pGambler))
		{
			pTeam = *i;
		}

		packet.u.arena.arena_gambling_info.nArenaTeam = (*i)->GetTeamNumber();
		packet.u.arena.arena_gambling_info.dwBattingMoney = (*i)->GetBattingMoney();
		SendPacketAll(&packet);
	}

	if (pTeam == NULL)
	{
		const DWORD dwBankMoney = pGambler->GetBankMoney();
		pGambler->SendCharInfoBasic(BANKMONEY, dwBankMoney);

		memset(&packet, 0, sizeof(t_arena_dividend_info));
		packet.h.header.type = CMD_ARENA_DIVIDEND_INFO;
		packet.h.header.size = sizeof(t_arena_dividend_info);
		packet.u.arena.arena_dividend_info.dwBattingMoney = 0;
		packet.u.arena.arena_dividend_info.dwDividendMoney = 0;
		::QueuePacket(connections, pGambler->GetServerID(), &packet, 1);
		return;
	}

	m_pGambling->InitBattingMoney();

	for (ITOR_TEAM j = m_ltTeam.begin(); j != m_ltTeam.end(); ++j)
	{
		m_pGambling->SumBattingMoney(*j);
	}

	for (ITOR_TEAM k = m_ltTeam.begin(); k != m_ltTeam.end(); ++k)
	{
		CArenaTeam::HASH_GAMBLER mpGambler = (*k)->GetGamblerSet();

		for (CArenaTeam::ITOR_GAMBLER l = mpGambler.begin(); l != mpGambler.end(); ++l)
		{
			CHARLIST* pTemp = l->first;
			const DWORD dwBattingMoney = l->second;
			const DWORD dwBankMoney = pTemp->GetBankMoney();
			pGambler->SendCharInfoBasic(BANKMONEY, dwBankMoney - dwBattingMoney);

			const DWORD dwDividendMoney = m_pGambling->GetDividendRate(*k) + dwBattingMoney;
			
			memset(&packet, 0, sizeof(t_arena_dividend_info));
			packet.h.header.type = CMD_ARENA_DIVIDEND_INFO;
			packet.h.header.size = sizeof(t_arena_dividend_info);
			packet.u.arena.arena_dividend_info.dwBattingMoney = dwBattingMoney;
			packet.u.arena.arena_dividend_info.dwDividendMoney = dwDividendMoney;
			::QueuePacket(connections, pTemp->GetServerID(), &packet, 1);
		}
	}
}

void CBaseArena::RequestProbability()
{
	m_pState->InitTeamLevel();

	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		m_pState->SumTeamLevel(*i);
	}

	t_packet packet;
	packet.h.header.type = CMD_ARENA_PROBABILITY_INFO;
	packet.h.header.size = sizeof(t_arena_probability_info);

	for (ITOR_TEAM j = m_ltTeam.begin(); j != m_ltTeam.end(); ++j)
	{
		packet.u.arena.arena_probability_info.nArenaTeam = (*j)->GetTeamNumber();
		packet.u.arena.arena_probability_info.fProbability = m_pState->GetTeamProbability(*j);
		SendPacketAll(&packet);
	}
}

void CBaseArena::StartReady(DWORD dwTime)
{	//< CSD-TW-030618
	if (!IsEnableReady())
	{
		m_pLeader->Message(MK_INFORMATION, 1, 122);
		return;
	}

	m_pState->SetReadyTime(dwTime);
	m_pState->ReadyState(g_curr_time);
}	//> CSD-TW-030618

void CBaseArena::EndReady()
{
	m_pState->SetReadyTime(0);

	if (m_pLeader != NULL)
	{
		SendStartGame(m_pLeader);
	}
}

bool CBaseArena::ReadyGame(DWORD dwTime)
{
	DWORD dwReadyTime = m_pState->GetReadyTime(dwTime);

	if (dwReadyTime <= 0)
	{
		return false;
	}

	t_packet packet;
	packet.h.header.type = CMD_ARENA_READY_INFO;
	packet.h.header.size = sizeof(t_arena_ready_info);
	packet.u.arena.arena_ready_info.dwReadyTime = dwReadyTime;
	SendPacketAll(&packet);
	return true;
}

void CBaseArena::StartGame(DWORD dwTime)
{
	t_packet packet;
	packet.h.header.type = CMD_FIGHT_MAP_START;
	packet.h.header.size = 0;
	SendPacketAll(&packet);

	m_pState->InitTeamLevel();
	m_pGambling->InitBattingMoney();

	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		CArenaTeam* pTeam = *i;
		
		if (!m_pGambling->IsEnableBattingMoney(pTeam))
		{	//< CSD-031119
			//pMember->Message(MK_SHORTAGE, 1, 112);
			return;
		}	//> CSD-031119

		pTeam->StartGame();

		m_pState->SumTeamLevel(pTeam);
		m_pGambling->SumBattingMoney(pTeam);
		m_pGambling->CalcBattingMoney(pTeam);
		m_pObserve->CalcObserveMoney(pTeam);
	}

	m_pState->StartState(dwTime);
}

void CBaseArena::EndGame(CArenaInfo* pArena)
{
	int nX = 0, nY = 0;
	pArena->GetWaitPosition(nX, nY);

	m_pLobby->Clear();

	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		CArenaTeam::LIST_MEMBER ltMember = (*i)->GetMemberSet();

		for (CArenaTeam::ITOR_MEMBER j = ltMember.begin(); j != ltMember.end(); ++j)
		{
			::CallClient((*j)->GetServerID(), CMD_FIGHT_MAP_END);
		}
	}

	for (ITOR_TEAM k = m_ltTeam.begin(); k != m_ltTeam.end(); ++k)
	{
		(*k)->EndGame(nX, nY);
	}

	m_pState->EndState();
	m_pGambling->InitBattingMoney();
}

bool CBaseArena::PlayGame(DWORD dwTime)
{
	int nCheck = m_pState->CheckState(dwTime);
	
	if (nCheck >= 0)
	{
		SendPacketTeam(CMD_FIGHT_MAP_REMAIN_TIME, &nCheck, 1);
	}

	return true;
}

///////////////////////////////////////////////////////////////////////////////
// Protected Method
///////////////////////////////////////////////////////////////////////////////

void CBaseArena::DoResult(CArenaTeam* pTeam)
{
	switch (pTeam->GetGameResult())
	{
	case FST_WIN:
		{
			DoVictory(pTeam);
			break;
		}
	case FST_DEFEAT:
		{
			DoDefeat(pTeam);
			break;
		}
	}
}

void CBaseArena::DoVictory(CArenaTeam* pTeam)
{
	t_packet packet;
	packet.h.header.type = CMD_FIGHT_MAP_YOU_WIN;
	packet.h.header.size = 0;
	pTeam->SendPacket(&packet);

	m_pState->CalcWinTeamLaderScore(pTeam);
	m_pGambling->CalcDividendMoney(pTeam);
}

void CBaseArena::DoDefeat(CArenaTeam* pTeam)
{
	t_packet packet;
	packet.h.header.type = CMD_FIGHT_MAP_YOU_DEFEAT;
	packet.h.header.size = 0;
	pTeam->SendPacket(&packet);

	m_pState->CalcLoseTeamLaderScore(pTeam);
}

void CBaseArena::SendPacketAll(int nType, void* pMsg, int nSize)
{
	t_packet packet;
	packet.h.header.type = nType;
	packet.h.header.size = nSize;
	
	if (pMsg != NULL)
	{
		memcpy(packet.u.data, pMsg, nSize);
	}

	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		(*i)->SendPacket(&packet);
	}

	m_pLobby->SendPacket(&packet);
}

void CBaseArena::SendPacketTeam(t_packet* pPacket)
{
	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		(*i)->SendPacket(pPacket);
	}
}

void CBaseArena::SendPacketTeam(int nType, void* pMsg, int nSize)
{
	t_packet packet;
	packet.h.header.type = nType;
	packet.h.header.size = nSize;
	
	if (pMsg != NULL)
	{
		memcpy(packet.u.data, pMsg, nSize);
	}

	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		(*i)->SendPacket(&packet);
	}
}

void CBaseArena::SendPacketWait(t_packet* pPacket)
{
	m_pLobby->SendPacket(pPacket);
}

void CBaseArena::SendPacketWait(int nType, void* pMsg, int nSize)
{
	t_packet packet;
	packet.h.header.type = nType;
	packet.h.header.size = nSize;
	
	if (pMsg != NULL)
	{
		memcpy(packet.u.data, pMsg, nSize);
	}

	m_pLobby->SendPacket(&packet);
}

int CBaseArena::GetGameMemberCount()
{	//< CSD-TW-030701
	int nCount = m_pLobby->GetMemberCount();

	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		nCount += (*i)->GetMemberCount();
	}

	return nCount;
}	//> CSD-TW-030618

///////////////////////////////////////////////////////////////////////////////
// Private Method
///////////////////////////////////////////////////////////////////////////////

bool CBaseArena::IsEnableReady()
{	//< CSD-TW-030618
	int nCount = 0;

	for (ITOR_TEAM i = m_ltTeam.begin(); i != m_ltTeam.end(); ++i)
	{
		if ((*i)->IsEmptyMember())
		{
			return false;
		}
		
		nCount = __max((*i)->GetMemberCount(), nCount);
	}

	if (nCount > MAX_TEAM_NUMBER)
	{
		return false;
	}

	for (ITOR_TEAM j = m_ltTeam.begin(); j != m_ltTeam.end(); ++j)
	{
		if (nCount != (*j)->GetMemberCount())
		{
		 	return false;
		}
	}

	return true;
}	//> CSD-TW-030618