arenadef.cpp

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

	return (m_dwPrepareTime <= dwTime) ? 0:m_dwPrepareTime - dwTime;
}

DWORD CArenaState::GetRemainTime(DWORD dwTime) const
{
	return (m_dwContinueTime <= dwTime) ? 0:m_dwContinueTime - dwTime;
}

DWORD CArenaState::GetFlowTime(DWORD dwTime) const
{
	return m_dwPlayMinute*60 - (m_dwContinueTime - dwTime);
}

void CArenaState::CalcWinTeamLaderScore(CArenaTeam* pTeam)
{
	const int nPoint = GetWinTeamLaderScore(pTeam);

	CArenaTeam::LIST_MEMBER ltMember = pTeam->GetMemberSet();

	for (CArenaTeam::ITOR_MEMBER i = ltMember.begin(); i != ltMember.end(); ++i)
	{
		CHARLIST* pMember = *i;
		::SaveChangeLadder(pMember, pMember->LadderScore, pMember->LadderScore + nPoint, CLT_WIN_COLOSSUS);
		pMember->LadderScore += nPoint;
		pMember->refresh_ladder = true;
		::CalcWinLoseScore(pMember->WinLoseScore, FST_WIN);
	}
}

void CArenaState::CalcLoseTeamLaderScore(CArenaTeam* pTeam)
{
	int nPoint = GetLoseTeamLaderScore(pTeam);

	CArenaTeam::LIST_MEMBER ltMember = pTeam->GetMemberSet();

	for (CArenaTeam::ITOR_MEMBER i = ltMember.begin(); i != ltMember.end(); ++i)
	{
		CHARLIST* pMember = *i;
	
		if (pMember->LadderScore < nPoint)
		{
			nPoint = pMember->LadderScore;
		}
		// 020830 YGI
		::SaveChangeLadder(pMember, pMember->LadderScore, pMember->LadderScore - nPoint, CLT_LOSE_COLOSSUS);

		pMember->LadderScore -= nPoint;
		pMember->refresh_ladder = true;
		::CalcWinLoseScore(pMember->WinLoseScore, FST_DEFEAT);
	}
}

float CArenaState::GetTeamProbability(CArenaTeam* pTeam)
{
	if (m_nTotalLevel == 0)
	{
		return 0.0;
	}

	return pTeam->GetTeamLevel()*100.0/m_nTotalLevel;
}

bool CArenaState::IsReadyGame() const
{ 
	return (m_dwReadySecond != 0) ? true:false;
}

bool CArenaState::IsPlayGame() const
{ 
	return (m_nState == CS_NOW_FIGHT) ? true:false;
}

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

int CArenaState::GetWinTeamLaderScore(CArenaTeam* pTeam)
{
	const int nTeamLevel = pTeam->GetTeamLevel();
	float fTeamRate = (float)(m_nTotalLevel - nTeamLevel)/nTeamLevel;

	if (m_nTotalLevel == 0)
	{
		fTeamRate = 1.0;
	}
	
	bool bHiLevel = (nTeamLevel >= m_nTotalLevel - nTeamLevel) ? true:false;

	int nCorrection = 10;

	if (fTeamRate > 2.0)
	{
		nCorrection = 20;
		fTeamRate = 1.0;
	}
	else if (fTeamRate < 0.5)
	{
		nCorrection = 5;
		fTeamRate = 1.0;
	}
	else 
	{
		if (bHiLevel)
		{
			fTeamRate = pow(fTeamRate, 1.2);
		}
		else
		{
			fTeamRate = pow(fTeamRate, 1.5);
		}
	}

	return fTeamRate*5*nCorrection;
}

