#include "StdAfx.h"
#include "DnDissolveDebufBlow.h"

#ifdef _DEBUG
#define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
#endif

CDnDissolveDebufBlow::CDnDissolveDebufBlow( DnActorHandle hActor, const char* szValue ) : CDnBlow( hActor )
{
	m_StateBlow.emBlowIndex = STATE_BLOW::BLOW_069;
	SetValue( szValue );
	//m_nValue = atoi( szValue );
	m_fValue = (float)atof(szValue);
}

CDnDissolveDebufBlow::~CDnDissolveDebufBlow(void)
{
}



bool CDnDissolveDebufBlow::_IsBadStateBlow( DnBlowHandle hBlow )
{
	return hBlow->GetBlowIndex() == STATE_BLOW::BLOW_041 ||
		   hBlow->GetBlowIndex() == STATE_BLOW::BLOW_042 ||
		   hBlow->GetBlowIndex() == STATE_BLOW::BLOW_043 ||
		   hBlow->GetBlowIndex() == STATE_BLOW::BLOW_044 ||
		   hBlow->GetBlowIndex() == STATE_BLOW::BLOW_045 || // ¼ö¸é
		   hBlow->GetBlowIndex() == STATE_BLOW::BLOW_078 ||	// ½ºÅ³ »ç¿ë ºÒ°¡ »óÅÂÈ¿°ú
		   hBlow->GetBlowIndex() == STATE_BLOW::BLOW_070 ||
		   hBlow->GetBlowIndex() == STATE_BLOW::BLOW_071;
}


void CDnDissolveDebufBlow::OnBegin( LOCAL_TIME LocalTime, float fDelta )
{

#ifdef _GAMESERVER
	// ÇØÁ¦ ´ÜÀ§´Â »óÅÂÈ¿°ú °¹¼ö°¡ ¾Æ´Ï¶ó µð¹öÇÁ ½ºÅ³ ¹­À½ ´ÜÀ§.
	multimap<int, DnBlowHandle> mmapDebuffBlowsBySkill;

	int iDissolveCount = 0;
	int iNumAppliedBlow = m_hActor->GetNumAppliedStateBlow();
	vector<int> vlDebuffSkillID;
	for( int iBlow = 0; iBlow < iNumAppliedBlow; ++iBlow )
	{
		DnBlowHandle hBlow = m_hActor->GetAppliedStateBlow( iBlow );
		if( !hBlow )
			continue;

		CDnSkill::SkillInfo* pSkillInfo = const_cast<CDnSkill::SkillInfo*>(hBlow->GetParentSkillInfo());

		if( pSkillInfo && pSkillInfo->iSkillID )
		{
			// ¾ÈÁÁÀº »óÅÂÈ¿°ú. °¨Àü, Áßµ¶, È­»ó, ÇൿºÒ°¡, À̵¿ºÒ°¡, ȤÀº µð¹öÇÁ·Î ¼ÂÆÃµÈ ½ºÅ³µé
			if( (0 == pSkillInfo->iDissolvable) && 
				(CDnSkill::Debuff == pSkillInfo->eDurationType || _IsBadStateBlow(hBlow)) )
			{
				// ¸¸¾à µð¹öÇÁÀÌ°í ÁöÁ¤µÈ ³ª»Û »óÅÂÈ¿°ú°¡ ¾Æ´Ï¶ó¸é ÆÀ¿¡ ´ëÇÑ °í·Á°¡ ÀÖ¾î¾ß ÇÑ´Ù.
				bool bBadBlow = true;
				if( (pSkillInfo->hSkillUser) && (false == _IsBadStateBlow(hBlow)) )
				{
					bBadBlow = false;
					bool bOtherTeam = (m_hActor->GetTeam() != pSkillInfo->hSkillUser->GetTeam());
					if( (CDnSkill::Enemy == pSkillInfo->eTargetType) && bOtherTeam )
					{
						bBadBlow = true;
					}

					// ¹öºí¹öºíó·³ ½ºÅ³ Ÿ°ÙŸÀÔÀÌ All ÀÌ°í °¢ »óÅÂÈ¿°úº°·Î Ÿ°ÙÀÌ ÀÖ´Â °æ¿ì.
					if( (CDnSkill::All == pSkillInfo->eTargetType) && bOtherTeam )
					{
						DnSkillHandle hSkill = pSkillInfo->hSkillUser->FindSkill( pSkillInfo->iSkillID );
						if( hSkill )
						{
							DWORD dwNumSE = hSkill->GetStateEffectCount();
							for( DWORD dwSE = 0; dwSE < dwNumSE; ++dwSE )
							{
								const CDnSkill::StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex( dwSE );
								if( pSE && pSE->ApplyType == CDnSkill::StateEffectApplyType::ApplyEnemy )
								{
									if( (STATE_BLOW::emBLOW_INDEX)pSE->nID == hBlow->GetBlowIndex() )
									{
										bBadBlow = true;
										break;
									}
								}
							}
						}
					}
				}

				if( bBadBlow )
				{
					mmapDebuffBlowsBySkill.insert( make_pair(pSkillInfo->iSkillID, hBlow) );

					// ÇϳªÀÇ ½ºÅ³¿¡ ¿©·¯°³ÀÇ »óÅÂÈ¿°ú°¡ ÀÖÀ» ¼ö ÀÖ´Ù. À¯´ÏÅ©ÇÑ ½ºÅ³ ¾ÆÀ̵𸸠³Ö¾îÁØ´Ù.
					if( vlDebuffSkillID.end() == find( vlDebuffSkillID.begin(), vlDebuffSkillID.end(), pSkillInfo->iSkillID ) )
						vlDebuffSkillID.push_back( pSkillInfo->iSkillID );
				}
			}
		}
	}

	DNVector(int) vlAppliedDebuffBlowIds;
	for( int i = 0; i < (int)vlDebuffSkillID.size(); ++i )
	{
		if( iDissolveCount >= (int)m_fValue )
			break;

		pair<multimap<int, DnBlowHandle>::iterator, multimap<int, DnBlowHandle>::iterator> iter_pair = 
			mmapDebuffBlowsBySkill.equal_range( vlDebuffSkillID.at(i) );

		// °°Àº ½ºÅ³¿¡¼­ ºñ·ÔµÈ µð¹öÇÁ »óÅÂÈ¿°úµéÀ» ¸ð¾ÆµÐ´Ù.
		multimap<int, DnBlowHandle>::iterator iter = iter_pair.first;
		for( iter; iter != iter_pair.second; ++iter )
			vlAppliedDebuffBlowIds.push_back( iter->second->GetBlowID() );

		++iDissolveCount;
	}


	// ÇØÁ¦ °¡´ÉÇÑ ³ª»Û ½ºÅ³, »óÅÂÈ¿°ú¸¸ ÇØÁ¦
	int iNumBlow = (int)vlAppliedDebuffBlowIds.size();
	for( int iBlow = 0; iBlow < iNumBlow; ++iBlow )
	{
		int iBlowID = vlAppliedDebuffBlowIds.at( iBlow );
		m_hActor->CmdRemoveStateEffectFromID( iBlowID );
	}
#endif
}


