#include "StdAfx.h"
#include "DnRecoverHPByAttackBlow.h"

#if defined(_GAMESERVER)
#include "DnMonsterActor.h"
#endif // _GAMESERVER

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


CDnRecoverHPByAttackBlow::CDnRecoverHPByAttackBlow( DnActorHandle hActor, const char* szValue ) : CDnBlow( hActor )
{
	m_StateBlow.emBlowIndex = STATE_BLOW::BLOW_248;

	SetValue( szValue );
	
	m_fValue = 0.0f;
	m_nLimitHP = -1;

	std::string str = szValue;//"ȸº¹·®;ȸº¹·®Á¦ÇÑ°ª";
	std::vector<std::string> tokens;
	std::string delimiters = ";";

	//1. ±¸ºÐ
	TokenizeA(str, tokens, delimiters);
	int nTokenSize = (int)tokens.size();
	
	if (nTokenSize >= 1)
	{
		m_fValue = (float)(atof(tokens[0].c_str()));
		if (nTokenSize >= 2)
			m_nLimitHP = atoi(tokens[1].c_str());
	}
	else
	{
		OutputDebug("%s Invalid Value %s\n", __FUNCTION__, szValue);
	}

#if defined(_GAMESERVER)
	AddCallBackType(SB_ONTARGETHIT);
#endif // _GAMESERVER

}

CDnRecoverHPByAttackBlow::~CDnRecoverHPByAttackBlow(void)
{

}

void CDnRecoverHPByAttackBlow::OnSetParentSkillInfo()
{

#if defined( _GAMESERVER )
	CalcHealValueLimit( m_StateBlow.emBlowIndex, m_fValue );
#endif

}

void CDnRecoverHPByAttackBlow::OnBegin( LOCAL_TIME LocalTime, float fDelta )
{
	__super::OnBegin(LocalTime, fDelta);

	OutputDebug( "%s\n", __FUNCTION__ );
}


void CDnRecoverHPByAttackBlow::Process( LOCAL_TIME LocalTime, float fDelta )
{
	__super::Process( LocalTime, fDelta );

}


void CDnRecoverHPByAttackBlow::OnEnd( LOCAL_TIME LocalTime, float fDelta )
{
	__super::OnEnd(LocalTime, fDelta);

#if defined(_GAMESERVER)
	//°°Àº ½ºÅ³¿¡ ÀÇÇÑ »óÅÂÈ¿°ú Á¦°Å...
	//#60311 »óÅÂÈ¿°ú Á¦°Å½Ã °°Àº ½ºÅ³ »óÅÂÈ¿°ú Á¦°Å ±â´É ¸·À½.
	//RemoveStateBlowBySkillID(m_ParentSkillInfo.iSkillID);
#endif // _GAMESERVER
	OutputDebug( "%s\n", __FUNCTION__);
}

#if defined(_GAMESERVER)
void CDnRecoverHPByAttackBlow::RemoveStateBlowBySkillID(int nSkillID)
{
	DNVector(DnBlowHandle) vlBlowList;

	FindSkillBlowList(m_hActor, nSkillID, vlBlowList);

	int nBlowCount = (int)vlBlowList.size();
	for (int n = 0; n < nBlowCount; ++n)
	{
		DnBlowHandle hBlow = vlBlowList[n];
		if (!hBlow)
			continue;

		// ½ºÅ³ À¯Àú ¾×ÅÍ È®ÀÎÀº ¾È Çϴ°ɷÎ..(ÇÁ¶ø?¿¡ ÀÇÇؼ­ Ãß°¡µÈ »óÅÂÈ¿°ú´Â ½ºÅ³ À¯Àú ¾×ÅÍ°¡ ¾øÀ½.)
		CDnSkill::SkillInfo* pSkillInfo = const_cast<CDnSkill::SkillInfo*>(hBlow->GetParentSkillInfo());
		if (!pSkillInfo /*|| !pSkillInfo->hSkillUser*/)
			continue;

		//Àڽſ¡°Ô Àû¿ëÇÒ »óÅÂÈ¿°ú¸¦ ¿¹¾àÇÑ´Ù..
		m_hActor->CmdRemoveStateEffectFromID(hBlow->GetBlowID());
	}

}

void CDnRecoverHPByAttackBlow::FindSkillBlowList(DnActorHandle hActor, int nSkillID, DNVector(DnBlowHandle)& vlBlowList)
{
	if (!hActor)
		return;

	int nStateBlowCount = hActor->GetNumAppliedStateBlow();

	for (int i = 0; i < nStateBlowCount; ++i)
	{
		DnBlowHandle hBlow = hActor->GetAppliedStateBlow(i);
		if (!hBlow)
			continue;

		CDnSkill::SkillInfo* pSkillInfo = const_cast<CDnSkill::SkillInfo*>(hBlow->GetParentSkillInfo());
		//½ºÅ³ Á¤º¸°¡ ¾øÀ¸¸é °Ç³Ê¶Ü. (½ºÅ³ À¯Àú°¡ ¾øÀ» ¼ö ÀÖÀ½..(ÇÁ¶ø?¿¡ ÀÇÇØ Àû¿ëµÈ »óÅÂÈ¿°ú)
		if (!pSkillInfo /*|| !pSkillInfo->hSkillUser*/)
			continue;

		if (pSkillInfo->iSkillID == nSkillID)
			vlBlowList.push_back(hBlow);
	}
}