int CArenaState::GetLoseTeamLaderScore(CArenaTeam* pTeam)
{
	const int nTeamLevel = pTeam->GetTeamLevel();
	float fTeamRate = (float)(m_nTotalLevel - nTeamLevel)/nTeamLevel;

	if (m_nTotalLevel == 0)
	{
		fTeamRate = 1.0;
	}
	
	bool bHiLevel = (nTeamLevel >= m_nTotalLevel - nTeamLevel) ? true:false;

	int nCorrection = 10;

	if (fTeamRate > 2.0)
	{
		nCorrection = 20;
		fTeamRate = 1.0;
	}
	else if (fTeamRate < 0.5)
	{
		nCorrection = 5;
		fTeamRate = 1.0;
	}
	else 
	{
		if (bHiLevel)
		{
			fTeamRate = pow(fTeamRate, 1.5);
		}
		else
		{
			fTeamRate = pow(fTeamRate, 1.2);
		}
	}

	return (fTeamRate*5 - 1)*nCorrection;
}

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////
	
CArenaGambling::CArenaGambling()
{
	m_dwMaxBattingMoney = 0;
	m_dwMinBattingMoney = 0;
	m_dwBattingMoney = 0;
	m_fDividendRate = 0.0;
}

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

void CArenaGambling::InitBattingMoney()
{
	m_dwBattingMoney = 0;
}

void CArenaGambling::SumBattingMoney(CArenaTeam* pTeam)
{
	const DWORD dwTeamMoney = pTeam->GetBattingMoney();
	m_dwBattingMoney += dwTeamMoney;
}

void CArenaGambling::CalcBattingMoney(CArenaTeam* pTeam)
{	//< CSD-030723
	CArenaTeam::HASH_GAMBLER mpGambler = pTeam->GetGamblerSet();

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

		const DWORD dwOldMoney = pGambler->GetBankMoney();
		pGambler->DecBankMoney(i->second, BMCT_ARENA_GAMBLE_BETTING);

		const DWORD dwNewMoney = pGambler->GetBankMoney();
		::SaveChangeBattingMoney(pGambler, dwOldMoney, dwNewMoney);
	}
}	//> CSD-030723

void CArenaGambling::CalcDividendMoney(CArenaTeam* pTeam)
{	//< CSD-030723
	CArenaTeam::HASH_GAMBLER mpGambler = pTeam->GetGamblerSet();

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

		const DWORD dwDividendMoney = GetDividendRate(pTeam) + i->second;

		if (pGambler->GetBankMoney() + dwDividendMoney < MAX_BANK_MONEY)
		{
			const DWORD dwOldMoney = pGambler->GetBankMoney();
			pGambler->IncBankMoney(dwDividendMoney, BMCT_ARENA_GAMBLE_DIVIDEND);

			const DWORD dwNewMoney = pGambler->GetBankMoney();
			::SaveChangeDividendMoney(pGambler, dwOldMoney, dwNewMoney, true);
			::SendGamblingResult(pGambler, 0, dwDividendMoney);
		}
		else
		{
			const DWORD dwOldMoney = ::GetMoneyByItem(pGambler);
			::GiveMoney(pGambler, dwDividendMoney);
			
			const DWORD dwNewMoney = ::GetMoneyByItem(pGambler);
			::SaveChangeDividendMoney(pGambler, dwOldMoney, dwNewMoney, false);
			::SendGamblingResult(pGambler, 1, dwDividendMoney);
		}
	}
}	//> CSD-030723

DWORD CArenaGambling::GetDividendRate(CArenaTeam* pTeam)
{
	const int nTeamCount = pTeam->GetGamblerCount();
	
	if (nTeamCount == 0)
	{
		return 0;
	}
	
	const DWORD dwTeamMoney = pTeam->GetBattingMoney();
	return ((m_dwBattingMoney - dwTeamMoney)*m_fDividendRate)/nTeamCount;
}

bool CArenaGambling::IsEnableGamblerCount(CArenaTeam* pTeam) const
{
	if (pTeam->GetGamblerCount() > MAX_MEMBER_COUNT)
	{
		return false;
	}

	return true;
}

bool CArenaGambling::IsEnableBattingMoney(CArenaTeam* pTeam) const
{	//< CSD-031119
	CArenaTeam::HASH_GAMBLER mpGambler = pTeam->GetGamblerSet();

	for (CArenaTeam::ITOR_GAMBLER i = mpGambler.begin(); i != mpGambler.end(); ++i)
	{	
		CHARLIST* pGambler = i->first;
		
		if (pGambler->GetBankMoney() < i->second)
		{
			return false;
		}
	}

	return true;
}	//> CSD-031119
	
