arenadef.cpp

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

// ArenaDef.cpp: implementation of the CArenaDef class.
//
//////////////////////////////////////////////////////////////////////

#include "..\stdafx.h"
#include "ArenaDef.h"

#include "TeamBattle.h"
#include "BaseArena.h"

extern CGambleItem g_GambleItem;
extern void CalcWinLoseScore(WINLOSEPOINT& win_lose, int wintype);
extern ItemAttr GenerateItem(const int iItemFullNo);
extern void SendViewType(CHARLIST *target, int view_Type, int continue_Time);
extern int SubtractMoney( DWORD money, CHARLIST *ch );
extern bool isLevelUp(CHARLIST*);
extern void SaveChangeBattingMoney(CHARLIST* pTarget, DWORD dwOldMoney, DWORD dwNewMoney);
extern void SaveChangeDividendMoney(CHARLIST* pTarget, DWORD dwOldMoney, DWORD dwNewMoney, bool bBank);

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////

CArenaInfo::CArenaInfo()
{
	m_nMapPort = 0;
	m_ptWait.x = 0;
	m_ptWait.y = 0;
}
	
CArenaInfo::~CArenaInfo()
{
	
}

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////

CArenaLobby::CArenaLobby()
{
	Clear();
}

CArenaLobby::~CArenaLobby()
{

}

///////////////////////////////////////////////////////////////////////////////
// Public Method
///////////////////////////////////////////////////////////////////////////////

void CArenaLobby::Clear()
{
	m_ltMember.clear();
}

void CArenaLobby::AddMember(int nGame, CHARLIST* pMember)
{
	m_ltMember.push_back(pMember);
}

void CArenaLobby::DelMember(CHARLIST* pMember)
{
	m_ltMember.remove(pMember);
}

void CArenaLobby::ClearMember()
{
	m_ltMember.clear();
}

void CArenaLobby::SendPacket(t_packet* pPacket)
{
	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		::QueuePacket(connections, (*i)->GetServerID(), pPacket, 1);
	}
}

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////

CArenaTeam::CArenaTeam()
{
	Clear();
}
	
CArenaTeam::~CArenaTeam()
{
	ClearMember();
	ClearObserve();
	ClearGambler();
}

///////////////////////////////////////////////////////////////////////////////
// Public Method
///////////////////////////////////////////////////////////////////////////////

void CArenaTeam::Clear()
{
	ClearMember();
	ClearObserve();
	ClearGambler();

	m_ptBase.x = 0;
	m_ptBase.y = 0;
	m_nHuntNumber = 0;
	m_nKillCount = 0;
	m_nGameResult = FST_DEFEAT;
}

void CArenaTeam::AddMember(CHARLIST* pMember)
{
	m_ltMember.push_back(pMember);
}
	
void CArenaTeam::DelMember(CHARLIST* pMember)
{
	m_ltMember.remove(pMember);
}

void CArenaTeam::ClearMember()
{
	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		(*i)->SetJoinArenaGame(NULL);
		(*i)->SetJoinArenaTeam(NULL);
	}

	m_ltMember.clear();
}

void CArenaTeam::AddObserve(CHARLIST* pObserve)
{
	m_ltObserve.push_back(pObserve);
}

void CArenaTeam::DelObserve(CHARLIST* pObserve)
{
	m_ltObserve.remove(pObserve);
}

void CArenaTeam::ClearObserve()
{
	for (ITOR_MEMBER i = m_ltObserve.begin(); i != m_ltObserve.end(); ++i)
	{
		(*i)->SetJoinArenaGame(NULL);
		(*i)->SetJoinArenaTeam(NULL);
	}

	m_ltObserve.clear();
}

void CArenaTeam::AddGambler(CHARLIST* pGambler, DWORD dwMoney)
{
	ITOR_GAMBLER itor = m_mpGambler.find(pGambler);

	if (itor != m_mpGambler.end())
	{
		MyLog(LOG_NORMAL, "CArenaTeam::AddGambler : Duplicate %s", pGambler->Name);
		return;
	}

	m_mpGambler.insert(PAIR_GAMBLER(pGambler, dwMoney));
}

void CArenaTeam::DelGambler(CHARLIST* pGambler)
{
	ITOR_GAMBLER itor = m_mpGambler.find(pGambler);

	if (itor != m_mpGambler.end())
	{
		m_mpGambler.erase(itor);	
	}
	else
	{
		MyLog(LOG_NORMAL, "CArenaTeam::DelGambler : Don't Exist %s", pGambler->Name);
		return;
	}
}

void CArenaTeam::ClearGambler()
{
	for (ITOR_GAMBLER i = m_mpGambler.begin(); i != m_mpGambler.end(); ++i)
	{
		i->first->SetJoinArenaGame(NULL);
		i->first->SetJoinArenaTeam(NULL);
	}

	m_mpGambler.clear();
}

int CArenaTeam::GetAliveCount()
{
	int nCount = 0;

	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		if ((*i)->bAlive == ALIVE_)
		{
			++nCount;
		}
	}

	return nCount;
}
	
int CArenaTeam::GetDeadCount()
{
	int nCount = 0;

	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		if ((*i)->bAlive != ALIVE_)
		{
			++nCount;
		}
	}

	return nCount;
}

bool CArenaTeam::ChanageLeader(CHARLIST*& rLeader)
{
	if (m_ltMember.empty())
	{
		return false;
	}

	rLeader = (*m_ltMember.begin());
	return true;
}