void CDnRecoverHPByAttackBlow::OnTargetHit( DnActorHandle hTargetActor )
{
	CDnDamageBase::SHitParam *pHitParam = NULL;
#if defined(PRE_FIX_59680)
	if (hTargetActor)
	{
		//¼Òȯ ¸ó½ºÅÍ ¾×ÅÍÀÌ°í, ÁÖÀÎ ¾×ÅÍ°¡ ÀÖ°í, TransmitDamageBlow(51)»óÅÂÈ¿°ú°¡ ÀÖ´Â °æ¿ì ÁÖÀÎ ¾×ÅÍÀÇ HitParamÀ» °¡Á® ¿Àµµ·Ï ÇÑ´Ù.
		//RequestDamage
		if (hTargetActor->IsMonsterActor())
		{
			CDnMonsterActor* pMonsterActor = dynamic_cast<CDnMonsterActor*>(hTargetActor.GetPointer());
			if (pMonsterActor && pMonsterActor->IsSummonedMonster() && pMonsterActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_051))
			{
				hTargetActor = pMonsterActor->GetSummonerPlayerActor();
			}
		}
		
		if (hTargetActor)
			pHitParam = hTargetActor->GetHitParam();
	}
#else
	if (hTargetActor)
		pHitParam = hTargetActor->GetHitParam();
#endif // PRE_FIX_59680

	INT64 nRecoverHP = 0;
	if (pHitParam)
		nRecoverHP = (INT64)(m_fValue * pHitParam->nCalcDamage);
	
	if (m_nLimitHP != -1)
	{
		//Á¦ÇÑ°ªÀÌ Á¤»óÀ϶§¸¸ HPȸº¹ Çϵµ·Ï ÇÑ´Ù.
		if (m_nLimitHP <= 0)
		{
			OutputDebug("%s HP ȸº¹ Á¦ÇÑ...  [%d] - [%d]\n", __FUNCTION__, m_nLimitHP, nRecoverHP);
			return;
		}

		//³²Àº Á¦ÇÑ HPȸº¹·® º¸´Ù ÇöÀç ȸº¹·®ÀÌ ÀÛÀº°ªÀÎ °æ¿ì´Â ³²Àº Á¦ÇÑ·®À» ÇöÀç ȸº¹·®¸¸Å­ °¨¼Ò ½ÃÄÑ ³õ°í
		if (m_nLimitHP >= nRecoverHP)
			m_nLimitHP -= nRecoverHP;
		//³²Àº Á¦ÇÑ HPȸº¹·®ÀÌ ÇöÀç ȸº¹·® º¸´Ù ÀÛÀº°ªÀÎ °æ¿ì´Â ³²Àº Á¦ÇÑ·®Àº 0À¸·Î, ȸº¹·®Àº ÇöÀç ³²Àº Á¦ÇÑ È¸º¹·®À¸·Î ¼³Á¤.
		else
		{
			nRecoverHP = m_nLimitHP;
			m_nLimitHP = 0;

			//#60311 Á¦ÇÑ ¼öÄ¡¸¸Å­ HPȸº¹ µÈ ÀÌÈÄ HPȸº¹Àº µÇÁö ¾Ê°í, »óÅÂÈ¿°ú´Â °è¼Ó À¯Áö µÊ.
			//³²Àº ȸº¹·®ÀÌ ¾øÀ¸¸é »óÅÂÈ¿°ú Á¦°Å µÊ.. »óÅÂÈ¿°ú Á¦°ÅµÉ¶§ °°Àº ½ºÅ³ÀÇ »óÅÂÈ¿°úµé °°ÀÌ Á¦°Å..
			//SetState(STATE_BLOW::STATE_END);
		}
	}

	if (nRecoverHP != 0)
	{
		//MaxHP¸¦ ³ÑÁö ¾Ê°Ô..
		INT64 nMaxHP = m_hActor->GetMaxHP();
		INT64 nCurHP = m_hActor->GetHP();
		INT64 nTempHP = nCurHP + nRecoverHP;

		//MaxHP¸¦ ³Ñ¾î °¡´Â ¸¸Å­ nRecoverHP¸¦ º¸Á¤ÇÑ´Ù.
		if (nTempHP > nMaxHP)
			nRecoverHP -= (nTempHP - nMaxHP);

		if (nRecoverHP > 0)
		{
			m_hActor->SetHP( m_hActor->GetHP() + nRecoverHP );
			m_hActor->RequestHPMPDelta( CDnState::ElementEnum::ElementEnum_Amount, nRecoverHP, UINT_MAX, false, true );
		}
	}
}
#endif // _GAMESERVER


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

	szNewValue = szOrigValue;
}

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

	szNewValue = szOrigValue;
}
#endif // PRE_ADD_PREFIX_SYSTE_RENEW