void CDnDissolveDebufBlow::OnEnd( LOCAL_TIME LocalTime, float fDelta )
{

}

#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
void CDnDissolveDebufBlow::AddStateEffectValue(const char* szOrigValue, const char* szAddValue, std::string& szNewValue)
{
	char szBuff[128] = {0, };

	//ÇÊ¿äÇÑ °ª º¯¼ö
	float fValue[2];

	//////////////////////////////////////////////////////////////////////////
	//ù¹ø° °ª
	fValue[0] = (float)atof( szOrigValue );
	//////////////////////////////////////////////////////////////////////////


	//////////////////////////////////////////////////////////////////////////
	//µÎ¹ø°
	fValue[1] = (float)atof( szAddValue );
	//////////////////////////////////////////////////////////////////////////

	//µÎ °ªÀ» ´õÇÑ´Ù.
	float fResultValue = fValue[0] + fValue[1];

	sprintf_s(szBuff, "%f", fResultValue);

	szNewValue = szBuff;
}

void CDnDissolveDebufBlow::RemoveStateEffectValue(const char* szOrigValue, const char* szAddValue, std::string& szNewValue)
{
	char szBuff[128] = {0, };

	//ÇÊ¿äÇÑ °ª º¯¼ö
	float fValue[2];

	//////////////////////////////////////////////////////////////////////////
	//ù¹ø° °ª
	fValue[0] = (float)atof( szOrigValue );
	//////////////////////////////////////////////////////////////////////////


	//////////////////////////////////////////////////////////////////////////
	//µÎ¹ø°
	fValue[1] = (float)atof( szAddValue );
	//////////////////////////////////////////////////////////////////////////

	//°ª °è»ê
	float fResultValue = fValue[0] - fValue[1];

	sprintf_s(szBuff, "%f", fResultValue);

	szNewValue = szBuff;
}
#endif // PRE_ADD_PREFIX_SYSTE_RENEW