void CArenaTeam::GiveBonus()
{
	const int nSize = m_ltMember.size();

	if (nSize <= 1 || nSize > 15) 
	{
		return;
	}

	const int nParam = ::ChoiceParam(g_game_rate_data.give_gamble_item_rate[nSize], 
		                             2, 
									 rand()%100 + 1);

	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		const int nItemNo = g_GambleItem.GetRandItem(GT_RESOURCE, nParam);
		
		if (nItemNo == 0) 
		{
			continue;
		}

		ItemAttr item = ::GenerateItem(nItemNo);
		
		if (item.item_no == 0) 
		{
			continue;
		}

		CHARLIST* pMember = *i;
		::SendItemEventLog(&item, pMember->GetServerID(), SN_NOT_USER, SILT_GET_GUILD_WAR, 2);
		::MoveEmptyInv(&item, pMember);
	}
}

void CArenaTeam::StartGame()
{
	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		CHARLIST* pMember = *i;
		pMember->Cp = pMember->CpMax;
		::MovePc(pMember->GetServerID(), m_ptBase.x, m_ptBase.y);
	}

	for (ITOR_MEMBER j = m_ltObserve.begin(); j != m_ltObserve.end(); ++j)
	{
		CHARLIST* pMember = *j;
		::MovePc(pMember->GetServerID(), m_ptBase.x, m_ptBase.y);
	}

	m_nKillCount = 0;
}

void CArenaTeam::EndGame(int nX, int nY)
{
	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		CHARLIST* pMember = *i;
		pMember->Cp = 0;
		SkillMgr.CharacterToAlive(pMember, 1);
		::MovePc(pMember->GetServerID(), nX, nY);
		::CheckAndSendChangeEquip(pMember, 1);
	}

	for (ITOR_MEMBER j = m_ltObserve.begin(); j != m_ltObserve.end(); ++j)
	{
		CHARLIST* pObserve = *j;
		::CallClient(pObserve->GetServerID(), CMD_FIGHT_MAP_END);

		pObserve->viewtype = VIEWTYPE_NORMAL_;
		::SendViewType(pObserve, VIEWTYPE_NORMAL_, 0);
		::MovePc(pObserve->GetServerID(), nX, nY);
	}
	
	ClearMember();
	ClearObserve();
	ClearGambler();

	m_nKillCount = 0;
}

void CArenaTeam::SendPacket(t_packet* pPacket)
{
	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		::QueuePacket(connections, (*i)->GetServerID(), pPacket, 1);
	}
}

void CArenaTeam::SendPacket(int idTarget, int nType)
{
	t_packet packet;
	packet.h.header.type = nType;
	packet.h.header.size = sizeof(k_team_add_message);
		
	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		packet.u.kein.team_add_message.total_id = (*i)->total_id;
		packet.u.kein.team_add_message.team_num = m_nTeamNumber;
		packet.u.kein.team_add_message.id = (*i)->GetServerID();
		strcpy(packet.u.kein.team_add_message.name, (*i)->Name);
		::QueuePacket(connections, idTarget, &packet, 1);
	}
}	

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

int CArenaTeam::GetTeamLevel()
{
	int nTeamLevel = 0;

	for (ITOR_MEMBER i = m_ltMember.begin(); i != m_ltMember.end(); ++i)
	{
		nTeamLevel += (*i)->GetLevel(); // CSD-030806
	}

	return nTeamLevel;
}

DWORD CArenaTeam::GetBattingMoney()
{
	DWORD dwBattingMoney = 0;

	for (ITOR_GAMBLER i = m_mpGambler.begin(); i != m_mpGambler.end(); ++i)
	{
		dwBattingMoney += i->second;
	}

	return dwBattingMoney;
}

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////

CArenaState::CArenaState()
{
	m_nState = CS_NOW_PEACE;
	m_nCheck = 0;
	m_dwReadySecond = 0;
	m_dwPlayMinute = 0;
	m_dwPrepareTime = 0;
	m_dwContinueTime = 0;
	m_nTotalLevel = 0;
}

///////////////////////////////////////////////////////////////////////////////
// Public Method
///////////////////////////////////////////////////////////////////////////////

void CArenaState::InitTeamLevel()
{
	m_nTotalLevel = 0;
}

void CArenaState::SumTeamLevel(CArenaTeam* pTeam)
{
	const int nTeamLevel = pTeam->GetTeamLevel();
	m_nTotalLevel += nTeamLevel;
}

void CArenaState::ReadyState(DWORD dwTime)
{
	m_dwPrepareTime = dwTime + m_dwReadySecond;
}

void CArenaState::StartState(DWORD dwTime)
{
	m_nState = CS_NOW_FIGHT;
	m_dwContinueTime = dwTime + m_dwPlayMinute*60; 
	
	DWORD dwRemainTime = GetRemainTime(dwTime);

	for (int i = 0; i < 4; ++i)
	{
		if (dwRemainTime > s_aCheckTime[i])
		{
			m_nCheck = i;
			return;
		}
	}
}

void CArenaState::EndState()
{
	m_nState = CS_NOW_PEACE;
	m_nCheck = 0;
	m_dwContinueTime = 0;
}

int CArenaState::CheckState(DWORD dwTime)
{
	DWORD dwRemainTime = GetRemainTime(dwTime);

	if (dwRemainTime >= 20 && dwRemainTime < s_aCheckTime[m_nCheck])
	{
		return ++m_nCheck;
	}

	return -1;
}

DWORD CArenaState::GetReadyTime(DWORD dwTime) const
{