bool CArenaGambling::IsEnableBattingMoney(DWORD dwMoney) const
{
	if (m_dwMinBattingMoney > dwMoney)
	{
		return false;
	}

	if (m_dwMaxBattingMoney < dwMoney)
	{
		return false;
	}

	return true;
}

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

CArenaObserve::CArenaObserve()
{
	m_dwObserveMoney = 0;
}

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

void CArenaObserve::CalcObserveMoney(CArenaTeam* pTeam)
{
	CArenaTeam::LIST_MEMBER ltObserve = pTeam->GetObserveSet();

	for (CArenaTeam::ITOR_MEMBER i = ltObserve.begin(); i != ltObserve.end(); ++i)
	{
		CHARLIST* pObserve = *i;
		pObserve->viewtype = VIEWTYPE_OBSERVE_;
		::SendViewType(pObserve, VIEWTYPE_OBSERVE_, 0);
		::SubtractMoney(m_dwObserveMoney, pObserve);
	}
}

bool CArenaObserve::IsEnoughMoney(CHARLIST* pObserve) const
{
	if (::GetMoneyByItem(pObserve) < m_dwObserveMoney)
	{
		return false;
	}

	return true;
}

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

CArenaBonus::CArenaBonus()
{
	Clear();
}

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

void CArenaBonus::Clear()
{
	m_nMinLevel = 0;
	m_nMaxLevel = 0;
	m_nItemHouse = 0;
	m_nItemKind = 0;
	m_nItemGrade = 0;
	m_fItemGainRate = 0.0;
	m_fExpRate = 0.0;
}

bool CArenaBonus::GiveBonus(CHARLIST* pMember)
{
	const int nLevel = pMember->GetLevel(); // CSD-030806

	if (m_nMinLevel > nLevel)
	{
		return false;
	}

	if (m_nMaxLevel < nLevel)
	{
		return false;
	}

	AddExperience(pMember);
	AddGambleItem(pMember);
	return true;
}

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

void CArenaBonus::AddExperience(CHARLIST* pMember)
{	//< CSD-030806
	const int nLevel = pMember->GetLevel();
	pMember->ChangeUpAddExpBonus((NPC_Lev_Ref[nLevel].nNeedExp/100)*m_fExpRate);
	::isLevelUp(pMember);
}	//> CSD-030806

void CArenaBonus::AddGambleItem(CHARLIST* pMember)
{	
	ItemAttr item;
	
	if (rand()%1000 > int(m_fItemGainRate)*10)
	{
		const int nParam = ::ChoiceParam(g_game_rate_data.give_gamble_item_rate[15],
										 2, 
										 rand()%100 + 1);
		const int nItemNo = g_GambleItem.GetRandItem(GT_RESOURCE, nParam);
		
		if (nItemNo == 0) 
		{
			return;
		}

		item = ::GenerateItem(nItemNo);
	}
	else
	{
		const int nItem = g_GambleItem.GetRandItem(m_nItemHouse, 0);
			
		if (nItem == 0) 
		{
			return;
		}

		RareMain r;

		switch (m_nItemKind)
		{
		case H_LV_NO_HIGH_ITEM:
			{
				item = ItemMgr.GiveRareItem(nItem, 
											0, 
											RARE_ABLE, 
											1,
											1, m_nItemGrade, 
											r, 
											H_LV_NO_HIGH_ITEM);
				break;
			}
		case H_LV_HIGH_ITEM:
			{
				item = ItemMgr.GiveRareItem(nItem, 
											0,
											1,
											RARE_ABLE, 
											1, m_nItemGrade,
											r, 
											H_LV_HIGH_ITEM);
				break;
			}
		default:
			{
				return;
			}
		}
	}

	if (item.item_no == 0) 
	{
		return;
	}

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