#include "StdAfx.h"
#include "DnSkill.h"
#include "DnTableDB.h"
#include "DnItemTask.h"
#include "IDnSkillUsableChecker.h"
#include "IDnSkillProcessor.h"
#include "DnDivideSEArgumentByTargets.h"
#include "DnPlayerActor.h"
#include "DnBlow.h"
#include "TaskManager.h"
#include "DnPartyTask.h"
#include "DNUserSession.h"
#include "DnPlayAniProcess.h"
#include "DnPartialPlayProcessor.h"
#include "DnApplySEWhenActionSetBlowEnabledProcessor.h"
#include "DnChangeActionStrProcessor.h"
#include "DnChangeActionStrByBubbleProcessor.h"
#include "DnStateEffectApplyOnOffByBubbleProcessor.h"
#include "DnStateBlow.h"
#include "DnBubbleSystem.h"
#include "DnObserverEventMessage.h"
#include "DnPingpongBlow.h"
#include "DnBasicBlow.h"
#include "DnHealingBlow.h"
#include "DnHPIncBlow.h"
#include "DnInvincibleAtBlow.h"
#include "DnProbabilityChecker.h"
#include "DnCreateBlow.h"
#include "DnAllowedSkillsBlow.h"
#include "DnMonsterActor.h"
#include "DnProjectile.h"
#include "DnAdditionalStateInfoBlow.h"
#include "DnAddStateBySkillGroupBlow.h"
#include "DnTransformBlow.h"
#include "DnBloodSuckingBlow.h"
#include "DnOrderMySummonedMonsterBlow.h"

#if defined(PRE_FIX_NEXTSKILLINFO)
#include "DNGameDataManager.h"
#endif // PRE_FIX_NEXTSKILLINFO

#if defined(PRE_FIX_46381)
#include "DnContinueBaseMPIncBlow.h"
#endif // PRE_FIX_46381

using namespace BubbleSystem;
using namespace boost;

DECL_MULTISMART_PTR_STATIC( CDnSkill, MAX_SESSION_COUNT, 100 )


CDnSkill::CDnSkill( DnActorHandle hActor ) : CMultiSmartPtrBase< CDnSkill, MAX_SESSION_COUNT >(hActor->GetRoom()),
											 m_hActor( hActor ),
											 m_LastTimeToggleMPDecreaseTime( 0 ),
											 m_bToggle( false ),
											 m_bAura( false ),
											 m_bItemSkill( false ),
											 m_fPassiveActionSkillLength( 0.0f ),
											 m_eElement( CDnState::ElementEnum_Amount ),
											 m_iNextLevelSkillPoint( -1 ),
											 m_bChainingPassiveSkill( false ),
											 m_bAppliedPassiveSelfBlows( false ),
											 m_bTempSkill( false )
{
	SecureZeroMemory( m_iNeedItemID, sizeof(m_iNeedItemID) );
	SecureZeroMemory( m_iNeedItemDecreaseCount, sizeof(m_iNeedItemDecreaseCount) );
	SecureZeroMemory( m_fHPConsumeType, sizeof(m_fHPConsumeType) );
	SecureZeroMemory( m_fMPConsumeType, sizeof(m_fMPConsumeType) );
	SecureZeroMemory( m_iNeedHP, sizeof(m_iNeedHP) );
	SecureZeroMemory( m_iNeedMP, sizeof(m_iNeedMP) );
	SecureZeroMemory( m_iIncreaseRange, sizeof(m_iIncreaseRange) );
	SecureZeroMemory( m_iDecreaseHP, sizeof(m_iDecreaseHP) );
	SecureZeroMemory( m_iDecreaseMP, sizeof(m_iDecreaseMP) );
	SecureZeroMemory( m_fOriginalDelayTime, sizeof(m_fOriginalDelayTime) );
	SecureZeroMemory( m_fDelayTime, sizeof(m_fDelayTime) );

	m_iSkillID = 0;
	m_iSkillLevelID = 0;
	m_iDissolvable = 0;
	m_iDuplicateCount = 0;
	m_iSkillDuplicateMethod = 0;
	m_iEffectDuplicateMethod = 0;

	m_iLevel = 0;
	m_iMaxLevel = 0;

	m_eSkillType = SkillTypeEnum::Active;
	m_eDurationType = DurationTypeEnum::Instantly;
	m_eTargetType = TargetTypeEnum::Self;
	m_iLevelLimit = 0;

	m_fLeftDelayTime = 0.f;
	m_fCoolTime = 0.f;
	m_iAdditionalThreat = 0;

	m_iCPScore = 0;

	m_pEffectAction = NULL;
	
	m_fOnceDelayTime = 0.0f;
	m_fOnceElapsedDelayTime = 0.0f;
	m_bEquipItemSkill = false;
	m_iEquipIndex = -1;

	m_fCoolTimeAdjustBlowValue = 1.0f;

	m_fStartSuperArmor = 0.0f;
	m_bStartCanHit = true;

	m_fResetCooltime = 0.0f;

	m_dwLastUseSkillTimeStamp = 0;

	m_iExclusiveID = 0;

	m_iSelectedSkillLevelDataApplyType = PVE;		// 디폴트는 pve 이다.

	m_iBaseSkillID = 0;
	m_iAppliedEnchantPassiveSkillID = 0;

	m_nPriority = 0;

	m_nItemID = -1;

	m_fCoolTimeMultipier = 1.0f;

	m_isIgnoreImmuneBackup = false;

	m_nLevelUpValue = 0;

#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
	m_nPrefixSkillType = -1;
#endif // PRE_ADD_PREFIX_SYSTE_RENEW

	m_iGlobalSkillGroupID = 0;
	SecureZeroMemory( m_afGlobalCoolTime, sizeof(m_afGlobalCoolTime) );
	m_fAnotherGlobalSkillCoolTime = 0.0f;

	m_nAnotherGlobakSkillID = 0;

#if defined( PRE_ADD_ACADEMIC )
	m_iSummonerDecreaseSP = 0;
	m_iSummonerDecreaseSPSkillID = 0;
#endif // #if defined( PRE_ADD_ACADEMIC )

	m_SummonMonsterID = -1;

	m_bAddStateEffectQueue = false;

	m_bEnchantedFromBubble = false;

	m_SkillStartTime = 0;
	m_bFinished = false;
	m_bIsPrefixTriggerSkill = false;
	m_iNeedJobClassID = 0;
	m_iNowLevelSkillPoint = 0;

	memset (m_iOriginalNeedMP, 0x00, sizeof(m_iOriginalNeedMP));
	memset (m_aeNeedEquipType, 0x00, sizeof(m_aeNeedEquipType));

#if defined(PRE_FIX_64312)
	m_isAppliedSummonMonsterEnchantSkill = false;
	m_bIsSummonMonsterSkill = false;
#endif // PRE_FIX_64312

#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
	m_fDeltaGlobalCoolTime = 0.0f;
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
}

CDnSkill::~CDnSkill(void)
{
	for( int iSelectedLevelData = PVE; iSelectedLevelData < NUM_SKILLLEVEL_APPLY_TYPE; ++iSelectedLevelData )
	{
		SAFE_DELETE_PVEC( m_vlpUsableCheckers[ iSelectedLevelData ] );
	}

	for( int iSelectedLevelData = PVE; iSelectedLevelData < NUM_SKILLLEVEL_APPLY_TYPE; ++iSelectedLevelData )
	{
		SAFE_DELETE_PVEC( m_vlpProcessors[ iSelectedLevelData ] );
	}

	for( int iSelectedLevelData = PVE; iSelectedLevelData < NUM_SKILLLEVEL_APPLY_TYPE; ++iSelectedLevelData )
	{
		SAFE_DELETE_PVEC( m_vlpProcessorBackup[ iSelectedLevelData ] );
	}

#if defined(PRE_FIX_66175)
	for( int iSelectedLevelData = PVE; iSelectedLevelData < NUM_SKILLLEVEL_APPLY_TYPE; ++iSelectedLevelData )
	{
		SAFE_DELETE_PVEC( m_vlUsableCheckersBackup[ iSelectedLevelData ] );
	}
#endif // PRE_FIX_66175
}



void CDnSkill::SetHasActor( DnActorHandle hActor )
{
	_ASSERT( hActor && "CDnSkill::SetHasActor() 액터 핸들이 NULL 임" );

	m_hActor = hActor;

	for( int iSelectedLevelData = PVE; iSelectedLevelData < NUM_SKILLLEVEL_APPLY_TYPE; ++iSelectedLevelData )
	{
		int iNumChecker = (int)m_vlpUsableCheckers[ iSelectedLevelData ].size();
		for( int iChecker = 0; iChecker < iNumChecker; ++iChecker )
		{
			IDnSkillUsableChecker* pChecker = m_vlpUsableCheckers[ iSelectedLevelData ].at( iChecker );
			pChecker->SetHasActor( hActor );
		}
	}

	for( int iSelectedLevelData = PVE; iSelectedLevelData < NUM_SKILLLEVEL_APPLY_TYPE; ++iSelectedLevelData )
	{
		int iNumProcessor = (int)m_vlpProcessors[ iSelectedLevelData ].size();
		for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
		{
			IDnSkillProcessor* pProcessor = m_vlpProcessors[ iSelectedLevelData ].at( iProcessor );
			pProcessor->SetHasActor( hActor );
			pProcessor->SetParentSkill( GetMySmartPtr() );
		}
	}
}


DnSkillHandle CDnSkill::CreateSkill( DnActorHandle hActor, int iSkillTableID, int iLevel )
{
	CDnSkill* pNewSkill = NULL;

	// 스킬 발동 조건, 발동 프로세서들을 달아준다.
	// 각각 5개씩 있고 파라메터는 전부 합쳐 10개임. 변경될 가능성도 있다.
	pNewSkill = new CDnSkill( hActor );
	
	bool bResult = pNewSkill->Initialize( iSkillTableID, iLevel );
	if( false == bResult )
	{
		delete pNewSkill;
		return CDnSkill::Identity();
	}

	if( hActor && hActor->IsPlayerActor() )
	{
		CDnPlayerActor* pPlayerActor = static_cast<CDnPlayerActor*>(hActor.GetPointer());
		pNewSkill->RegisterObserver( pPlayerActor->GetBubbleSystem() );
	}
	
	return pNewSkill->GetMySmartPtr();
}

#ifdef PRE_FIX_GAMESERVER_OPTIMIZE
bool CDnSkill::_LoadMonsterSkillLevelData( int iSkillTableID, int iLevel, int iSkillLevelDataApplyType )
{
	DNTableFileFormat* pSkillTable = GetDNTable( CDnTableDB::TSKILL );
	DNTableFileFormat* pSkillLevelTable = GetDNTable( CDnTableDB::TSKILLLEVEL );

	vector<int> vlSkillLevelList;
	if( pSkillLevelTable->GetItemIDListFromField( "_SkillIndex", iSkillTableID, vlSkillLevelList ) <= 0 ) 
		return false;

	if( !pSkillTable->IsExistItem( iSkillTableID) )
		return false;

	// pve, pvp 대상인지 확인하여 걸러냄.
	vector<int>::iterator iterLevelList = vlSkillLevelList.begin();
	for( iterLevelList; iterLevelList != vlSkillLevelList.end(); )
	{
		int iSkillLevelTableID = *iterLevelList;
		int iApplyType = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_ApplyType" )->GetInteger();
		if( iApplyType != iSkillLevelDataApplyType )
			iterLevelList = vlSkillLevelList.erase( iterLevelList );
		else
			++iterLevelList;
	}

	// 해당 대상의 데이터가 없는 경우엔 그냥 아무것도 안하고 리턴하면 된다.
	if( vlSkillLevelList.empty() )
		return true;

	int iSkillLevelTableID = -1;
	for( int i = 0; i < (int)vlSkillLevelList.size(); ++i )
	{
		int iNowLevel = pSkillLevelTable->GetFieldFromLablePtr( vlSkillLevelList.at(i), "_SkillLevel" )->GetInteger();
		if( iNowLevel == iLevel )
		{
			iSkillLevelTableID = vlSkillLevelList.at( i );
			break;
		}
	}

	if( -1 == iSkillLevelTableID )
		return false;

	char caLabel[ 32 ];
	int iCheckerParamOffset = 0;
	int iProcessorParamOffset = 0;
	for( int i = 0; i < MAX_PROCESSOR_COUNT; ++i )
	{
		// 발동조건 객체 이름을 찾는다. 파라메터 필드가 비어있으면 생성 함수들에서 NULL 리턴됨
		sprintf_s( caLabel, "_UsableChecker%d", i + 1 );
		int iUsableChecker = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLabel )->GetInteger();

		sprintf_s( caLabel, "_Processor%d", i + 1 );
		int iProcessor = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLabel )->GetInteger();

		int iOffsetCheck = iCheckerParamOffset;
		IDnSkillUsableChecker* pUsableChecker = IDnSkillUsableChecker::Create( m_hActor, iUsableChecker, iSkillLevelTableID, &iCheckerParamOffset );

		if( NULL != pUsableChecker )
		{
			if( (iCheckerParamOffset - iOffsetCheck) != pUsableChecker->GetNumArgument() )
			{
				OutputDebug( "[SkillLevelTable Error!] %d 의 파라메터 개수가 잘못되었습니다.\n", iSkillLevelTableID );
				_ASSERT( !"스킬 레벨 테이블 파라메터 잘못됨. OutputDebug 출력 확인!" );
			}

			this->AddUsableCheckers( pUsableChecker, iSkillLevelDataApplyType );
		}

		iOffsetCheck = iProcessorParamOffset;
		IDnSkillProcessor* pSkillProcessor = IDnSkillProcessor::Create( m_hActor, iProcessor, iSkillLevelTableID, &iProcessorParamOffset, this->GetUseActionNames() );

		if( NULL != pSkillProcessor )
		{
			if( (iProcessorParamOffset - iOffsetCheck) != pSkillProcessor->GetNumArgument() )
			{
				OutputDebug( "[SkillLevelTable Error!] %d 의 파라메터 개수가 잘못되었습니다.\n", iSkillLevelTableID );
				_ASSERT( !"스킬 레벨 테이블 파라메터 잘못됨. OutputDebug 출력 확인!" );
			}

			this->AddProcessor( pSkillProcessor, iSkillLevelDataApplyType );
		}
	}

	// skill table
	m_strStaticName = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_StaticName" )->GetString();

	char caLable[ 64 ];
	ZeroMemory( caLable, sizeof(caLable) );
	for( int i = 0; i < 2; ++i )
	{
		sprintf_s( caLable,  "_NeedWeaponType%d", i+1 );
		int iEquipType = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLable )->GetInteger();
		if( -1 != iEquipType )
			m_aeNeedEquipType[ i ] = (CDnWeapon::EquipTypeEnum)iEquipType;
		else
			m_aeNeedEquipType[ i ] = CDnWeapon::EquipTypeEnum_Amount;
	}

	// 스킬 테이블의 최대 레벨은 신뢰할 수 없다. -_-
	// 실제 갯수로 업데이트.
	if( 0 == m_iMaxLevel )
	{
		m_iMaxLevel = (int)vlSkillLevelList.size();
	}
	else
	{
		_ASSERT( m_iMaxLevel == (int)vlSkillLevelList.size() );
	}

	m_eSkillType = (SkillTypeEnum)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_SkillType" )->GetInteger();
	m_eDurationType = (DurationTypeEnum)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_DurationType" )->GetInteger();
	m_eTargetType = (TargetTypeEnum)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_TargetType" )->GetInteger();

	m_iDissolvable = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_Dissolvable" )->GetInteger();
	m_iDuplicateCount = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_EffectAmassCount" )->GetInteger();
	m_iSkillDuplicateMethod = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_SkillDuplicate" )->GetInteger();
	m_iEffectDuplicateMethod = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_EffectDuplicate" )->GetInteger();
	m_eElement = (CDnState::ElementEnum)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_Element" )->GetInteger();
	m_iNeedJobClassID = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_NeedJob" )->GetInteger();
	if( (CDnState::ElementEnum)-1 == m_eElement )
		m_eElement = CDnState::ElementEnum_Amount;

	// skill level table
	m_iSkillLevelID = iSkillLevelTableID;
	m_iLevel = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_SkillLevel" )->GetInteger();
	m_iNowLevelSkillPoint = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_NeedSkillPoint" )->GetInteger();

#if defined(PRE_FIX_NEXTSKILLINFO)
	SKILL_LEVEL_INFO* pTabelInfo = g_pDataManager->GetSkillLevelTableIDList(iSkillTableID, iSkillLevelDataApplyType);
	int nextSkillLevel = m_iLevel + 1;

	if( m_iLevel < m_iMaxLevel )
	{
		int nextLevelTableID = -1;
		SKILL_LEVEL_TABLE_IDS::iterator findIter = pTabelInfo->_SkillLevelTableIDs.find(nextSkillLevel);
		if (findIter != pTabelInfo->_SkillLevelTableIDs.end())
			nextLevelTableID = findIter->second;

		m_iNextLevelSkillPoint = pSkillLevelTable->GetFieldFromLablePtr( nextLevelTableID, "_NeedSkillPoint" )->GetInteger();
	}
	else
		m_iNextLevelSkillPoint = 0;

#else
	if( m_iLevel < m_iMaxLevel )
		m_iNextLevelSkillPoint = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID+1, "_NeedSkillPoint" )->GetInteger();
	else
		m_iNextLevelSkillPoint = 0;
#endif // PRE_FIX_NEXTSKILLINFO

	m_iIncreaseRange[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_AddRange" )->GetInteger();

	m_iAdditionalThreat = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_AddThreat" )->GetInteger();

	m_iCPScore = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_CPScore" )->GetInteger();
	m_fStartSuperArmor = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_StartSuperArmor" )->GetFloat();
	m_bStartCanHit = (pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_StartCanHit" )->GetInteger() == 1) ? true : false;

	// 상태 효과 정보 로딩
	StateEffectStruct StateEffect;
	for( int i = 0; i < MAX_STATE_EFFECT_COUNT; ++i )
	{
		sprintf_s( caLable, "_EffectClass%d", i + 1 );
		StateEffect.nID = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLable )->GetInteger();

		if( StateEffect.nID < 1 ) 
			continue;

		sprintf_s( caLable, "_EffectClass%dApplyType", i + 1 );
		int iApplyType = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLable )->GetInteger();
		// 모두 적용임. 타겟만 다르게 해서 똑같은 상태효과 2개를 추가해준다.
		// 하지만 강화 패시브로 사용되는 스킬은 2개로 하지 않고 그냥 생성. 다른 스킬을 강화시키는 데이터 역할만 수행하기 때문.
		bool bApplyAll = (StateEffectApplyType::ApplyAll == iApplyType) && (SkillTypeEnum::EnchantPassive != m_eSkillType);

		if( bApplyAll )
			StateEffect.ApplyType = StateEffectApplyType::ApplySelf;
		else
			StateEffect.ApplyType = (StateEffectApplyType)iApplyType;

		sprintf_s( caLable, "_EffectClassValue%d", i + 1 );
		StateEffect.szValue = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, caLable )->GetString();

		sprintf_s( caLable, "_EffectClassValue%dDuration", i + 1 );
		StateEffect.nDurationTime = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, caLable )->GetInteger();

		m_vlStateEffectList[ iSkillLevelDataApplyType ].push_back( StateEffect );

		// 모두 적용이면 타겟으로 바꿔서 똑같이 한 번 더 넣어줌.
		if( bApplyAll )
		{
			StateEffect.ApplyType = StateEffectApplyType::ApplyTarget;
			m_vlStateEffectList[ iSkillLevelDataApplyType ].push_back( StateEffect );
		}
	}

	SkillInfo& MySkillInfo = m_SkillInfo[ iSkillLevelDataApplyType ];
	MySkillInfo.iSkillID = m_iSkillID;
	MySkillInfo.iSkillLevelID = m_iSkillLevelID;
	MySkillInfo.iLevel = m_iLevel;
	MySkillInfo.iSkillDuplicateMethod = m_iSkillDuplicateMethod;
	MySkillInfo.iDuplicateCount = m_iDuplicateCount;

	MySkillInfo.eSkillType = m_eSkillType;
	MySkillInfo.eDurationType = m_eDurationType;
	MySkillInfo.eTargetType = m_eTargetType;
	MySkillInfo.eApplyType = StateEffect.ApplyType;
	MySkillInfo.iDissolvable = m_iDissolvable;
	MySkillInfo.eSkillElement = m_eElement;
	MySkillInfo.hSkillUser = m_hActor;				// Note: 액터가 항상 유효한 것은 아님
	if( m_hActor )
		MySkillInfo.iSkillUserTeam = m_hActor->GetTeam();

	if( m_hActor && _tcslen(m_hActor->GetName()) > 0 )
		MySkillInfo.strUserName = m_hActor->GetName();

	MySkillInfo.szEffectOutputIDs = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_StateEffectTableID" )->GetString();

	return true;
}

bool CDnSkill::InitializeMonsterSkill( int iSkillTableID, int iLevel )
{
	m_iSkillID = iSkillTableID;

	// 각 모드별로 데이터 로드. 먼저 PVP 를 읽는다.
	// PVE 는 디폴트 값이기 때문에 모드별로 나뉘어지는 값이 아니면 디폴트 값으로 채워지게 된다.

	// 몬스터 스킬 생성 함수이므로 PVE 만 호출.
	if( false == _LoadSkillLevelData( iSkillTableID, iLevel, PVP ) )
		return false;

	if( false == _LoadSkillLevelData( iSkillTableID, iLevel, PVE ) )
		return false;

	int iNumProcessor = (int)m_vlpProcessors[ PVE ].size();
	for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
	{
		IDnSkillProcessor* pProcessor = m_vlpProcessors[ PVE ].at( iProcessor );

		// 사용하는 액션이 있으면 외부에서 조회용으로 데이터 채워놓음
		if( pProcessor->GetType() == IDnSkillProcessor::PLAY_ANI )
			m_setUseActionNames.insert( static_cast<CDnPlayAniProcess*>(pProcessor)->GetActionName() );
		else
			if( pProcessor->GetType() == IDnSkillProcessor::PARTIAL_PLAY_ANI )
			{
				CDnPartialPlayProcessor* pPartialPlayAni = static_cast<CDnPartialPlayProcessor*>(pProcessor);
				m_setUseActionNames.insert( pPartialPlayAni->GetStartActionName() );
				m_setUseActionNames.insert( pPartialPlayAni->GetLoopActionName() );
				m_setUseActionNames.insert( pPartialPlayAni->GetEndActionName() );
			}
	}

	// 초기화 했을 때는 pve 모드가 디폴트임.
	m_iSelectedSkillLevelDataApplyType = PVE;

	return true;
}

DnSkillHandle CDnSkill::CreateMonsterSkill( DnActorHandle hActor, int iSkillTableID, int iLevel )
{
	if( hActor )
	{
		CDnSkill* pNewSkill = pNewSkill = new CDnSkill( hActor );
		if( pNewSkill )
		{
			bool bResult = pNewSkill->InitializeMonsterSkill( iSkillTableID, iLevel );
			if( false == bResult )
			{
				SAFE_DELETE( pNewSkill );
				return CDnSkill::Identity();
			}

			if( hActor->IsPlayerActor() )
			{
				CDnPlayerActor* pPlayerActor = static_cast<CDnPlayerActor*>(hActor.GetPointer());
				pNewSkill->RegisterObserver( pPlayerActor->GetBubbleSystem() );
			}

			return pNewSkill->GetMySmartPtr();
		}
		else
		{
			SAFE_DELETE( pNewSkill );
			return CDnSkill::Identity();
		}
	}

	return CDnSkill::Identity();
}
#endif // #ifdef PRE_FIX_GAMESERVER_OPTIMIZE

void CDnSkill::CreateSkillInfo( int nSkillID, int nSkillLevel, CDnSkill::SkillInfo & sSkillInfo, std::vector<CDnSkill::StateEffectStruct> & vecSkillEffect, bool bUseBattleGround/* = false*/ )
{
	if( nSkillID == 0 || nSkillLevel == 0 )
		return;

	DNTableFileFormat* pSkillTable = NULL;
	DNTableFileFormat* pSkillLevelTable = NULL;
	if (bUseBattleGround)
	{
		pSkillTable = GetDNTable( CDnTableDB::TBATTLEGROUNDSKILL );
		pSkillLevelTable = GetDNTable( CDnTableDB::TBATTLEGROUNDSKILLLEVEL );
	}
	else
	{
		pSkillTable = GetDNTable( CDnTableDB::TSKILL );
		pSkillLevelTable = GetDNTable( CDnTableDB::TSKILLLEVEL );
	}

	if (pSkillLevelTable == NULL || pSkillTable == NULL)
	{
		_DANGER_POINT();
		return;
	}
	std::vector<int> vlSkillLevelList;
	if( pSkillLevelTable->GetItemIDListFromField( "_SkillIndex", nSkillID, vlSkillLevelList ) <= 0 ) 
		return;

	int iSkillLevelTableID = -1;
	for( int i = 0; i < (int)vlSkillLevelList.size(); ++i )
	{
		int iNowLevel = pSkillLevelTable->GetFieldFromLablePtr( vlSkillLevelList.at(i), "_SkillLevel" )->GetInteger();
		if( iNowLevel == nSkillLevel )
		{
			iSkillLevelTableID = vlSkillLevelList.at( i );
			break;
		}
	}

	if( -1 == iSkillLevelTableID )
		return;

	sSkillInfo.iSkillID = nSkillID;
	sSkillInfo.iSkillLevelID = iSkillLevelTableID;
#ifdef PRE_FIX_SYNC_ENCHANT_SKILL
	sSkillInfo.iAppliedEnchantSkillID = 0;
#endif
	sSkillInfo.iLevel = nSkillLevel;
	sSkillInfo.eDurationType = (CDnSkill::DurationTypeEnum)pSkillTable->GetFieldFromLablePtr( nSkillID, "_DurationType" )->GetInteger();
	sSkillInfo.eTargetType = (CDnSkill::TargetTypeEnum)pSkillTable->GetFieldFromLablePtr( nSkillID, "_TargetType" )->GetInteger();
	sSkillInfo.iSkillDuplicateMethod = pSkillTable->GetFieldFromLablePtr( nSkillID, "_SkillDuplicate" )->GetInteger();
	sSkillInfo.iDuplicateCount = pSkillTable->GetFieldFromLablePtr( nSkillID, "_EffectAmassCount" )->GetInteger();
	sSkillInfo.iDissolvable = pSkillTable->GetFieldFromLablePtr( nSkillID, "_Dissolvable" )->GetInteger();
	sSkillInfo.szEffectOutputIDToClient = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_StateEffectTableID" )->GetString();

	sSkillInfo.bFromBuffProp = true;

	// 상태 효과 정보 로딩
	CDnSkill::StateEffectStruct StateEffect;
	char caLable[ 64 ];
	ZeroMemory( caLable, sizeof(caLable) );
	for( int i = 0; i < MAX_STATE_EFFECT_COUNT; ++i )
	{
		sprintf_s( caLable, "_EffectClass%d", i + 1 );
		StateEffect.nID = pSkillTable->GetFieldFromLablePtr( nSkillID, caLable )->GetInteger();

		if( StateEffect.nID < 1 ) 
			continue;

		sprintf_s( caLable, "_EffectClass%dApplyType", i + 1 );
		StateEffect.ApplyType = (CDnSkill::StateEffectApplyType)pSkillTable->GetFieldFromLablePtr( nSkillID, caLable )->GetInteger();

		sprintf_s( caLable, "_EffectClassValue%d", i + 1 );
		StateEffect.szValue = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, caLable )->GetString();

		sprintf_s( caLable, "_EffectClassValue%dDuration", i + 1 );
		StateEffect.nDurationTime = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, caLable )->GetInteger();

		vecSkillEffect.push_back( StateEffect );
	}
}

void CDnSkill::CreateBattleGroundSkillInfo( int nSkillID, int nSkillLevel, CDnSkill::SkillInfo & sSkillInfo, std::vector<CDnSkill::StateEffectStruct> & vecSkillEffect )
{
	CreateSkillInfo(nSkillID, nSkillLevel, sSkillInfo, vecSkillEffect, true);
}

bool CDnSkill::_LoadSkillLevelData( int iSkillTableID, int iLevel, int iSkillLevelDataApplyType )
{
	DNTableFileFormat* pSkillTable = GetDNTable( CDnTableDB::TSKILL );
	DNTableFileFormat* pSkillLevelTable = GetDNTable( CDnTableDB::TSKILLLEVEL );

	vector<int> vlSkillLevelList;
	if( pSkillLevelTable->GetItemIDListFromField( "_SkillIndex", iSkillTableID, vlSkillLevelList ) <= 0 ) 
		return false;

	if( !pSkillTable->IsExistItem( iSkillTableID) )
		return false;

	// pve, pvp 대상인지 확인하여 걸러냄.
	vector<int>::iterator iterLevelList = vlSkillLevelList.begin();
	for( iterLevelList; iterLevelList != vlSkillLevelList.end(); )
	{
		int iSkillLevelTableID = *iterLevelList;
		int iApplyType = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_ApplyType" )->GetInteger();
		if( iApplyType != iSkillLevelDataApplyType )
			iterLevelList = vlSkillLevelList.erase( iterLevelList );
		else
			++iterLevelList;
	}

	// 해당 대상의 데이터가 없는 경우엔 그냥 아무것도 안하고 리턴하면 된다.
	if( vlSkillLevelList.empty() )
		return true;

	int iSkillLevelTableID = -1;
	for( int i = 0; i < (int)vlSkillLevelList.size(); ++i )
	{
		int iNowLevel = pSkillLevelTable->GetFieldFromLablePtr( vlSkillLevelList.at(i), "_SkillLevel" )->GetInteger();
		if( iNowLevel == iLevel )
		{
			iSkillLevelTableID = vlSkillLevelList.at( i );
			break;
		}
	}

	if( -1 == iSkillLevelTableID )
		return false;

#if defined(PRE_FIX_NEXTSKILLINFO)
	//NextLevel이 연속으로 있지 않을 수 있다.. 그래서 여기서 다음 레벨 데이타 테이블 ID를 찾아 놓는다.
	int iMinSkillLevelTableID = -1;
	int iNextSkillLevelTableID = -1;

	SKILL_LEVEL_INFO* pTableInfo = g_pDataManager->GetSkillLevelTableIDList(iSkillLevelTableID, iSkillLevelDataApplyType);
	SKILL_LEVEL_TABLE_IDS::iterator findIter = pTableInfo->_SkillLevelTableIDs.find(pTableInfo->_MinLevel);
	if (findIter != pTableInfo->_SkillLevelTableIDs.end())
		iMinSkillLevelTableID = findIter->second;

	findIter = pTableInfo->_SkillLevelTableIDs.find(iLevel + 1);
	if (findIter != pTableInfo->_SkillLevelTableIDs.end())
		iNextSkillLevelTableID = findIter->second;

#endif // PRE_FIX_NEXTSKILLINFO

	char caLabel[ 32 ];
	int iCheckerParamOffset = 0;
	int iProcessorParamOffset = 0;
	for( int i = 0; i < MAX_PROCESSOR_COUNT; ++i )
	{
		// 발동조건 객체 이름을 찾는다. 파라메터 필드가 비어있으면 생성 함수들에서 NULL 리턴됨
		sprintf_s( caLabel, "_UsableChecker%d", i + 1 );
		int iUsableChecker = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLabel )->GetInteger();

		sprintf_s( caLabel, "_Processor%d", i + 1 );
		int iProcessor = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLabel )->GetInteger();
		
		int iOffsetCheck = iCheckerParamOffset;
		IDnSkillUsableChecker* pUsableChecker = IDnSkillUsableChecker::Create( m_hActor, iUsableChecker, iSkillLevelTableID, &iCheckerParamOffset );

		if( NULL != pUsableChecker )
		{
			if( (iCheckerParamOffset - iOffsetCheck) != pUsableChecker->GetNumArgument() )
			{
				OutputDebug( "[SkillLevelTable Error!] %d 의 파라메터 개수가 잘못되었습니다.\n", iSkillLevelTableID );
				_ASSERT( !"스킬 레벨 테이블 파라메터 잘못됨. OutputDebug 출력 확인!" );
			}

			this->AddUsableCheckers( pUsableChecker, iSkillLevelDataApplyType );
		}

		iOffsetCheck = iProcessorParamOffset;
		IDnSkillProcessor* pSkillProcessor = IDnSkillProcessor::Create( m_hActor, iProcessor, iSkillLevelTableID, &iProcessorParamOffset, this->GetUseActionNames() );

		if( NULL != pSkillProcessor )
		{
			if( (iProcessorParamOffset - iOffsetCheck) != pSkillProcessor->GetNumArgument() )
			{
				OutputDebug( "[SkillLevelTable Error!] %d 의 파라메터 개수가 잘못되었습니다.\n", iSkillLevelTableID );
				_ASSERT( !"스킬 레벨 테이블 파라메터 잘못됨. OutputDebug 출력 확인!" );
			}

			this->AddProcessor( pSkillProcessor, iSkillLevelDataApplyType );
		}
	}

	// skill table
	m_strStaticName = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_StaticName" )->GetString();

	char caLable[ 64 ];
	ZeroMemory( caLable, sizeof(caLable) );
	for( int i = 0; i < 2; ++i )
	{
		sprintf_s( caLable,  "_NeedWeaponType%d", i+1 );
		int iEquipType = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLable )->GetInteger();
		if( -1 != iEquipType )
			m_aeNeedEquipType[ i ] = (CDnWeapon::EquipTypeEnum)iEquipType;
		else
			m_aeNeedEquipType[ i ] = CDnWeapon::EquipTypeEnum_Amount;
	}

	// 스킬 테이블의 최대 레벨은 신뢰할 수 없다. -_-
	// 실제 갯수로 업데이트.
	if( 0 == m_iMaxLevel )
	{
		m_iMaxLevel = (int)vlSkillLevelList.size();
	}
	else
	{
		_ASSERT( m_iMaxLevel == (int)vlSkillLevelList.size() );
	}

	m_eSkillType = (SkillTypeEnum)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_SkillType" )->GetInteger();
	m_eDurationType = (DurationTypeEnum)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_DurationType" )->GetInteger();
	m_eTargetType = (TargetTypeEnum)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_TargetType" )->GetInteger();

	m_iDissolvable = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_Dissolvable" )->GetInteger();
	m_iDuplicateCount = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_EffectAmassCount" )->GetInteger();
	m_iSkillDuplicateMethod = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_SkillDuplicate" )->GetInteger();
	m_iEffectDuplicateMethod = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_EffectDuplicate" )->GetInteger();
	m_eElement = (CDnState::ElementEnum)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_Element" )->GetInteger();
	m_iNeedJobClassID = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_NeedJob" )->GetInteger();
	if( (CDnState::ElementEnum)-1 == m_eElement )
		m_eElement = CDnState::ElementEnum_Amount;

	m_iExclusiveID = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_DuplicatedSkillType" )->GetInteger();
	m_iBaseSkillID = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_BaseSkillID" )->GetInteger();

	m_iGlobalSkillGroupID = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_GlobalSkillGroup" )->GetInteger();

	float fGlobalCoolTime = 0.0f;
	if( PVE == iSkillLevelDataApplyType )
		fGlobalCoolTime = (float)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_GlobalCoolTimePvE" )->GetInteger() / 1000.0f;
	else
	if( PVP == iSkillLevelDataApplyType )
		fGlobalCoolTime = (float)pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_GlobalCoolTimePvP" )->GetInteger() / 1000.0f;

	m_afGlobalCoolTime[ iSkillLevelDataApplyType ] = fGlobalCoolTime;

	// skill level table
	m_iSkillLevelID = iSkillLevelTableID;
	m_iLevel = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_SkillLevel" )->GetInteger();
	m_iNowLevelSkillPoint = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_NeedSkillPoint" )->GetInteger();
	if( m_iLevel < m_iMaxLevel )
#if defined(PRE_FIX_NEXTSKILLINFO)
		m_iNextLevelSkillPoint = pSkillLevelTable->GetFieldFromLablePtr( iNextSkillLevelTableID, "_NeedSkillPoint" )->GetInteger();
#else
		m_iNextLevelSkillPoint = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID+1, "_NeedSkillPoint" )->GetInteger();
#endif // PRE_FIX_NEXTSKILLINFO
	else
		m_iNextLevelSkillPoint = 0;

	m_iNeedItemID[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_NeedItem" )->GetInteger();
	m_iNeedItemDecreaseCount[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_NeedItemDecreaseCount" )->GetInteger();
	m_iIncreaseRange[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_AddRange" )->GetInteger();
	m_iDecreaseHP[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_DecreaseHP" )->GetInteger();
	m_iDecreaseMP[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_DecreaseSP" )->GetInteger();
	m_iLevelLimit = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_LevelLimit" )->GetInteger();
	m_fDelayTime[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_DelayTime" )->GetInteger() / 1000.f;

	// 만약 글로벌 스킬 그룹이 설정되어있다면 스킬 쿨타임을 글로벌 쿨타임으로 대체 시켜준다.
	if( 0 < m_iGlobalSkillGroupID )
		m_fDelayTime[ iSkillLevelDataApplyType ] = m_afGlobalCoolTime[ iSkillLevelDataApplyType ];

	m_fOriginalDelayTime[ iSkillLevelDataApplyType ] = m_fDelayTime[ iSkillLevelDataApplyType ];
	m_iAdditionalThreat = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_AddThreat" )->GetInteger();

	m_fHPConsumeType[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_HPConsumeType" )->GetFloat();
	m_fMPConsumeType[ iSkillLevelDataApplyType ] = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_SPConsumeType" )->GetFloat();
	m_iCPScore = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_CPScore" )->GetInteger();
	m_fStartSuperArmor = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_StartSuperArmor" )->GetFloat();
	m_bStartCanHit = (pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_StartCanHit" )->GetInteger() == 1) ? true : false;

	// 상태 효과 정보 로딩
	StateEffectStruct StateEffect;
	for( int i = 0; i < MAX_STATE_EFFECT_COUNT; ++i )
	{
		sprintf_s( caLable, "_EffectClass%d", i + 1 );
		StateEffect.nID = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLable )->GetInteger();

		if( StateEffect.nID < 1 ) 
			continue;

		sprintf_s( caLable, "_EffectClass%dApplyType", i + 1 );
		int iApplyType = pSkillTable->GetFieldFromLablePtr( iSkillTableID, caLable )->GetInteger();
		// 모두 적용임. 타겟만 다르게 해서 똑같은 상태효과 2개를 추가해준다.
		// 하지만 강화 패시브로 사용되는 스킬은 2개로 하지 않고 그냥 생성. 다른 스킬을 강화시키는 데이터 역할만 수행하기 때문.
		bool bApplyAll = (StateEffectApplyType::ApplyAll == iApplyType) && (SkillTypeEnum::EnchantPassive != m_eSkillType);		

		if( bApplyAll )
		{
			StateEffect.ApplyType = StateEffectApplyType::ApplySelf;
			StateEffect.bApplyAllPair = true;
		}
		else
			StateEffect.ApplyType = (StateEffectApplyType)iApplyType;

		sprintf_s( caLable, "_EffectClassValue%d", i + 1 );
		StateEffect.szValue = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, caLable )->GetString();

		sprintf_s( caLable, "_EffectClassValue%dDuration", i + 1 );
		StateEffect.nDurationTime = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, caLable )->GetInteger();

		m_vlStateEffectList[ iSkillLevelDataApplyType ].push_back( StateEffect );

		// 모두 적용이면 타겟으로 바꿔서 똑같이 한 번 더 넣어줌.
		if( bApplyAll )
		{
			StateEffect.ApplyType = StateEffectApplyType::ApplyTarget;
			m_vlStateEffectList[ iSkillLevelDataApplyType ].push_back( StateEffect );
		}
	}

	SkillInfo& MySkillInfo = m_SkillInfo[ iSkillLevelDataApplyType ];
	MySkillInfo.iSkillID = m_iSkillID;
	MySkillInfo.iSkillLevelID = m_iSkillLevelID;
	MySkillInfo.iLevel = m_iLevel;
	MySkillInfo.iSkillDuplicateMethod = m_iSkillDuplicateMethod;
	MySkillInfo.iDuplicateCount = m_iDuplicateCount;

	MySkillInfo.eSkillType = m_eSkillType;
	MySkillInfo.eDurationType = m_eDurationType;
	MySkillInfo.eTargetType = m_eTargetType;
	MySkillInfo.eApplyType = StateEffect.ApplyType;
	MySkillInfo.iDissolvable = m_iDissolvable;
	MySkillInfo.eSkillElement = m_eElement;
	MySkillInfo.hSkillUser = m_hActor;				// Note: 액터가 항상 유효한 것은 아님
	if( m_hActor )
		MySkillInfo.iSkillUserTeam = m_hActor->GetTeam();

	if( m_hActor && _tcslen(m_hActor->GetName()) > 0 )
		MySkillInfo.strUserName = m_hActor->GetName();

	MySkillInfo.szEffectOutputIDs = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_StateEffectTableID" )->GetString();

	if( 0.0f == m_fHPConsumeType[ iSkillLevelDataApplyType ] )
	{
		m_iNeedHP[ iSkillLevelDataApplyType ] = m_iDecreaseHP[ iSkillLevelDataApplyType ];
	}
	else
	{
		m_iNeedHP[ iSkillLevelDataApplyType ] = int((float)m_hActor->GetMaxHP() * m_fHPConsumeType[ iSkillLevelDataApplyType ]);
	}

#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
	m_nPrefixSkillType = pSkillTable->GetFieldFromLablePtr( iSkillTableID, "_Group" )->GetInteger();

	//스킬 정보에 접미사 스킬 그룹ID를 설정 해 놓는다..(클라이언트는 몰라도 됨?...)
	SetPrefixSkillType(m_nPrefixSkillType);
#endif // PRE_ADD_PREFIX_SYSTE_RENEW

	return true;
}


void CDnSkill::_OnInitialize( void )
{
	// 129번 ChangeActionSet 상태효과와 DnApplySEWhenActionSetBlowEnabledProcessor 발현 타입이 있다면 ChangeActionSet 을 제외한 모든 상태효과를
	// 발현타입 객체에 몰아주고 삭제. 추후에 바뀐 액션에서만 상태효과가 유효하도록 발현타입에서 컨트롤 하게 된다.
	// 우선 그냥 포인터를 물려볼까..
	for( int k = PVE; k < NUM_SKILLLEVEL_APPLY_TYPE; ++k )
	{
		CDnApplySEWhenActionSetBlowEnabledProcessor* pApplySEWhenActionSetBlowEnableProcessor = 
			static_cast<CDnApplySEWhenActionSetBlowEnabledProcessor*>(GetProcessor( IDnSkillProcessor::APPLY_SE_WHEN_ACTIONSET_ENABLED, k ));
		if( pApplySEWhenActionSetBlowEnableProcessor )
		{
			// 이 발현타입이 있는데 ChangeActionSet 상태효과와 ChangeActionStr 발현타입이 없으면 오류..
			bool bValid = false;
			for( int i = 0; i < (int)m_vlStateEffectList[ k ].size(); ++i )
			{
				StateEffectStruct& StateEffect = m_vlStateEffectList[ k ].at( i );
				if( STATE_BLOW::BLOW_129 == StateEffect.nID )
				{
					bValid = true;
					break;
				}
			}

			if( bValid )
			{
				CDnChangeActionStrProcessor* pChangeActionStrProcessor = static_cast<CDnChangeActionStrProcessor*>(GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR, k ));
				if( pChangeActionStrProcessor )
					bValid = true;
				else
					bValid = false;
			}

			if( bValid )
			{
				for( int i = 0; i < (int)m_vlStateEffectList[ k ].size(); ++i )
				{
					StateEffectStruct& StateEffect = m_vlStateEffectList[ k ].at( i );
					if( STATE_BLOW::BLOW_129 != StateEffect.nID )
					{
						pApplySEWhenActionSetBlowEnableProcessor->AddStateEffect( &StateEffect );
						StateEffect.bApplyInProcessor = true;
					}
				}
			}
		}
	}
}


bool CDnSkill::Initialize( int iSkillTableID, int iLevel )
{
	m_iSkillID = iSkillTableID;

	// 각 모드별로 데이터 로드. 먼저 PVP 를 읽는다.
	// PVE 는 디폴트 값이기 때문에 모드별로 나뉘어지는 값이 아니면 디폴트 값으로 채워지게 된다.

	// 몬스터인 경우엔 pvp 데이터가 없으므로 함수 안에서 아무것도 안되고 리턴된다.
	// 만약 플레이어인데 아무것도 없다면 잘못된 거임.
	if( false == _LoadSkillLevelData( iSkillTableID, iLevel, PVP ) )
		return false;

	if( false == _LoadSkillLevelData( iSkillTableID, iLevel, PVE ) )
		return false;

	// 초기화 이후에 따로 모아놓을 정보들.
	DNTableFileFormat* pSkillTable = GetDNTable( CDnTableDB::TSKILL );

	RefreshDecreaseMP();

	int iNumProcessor = (int)m_vlpProcessors[ PVE ].size();
	for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
	{
		IDnSkillProcessor* pProcessor = m_vlpProcessors[ PVE ].at( iProcessor );

		// 사용하는 액션이 있으면 외부에서 조회용으로 데이터 채워놓음
		if( pProcessor->GetType() == IDnSkillProcessor::PLAY_ANI )
			m_setUseActionNames.insert( static_cast<CDnPlayAniProcess*>(pProcessor)->GetActionName() );
		else
		if( pProcessor->GetType() == IDnSkillProcessor::PARTIAL_PLAY_ANI )
		{
			CDnPartialPlayProcessor* pPartialPlayAni = static_cast<CDnPartialPlayProcessor*>(pProcessor);
			m_setUseActionNames.insert( pPartialPlayAni->GetStartActionName() );
			m_setUseActionNames.insert( pPartialPlayAni->GetLoopActionName() );
			m_setUseActionNames.insert( pPartialPlayAni->GetEndActionName() );
		}
	}

	// 초기화 했을 때는 pve 모드가 디폴트임.
	m_iSelectedSkillLevelDataApplyType = PVE;

	_OnInitialize();

	if (m_eDurationType == SummonOnOff)
		OnInitializeSummonMonsterInfo();

	return true;
}


bool CDnSkill::AddUsableCheckers( IDnSkillUsableChecker* pUsableChecker, int iSelectedLevelData )
{
	bool bResult = false;

	if( pUsableChecker )
	{
		m_vlpUsableCheckers[ iSelectedLevelData ].push_back( pUsableChecker );
		bResult = true;
	}

	return bResult;
}


bool CDnSkill::AddProcessor( IDnSkillProcessor* pProcessor, int iSelectedLevelData )
{
	bool bResult = false;

	if( pProcessor )
	{
		m_vlpProcessors[ iSelectedLevelData ].push_back( pProcessor );
		bResult = true;
	}

	return bResult;
}


bool CDnSkill::IsSatisfyWeapon( void )
{
	bool bSatisfy = true;

	if( (CDnWeapon::EquipTypeEnum_Amount != m_aeNeedEquipType[ 0 ]) ||
		(CDnWeapon::EquipTypeEnum_Amount != m_aeNeedEquipType[ 1 ]) )
	{
		bSatisfy = false;

		if( CDnWeapon::EquipTypeEnum_Amount != m_aeNeedEquipType[ 0 ] && CDnWeapon::EquipTypeEnum_Amount != m_aeNeedEquipType[ 1 ] )
		{
			if( CDnWeapon::IsSubWeapon( m_aeNeedEquipType[ 0 ] ) == CDnWeapon::IsSubWeapon( m_aeNeedEquipType[ 1 ] ) )	// 1. 둘다 주무기이거나 보조무기 인 경우 or
			{
				int nWeapon = CDnWeapon::IsSubWeapon( m_aeNeedEquipType[ 0 ] ) ? 1 : 0;
#ifdef _GAMESERVER
				if( m_hActor->GetWeapon( nWeapon ) && m_aeNeedEquipType[ 0 ] == m_hActor->GetWeapon( nWeapon )->GetEquipType()
					|| m_hActor->GetWeapon( nWeapon ) && m_aeNeedEquipType[ 1 ] == m_hActor->GetWeapon( nWeapon )->GetEquipType() )
#else // _GAMESERVER
				if( m_hActor->GetWeapon( nWeapon, false ) && m_aeNeedEquipType[ 0 ] == m_hActor->GetWeapon( nWeapon, false )->GetEquipType()
					|| m_hActor->GetWeapon( nWeapon, false ) && m_aeNeedEquipType[ 1 ] == m_hActor->GetWeapon( nWeapon, false )->GetEquipType() )
#endif // _GAMESERVER
					bSatisfy = true;
			}
			else	// 2. 주무기, 보조무기인 경우 and
			{
				if( CDnWeapon::IsSubWeapon( m_aeNeedEquipType[ 0 ] ) )
				{
#ifdef _GAMESERVER
					if( m_hActor->GetWeapon( 1 ) && m_aeNeedEquipType[ 0 ] == m_hActor->GetWeapon( 1 )->GetEquipType()
						&& m_hActor->GetWeapon( 0 ) && m_aeNeedEquipType[ 1 ] == m_hActor->GetWeapon( 0 )->GetEquipType() )
#else // _GAMESERVER
					if( m_hActor->GetWeapon( 1, false ) && m_aeNeedEquipType[ 0 ] == m_hActor->GetWeapon( 1, false )->GetEquipType()
						&& m_hActor->GetWeapon( 0, false ) && m_aeNeedEquipType[ 1 ] == m_hActor->GetWeapon( 0, false )->GetEquipType() )
#endif // _GAMESERVER
						bSatisfy = true;
				}
				else
				{
#ifdef _GAMESERVER
					if( m_hActor->GetWeapon( 0 ) && m_aeNeedEquipType[ 0 ] == m_hActor->GetWeapon( 0 )->GetEquipType()
						&& m_hActor->GetWeapon( 1 ) && m_aeNeedEquipType[ 1 ] == m_hActor->GetWeapon( 1 )->GetEquipType() )
#else // _GAMESERVER
					if( m_hActor->GetWeapon( 0, false ) && m_aeNeedEquipType[ 0 ] == m_hActor->GetWeapon( 0, false )->GetEquipType()
						&& m_hActor->GetWeapon( 1, false ) && m_aeNeedEquipType[ 1 ] == m_hActor->GetWeapon( 1, false )->GetEquipType() )
#endif // _GAMESERVER
						bSatisfy = true;
				}
			}
		}
		else
		{
			for( int i=0; i<MAX_SKILL_NEED_EQUIP_COUNT; ++i )
			{
				if( CDnWeapon::EquipTypeEnum_Amount != m_aeNeedEquipType[ i ] )
				{
					for( int k=0; k<2; ++k )
					{
						// bActionMatchWeapon 를 디폴트로 true 로 호출하니까 액션에 따라 무기가 다르게 나오는 듯 하여 항상 차고 있는 메인 무기 위주로 체크토록..
#ifdef _GAMESERVER
						if( m_hActor->GetWeapon( k ) && m_aeNeedEquipType[ i ] == m_hActor->GetWeapon( k )->GetEquipType() )
#else // _GAMESERVER
						if( m_hActor->GetWeapon( k, false ) && m_aeNeedEquipType[ i ] == m_hActor->GetWeapon( k, false )->GetEquipType() )
#endif // _GAMESERVER
						{
							bSatisfy = true;
							break;
						}
					}
					if( bSatisfy )
						break;
				}
			}
		}
	}

	return bSatisfy;
}

CDnSkill::UsingResult CDnSkill::CanExecute( void )
{
	UsingResult eResult = UsingResult::Failed;

	if( !m_hActor )
		return UsingResult::Failed;

	if( m_hActor->IsPlayerActor() )
	{
		CDnPlayerActor* pPlayerActor = static_cast<CDnPlayerActor*>(m_hActor.GetPointer());
		if( pPlayerActor && pPlayerActor->IsSwapSingleSkin() )
		{
			if( pPlayerActor->IsTransformSkill(GetClassID()) == false )
				return UsingResult::Failed;
		}
	}
	if (m_hActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_176))
	{
		DNVector(DnBlowHandle) vlBlows;
		CDnAllowedSkillsBlow* pAllowedSkillBlow = NULL;
		m_hActor->GatherAppliedStateBlowByBlowIndex(STATE_BLOW::BLOW_176, vlBlows);
		for (int i = 0; i < (int)vlBlows.size(); ++i)
		{
			pAllowedSkillBlow = static_cast<CDnAllowedSkillsBlow*>(vlBlows[i].GetPointer());
			if (!pAllowedSkillBlow) continue;

			if (!pAllowedSkillBlow->IsAllowSkill(m_iSkillID))
				return UsingResult::Failed;
		}
	}

	// 잔여 SP 체크, 체력 체크, 레벨 체크 등등
	// 오라나 토글은 현재 활성화 중이라면 MP 상관 없이 끌 수 있다.
	if( !IsToggleOn() && !IsAuraOn() )
		if( m_hActor->GetSP() < m_iNeedMP[ m_iSelectedSkillLevelDataApplyType ] )
			return UsingResult::Failed;

	// 워리어의 릴리브같은 스킬은 수면, 스턴 중일때도 사용가능해야 한다.
	// 테이블에 공격불가 무시 발현타입을 추가할까하다가 현재 릴리브에서만 의미있는 것이므로
	// 다른 곳에서 어떤 식으로 쓰이게 될지 좀 더 지켜보고 규격화 시키도록 한다.
	// 우선 Dissolve 상태효과 있는 스킬은 행동 불가 체크를 건너뛴다.
	// 스킬에 해당하는 액션의 State 시그널에 반드시 IgnorectCantAction 이 켜져 있어야 스킬 액션이 나간다.
	bool bPassCheckCantAction = false;
	for( DWORD i = 0; i < GetStateEffectCount(); ++i )
	{
		//#40480 결빙상태에서 단축슬롯 활성화를 위해서..
		CDnSkill::StateEffectStruct* pSE = GetStateEffectFromIndex( i );

		if( STATE_BLOW::BLOW_069 == pSE->nID )
		{
			// 76643 ( Dissolvable 이 2면 그냥 비활성화 해달라고 합니다 )
			for( int i=0 ; i<m_hActor->GetNumAppliedStateBlow() ; ++i )
			{
				DnBlowHandle hBlow = m_hActor->GetAppliedStateBlow( i );
				if( hBlow )
				{
					const CDnSkill::SkillInfo* pSkillInfo = hBlow->GetParentSkillInfo();
					if( pSkillInfo && pSkillInfo->iDissolvable == 2 )
						return UsingResult::Failed;
				}
			}

			bPassCheckCantAction = true;
			break;
		}

		if( STATE_BLOW::BLOW_155 == pSE->nID )
		{
			bPassCheckCantAction = true;
			break;
		}
	}

	// 스킬 사용불가 상태효과가 있으면 mp 소모하는 스킬은 사용할 수 없다.
	if( 0 < m_hActor->GetCantUseSkillSEReferenceCount() )
		if( 0 < m_iNeedMP[ m_iSelectedSkillLevelDataApplyType ] )
			return UsingResult::Failed;

	// 67번 스킬 제한 상태효과가 있으면 액티브 스킬은 사용할 수 없음. 
	if( m_eSkillType == CDnSkill::Active )
	{
		int iAppliedStateBlow = m_hActor->GetNumAppliedStateBlow();
		for( int iBlow = 0; iBlow < iAppliedStateBlow; ++iBlow )
		{
			DnBlowHandle hBlow = m_hActor->GetAppliedStateBlow( iBlow );
			if( hBlow && hBlow->GetBlowIndex() == STATE_BLOW::BLOW_067 )
				return UsingResult::Failed;
		}
	}

	// HP 
	if( m_hActor->GetHP() < m_iNeedHP[ m_iSelectedSkillLevelDataApplyType ] )
		return UsingResult::Failed;

	bool isCharacterLevelCheck = true;
	//스킬 레벨업 아이템에 의해 스킬레벨업이 된 스킬은 캐릭터 레벨 체크 하지 않도록 한다.
	isCharacterLevelCheck = (GetLevelUpValue() == 0);
	
	if (isCharacterLevelCheck)
	{
		if( m_hActor->GetLevel() < m_iLevelLimit )
			return UsingResult::Failed;
	}

	// 필요 무기가 있다면 장착했는지 확인. 최대 2개임. 둘 중 하나만 충족되도 스킬 사용 가능.
	if( (CDnWeapon::EquipTypeEnum_Amount != m_aeNeedEquipType[ 0 ]) ||
		(CDnWeapon::EquipTypeEnum_Amount != m_aeNeedEquipType[ 1 ]) )
	{
		bool bSatisfy = false;
		for( int i = 0; i < MAX_SKILL_NEED_EQUIP_COUNT; ++i )
		{
			if( CDnWeapon::EquipTypeEnum_Amount != m_aeNeedEquipType[ i ] )
			{
				for( int k = 0; k < 2; ++k )
				{
					// #11120 관련. 발차기 상태에서는 장착하고 있는 무기를 얻지 못하기 때문에 명시적으로 원래 함수로 장착하고 있는 무기를 얻어오자.
					if( m_hActor->CDnActor::GetWeapon( k ) && m_aeNeedEquipType[ i ] == m_hActor->CDnActor::GetWeapon( k )->GetEquipType() )
					{
						bSatisfy = true;
						break;
					}
				}
				if( bSatisfy )
					break;
			}
		}

		if( false == bSatisfy )
			return UsingResult::Failed;
	}

	// 화살 같은 소모성 아이템의 갯수 확인
	bool bCheckNeedItem = true;
	if( GetRoom() && bIsExtremitySkill() && static_cast<CDNGameRoom*>(GetRoom())->bIsLadderRoom() )	// 래더에서 궁극기 스킬
		bCheckNeedItem = false;

	if( bCheckNeedItem && m_iNeedItemID[ m_iSelectedSkillLevelDataApplyType ] > 0 )
	{
		int iNumNeedItem = CDnItemTask::GetInstance( m_hActor->GetRoom() ).ScanItemFromID( m_hActor, m_iNeedItemID[ m_iSelectedSkillLevelDataApplyType ], NULL );
		if( iNumNeedItem < m_iNeedItemDecreaseCount[ m_iSelectedSkillLevelDataApplyType ] )
			return UsingResult::Failed;
	}
	// 직업 체크
	//if( m_hActor->GetClassID() <= CDnActor::Reserved6  )
	if( m_hActor->IsPlayerActor() )
	{
		//CDnPlayerActor* pActor = dynamic_cast<CDnPlayerActor*>(m_hActor.GetPointer());
		CDnPlayerActor* pActor = static_cast<CDnPlayerActor*>(m_hActor.GetPointer());
		if( NULL == pActor )
			return UsingResult::Failed;
		if( 0 != m_iNeedJobClassID )
		{
			if( pActor->IsPassJob( m_iNeedJobClassID ) == false ) 
				return UsingResult::Failed;
		}

		// 배틀 모드가 아니면 스킬 발동 불가!
		if( !pActor->IsBattleMode() )
			return UsingResult::Failed;
	}

	switch( m_eDurationType )
	{
	    case CDnSkill::Instantly:
		case CDnSkill::Buff:
		case CDnSkill::Debuff:
		case CDnSkill::SummonOnOff:
		case CDnSkill::StanceChange:
			{
				// 쿨타임이 끝나지 않았다면 스킬 발동 불가.. 우선 클라에서 체크해서 보내주므로 서버에선 약간의 유예 시간을 남겨둔다.
				// 몬스터이거나 오토 패시브 스킬인 경우엔 칼같이 체크.
				if( m_hActor->IsMonsterActor() ||
					SkillTypeEnum::AutoPassive == m_eSkillType )
				{
					if( m_fCoolTime > 0.0f )
						return UsingResult::FailedByCooltime;
				}
				else
				{
					if( m_fLeftDelayTime > 0.5f )
						return UsingResult::FailedByCooltime;
				}
			}
			break;

		case CDnSkill::TimeToggle: 
			break;

		case CDnSkill::ActiveToggle:
		case CDnSkill::ActiveToggleForSummon:
			break;

		case CDnSkill::Aura:
			break;
	}

	if( m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].empty() )
		eResult = UsingResult::Success;
	else
	{
		int iNumChecker = (int)m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].size();

		for( int iChecker = 0; iChecker < iNumChecker; ++iChecker )
		{
			IDnSkillUsableChecker* pChecker = m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].at( iChecker );
			if( false == pChecker->CanUse() )
			{
				eResult = UsingResult::FailedByUsableChecker;
				break;
			}
			else
				eResult = UsingResult::Success;
		}
	}

	return eResult;
}



float CDnSkill::GetDelayTime( void ) 
{ 

#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
	float fDelayTime = 0.0f;

	if( 0.0f < m_fAnotherGlobalSkillCoolTime )
	{
		fDelayTime = m_fAnotherGlobalSkillCoolTime;

		DnSkillHandle hAnotherSkill;
		if (m_hActor)
			hAnotherSkill = m_hActor->FindSkill(m_nAnotherGlobakSkillID);

		if (hAnotherSkill)
		{
			if (hAnotherSkill->GetAnotherGlobalSkillID() != GetClassID())
				fDelayTime = hAnotherSkill->GetDelayTime();
		}
	}
	else
	//위m_fAnotherGlobalSkillCoolTime이 적용 되어 있으면 적용 안 하도록..
	{
		fDelayTime = m_fDelayTime[ m_iSelectedSkillLevelDataApplyType ]; 

		float fGlobalCoolTimeRate = 0.0f;
		if (m_hActor &&
			m_hActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_269) && 
			m_iGlobalSkillGroupID > 0)
		{
			DNVector(DnBlowHandle) vlBlows;
			m_hActor->GatherAppliedStateBlowByBlowIndex(STATE_BLOW::BLOW_269, vlBlows);
			{
				int nCount = (int)vlBlows.size();
				for (int i = 0; i < nCount; ++i)
				{
					DnBlowHandle hBlow = vlBlows[i];
					if (hBlow && hBlow->IsEnd() == false)
					{
						fGlobalCoolTimeRate += hBlow->GetFloatValue();
					}
				}
			}
		}

		fDelayTime -= fDelayTime * fGlobalCoolTimeRate;
	}	

	return fDelayTime;
#else
	if( 0.0f < m_fAnotherGlobalSkillCoolTime )
		return m_fAnotherGlobalSkillCoolTime;

	return  m_fDelayTime[ m_iSelectedSkillLevelDataApplyType ]; 
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
}


void CDnSkill::OnBeginCoolTime()
{
	m_dwLastUseSkillTimeStamp = timeGetTime();

	m_fCoolTime = (GetDelayTime() == 0.0f) ? 0.0f : 1.0f;

	m_fCoolTimeAdjustBlowValue = 1.0f;

	m_fLeftDelayTime = GetDelayTime()*m_fCoolTimeAdjustBlowValue;

	m_fLeftDelayTime *= m_fCoolTimeMultipier;

	// [2011/03/09 semozz]
	// 시작할때 LeftDelayTime이 0.0이 되면 m_fCoolTime을 0.0f로 변경해야한다.
	// 그렇지 않으면 쿨타임이 1.0으로 계속 유지됨.(Process함수에서 m_fLeftDelayTime이 0이면 CoolTime갱신안됨.
	if (m_fLeftDelayTime == 0.0f)
	{
		m_fCoolTime = 0.0f;

#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
		m_fDeltaGlobalCoolTime = 0.0f;
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
	}
}



void CDnSkill::_OnBeginProcessException( void )
{
	// 결빙상태에서 워리어 릴리브 스킬을 쓰는 경우 바로 프레임 고정을 풀어준다. #12438
	// 결빙상태효과가 걸린 상태에서 디버프 상태효과 해제 상태효과가 self 로 적용되는 스킬을 
	// 사용하는 경우로 일반화 시킴.
	if( m_hActor && 
		(
		m_hActor->IsAppliedThisStateBlow( STATE_BLOW::BLOW_041 ) ||
		m_hActor->IsAppliedThisStateBlow( STATE_BLOW::BLOW_146 ) ||
		m_hActor->IsAppliedThisStateBlow( STATE_BLOW::BLOW_218 ) //#53900 Escape스킬 추가
		))
	{
		int iNumStateBlow = (int)m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].size();
		for( int i = 0; i < iNumStateBlow; ++i )
		{
			const StateEffectStruct& SE = m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].at( i );
			if( STATE_BLOW::BLOW_069 == SE.nID &&
				StateEffectApplyType::ApplySelf == SE.ApplyType )
			{
				// 프레임 정지 상태효과 참조 인덱스를 모두 풀어준다. 프레임이 돌아야 액션이 돌아가고
				// 액션이 돌아가야 릴리브 상태효과가 들어간다.
				while( 0 < m_hActor->GetFrameStopRefCount() )
					m_hActor->RemovedFrameStop();
				break;
			}
		}
	}

	//낙인 상태효과 제거
	ClearStigmaStateEffect();
}

void CDnSkill::ClearStigmaStateEffect()
{
	//////////////////////////////////////////////////////////////////////////
	//낙인 상태효과가 있는 스킬인지 확인...
	bool hasStigmaState = false;
	int nListCount = (int)m_vlStateEffectList[m_iSelectedSkillLevelDataApplyType].size();
	for (int i = 0; i < nListCount; ++i)
	{
		const StateEffectStruct& SE = m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].at( i );
		if (SE.nID == STATE_BLOW::BLOW_246)
		{
			hasStigmaState = true;
			break;
		}
	}

	//주위 낙인 효과를 찾아서 제거 해준다...
	if (hasStigmaState == true)
	{
		DNVector(DnActorHandle) hVecList;
		m_hActor->ScanActor(m_hActor->GetRoom(), *m_hActor->GetPosition(), FLT_MAX, hVecList);

		int nActorCount = (int)hVecList.size();
		for (int i = 0; i < nActorCount; ++i)
		{
			DnActorHandle hActor = hVecList[i];
			if (hActor && hActor->IsDie() == false && hActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_246))
			{
				DNVector(DnBlowHandle) vlhBlows;
				hActor->GetStateBlow()->GetStateBlowFromBlowIndex( STATE_BLOW::BLOW_246, vlhBlows );
				int iNumBlow = (int)vlhBlows.size();
				for( int j = 0; j < iNumBlow; ++j )
				{
					DnBlowHandle hBlow = vlhBlows[j];
					if (hBlow && hBlow->IsEnd() == false)
					{
						CDnSkill::SkillInfo* pSkillInfo = const_cast<CDnSkill::SkillInfo*>(hBlow->GetParentSkillInfo());
						if (pSkillInfo && pSkillInfo->hSkillUser == m_hActor)
						{
							int nBlowID = hBlow->GetBlowID();
							hActor->SendRemoveStateEffectFromID(nBlowID);	//제거 패킷 보내고
							hActor->GetStateBlow()->RemoveImediatlyStateEffectFromID(nBlowID);	//즉시 제거 한다.
						}
					}
				}
			}

		}

	}
	//////////////////////////////////////////////////////////////////////////
}

// 스킬에 달려있는 Processor 들 중에 선처리 해야하는 것들 먼저 처리.
void CDnSkill::CheckProcessorOnBegin( void )
{
	CheckChangeActionStrByBubbleProcessor();
	CheckStateEffectApplyOnOffByBubbleProcessor();
}

void CDnSkill::CheckChangeActionStrByBubbleProcessor( void )
{
	CDnChangeActionStrByBubbleProcessor* pProcessor = static_cast<CDnChangeActionStrByBubbleProcessor*>(GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR_BY_BUBBLE ));
	if( pProcessor )
	{
		bool bChanged = false;
		const char* pChangedActionName = pProcessor->GetChangeActionNameAndRemoveNeedBubble( &bChanged );
		if( bChanged )
		{
			// 액션을 바꿔준다.
			CDnPlayAniProcess* pPlayAniProcessor = static_cast<CDnPlayAniProcess*>(GetProcessor( IDnSkillProcessor::PLAY_ANI ));
			if (pPlayAniProcessor)
				pPlayAniProcessor->ChangeActionNameOnce( pChangedActionName );
		}
	}
}


void CDnSkill::CheckStateEffectApplyOnOffByBubbleProcessor( void )
{
	// 버블 갯수에 따라 상태효과 갯수를 변경시키는 Processor
	CDnStateEffectApplyOnOffByBubbleProcessor* pProcessor = static_cast<CDnStateEffectApplyOnOffByBubbleProcessor*>(GetProcessor(IDnSkillProcessor::STATE_EFFECT_APPLY_ONOFF_BY_BUBBLE));
	if( pProcessor )
	{
		pProcessor->SelectAvailableSE( m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ] );
	}
}


void CDnSkill::OnBegin( LOCAL_TIME LocalTime, float fDelta )
{
	ApplyAddtionalStateInfo();

	// 등록된 옵저버에게 스킬 사용 메시지 보냄.
	boost::shared_ptr<IDnObserverNotifyEvent> pNotifyEvent( new CDnUseSkillMessage );
    boost::shared_ptr<CDnUseSkillMessage> pSkillUseEvent = shared_polymorphic_downcast<CDnUseSkillMessage>( pNotifyEvent );
	pSkillUseEvent->SetSkillID( m_iSkillID );
	CDnObservable::Notify( pNotifyEvent );

	CheckProcessorOnBegin();

	// 같은 글로벌 ID 를 사용하는 다른 글로벌 스킬을 사용하여 셋팅된 쿨타임 값을 실제로 이 스킬 사용될 때는 제거한다.
	m_fAnotherGlobalSkillCoolTime = 0.0f;

	m_nAnotherGlobakSkillID = 0;

	m_SkillStartTime = LocalTime;
	//m_LastAuraCheckTime = 0;

#if defined( PRE_ADD_ACADEMIC ) // 소환형 몬스터 액티브 토글 스킬은 쿨타임이 돌필요가 없습니다.
	if(m_eDurationType != DurationTypeEnum::ActiveToggleForSummon)
		//OnBeginCoolTime();

	{
		//--------------------------------------------------
		//[debug_skill]  server
		//세콘늴鑒阮?
		//祺꼍鸞=6001   槿近랐땄=6003  莖슉黛듐=6204   섐똑댔샌=6208

		if ( 6001 == GetClassID() || 6003 == GetClassID() || 6204 == GetClassID() || 6208 == GetClassID() )
		{
			//int nSkillID = GetClassID();
		} 
		else
		{
			OnBeginCoolTime();
		}
		//--------------------------------------------------
	}
#else
		//--------------------------------------------------
		//[debug_skill]  server
		//세콘늴鑒阮?
	    //祺꼍鸞=6001   槿近랐땄=6003  莖슉黛듐=6204   섐똑댔샌=6208

	    if ( 6001 == GetClassID() || 6003 == GetClassID() || 6204 == GetClassID() || 6208 == GetClassID() )
		{
			int nSkillID = GetClassID();
		} 
		else
		{
			OnBeginCoolTime();
		}
		//--------------------------------------------------
#endif

	m_LastTimeToggleMPDecreaseTime = LocalTime;
	m_bFinished = false;

	// 아이템 소모로 셋팅되어있다면 소모하도록 처리.
	bool bCheckNeedItem = true;
	if( GetRoom() && bIsExtremitySkill() && static_cast<CDNGameRoom*>(GetRoom())->bIsLadderRoom() )	// 래더에서 궁극기 스킬
		bCheckNeedItem = false;

	if( bCheckNeedItem && m_iNeedItemID[ m_iSelectedSkillLevelDataApplyType ] > 0 )
	{
		if( m_hActor && m_hActor->IsPlayerActor() )
		{
			CDNUserItem* pUserItem = static_cast<CDnPlayerActor*>(m_hActor.GetPointer())->GetUserSession()->GetItem();
			//int iNeedItemSlotIndex = pUserItem->FindInventorySlot( m_iNeedItemID, m_iNeedItemDecreaseCount );
			if (!pUserItem->DeleteInventoryByItemID( m_iNeedItemID[ m_iSelectedSkillLevelDataApplyType ], m_iNeedItemDecreaseCount[ m_iSelectedSkillLevelDataApplyType ], DBDNWorldDef::UseItem::Use )) return;
		}
	}

	if( ActiveToggle != m_eDurationType && TimeToggle != m_eDurationType && ActiveToggleForSummon != m_eDurationType )
	{
		CheckAndAddSelfStateEffect();
	}

	int iNumProcessor = (int)m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].size();
	for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
	{
		IDnSkillProcessor* pProcessor = m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].at( iProcessor );
		pProcessor->OnBegin( LocalTime, fDelta, GetMySmartPtr() );
	}

	if( false == m_bItemSkill )
	{
		m_hActor->SetSkillSuperAmmor( int(m_hActor->GetSuperAmmor() * m_fStartSuperArmor) );
		m_hActor->SetHittable( m_bStartCanHit );
	}

	// 스킬 사용 관련 예외 상황 처리.
	_OnBeginProcessException();

	if( m_hActor->IsPlayerActor() && 0.0f != m_fResetCooltime )
	{
		int nRand = _rand(m_hActor->GetRoom())%100;

		if( nRand < (int)(m_fResetCooltime * 100) )
		{
			static_cast<CDnPlayerActor*>(m_hActor.GetPointer())->RequestCooltimeReset( m_iSkillID );
			m_fCoolTime = 0.0f; 
			m_fLeftDelayTime = 0.0f;

#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
			m_fDeltaGlobalCoolTime = 0.0f;
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
		}
	}

#if defined(PRE_ADD_50903)
	//스킬 시작될때 리셋 시킴..
	SetHitCountForVarianceDamage(0);
#endif // PRE_ADD_50903
}


// 실제로 스킬이 발동 되었을 시에 처리
void CDnSkill::ProcessExecute( LOCAL_TIME LocalTime, float fDelta )
{
	switch( m_eDurationType )
	{
		case DurationTypeEnum::TimeToggle:
			break;

		case DurationTypeEnum::Aura:
			break;
	}

	// 딸려 있는 프로세서 처리
	int iNumProcessor = (int)m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].size();
	for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
	{
		IDnSkillProcessor* pProcessor = m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].at( iProcessor );
		pProcessor->Process( LocalTime, fDelta );
	}

	// -1 인 경우는 대시 처럼 방향키를 누르고 있는동안 계속 발동되는 스킬.
	if( -1.0f != m_fPassiveActionSkillLength )
	{
		m_fPassiveActionSkillLength -= fDelta;
		if( m_fPassiveActionSkillLength < 0.0f )
		{
			m_fPassiveActionSkillLength = 0.0f;
		}
	}
}


void CDnSkill::OnEnd( LOCAL_TIME LocalTime, float fDelta )
{
	CheckAndRemoveInstantApplySelfStateEffect();

	//접두어에서 추가된 상태 효과 제거
	RemovePrefixBlow();

	int iNumProcessor = (int)m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].size();
	for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
	{
		IDnSkillProcessor* pProcessor = m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].at( iProcessor );
		pProcessor->OnEnd( LocalTime, fDelta );
	}

	m_SkillInfo->bIgnoreImmune = m_isIgnoreImmuneBackup;

	CheckProcessorOnEnd();

	// 버블로 강화된 상태라면 원래대로.
	if( m_bEnchantedFromBubble )
	{
		ReleaseEnchantSkill();
		m_bEnchantedFromBubble = false;
	}

	RemoveAddtionalStateInfo();

#if defined(PRE_FIX_64312)
	if (m_isAppliedSummonMonsterEnchantSkill == true)
	{
		ReleaseEnchantSkill();
		m_isAppliedSummonMonsterEnchantSkill = false;
	}
#endif // PRE_FIX_64312

}


void CDnSkill::CheckProcessorOnEnd( void )
{
	// 버블 갯수에 따라 상태효과 갯수를 변경시키는 Processor
	CDnStateEffectApplyOnOffByBubbleProcessor* pProcessor = static_cast<CDnStateEffectApplyOnOffByBubbleProcessor*>(GetProcessor(IDnSkillProcessor::STATE_EFFECT_APPLY_ONOFF_BY_BUBBLE));
	if( pProcessor )
	{
		pProcessor->RestoreSEList( m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ] );
	}
}


// 쿨 타임 등등의 처리
void CDnSkill::Process( LOCAL_TIME LocalTime, float fDelta )
{
	if( TIME_ACCELERATION_SKILL_ID != m_iSkillID && SPRIT_BOOST_SKILL_ID != m_iSkillID )
		fDelta *= m_hActor->GetCoolTimeDeltaAdjustValue();

	float fTempAdjustValue = m_fCoolTimeAdjustBlowValue;

	fTempAdjustValue *= m_fCoolTimeMultipier;

	switch( m_eDurationType )
	{
		case DurationTypeEnum::Instantly:
		case DurationTypeEnum::Buff:
		case DurationTypeEnum::Debuff:
		case DurationTypeEnum::SummonOnOff:
		case DurationTypeEnum::StanceChange:
			{
				if( 0.0f == m_fOnceElapsedDelayTime )
				{
					if( m_fLeftDelayTime == 0.0f ) return;

					m_fLeftDelayTime -= fDelta;
					if( m_fLeftDelayTime < 0.f ) 
					{
						m_fLeftDelayTime = 0.f;

#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
						m_fDeltaGlobalCoolTime = 0.0f;
#endif // PRE_ADD_TOTAL_LEVEL_SKILL
					}

					// [2011/03/09 semozz]
					// 윈드워커의 스킬중 쇼타임에 의해 fTempAdjustValue가 0이되는 경우가 발생..
					// 예외 처리 추가
					float fTempDelayTime = (GetDelayTime()*fTempAdjustValue);
					if (fTempDelayTime == 0.0f)
						m_fCoolTime = 0.0f;
					else
						m_fCoolTime = ( 1.0f / fTempDelayTime ) * m_fLeftDelayTime;

				}
				else
				{
					if( m_fOnceElapsedDelayTime == 0.0f ) 
					{
						m_fOnceDelayTime = 0.0f;
						return;
					}

					m_fOnceElapsedDelayTime -= fDelta;
					if( m_fOnceElapsedDelayTime < 0.0f )
						m_fOnceElapsedDelayTime = 0.0f;

					m_fCoolTime = ( 1.0f / (m_fOnceDelayTime*m_fCoolTimeAdjustBlowValue) ) * m_fOnceElapsedDelayTime;

				}
			}
			break;

		case DurationTypeEnum::TimeToggle:

			break;

		case DurationTypeEnum::ActiveToggle:
		case DurationTypeEnum::ActiveToggleForSummon:

			break;


		case DurationTypeEnum::Aura:
		
			break;
	}

	// 쿨이 종료된 상태라면 셋팅된 글로벌 스킬 쿨타임을 다시 없애준다.
	if( 0.0f < m_fAnotherGlobalSkillCoolTime && 0.0f == m_fCoolTime )
	{
		m_fAnotherGlobalSkillCoolTime = 0.0f;

		m_nAnotherGlobakSkillID = 0;
	}
}

bool CDnSkill::IsFinished( void )
{
	bool bResult = false;

	// 오라 스킬이라면 맵 이동 하기 전엔 끝내지 않음.
	if( Aura == m_eDurationType )
		return IsFinishedAuraSkill();
	
	if( m_bFinished )
		return m_bFinished;

	if( m_bChainingPassiveSkill )
		return false;

	// MP 를 지속적으로 소모하는 스킬일경우 엠피를 모두 소진하였을때 스킬을 끝내줍니다.
	if( 0.0f < m_fPassiveActionSkillLength || -1.0f == m_fPassiveActionSkillLength )
	{
		float fDecreaseMPRatio = 0.f;
		DNVector( DnBlowHandle ) vlhBlows;
		m_hActor->GatherAppliedStateBlowByBlowIndex( STATE_BLOW::BLOW_014, vlhBlows );

		for( DWORD i=0; i<vlhBlows.size(); i++ )
		{
			if( vlhBlows[i] && vlhBlows[i]->GetParentSkillInfo()->iSkillID == GetClassID() )
			{
				fDecreaseMPRatio = vlhBlows[i]->GetFloatValue();
				break;
			}
		}

		if( m_hActor->GetSP() < m_iNeedMP[ m_iSelectedSkillLevelDataApplyType ] && fDecreaseMPRatio < 0.f )
			return true;

		return false;
	}

#ifdef PRE_FIX_76603
	if( m_hActor->IsAppliedThisStateBlow( STATE_BLOW::BLOW_232 ) )
	{
		DNVector(DnBlowHandle) vlBlows;
		m_hActor->GatherAppliedStateBlowByBlowIndex(STATE_BLOW::BLOW_232, vlBlows);

		for (DWORD i = 0; i < vlBlows.size(); i++)
		{
			if( vlBlows[i] )
			{
				CDnTransformBlow *pTransformBlow = static_cast<CDnTransformBlow*>( vlBlows[i].GetPointer() );
				if( pTransformBlow && pTransformBlow->GetParentSkillInfo()->iSkillID == GetClassID() )
				{
					if( pTransformBlow->CheckSkillDefendency() == true )
						return false;
				}
			}
		}
	}
#endif

	if( m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].empty() )
		bResult = true;
	else
	{
		int iNumProcessor = (int)m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].size();
		for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
		{
			IDnSkillProcessor* pProcessor = m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].at( iProcessor );

			if( true == pProcessor->IsFinished() )
				bResult = true;
			else
			{
				bResult = false;
				break;
			}
		}
	}

	// lazy evaluation
	m_bFinished = bResult;

	return bResult;
}



IDnSkillProcessor* CDnSkill::GetProcessor( int iType )
{
	IDnSkillProcessor* pResult = NULL;

	int iNumProcessor = (int)m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].size();
	for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
	{
		IDnSkillProcessor* pSkillProcessor = m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].at( iProcessor );
		if( iType == pSkillProcessor->GetType() )
		{
			pResult = pSkillProcessor;
			break;
		}
	}

	return pResult;
}

IDnSkillProcessor* CDnSkill::GetProcessor( int iType, int iLevelDataApplyType )
{
	IDnSkillProcessor* pResult = NULL;

	int iNumProcessor = (int)m_vlpProcessors[ iLevelDataApplyType ].size();
	for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
	{
		IDnSkillProcessor* pSkillProcessor = m_vlpProcessors[ iLevelDataApplyType ].at( iProcessor );
		if( iType == pSkillProcessor->GetType() )
		{
			pResult = pSkillProcessor;
			break;
		}
	}

	return pResult;
}


void CDnSkill::CheckTargetCount( int iTargetActorCount )
{
	// 일단은 힐링 에이리어에서만 쓰이게 될 것임..
	IDnSkillProcessor* pProcessor = GetProcessor( IDnSkillProcessor::DIVIDE_STATE_EFFECT_ARG );
	
	if( pProcessor )
	{
		// 브레스 오브 가데스 스킬 테이블에서는 타겟으로만 설정하고 여기서 본인의 상태효과를 추가하게 합니다.
		_ASSERT( "아직 이 부분은 브레스 오브 가데스에서만 쓰입니다..." && m_iSkillID == 3004 );

		CDnDivideSEArgumentByTargets* pDivideSEProcessor = static_cast<CDnDivideSEArgumentByTargets*>(pProcessor);
		int iSEArgument = pDivideSEProcessor->GetStateEffectArgument();

		// 자기 자신까지 포함해서 하나 더 추가
		int iDividedValue = iSEArgument / (iTargetActorCount+1);

		int iNumStateEffect = (int)m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].size();
		char acBuf[ 256 ];
		for( int iStateEffect = 0; iStateEffect < iNumStateEffect; ++iStateEffect )
		{
			ZeroMemory( acBuf, sizeof(acBuf) );
			StateEffectStruct& StateEffect = m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].at( iStateEffect );
			itoa( iDividedValue, acBuf, 10 );
			StateEffect.szValue.assign( acBuf );

			// 자기 자신에게도 추가
			int iID = m_hActor->CmdAddStateEffect( /*m_hActor,*/ GetInfo(), (STATE_BLOW::emBLOW_INDEX)StateEffect.nID, 
												   StateEffect.nDurationTime, StateEffect.szValue.c_str() );
		}
	}

#if defined(PRE_ADD_50903)
	SetHitCountForVarianceDamage(iTargetActorCount);
#endif // PRE_ADD_50903
}



void CDnSkill::CheckAndAddSelfStateEffect( void )
{
	map<int, bool> mapDuplicateResult;		// 자기 자신에게 거는 상태효과는 따로 확률 중첩 처리 하지 않는다.
	CanApply eResult = CDnSkill::CanApplySkillStateEffect( m_hActor, GetMySmartPtr(), mapDuplicateResult );

	if( CanApply::Fail != eResult )
	{
		int nID(-1);
		StateEffectStruct *pStruct(NULL);

		// Note 한기: 2009.12.21
		// 자신에게 사용하는 효과 적용 시간 관련 (#1911)
		// 자기 자신에게 사용하는 상태효과 적용 시그널을 찾아서 갯수를 지정한다.
		// 현재 패시브 스킬의 경우엔 playaniprocessor 를 설정하지 않기 때문에 이 부분에서 걸러진다. 
		// 자기 자신에게 사용하는 상태효과 타이밍 시그널을 사용할 수 없음.
		// 따라서 추후에 패시브로 사용하는 액션 스킬들도 상태효과 타이밍 시그널이 필요하다면
		// 추가적인 작업이 필요하다.
		bool bUseApplySelfStateBlowSignal = false;
		CDnPlayAniProcess* pPlayAniProcessor = static_cast<CDnPlayAniProcess*>(GetProcessor( IDnSkillProcessor::PLAY_ANI ));
		if( pPlayAniProcessor )
		{
			const char* pActionName = pPlayAniProcessor->GetActionName();

			CEtActionBase::ActionElementStruct* pActionElement = m_hActor->GetElement( pActionName );
			_ASSERT( pActionElement );
			if( pActionElement )
			{
				int iApplyStateEffectSignalCount = 0;
				int iNumSignal = (int)pActionElement->pVecSignalList.size();
				for( int iSignal = 0; iSignal < iNumSignal; ++iSignal )
				{
					CEtActionSignal* pSignal = pActionElement->pVecSignalList.at( iSignal );
					if( STE_ApplyStateEffect == pSignal->GetSignalIndex() )
					{
						bUseApplySelfStateBlowSignal = true;
						++iApplyStateEffectSignalCount;
					}
				}
			}
		}

		for( DWORD i=0; i<m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].size(); i++ ) 
		{
			pStruct = &m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ][ i ];
			if( !pStruct ) 
				continue;
			
			// 발현타입에서 직접 상태효과 추가를 컨트롤 하는 경우가 있음. (세이크리드 해머링)
			if( pStruct->bApplyInProcessor )
				continue;

			if( pStruct->ApplyType == ApplySelf )
			{
				// 액션이 끝날 시점에 종료되는 자기 자신에게 사용하는 상태효과.
				if( 0 == pStruct->nDurationTime || -1 == pStruct->nDurationTime  )
				{
					// 테이블에선 0으로 하나 -1로 하나 프로그램쪽에선 -1로 기준시킴
					pStruct->nDurationTime = -1;

					// 한기 2009.7.27 
					// 자신에게 사용하는 효과 적용 시간 관련 (#1911)
					// 스킬 강화 문장으로 추가된 상태효과들은 원래 상태효과에 있던 상태효과들이 아니므로 
					// 자기 자신에게 거는 상태효과 타이밍 시그널을 무시하고 곧바로 추가.
					if( bUseApplySelfStateBlowSignal && (0 == pStruct->nGlyphID) )
					{
						StateEffectStruct InstantSelfStateEffect = *pStruct;
						InstantSelfStateEffect.nDurationTime = pStruct->nDurationTime;
						m_hActor->AddStateEffectQueue( *GetInfo(), InstantSelfStateEffect );

						SetAddStateEffectQueue(true);
					}
					else
					{
						// [2010/12/13 semozz]
						// 기존 패킷 없이 추가 되는 상태 효과들 처리를 위해 직접 생성하고 m_vlApplyNoPacketStateEffectList에 담아 놓는데,
						// 패킷으로 생성하고, m_vlApplyNoPacketStateEffectList에 담아 놓는다.

						// #32160 바뀐 스킬 중첩 처리 루틴이 아이템의 스킬에서도 적용되도록 처리.
						// 아이템 뿐만 아니라 ApplyStateEffect 시그널 안 붙어있는 스킬은 여기서 바로 상태효과 추가 되므로 빼야될 상태효과들 뺀다.
						m_hActor->RemoveResetStateBlow();

						nID = m_hActor->CmdAddStateEffect( GetInfo(), (STATE_BLOW::emBLOW_INDEX)pStruct->nID, pStruct->nDurationTime, pStruct->szValue.c_str() );
						
						if( -1 == nID ) 
							continue;

						// Note 한기: 물약 같은 거 빨고 나서 상태효과 1프레임 돌고 적용될 시에 데미지 받아서 죽으면 클라엔 
						// 먹은 거 적용되고 서버엔 죽으면서 상태효과 전부 비워서 적용안 될 수가 있다.. HP 동기 틀어질 수도 있음.
						if( m_bItemSkill )
						{
							DnBlowHandle hBlow = m_hActor->GetStateBlowFromID( nID );
							hBlow->OnBegin( 0, 0.0f );

#ifndef _GAMESERVER
							if( hBlow->IsUseTableDefinedGraphicEffect() )
								hBlow->AttachGraphicEffectDefaultType();
#endif
							m_hActor->OnBeginStateBlow( hBlow );

							hBlow->SetState( STATE_BLOW::STATE_DURATION );
						}

						m_vlApplySelfNoDurationStateEffectList.push_back( nID );
					}
				}
				else
				{
					// 지속 시간이 있는 self 상태효과
					if( bUseApplySelfStateBlowSignal && (0 == pStruct->nGlyphID) )
					{
						m_hActor->AddStateEffectQueue( *GetInfo(), *pStruct );
						SetAddStateEffectQueue(true);
					}
					else
					{
						// #32160 바뀐 스킬 중첩 처리 루틴이 아이템의 스킬에서도 적용되도록 처리.
						// 아이템 뿐만 아니라 ApplyStateEffect 시그널 안 붙어있는 스킬은 여기서 바로 상태효과 추가 되므로 빼야될 상태효과들 뺀다.
						m_hActor->RemoveResetStateBlow();

						nID = m_hActor->CmdAddStateEffect( /*m_hActor,*/ GetInfo(), (STATE_BLOW::emBLOW_INDEX)pStruct->nID, 
															   pStruct->nDurationTime, pStruct->szValue.c_str() );
						if( -1 == nID )
							continue;
					}
				}
			}
		}
	}
}



void CDnSkill::CheckAndRemoveInstantApplySelfStateEffect( void )
{
	for( DWORD i=0; i<m_vlApplySelfNoDurationStateEffectList.size(); i++ ) 
	{
		if( m_hActor )
			m_hActor->CmdRemoveStateEffectFromID( m_vlApplySelfNoDurationStateEffectList[i] );
	}

	if( m_hActor )
	{
		// #40768 아이템 스킬은 MASkillUser::m_hItemSkill 로 MASkillUser::m_hProcessSkill 과 따로 놀고 있으므로
		// m_hItemSkill 이 끝나지 않더라도 m_hProcessSkill 이 시작될 수 있으므로 그 상태에서 
		// m_hItemSkill 이 종료되어 이 함수가 호출되면 m_hProcessSkill 에 등록된 BlowQueue 를 날려버리게 된다.
		// 따라서 아이템 스킬은 구분해서 처리해주도록 한다.

		//#40760
		//스킬 사용 시점에 접미사 스킬 발동될때 기존 스킬에서 등록된 상태효과가
		//접미사 스킬 끝나는 시점에서 아래 함수 호출로 인해서 큐가 비워저 버리는 경우가 발생.
		//AddStateEffectQueue호출 시 SetAddStateEffectQueue(true)로 플래그 설정 해 놓고
		//플래그가 설정되어 있는 스킬만 상태효과 큐를 초기화 하도록 한다..

		if ( IsAddStateEffectQueue() )
			m_hActor->ClearSelfStateSignalBlowQueue( IsItemSkill() );
	}

	SAFE_DELETE_VEC( m_vlApplySelfNoDurationStateEffectList );
}


DWORD CDnSkill::GetStateEffectCount( void )
{
	return (DWORD)m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].size();
}


CDnSkill::StateEffectStruct* CDnSkill::GetStateEffectFromIndex( DWORD dwIndex )
{
	if( dwIndex >= m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].size() ) return NULL;
	return &m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ][ dwIndex ];
}

bool CDnSkill::IsUseCheckerType( int iCheckerType )
{
	bool bResult = false;

	int iNumChecker = (int)m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].size();
	for( int iChecker = 0; iChecker < iNumChecker; ++iChecker )
	{ 
		if( m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].at( iChecker )->GetType() == iCheckerType )
		{
			bResult = true;
			break;
		}
	}

	return bResult;
}


bool CDnSkill::IsUseProcessorType( int iProcessorType )
{
	bool bResult = false;

	int iNumProcessor = (int)m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].size();
	for( int iProcessor = 0; iProcessor < iNumProcessor; ++iProcessor )
	{
		if( m_vlpProcessors[ m_iSelectedSkillLevelDataApplyType ].at( iProcessor )->GetType() == iProcessorType )
		{
			bResult = true;
			break;
		}
	}

	return bResult;
}

CDnSkill::SkillTypeEnum CDnSkill::GetSkillType( int nSkillID )
{
	if (nSkillID <= 0) return SkillTypeEnum::Active;

	DNTableFileFormat* pSkillTable = GetDNTable( CDnTableDB::TSKILL );
	if( pSkillTable->IsExistItem( nSkillID ) == false ) return SkillTypeEnum::Active;
	return (SkillTypeEnum)pSkillTable->GetFieldFromLablePtr( nSkillID, "_SkillType" )->GetInteger();
}


bool CDnSkill::IsUseActionNames( const set<string>& setUseActionNames )
{
	list<string> listIntersect;
	set_intersection( setUseActionNames.begin(), setUseActionNames.end(), 
					  m_setUseActionNames.begin(), m_setUseActionNames.end(), 
					  back_inserter(listIntersect) );

	return !listIntersect.empty();
}

void CDnSkill::_RefreshDecreaseMP( int iSkillLevelDataApplyType )
{
	if( 0.0f == m_fMPConsumeType[ iSkillLevelDataApplyType ] )
	{
		if( !m_hActor || m_hActor->IsMonsterActor() ) {
			m_iNeedMP[ iSkillLevelDataApplyType ] = m_iDecreaseMP[ iSkillLevelDataApplyType ];
			return;
		}

		if( m_hActor->IsPlayerActor() )
		{
#ifndef _ADD_NEW_MPCONSUME
			float fRatio = 1.f;
			if( m_hActor->GetLevel() > 0 )
			{
				int nJobClassID = ((CDnPlayerActor*)m_hActor.GetPointer())->GetJobClassID();
				float fDecreaseRatio = CPlayerLevelTable::GetInstance().GetValueFloat( nJobClassID , m_hActor->GetLevel(), CPlayerLevelTable::SPDecreaseRatio );
				fRatio =  fDecreaseRatio * m_hActor->GetLevelWeightValue();
			}

			m_iNeedMP[ iSkillLevelDataApplyType ] = (int)( m_iDecreaseMP[ iSkillLevelDataApplyType ] * fRatio );
#else
			m_iNeedMP[iSkillLevelDataApplyType] = (int)(m_iDecreaseMP[iSkillLevelDataApplyType]);
#endif
		}
	}
	else
	{
		m_iNeedMP[ iSkillLevelDataApplyType ] = int((float)m_hActor->GetMaxSP() * m_fMPConsumeType[ iSkillLevelDataApplyType ]);
	}

	m_iOriginalNeedMP[ iSkillLevelDataApplyType ] = m_iNeedMP[ iSkillLevelDataApplyType ];
}

void CDnSkill::RefreshDecreaseMP( int iSkillLevelDataApplyType /*= NUM_SKILLLEVEL_APPLY_TYPE*/ )
{
	if( iSkillLevelDataApplyType == NUM_SKILLLEVEL_APPLY_TYPE )
	{
		for( int iApplyType = PVE; iApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iApplyType )
			_RefreshDecreaseMP( iApplyType );
	}
	else
	{
		_RefreshDecreaseMP( iSkillLevelDataApplyType );
	}
}


void CDnSkill::SetOnceCoolTime( float fDelayTime, float fElapsedDelayTime )
{
	_ASSERT( fElapsedDelayTime <= fDelayTime );

	m_fOnceDelayTime = fDelayTime;
	m_fOnceElapsedDelayTime = fElapsedDelayTime;
}


void CDnSkill::SetPassiveSkillActionName( const char* pActionName )
{
	if( pActionName )
	{
		// 같은 것이 오면 자동으로 추가 되지 않음.
		m_setUseActionNames.insert( string(pActionName) );
	}
}


// 이슈 #6190 관련.
CDnSkill::CanApply CDnSkill::CanApplySkillStateEffect( const SkillInfo* pUsingSkillInfo, DnActorHandle hTargetActor, int iSkillID, int iLevel, 
													   int iSkillDuplicateMethod, int iDuplicateCount, map<int, bool>& mapDuplicateResult, bool isHitProcess )
{
	// 상태효과 검사할때 리셋리스트 초기화 [2010/12/09 semozz]
	if (hTargetActor)
		hTargetActor->InitStateBlowIDToRemove();

	CDnSkill::CanApply eResult = CDnSkill::CanApply::Apply;
	bool bExistingSameSkill = false;
	int iExistingSameSkillCount = 0;

	// 중복되어 같은 저렙 스킬의 상태효과가 제거될 시에 담아뒀다가 제거함.
	// 다른 스킬의 같은 상태효과가 걸려있는 경우도 있으므로 반드시 상태효과 생성시 부여받은 id 로 삭제한다.

	vector<int> vlStateBlowIDToRemove;
	DNVector( DnBlowHandle ) vlhSameSkillBlows;

	int iNumAppliedStateEffect = (int)hTargetActor->GetNumAppliedStateBlow();
	for( int iAppliedStateEffect = 0; iAppliedStateEffect < iNumAppliedStateEffect; ++iAppliedStateEffect )
	{
		DnBlowHandle hExistingBlow = hTargetActor->GetAppliedStateBlow( iAppliedStateEffect );

		const CDnSkill::SkillInfo* pExistingParentSkillInfo = NULL;
		if( hExistingBlow )
			pExistingParentSkillInfo = hExistingBlow->GetParentSkillInfo();

		// 모체 스킬 정보가 없는 상태효과는 스킬로 걸린 것이 아니므로 여기서 다룰 대상이 아님
		if( NULL == pExistingParentSkillInfo )
			continue;

		// 스킬 중복 카운트 체크
		// 같은 스킬 아이디에 동일한 상태효과가 또 나타난다면 중복된 스킬임.
		bool bIsSameSkillID = false;
#if defined(PRE_FIX_58505)
		//접미사 스킬 타입이 설정 되어 있지 않으면 스킬 아이디로 비교하고,
		//접미사 스킬 타입이 설정 되어 있으면 접미사 스킬 타입이 같은지 비교.
		if ( pUsingSkillInfo->bItemPrefixSkill == true && pUsingSkillInfo->nPrefixSkillType != CDnPrefixSkill::Prefix_Non )
			bIsSameSkillID = pUsingSkillInfo->nPrefixSkillType == pExistingParentSkillInfo->nPrefixSkillType;
		else
			bIsSameSkillID = iSkillID == pExistingParentSkillInfo->iSkillID;
#else
		if( iSkillID == pExistingParentSkillInfo->iSkillID )
			bIsSameSkillID = true;
#endif // PRE_FIX_58505

		if (bIsSameSkillID == true)
		{
			// 같은 스킬 아이디가 처음 나온다면 처음엔 적용중 스킬 카운트 하나 올려줌.

			// #27335 - 앵클샷 경우 [2011/01/11 semozz]
			// 상대방이 나에게 앵크샷을 쏘고 CantMove상태효과가 적용 되어 있을때
			// 내가 같은 앵클샷을 쏠때, 내 자신에 걸린 CantMove상태효과가 스킬ID가 같아서
			// 같은 스킬 중복 처리에 걸리게 됨..
			// 현재 상태효과의 ApplyType을 확인해서
			// 현재 상태효과를 건 Actor와 TargetActor를 비교해서
			// 유효한 Actor가 사용한게 아니면 같은 스킬이 아님으로 설정
			
			DnActorHandle hSkillUserActor = pUsingSkillInfo->hSkillUser;
			DnSkillHandle hSkill;
			if (hSkillUserActor)
				hSkill = hSkillUserActor->FindSkill( iSkillID );
			
			//Prop에의한 상태효과는 스킬 정보가 없을 수 있다.
			if (hSkill)
			{
				// 기존에 적용 중인, 지금 사용하려는 스킬의 상태효과 중 하나의 적용 대상 타입.
				StateEffectApplyType eExistingSEApplyType = ApplySelf;

				bExistingSameSkill = true;
				for( int i = 0; i < (int)hSkill->GetStateEffectCount(); ++i )
				{
					const StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex( i );
					if( pSE->nID == hExistingBlow->GetBlowIndex()
						&& pSE->ApplyType == pExistingParentSkillInfo->eApplyType )
					{
						eExistingSEApplyType = pSE->ApplyType;
						break;
					}
				}

				//현재 적용된 상태효과의 applyType에 따라
				switch(eExistingSEApplyType)
				{
				case StateEffectApplyType::ApplySelf:
					if (isHitProcess == false)
						bExistingSameSkill = (hTargetActor == hSkillUserActor);
					else
						bExistingSameSkill = false;
					break;
				case StateEffectApplyType::ApplyEnemy:
					bExistingSameSkill = (hTargetActor->GetTeam() != hSkillUserActor->GetTeam());
					break;
				case StateEffectApplyType::ApplyTarget:
					bExistingSameSkill = (hTargetActor != hSkillUserActor);
					break;
				case StateEffectApplyType::ApplyFriend:
					bExistingSameSkill = (hTargetActor->GetTeam() == hSkillUserActor->GetTeam());
					break;
				case StateEffectApplyType::ApplyAll:
					bExistingSameSkill = true;
					break;
				}
			}
			else
				bExistingSameSkill = true;
			
			if( bExistingSameSkill )
			{
				iExistingSameSkillCount += hExistingBlow->GetDuplicateCount();
				vlhSameSkillBlows.push_back( hExistingBlow );
			}
		}

		if (pUsingSkillInfo->eTargetType == All  //지금 사용 하는 스킬의 TargetType이 All이고, 
			&& (0 != iSkillDuplicateMethod && (iSkillDuplicateMethod == pExistingParentSkillInfo->iSkillDuplicateMethod)) //중첩 처리ID가 설정되어 있고, 기존 스킬과 동일한 ID일때,
			&& (hTargetActor == pUsingSkillInfo->hSkillUser) //자기 자신
			)
			continue;

		// 지속효과 구분 인덱스가 0이 아니라면 스킬 효과 중복 관련 처리가 필요함.
		// 지속효과 구분 인덱스가 0이면 그냥 중첩됨.
		// 혹은 같은 스킬이면서 최대 중첩 카운트가 1이하인경우엔 스킬 대체되도록 처리.
#if defined(PRE_FIX_58505)
		if( 0 != iSkillDuplicateMethod ||
			(bIsSameSkillID == true && iDuplicateCount <= 1) )
#else
		if( 0 != iSkillDuplicateMethod ||
			(iSkillID == pExistingParentSkillInfo->iSkillID && iDuplicateCount <= 1) )
#endif // PRE_FIX_58505
		{
			// 기존에 실행되고 있던 스킬과 같은 지속효과 인덱스인가. 그렇다면 중첩이 가능한지 체크들어간다.
			// 또한 스킬을 쓴 유저의 팀이 같을때만 중첩처리를 하도록 한다.
			// 다른 팀인데 같은 스킬을 쓸 경우 나에게 걸린 디버프 상태효과가 해제되어 버린다. (#19812)
			if( (iSkillDuplicateMethod == pExistingParentSkillInfo->iSkillDuplicateMethod) &&
				(pUsingSkillInfo->iSkillUserTeam == pExistingParentSkillInfo->iSkillUserTeam) )
			{
				if( iLevel >= pExistingParentSkillInfo->iLevel )
				{
					// 242번 상태효과는 한번 추가가 되면 리셋 되면 안된다.

					// 확률 체크에서 통과한다면 리셋시킬 상태효과에 넣어둠.
					// 실제 확률체크하는 객체는 기존에 적용된 상태효과 객체를 사용하지만 확률만 체크하는 것이기 때문에
					// 그대로 사용한다.
					if( hExistingBlow->CanBegin() )
					{
						bool isSelfStateEffect = false;

						//#60966 자신에게 적용하는 상태효과와 다른이에게 적용 하는 상태효과가 같이 있은 경우
						//스킬 시작에서는 상관 없지만, Hit처리시에는 self상태효과는 다시 적용 되지 않는다.
						//그래서 히트 처리되는 중에 여기서 self적용된 상태효과를 제거 리스트에 추가 해 놓으면
						//다시 추가 할 방법이 없다.
						//히트 처리시에 들어 온경우 Self적용 상태효과는 스킵..
						if (isHitProcess == true)
						{
							StateEffectApplyType eExistingSEApplyType = ApplySelf;

							bool bCheck = false;

							DnActorHandle hExistingSkillUserActor = pExistingParentSkillInfo->hSkillUser;
							DnSkillHandle hSkill;
							if (hExistingSkillUserActor)
								hSkill = hExistingSkillUserActor->FindSkill( pExistingParentSkillInfo->iSkillID );

							if (hSkill)
							{
								for( int i = 0; i < (int)hSkill->GetStateEffectCount(); ++i )
								{
									const StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex( i );
									if( pSE->nID == hExistingBlow->GetBlowIndex() 
										&& pSE->ApplyType == pExistingParentSkillInfo->eApplyType )
									{
										bCheck = true;
										eExistingSEApplyType = pSE->ApplyType;
										break;
									}
								}

								//자신에게 거는 상태효과는 적용 가능 하도록? 한다..
								if ( StateEffectApplyType::ApplySelf == eExistingSEApplyType && bCheck )
								{
									isSelfStateEffect = true;
								}
							}

						}

						if (isSelfStateEffect == false &&
							hExistingBlow->GetBlowIndex() != STATE_BLOW::BLOW_242 )
						{
							vlStateBlowIDToRemove.push_back( hExistingBlow->GetBlowID() );
							mapDuplicateResult[ hExistingBlow->GetBlowIndex() ] = true;

							// 리셋되어야할 상태들을 담아 놓는다. [2010/12/08 semozz]
							// 여기서 리스트에 담긴 상태들은 OnSignal의 STE_ApplyStateEffect 시점에 상태 적용할때
							// 기존의 상태를 제거 한다.
							hTargetActor->AddStateBlowIDToRemove( hExistingBlow->GetBlowID() );
						}
					}
					else
					{
						eResult = CDnSkill::CanApply::Fail;		// 효과 갱신 시 확률 체크에서 실패했으므로 추가하지 않는다.
						mapDuplicateResult[ hExistingBlow->GetBlowIndex() ] = false;
					}
				}
				else
				if( iLevel < pExistingParentSkillInfo->iLevel )
				{
					// 효과 적용 안됨.
					eResult = CDnSkill::CanApply::Fail;

					// Note 한기: 추후에 그래픽적으로 뭔가 표시해줘야 한다면 이 곳에서 처리하면 됨.

					// [2011/01/20 semozz]
					// 체인라이트닝 시전이 끝나기 전 헤븐스 저지먼트를 사용시 문제점.
					// A 스킬 레벨이 높고, 그 뒤에 사용되는 B스킬의 레벨이 낮을때, DuplicationMethod가 같으면
					// 여기서 스킬 추가 안됨으로 Self상태효과 적용이 되지 않음. Target은 상관 없을듯..

					// 현재 상태효과를 사용한 액터를 선택
					DnActorHandle hExistingSkillUserActor = pExistingParentSkillInfo->hSkillUser;
					DnSkillHandle hSkill;
					if (hExistingSkillUserActor)
						hSkill = hExistingSkillUserActor->FindSkill( pExistingParentSkillInfo->iSkillID );

					if (hSkill)
					{
						// 기존에 적용 중인, 지금 사용하려는 스킬의 상태효과 중 하나의 적용 대상 타입.
						StateEffectApplyType eExistingSEApplyType = ApplySelf;

						for( int i = 0; i < (int)hSkill->GetStateEffectCount(); ++i )
						{
							const StateEffectStruct* pSE = hSkill->GetStateEffectFromIndex( i );
							if( pSE->nID == hExistingBlow->GetBlowIndex() 
								&& pSE->ApplyType == pExistingParentSkillInfo->eApplyType )
							{
								eExistingSEApplyType = pSE->ApplyType;
								break;
							}
						}

						//자신에게 거는 상태효과는 적용 가능 하도록? 한다..
						if (StateEffectApplyType::ApplySelf == eExistingSEApplyType)
						{
							eResult = CDnSkill::CanApply::Apply;

							vlStateBlowIDToRemove.push_back( hExistingBlow->GetBlowID() );
							mapDuplicateResult[ hExistingBlow->GetBlowIndex() ] = true;

							hTargetActor->AddStateBlowIDToRemove( hExistingBlow->GetBlowID() );
						}
					}
				}
			}
		}
	}

	if( false == vlStateBlowIDToRemove.empty() )
	{
		// 스킬 효과 대체. 중첩 카운트 세었던 것 처리할 필요 없다.
		bExistingSameSkill = false;
		eResult = CDnSkill::CanApply::ApplyDuplicateSameSkill;
	}

	// 상태 효과를 중첩해서 적용해야하는 경우, 최대 중첩 갯수가 넘으면 안된다.
	// 높은 레벨의 상태효과가 이미 적용중이라면 중첩처리가 되지 않는다.
	if( CDnSkill::CanApply::Fail != eResult )
	{
		if( bExistingSameSkill )
		{
			if( iDuplicateCount <= iExistingSameSkillCount )
			{
				// 최대 중첩 갯수를 넘는 경우 기존 상태효과의 시간만 초기화 한다.
				int iNumSameSkillBlowsToResetDurationTime = (int)vlhSameSkillBlows.size();
				for( int iBlow = 0; iBlow < iNumSameSkillBlowsToResetDurationTime; ++iBlow )
				{
					DnBlowHandle hBlow = vlhSameSkillBlows.at( iBlow );

					//////////////////////////////////////////////////////////////////////////
					//#53448
					//249번 상태효과 경우 중첩 갯수 이상은 추가 될 수 없다.
					//최대 중첩 갯수를 넘은 경우 아래 루프를 돌면서 기존 상태효과 제거 하고, 다시 추가 작업 필요 없음.
					if (hBlow && 
						(hBlow->GetBlowIndex() == STATE_BLOW::BLOW_249 || hBlow->GetBlowIndex() == STATE_BLOW::BLOW_242)
						)
						continue;
					//////////////////////////////////////////////////////////////////////////

					// 아예 삭제했다가 새로 추가하는 것이 명확함.
					int nDurationTime = int(hBlow->GetDurationTime() * 1000.0f);
					hBlow->ResetDurationTime();

					CDnSkill::SkillInfo SkillInfo = *(hBlow->GetParentSkillInfo());
					STATE_BLOW::emBLOW_INDEX BlowIndex = hBlow->GetBlowIndex();
					string strValue( hBlow->GetValue() );

					// 이 시점에서 즉시 지워저야 한다. [2011/01/18 semozz]
					int nBlowID = hBlow->GetBlowID();
					// 패킷 보낼꺼 보내고
					hTargetActor->SendRemoveStateEffectFromID(nBlowID);
					// 바로 삭제한다..
					if (hTargetActor->GetStateBlow())
						hTargetActor->GetStateBlow()->RemoveImediatlyStateEffectFromID(nBlowID);

					// 여기에 결빙같은 확률 있는 상태효과를 100% 성공시켜야 하므로 
					// CanBegin 함수 호출하지 않도록 bCheckCanBegin 플래그를 꺼서 호출.
					hTargetActor->CmdAddStateEffect( &SkillInfo, BlowIndex, nDurationTime, strValue.c_str(), false, false );
				}

				eResult = CDnSkill::CanApply::Fail;
			}
		}
	}

	return eResult;
}


CDnSkill::CanApply CDnSkill::CanApplySkillStateEffect( DnActorHandle hTargetActor, DnSkillHandle hUsingSkill, map<int, bool>& mapDuplicateResult, bool isHitProcess )
{
	const SkillInfo* pUsingSkillInfo = hUsingSkill->GetInfo();
	int iSkillID = hUsingSkill->GetClassID();
	int iLevel = hUsingSkill->GetLevel();
	int iSkillDuplicateMethod = hUsingSkill->GetDuplicateMethod();
	int iDuplicateCount = hUsingSkill->GetMaxDuplicateCount();

	// 스킬에서 상태 효과들중에 지속시간이 하나라도 있으면 지속시간이 있는걸로 판단
	// 해당 스킬이 지속시간이 없다면 그냥 추가 될 수 있도록 한다. [2010/11/12 semozz]
	bool hasDuration = false;
	for( DWORD k = 0; k < hUsingSkill->GetStateEffectCount(); k++ ) 
	{
		CDnSkill::StateEffectStruct *pLocalStruct = hUsingSkill->GetStateEffectFromIndex(k);
		if( pLocalStruct && (IsNeedCheckApplyStateBlow((STATE_BLOW::emBLOW_INDEX)pLocalStruct->nID) || pLocalStruct->nDurationTime > 0) )
		{
			hasDuration = true;
			break;
		}
#if defined(PRE_FIX_52267)
		//#52267
		//상태효과 ApplyType이 Self가 아니어도 지속시간이 0인 경우 CanApplySkillStateEffect함수 호출이 되지 않아서
		//의도치 않게 중첩이 되는 경우가 발생한다.
		//ApplyType이 self가 아니고, durationTime이 0인경우도 체크 가능 하도록 hasDuration을 true로 설정 한다.
		else if (pLocalStruct->nDurationTime == 0 && pLocalStruct->ApplyType != StateEffectApplyType::ApplySelf)
		{
			hasDuration = true;
			break;
		}
#endif // PRE_FIX_52267
	}

	bool bResist = false;
	if( !hTargetActor->IsHittableSkill( iSkillID , bResist ) )
	{
		if( bResist )
		{
			hTargetActor->SendAddSEFail( CDnStateBlow::ADD_FAIL_BY_IMMUNE , STATE_BLOW::BLOW_154 );
		}

		return  CDnSkill::CanApply::Fail;
	}

	if ( false == hasDuration )
	{
		return CDnSkill::CanApply::Apply;
	}

	return CanApplySkillStateEffect( pUsingSkillInfo, hTargetActor, iSkillID, iLevel, iSkillDuplicateMethod, iDuplicateCount, mapDuplicateResult, isHitProcess );
}


// 액션 재생 프로세서가 반드시 있는 액티브 스킬의 동작 계승 요청!
void CDnSkill::OnChainInput( const char* pActionName )
{
	if( GetSkillType() == CDnSkill::Active &&
		( GetDurationType() == CDnSkill::Instantly ||
		  GetDurationType() == CDnSkill::Buff ||
		  GetDurationType() == CDnSkill::Debuff || 
		  GetDurationType() == CDnSkill::StanceChange ) )
	{
		IDnSkillProcessor* pProcessor = GetProcessor( IDnSkillProcessor::PLAY_ANI );
		_ASSERT( pProcessor );
		if( pProcessor )
		{
			CDnPlayAniProcess* pPlayAniProcessor = static_cast<CDnPlayAniProcess*>( pProcessor );
			pPlayAniProcessor->OnChainInput( pActionName );
		}
	}
	else
	if( GetSkillType() == CDnSkill::Passive )
	{
		CEtActionBase::ActionElementStruct* pStruct = m_hActor->GetElement( pActionName );
		if( pStruct )
		{
			m_fPassiveActionSkillLength += (float)pStruct->dwLength / s_fDefaultFps;
			m_bChainingPassiveSkill = true;
		}
	}
}

bool CDnSkill::IsChainInputAction( const char* pActionName )
{
	IDnSkillProcessor* pProcessor = GetProcessor( IDnSkillProcessor::PLAY_ANI );
	if( pProcessor )
	{
		CDnPlayAniProcess* pPlayAniProcessor = static_cast<CDnPlayAniProcess*>( pProcessor );
		if( strcmp( pActionName , pPlayAniProcessor->GetChainActionName() ) == 0 )
		{
			return true;
		}
	}

	return false;
}

bool CDnSkill::CheckChainingPassiveSkill( void )
{
	bool bResult = m_bChainingPassiveSkill;
	m_bChainingPassiveSkill = false;

	return bResult;
}

void CDnSkill::AddGlyphStateEffect( int nGlyphID )
{
	DNTableFileFormat* pGlyphTable = GetDNTable( CDnTableDB::TGLYPHSKILL );
	if( !pGlyphTable ) return;

#if defined(PRE_ADD_65808)
	int monsterID = -1;
	if (IsSummonMonsterRecall(monsterID) == true)
	{
		m_hActor->AddSummonMonsterGlyphInfo(monsterID, nGlyphID);
		return;
	}
#endif // PRE_ADD_65808

	char caLable[64];

	// 스킬 강화 문장 같은 경우 pvp/pve 모두 셋팅해준다.
	for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
	{
		// 원래 상태효과 갖고 있던 갯수
		int iNumOriginalStateEffect = (int)m_vlStateEffectList[ iSkillLevelApplyType ].size();

		// 상태 효과 추가
		StateEffectStruct StateEffect;
		StateEffect.nGlyphID = nGlyphID;
		for( int i = 0; i < MAX_GLYPH_STATE_EFFECT_COUNT; ++i )
		{
			sprintf_s( caLable, "_EffectClass%d", i + 1 );
			StateEffect.nID = pGlyphTable->GetFieldFromLablePtr( nGlyphID, caLable )->GetInteger();

			if( StateEffect.nID < 1 ) 
				continue;

			sprintf_s( caLable, "_EffectClass%dApplyType", i + 1 );
			int iApplyType = pGlyphTable->GetFieldFromLablePtr( nGlyphID, caLable )->GetInteger();
			bool bApplyAll = (StateEffectApplyType::ApplyAll == iApplyType);		// 모두 적용임. 타겟만 다르게 해서 똑같은 상태효과 2개를 추가해준다.

			if( bApplyAll )
			{
				StateEffect.ApplyType = StateEffectApplyType::ApplySelf;
				StateEffect.bApplyAllPair = true;
			}
			else
				StateEffect.ApplyType = (StateEffectApplyType)iApplyType;

			sprintf_s( caLable, "_EffectClassValue%d", i + 1 );
			StateEffect.szValue = pGlyphTable->GetFieldFromLablePtr( nGlyphID, caLable )->GetString();

			// 지속시간은 기존에 있던 상태효과에서 그대로 대체한다.
			bool bFound = false;
			for( int k = 0; k < iNumOriginalStateEffect; ++k )
			{
				const StateEffectStruct& OriginalSE = m_vlStateEffectList[ iSkillLevelApplyType ].at( k );
				if( OriginalSE.nID == StateEffect.nID )
				{
					StateEffect.nDurationTime = OriginalSE.nDurationTime;
					bFound = true;
				}
			}
			
			// 만약 같은 상태효과가 없다면 지속시간은 그냥 0 으로 해준다. 
			// 그럼 액션과 동일한 간격만큼 상태효과가 지속됨.
			if( false == bFound )
				StateEffect.nDurationTime = 0;

			m_vlStateEffectList[ iSkillLevelApplyType ].push_back( StateEffect );

			// 모두 적용이면 타겟으로 바꿔서 똑같이 한 번 더 넣어줌.
			if( bApplyAll )
			{
				StateEffect.ApplyType = StateEffectApplyType::ApplyTarget;
				m_vlStateEffectList[ iSkillLevelApplyType ].push_back( StateEffect );
			}
		}
	}

	// 스킬 속성 추가
	GlyphEffectStruct GlyphEffect;
	
	GlyphEffect.eEffectIndex = pGlyphTable->GetFieldFromLablePtr( nGlyphID, "_GlyphSkillEffect" )->GetInteger();
	GlyphEffect.fEffectValue = pGlyphTable->GetFieldFromLablePtr( nGlyphID, "_GlyphSkillEffectValue" )->GetFloat();
	GlyphEffect.nGlyphID = nGlyphID;

	switch( GlyphEffect.eEffectIndex )
	{
	case SKILLMP_PRO :
		{
			for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
				m_iNeedMP[ iSkillLevelApplyType ] += (int)( (float)m_iOriginalNeedMP[ iSkillLevelApplyType ] * GlyphEffect.fEffectValue );
			break;
		}

	case SKILLDELAY_PRO :
		{
			for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
				m_fDelayTime[ iSkillLevelApplyType ] += m_fOriginalDelayTime[ iSkillLevelApplyType ] * GlyphEffect.fEffectValue;
			break;
		}

	case SKILLDELAY_RESET_PRO :
		{
			m_fResetCooltime += GlyphEffect.fEffectValue;
			break;
		}

	case SKILLDURATION_PRO :
		{
			// pair<int, int> <상태효과, 기간>
			for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
			{
				bool bEmpty = m_vlStateDurationList[iSkillLevelApplyType].empty();
				for( int itr = 0; itr < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++itr ) {
					if( bEmpty )
						m_vlStateDurationList[iSkillLevelApplyType].push_back( make_pair(m_vlStateEffectList[ iSkillLevelApplyType ][itr].nID, m_vlStateEffectList[ iSkillLevelApplyType ][itr].nDurationTime) );
					else m_vlStateEffectList[ iSkillLevelApplyType ][itr].nDurationTime = m_vlStateDurationList[iSkillLevelApplyType][itr].second;
				}
			}

			float fRatio = GlyphEffect.fEffectValue;
			for( int itr = 0; itr < (int)m_vGlyphEffectList.size(); ++itr )
			{
				if( SKILLDURATION_PRO == m_vGlyphEffectList[itr].eEffectIndex )
					fRatio += m_vGlyphEffectList[itr].fEffectValue;
			}

			for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
			{
				for( int itr = 0; itr < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++itr )
					m_vlStateEffectList[ iSkillLevelApplyType ][itr].nDurationTime += (int)(m_vlStateEffectList[ iSkillLevelApplyType ][itr].nDurationTime * fRatio);
			}

			break;
		}
	case SKILLATTACKHEAL_ABSOLUTE:
		{
			float fValue = GlyphEffect.fEffectValue;

			for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
			{
				for( int itr = 0; itr < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++itr )
				{
					if( m_vlStateEffectList[ iSkillLevelApplyType ][itr].nID == STATE_BLOW::BLOW_248 )
					{
						m_vlStateEffectList[ iSkillLevelApplyType ][itr].szValue = FormatA( "%f", fValue + atof(m_vlStateEffectList[ iSkillLevelApplyType ][itr].szValue.c_str()) ).c_str();
					}
				}
			}
		}
		break;
	}

	m_vGlyphEffectList.push_back( GlyphEffect );
}

void CDnSkill::DelGlyphStateEffect( int nGlyphID )
{
#if defined(PRE_ADD_65808)
	int monsterID = -1;
	if (IsSummonMonsterRecall(monsterID) == true)
	{
		m_hActor->RemoveSummonMonsterGlyphInfo(monsterID, nGlyphID);
		return;
	}
#endif // PRE_ADD_65808

	// 스킬 강화 문장 같은 경우 pvp/pve 모두 셋팅해준다.
	for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
	{
		for( DNVector(StateEffectStruct)::iterator Itor = m_vlStateEffectList[ iSkillLevelApplyType ].begin(); 
			Itor < m_vlStateEffectList[ iSkillLevelApplyType ].end(); )
		{
			if( nGlyphID == Itor->nGlyphID )
				Itor = m_vlStateEffectList[ iSkillLevelApplyType ].erase(Itor);
			else
				++Itor;
		}
	}

	for( std::vector<GlyphEffectStruct>::iterator Itor = m_vGlyphEffectList.begin();
		Itor < m_vGlyphEffectList.end(); )
	{
		if( nGlyphID == Itor->nGlyphID )
		{
			switch( Itor->eEffectIndex )
			{
			case SKILLMP_PRO :
				{
					for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
						m_iNeedMP[ iSkillLevelApplyType ] -= (int)( (float)m_iOriginalNeedMP[ iSkillLevelApplyType ] * Itor->fEffectValue );
					break;
				}

			case SKILLDELAY_PRO :
				{
					for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
						m_fDelayTime[ iSkillLevelApplyType ] -= m_fOriginalDelayTime[ iSkillLevelApplyType ] * Itor->fEffectValue;
					break;
				}

			case SKILLDELAY_RESET_PRO :
				{
					m_fResetCooltime -= Itor->fEffectValue;
					break;
				}

			case SKILLDURATION_PRO :
				{
					// pair<int, int> <상태효과, 기간>
					bool bExist = false, bOnce = true;
					float fRatio = 0.0f;
					for( int itr = 0; itr < (int)m_vGlyphEffectList.size(); ++itr )
					{
						if( Itor->nGlyphID == m_vGlyphEffectList[itr].nGlyphID && bOnce) 
						{
							bOnce = false;
							continue;
						}
						if( SKILLDURATION_PRO == m_vGlyphEffectList[itr].eEffectIndex )
						{
							bExist = true;
							fRatio += m_vGlyphEffectList[itr].fEffectValue;
						}
					}

					if( !bExist )
					{
						for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
						{
							for( int itr = 0; itr < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++itr )
								m_vlStateEffectList[ iSkillLevelApplyType ][itr].nDurationTime = m_vlStateDurationList[iSkillLevelApplyType][itr].second;
							m_vlStateDurationList[iSkillLevelApplyType].clear();
						}
					}
					else
					{
						for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
						{
							for( int itr = 0; itr < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++itr )
								m_vlStateEffectList[ iSkillLevelApplyType ][itr].nDurationTime = m_vlStateDurationList[iSkillLevelApplyType][itr].second + (int)(m_vlStateDurationList[iSkillLevelApplyType][itr].second * fRatio);
						}
					}

					break;
				}
			case SKILLATTACKHEAL_ABSOLUTE:
				{
					float fValue = Itor->fEffectValue;
					for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
					{
						for( int itr = 0; itr < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++itr )
						{
							if( m_vlStateEffectList[ iSkillLevelApplyType ][itr].nID == STATE_BLOW::BLOW_248 )
								m_vlStateEffectList[ iSkillLevelApplyType ][itr].szValue = FormatA( "%f", atof(m_vlStateEffectList[ iSkillLevelApplyType ][itr].szValue.c_str()) - fValue).c_str();
						}
					}
				}
				break;
			}

			Itor = m_vGlyphEffectList.erase( Itor );
		}
		else
			++Itor;
	}
}

void CDnSkill::UpdateSkillCoolTimeExactly( void )
{
	// 96, 171번 쿨타임 변경 상태효과가 걸려있는 경우 서버에서 체크하지 않도록 처리.
	// 겜서버에서 쿨타임 갱신이 10프레임으로 줄어들었으므로 조작감 문제때문에 이렇게 풀어놓음. 2011.07.25
	DWORD dwNowTime = timeGetTime();
	if(	DWORD(GetDelayTime()*1000.0f) < dwNowTime - m_dwLastUseSkillTimeStamp )
	{
		ResetCoolTime();
	}
}


bool CDnSkill::SelectLevelDataType( int iSkillLevelDataType, bool bPlayerSummonedMonster/* = false*/ )
{ 
	_ASSERT( (m_hActor->IsPlayerActor() || bPlayerSummonedMonster) && (PVE <= iSkillLevelDataType) && (iSkillLevelDataType < NUM_SKILLLEVEL_APPLY_TYPE) );

	if( (m_hActor->IsPlayerActor() || bPlayerSummonedMonster) &&
		(PVE <= iSkillLevelDataType) &&
		(iSkillLevelDataType < NUM_SKILLLEVEL_APPLY_TYPE) ) 
	{
		m_iSelectedSkillLevelDataApplyType = iSkillLevelDataType;
		return true;
	}

	return false;
};


bool CDnSkill::IsNeedCheckApplyStateBlow( STATE_BLOW::emBLOW_INDEX emBlowIndex )
{
	bool bResult = false;

	if( STATE_BLOW::BLOW_030 == emBlowIndex )
		bResult = true;

	return bResult;
}

int CDnSkill::GetBaseSkillID( void )
{
	int iResult = 0;

	if( EnchantPassive == m_eSkillType )
	{
		iResult = m_iBaseSkillID;
	}

	return iResult;
}

// 클라이언트도 동기화 맞추어주세요 CheckAndDivideStateEffectArgument 이 함수도 수정해주세요 
bool CDnSkill::CheckAndUnifyStateEffectArgument( int iSkillLevelApplyType, StateEffectStruct* pEnchantSkillSE )
{
	bool bResult = false;

	if( CDnCreateBlow::IsBasicBlow( (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID ) )
	{
		for( int i = 0; i < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++i )
		{
			StateEffectStruct* pDestSkillSE = &(m_vlStateEffectList[ iSkillLevelApplyType ].at( i ));
			if( pDestSkillSE->nID == pEnchantSkillSE->nID )
			{
				CDnBasicBlow::AddStateEffectValue( pDestSkillSE->szValue.c_str(), pEnchantSkillSE->szValue.c_str(), pDestSkillSE->szValue );
				pDestSkillSE->strEnchantSkillSEParam = pEnchantSkillSE->szValue;
				bResult = true;
			}
		}
	}
	else if( STATE_BLOW::BLOW_016 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID )
	{
		for( int i = 0; i < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++i )
		{
			StateEffectStruct* pDestSkillSE = &(m_vlStateEffectList[ iSkillLevelApplyType ].at( i ));
			if( pDestSkillSE->nID == pEnchantSkillSE->nID )
			{
				CDnHPIncBlow::AddStateEffectValue( pDestSkillSE->szValue.c_str(), pEnchantSkillSE->szValue.c_str(), pDestSkillSE->szValue );
				pDestSkillSE->strEnchantSkillSEParam = pEnchantSkillSE->szValue;
				bResult = true;
			}
		}
	}
	else if( STATE_BLOW::BLOW_208 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID )
	{
		for( int i = 0; i < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++i )
		{
			StateEffectStruct* pDestSkillSE = &(m_vlStateEffectList[ iSkillLevelApplyType ].at( i ));
			if( pDestSkillSE->nID == pEnchantSkillSE->nID )
			{
				CDnPingpongBlow::AddStateEffectValue( pDestSkillSE->szValue.c_str(), pEnchantSkillSE->szValue.c_str(), pDestSkillSE->szValue );
				pDestSkillSE->strEnchantSkillSEParam = pEnchantSkillSE->szValue;
				bResult = true;
			}
		}
	}
	else if( STATE_BLOW::BLOW_140 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID )
	{
		for( int i = 0; i < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++i )
		{
			StateEffectStruct* pDestSkillSE = &(m_vlStateEffectList[ iSkillLevelApplyType ].at( i ));
			if( pDestSkillSE->nID == pEnchantSkillSE->nID )
			{
				CDnHealingBlow::AddStateEffectValue( pDestSkillSE->szValue.c_str(), pEnchantSkillSE->szValue.c_str(), pDestSkillSE->szValue );
				pDestSkillSE->strEnchantSkillSEParam = pEnchantSkillSE->szValue;
				bResult = true;
			}
		}
	}
	else if( STATE_BLOW::BLOW_227 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID )
	{
		for( int i = 0; i < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++i )
		{
			StateEffectStruct* pDestSkillSE = &(m_vlStateEffectList[ iSkillLevelApplyType ].at( i ));
			if( pDestSkillSE->nID == pEnchantSkillSE->nID )
			{
				CDnBloodSuckingBlow::AddStateEffectValue( pDestSkillSE->szValue.c_str(), pEnchantSkillSE->szValue.c_str(), pDestSkillSE->szValue );
				pDestSkillSE->strEnchantSkillSEParam = pEnchantSkillSE->szValue;
				bResult = true;
			}
		}
	}
	else if( STATE_BLOW::BLOW_215 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID )
	{
		for( int i = 0; i < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++i )
		{
			StateEffectStruct* pDestSkillSE = &(m_vlStateEffectList[ iSkillLevelApplyType ].at( i ));
			if( pDestSkillSE->nID == pEnchantSkillSE->nID )
			{
				CDnOrderMySummonedMonsterBlow::AddStateEffectValue( pDestSkillSE->szValue.c_str(), pEnchantSkillSE->szValue.c_str(), pDestSkillSE->szValue );
				pDestSkillSE->strEnchantSkillSEParam = pEnchantSkillSE->szValue;
				bResult = true;
			}
		}
	}
	else if( STATE_BLOW::BLOW_179 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID
			|| STATE_BLOW::BLOW_121 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID
			|| STATE_BLOW::BLOW_129 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID
			|| STATE_BLOW::BLOW_062 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID 
			|| STATE_BLOW::BLOW_242 == (STATE_BLOW::emBLOW_INDEX)pEnchantSkillSE->nID )
	{
		for( int i = 0; i < (int)m_vlStateEffectList[ iSkillLevelApplyType ].size(); ++i )
		{
			StateEffectStruct* pDestSkillSE = &(m_vlStateEffectList[ iSkillLevelApplyType ].at( i ));
			if( pDestSkillSE->nID == pEnchantSkillSE->nID )
			{
				pDestSkillSE->strEnchantSkillSEParam = pDestSkillSE->szValue;
				pDestSkillSE->szValue = pEnchantSkillSE->szValue;
				bResult = true;
				break;
			}
		}
	}

	return bResult;
}

bool CDnSkill::ApplyEnchantSkill( DnSkillHandle hEnchantPassiveSkill )
{
	bool bSuccess = false;

	if( 0 < m_iAppliedEnchantPassiveSkillID )
		return false;

	_ASSERT( m_iSkillID == hEnchantPassiveSkill->GetBaseSkillID() );
	_ASSERT( EnchantPassive != m_eSkillType );
	if( EnchantPassive != m_eSkillType )
	{
		int iNowLevelDataType = m_iSelectedSkillLevelDataApplyType;
		for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
		{
			// 기존에 존재하는 상태효과엔 인자값을 더해주고 새로운 상태효과는 리스트에 추가.
			// 쿨타임은 강화 패시브 스킬의 쿨타임으로 덮어씌워준다.
			SelectLevelDataType( iSkillLevelApplyType );
			hEnchantPassiveSkill->SelectLevelDataType( iSkillLevelApplyType );
			int iNumStateEffect = (int)hEnchantPassiveSkill->GetStateEffectCount();
			for( int i = 0; i < iNumStateEffect; ++i )
			{
				StateEffectStruct* pEnchantPassiveSE = hEnchantPassiveSkill->GetStateEffectFromIndex( i );

				// #40643 핑퐁밤EX 처럼 특수하게 구현된 상태효과의 인자를 건드리는 경우..
				// 어쩔 수 없이 합쳐줘야 한다. 실제로 m_vlStateEffectList 에 추가되는 것이 아님.
				if( false == CheckAndUnifyStateEffectArgument( iSkillLevelApplyType, pEnchantPassiveSE ) )
				{
					// 공격력 강화 상태효과던 아니건 추가해주면 스킬 사용시 자동으로 능력치 리프레시 된다.
					m_vlStateEffectList[ iSkillLevelApplyType ].push_back( *pEnchantPassiveSE );
					m_vlStateEffectList[ iSkillLevelApplyType ].back().nFromEnchantPassiveSkillID = hEnchantPassiveSkill->GetClassID();
				}
			}

			// 액션 프로세서를 강화 스킬의 것으로 변경한다.
			IDnSkillProcessor* pMyPlayAniProcessor = GetProcessor( IDnSkillProcessor::PLAY_ANI );
			if( pMyPlayAniProcessor )
			{
				IDnSkillProcessor* pEnchantPassiveSkillPlayAniProcessor =  hEnchantPassiveSkill->GetProcessor( IDnSkillProcessor::PLAY_ANI );
				if( pEnchantPassiveSkillPlayAniProcessor )
				{
					// 기존 것 백업.
					IDnSkillProcessor* pBackup = new CDnPlayAniProcess;
					pBackup->CopyFrom( pMyPlayAniProcessor );
					m_vlpProcessorBackup[ iSkillLevelApplyType ].push_back( pBackup );

					// 강화 패시브 스킬의 것으로 데이터 적용.
					pMyPlayAniProcessor->CopyFrom( pEnchantPassiveSkillPlayAniProcessor );
				}
			}

			IDnSkillProcessor* pMyPartialPlayAniProcessor = GetProcessor( IDnSkillProcessor::PARTIAL_PLAY_ANI );
			if( pMyPartialPlayAniProcessor )
			{
				IDnSkillProcessor* pEnchantPassivePartialSkillPlayAniProcessor =  hEnchantPassiveSkill->GetProcessor( IDnSkillProcessor::PARTIAL_PLAY_ANI );
				if( pEnchantPassivePartialSkillPlayAniProcessor )
				{
					// 기존 것 백업.
					IDnSkillProcessor* pBackup = new CDnPartialPlayProcessor;
					pBackup->CopyFrom( pMyPartialPlayAniProcessor );
					m_vlpProcessorBackup[ iSkillLevelApplyType ].push_back( pBackup );

					pMyPartialPlayAniProcessor->CopyFrom( pEnchantPassivePartialSkillPlayAniProcessor );
				}
			}

			IDnSkillProcessor* pMyChangeActionStrProcessor = GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR );
			if( pMyChangeActionStrProcessor )
			{
				IDnSkillProcessor* pEnchantPassiveChangeActionStrProcessor =  hEnchantPassiveSkill->GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR );
				if( pEnchantPassiveChangeActionStrProcessor )
				{
					// 기존 것 백업.
					IDnSkillProcessor* pBackup = new CDnChangeActionStrProcessor;
					pBackup->CopyFrom( pMyChangeActionStrProcessor );
					m_vlpProcessorBackup[ iSkillLevelApplyType ].push_back( pBackup );

					pMyChangeActionStrProcessor->CopyFrom( pEnchantPassiveChangeActionStrProcessor );
				}
			}

#ifdef PRE_ADD_ENCHANTSKILL_BUBBLE_ACTION
			IDnSkillProcessor* pMyChangeActionStrByBubbleProcessor = GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR_BY_BUBBLE );
			if( pMyChangeActionStrByBubbleProcessor )
			{
				IDnSkillProcessor* pEnchantPassiveChangeActionStrProcessor =  hEnchantPassiveSkill->GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR_BY_BUBBLE );
				if( pEnchantPassiveChangeActionStrProcessor )
				{
					IDnSkillProcessor* pBackup = new CDnChangeActionStrByBubbleProcessor( );
					pBackup->CopyFrom( pMyChangeActionStrByBubbleProcessor );
					m_vlpProcessorBackup[ iSkillLevelApplyType ].push_back( pBackup );

					pMyChangeActionStrByBubbleProcessor->CopyFrom( pEnchantPassiveChangeActionStrProcessor );
				}
			}
#endif

			m_eElement = hEnchantPassiveSkill->GetElement();
			m_SkillInfo[iSkillLevelApplyType].eSkillElement = hEnchantPassiveSkill->GetElement();

#ifdef PRE_FIX_SYNC_ENCHANT_SKILL
			bool bSummonMonsterToggleSkill = ( m_isAppliedSummonMonsterEnchantSkill && hEnchantPassiveSkill->GetDurationType() == CDnSkill::ActiveToggleForSummon );
			if( bSummonMonsterToggleSkill == false )
			{
				m_eDurationType = hEnchantPassiveSkill->GetDurationType();
				m_SkillInfo[iSkillLevelApplyType].eDurationType = hEnchantPassiveSkill->GetDurationType();
			}
#endif

#if defined(PRE_FIX_66175)
			//#66175
			//UsableChecker를 베이스 스킬과 EX스킬 교체한다...
			vector<IDnSkillUsableChecker*>& enchangeSkillUsableChecker = hEnchantPassiveSkill->GetUsableChecker(iSkillLevelApplyType);

			//EX스킬에 UsableChecker가 설정 되어 있는 경우만 교체 하도록 한다...
			if (enchangeSkillUsableChecker.size() > 0)
			{
				vector<IDnSkillUsableChecker*>& baseSkillUsableChecker = GetUsableChecker(iSkillLevelApplyType);

				{
					//자신의 Checker들을 백업 리스트에 담아 놓는다.
					vector<IDnSkillUsableChecker*>::iterator iter = baseSkillUsableChecker.begin();
					vector<IDnSkillUsableChecker*>::iterator endIter = baseSkillUsableChecker.begin();

					//백업 리스트에 저장 해놓고...
					m_vlUsableCheckersBackup[iSkillLevelApplyType].clear();

					for (; iter != endIter; ++iter)
					{
						m_vlUsableCheckersBackup[iSkillLevelApplyType].push_back((*iter));
					}

				}				

				//EX스킬의 usableChecker를 베이스 스킬에 적용한다.
				baseSkillUsableChecker.clear();
				vector<IDnSkillUsableChecker*>::iterator iter = enchangeSkillUsableChecker.begin();
				vector<IDnSkillUsableChecker*>::iterator endIter = enchangeSkillUsableChecker.end();
				for (; iter != endIter; ++iter)
				{
					IDnSkillUsableChecker* pChecker = (*iter);
					baseSkillUsableChecker.push_back(pChecker->Clone());
				}
			}
#endif // PRE_FIX_66175

			//EffectIDs도 변경..
			string enchantEffectIDs = hEnchantPassiveSkill->GetEffectOutputIDs(iSkillLevelApplyType);
			string enchantEffectIDToClient = hEnchantPassiveSkill->GetEffectOutputIDToClient(iSkillLevelApplyType);

			m_BackupEffectOutputIDs[iSkillLevelApplyType] = m_SkillInfo[iSkillLevelApplyType].szEffectOutputIDs;
			m_BackupEffectOutputIDToClient[iSkillLevelApplyType] = m_SkillInfo[iSkillLevelApplyType].szEffectOutputIDToClient;

			//SC_CMDADDSTATEEFFECT 패킷을 클라이언트로 보낼때, szEffectOutputIDToClient값이 없으면 클라이언트는 테이블 값을 읽어서 사용한다.
			//EX스킬을 사용 시 스킬 ID는 베이스 스킬 ID가 전달 되기 때문에, EX스킬에의해 변경된 값을 사용 하지 못하게 됨.
			//eX스킬 적용시 szEffectOutputIDToClient값을 EX스킬 값으로 변경 해놓는다.
			m_SkillInfo[iSkillLevelApplyType].szEffectOutputIDs = enchantEffectIDs;
			m_SkillInfo[iSkillLevelApplyType].szEffectOutputIDToClient = enchantEffectIDs;

#ifdef PRE_FIX_SYNC_ENCHANT_SKILL
			m_SkillInfo[iSkillLevelApplyType].iAppliedEnchantSkillID = hEnchantPassiveSkill->GetClassID();
#endif
		}

		SelectLevelDataType( iNowLevelDataType );

		m_iAppliedEnchantPassiveSkillID = hEnchantPassiveSkill->GetClassID();
		bSuccess = true;
	}

	return bSuccess;
}


void CDnSkill::ApplyEnchantSkillOnceFromBubble( DnSkillHandle hEnchantPassiveSkill )
{
	m_bEnchantedFromBubble = true;
	ApplyEnchantSkill( hEnchantPassiveSkill );
}


bool CDnSkill::CheckAndDivideStateEffectArgument( StateEffectStruct* pDestSkillSE )
{
	if( pDestSkillSE->strEnchantSkillSEParam.empty() == true )
		return false;

	bool bResult = false;

	if( CDnCreateBlow::IsBasicBlow( (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID ) )
	{
		CDnBasicBlow::RemoveStateEffectValue( pDestSkillSE->szValue.c_str(), pDestSkillSE->strEnchantSkillSEParam.c_str(), pDestSkillSE->szValue );
		pDestSkillSE->strEnchantSkillSEParam.clear();
		bResult = true;
	}
	else if( STATE_BLOW::BLOW_016 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID )
	{
		CDnHPIncBlow::RemoveStateEffectValue( pDestSkillSE->szValue.c_str(), pDestSkillSE->strEnchantSkillSEParam.c_str(), pDestSkillSE->szValue );
		pDestSkillSE->strEnchantSkillSEParam.clear();
		bResult = true;
	}
	else if( STATE_BLOW::BLOW_208 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID )
	{
		CDnPingpongBlow::RemoveStateEffectValue( pDestSkillSE->szValue.c_str(), pDestSkillSE->strEnchantSkillSEParam.c_str(), pDestSkillSE->szValue );
		pDestSkillSE->strEnchantSkillSEParam.clear();
		bResult = true;
	}
	else if( STATE_BLOW::BLOW_140 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID )
	{
		CDnHealingBlow::RemoveStateEffectValue( pDestSkillSE->szValue.c_str(), pDestSkillSE->strEnchantSkillSEParam.c_str(), pDestSkillSE->szValue );
		pDestSkillSE->strEnchantSkillSEParam.clear();
		bResult = true;
	}
	else if( STATE_BLOW::BLOW_227 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID )
	{
		CDnBloodSuckingBlow::RemoveStateEffectValue( pDestSkillSE->szValue.c_str(), pDestSkillSE->strEnchantSkillSEParam.c_str(), pDestSkillSE->szValue );
		pDestSkillSE->strEnchantSkillSEParam.clear();
		bResult = true;
	}
	else if( STATE_BLOW::BLOW_215 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID )
	{
		CDnOrderMySummonedMonsterBlow::RemoveStateEffectValue( pDestSkillSE->szValue.c_str(), pDestSkillSE->strEnchantSkillSEParam.c_str(), pDestSkillSE->szValue );
		pDestSkillSE->strEnchantSkillSEParam.clear();
		bResult = true;
	}
	else if( STATE_BLOW::BLOW_179 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID
		|| STATE_BLOW::BLOW_121 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID
		|| STATE_BLOW::BLOW_129 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID
		|| STATE_BLOW::BLOW_062 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID 
		|| STATE_BLOW::BLOW_242 == (STATE_BLOW::emBLOW_INDEX)pDestSkillSE->nID )
	{
		pDestSkillSE->szValue = pDestSkillSE->strEnchantSkillSEParam;
		pDestSkillSE->strEnchantSkillSEParam.clear();
		bResult = true;
	}
	
	return bResult;
}

void CDnSkill::ReleaseEnchantSkill( void )
{
	if( 0 == m_iAppliedEnchantPassiveSkillID )
		return;

	_ASSERT( EnchantPassive != m_eSkillType );
	if( EnchantPassive != m_eSkillType )
	{
		int iNowLevelDataType = m_iSelectedSkillLevelDataApplyType;
		for( int iSkillLevelApplyType = PVE; iSkillLevelApplyType < NUM_SKILLLEVEL_APPLY_TYPE; ++iSkillLevelApplyType )
		{
			// 기존에 존재하는 상태효과엔 인자값을 더해주고 새로운 상태효과는 리스트에 추가.
			// 쿨타임은 강화 패시브 스킬의 쿨타임으로 덮어씌워준다.
			SelectLevelDataType( iSkillLevelApplyType );
			DNVector( StateEffectStruct )::iterator iter = m_vlStateEffectList[ iSkillLevelApplyType ].begin();
			for( iter; iter != m_vlStateEffectList[ iSkillLevelApplyType ].end(); )
			{
				if( false == CheckAndDivideStateEffectArgument( &(*iter) ) )
				{
					if( 0 < iter->nFromEnchantPassiveSkillID )
					{
						iter = m_vlStateEffectList[ iSkillLevelApplyType ].erase( iter );
						continue;
					}
				}

				++iter;
			}

			for( int i = 0; i < (int)m_vlpProcessorBackup[ iSkillLevelApplyType ].size(); ++i )
			{
				IDnSkillProcessor* pProcessor = m_vlpProcessorBackup[ iSkillLevelApplyType ].at( i );
				switch( pProcessor->GetType() )
				{
					case IDnSkillProcessor::PLAY_ANI:
						{
							IDnSkillProcessor* pMyPlayAniProcessor = GetProcessor( IDnSkillProcessor::PLAY_ANI );
							if( pMyPlayAniProcessor )
								pMyPlayAniProcessor->CopyFrom( pProcessor );
						}
						break;

					case IDnSkillProcessor::PARTIAL_PLAY_ANI:
						{
							IDnSkillProcessor* pMyPartialPlayAniProcessor = GetProcessor( IDnSkillProcessor::PARTIAL_PLAY_ANI );
							if( pMyPartialPlayAniProcessor )
								pMyPartialPlayAniProcessor->CopyFrom( pProcessor );
						}
						break;
					case IDnSkillProcessor::CHANGE_ACTIONSTR:
						{
							IDnSkillProcessor* pMyChangeActionStrProcessor = GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR );
							if( pMyChangeActionStrProcessor )
								pMyChangeActionStrProcessor->CopyFrom( pProcessor );
						}
						break;
#ifdef PRE_ADD_ENCHANTSKILL_BUBBLE_ACTION
					case IDnSkillProcessor::CHANGE_ACTIONSTR_BY_BUBBLE:
						{
							IDnSkillProcessor* pMyChangeActionStrByBubbleProcessor = GetProcessor( IDnSkillProcessor::CHANGE_ACTIONSTR_BY_BUBBLE );
							if( pMyChangeActionStrByBubbleProcessor )
								pMyChangeActionStrByBubbleProcessor->CopyFrom( pProcessor );
						}
						break;
#endif
				}
			}

			SAFE_DELETE_PVEC( m_vlpProcessorBackup[ iSkillLevelApplyType ] );

#if defined(PRE_FIX_66175)
			if (m_vlUsableCheckersBackup[iSkillLevelApplyType].size() > 0)
			{
				std::swap(m_vlpUsableCheckers[iSkillLevelApplyType], m_vlUsableCheckersBackup[iSkillLevelApplyType]);
			}
#endif // PRE_FIX_66175

			//EffectIDs도 변경..
			m_SkillInfo[iSkillLevelApplyType].szEffectOutputIDs = m_BackupEffectOutputIDs[iSkillLevelApplyType];
			m_SkillInfo[iSkillLevelApplyType].szEffectOutputIDToClient = m_BackupEffectOutputIDToClient[iSkillLevelApplyType];

			m_BackupEffectOutputIDs[iSkillLevelApplyType].clear();
			m_BackupEffectOutputIDToClient[iSkillLevelApplyType].clear();
		}

		SelectLevelDataType( iNowLevelDataType );
		m_iAppliedEnchantPassiveSkillID = 0;
	}
}


IDnSkillUsableChecker* CDnSkill::GetChecker( int iType )
{
	IDnSkillUsableChecker* pResult = NULL;

	int iNumChecker = (int)m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].size();
	for( int iChecker = 0; iChecker < iNumChecker; ++iChecker )
	{
		IDnSkillUsableChecker* pSkillChecker = m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].at( iChecker );
		if( iType == pSkillChecker->GetType() )
		{
			pResult = pSkillChecker;
			break;
		}
	}

	return pResult;
}

bool CDnSkill::IsExistUsableChecker( int iType ) // 정의된 UsableChecker을 가지고있느냐?
{
	int iNumChecker = (int)m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].size();
	for( int iChecker = 0; iChecker < iNumChecker; ++iChecker )
	{
		IDnSkillUsableChecker* pSkillChecker = m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].at( iChecker );
		if( iType == pSkillChecker->GetType() )
			return true;
	}
	return false;
}

bool CDnSkill::IsFinishedAuraSkill()
{
	//오라 스킬일때 지속 절대/비율 마나 증가가 있을때 총 마나 변화량을 합산해서 지금 남은 마나와 비교해서
	//스킬 지속 가능 여부를 판단한다.
	if (m_hActor)
	{
		float fIncManaDelta = 0.0f;

		//절대 증가 분
		DNVector( DnBlowHandle ) vlManaAbIncBlows;
		m_hActor->GatherAppliedStateBlowByBlowIndex( STATE_BLOW::BLOW_013, vlManaAbIncBlows );
		if (!vlManaAbIncBlows.empty())
		{
			for( int i = 0; i < (int)vlManaAbIncBlows.size(); ++i )
			{
				DnBlowHandle hBlow = vlManaAbIncBlows.at( i );
				fIncManaDelta += hBlow->GetFloatValue();							
			}
		}

		//비율 증가 분
		float fMaxMP = static_cast<float>(m_hActor->GetMaxSP());
		DNVector( DnBlowHandle ) vlManaRateIncBlows;
		m_hActor->GatherAppliedStateBlowByBlowIndex( STATE_BLOW::BLOW_014, vlManaRateIncBlows );
		if (!vlManaRateIncBlows.empty())
		{
			for( int i = 0; i < (int)vlManaRateIncBlows.size(); ++i )
			{
				DnBlowHandle hBlow = vlManaRateIncBlows.at( i );
				fIncManaDelta += fMaxMP * hBlow->GetFloatValue();							
			}
		}

#if defined(PRE_FIX_46381)
		//231번 상태효과 적용.
		DNVector(DnBlowHandle) vlContinueBaseMPIncBlows;
		m_hActor->GatherAppliedStateBlowByBlowIndex( STATE_BLOW::BLOW_231, vlContinueBaseMPIncBlows);
		if (!vlContinueBaseMPIncBlows.empty())
		{
			for (int i = 0; i < (int)vlContinueBaseMPIncBlows.size(); ++i)
			{
				DnBlowHandle hBlow = vlContinueBaseMPIncBlows.at(i);
				fIncManaDelta += static_cast<CDnContinueBaseMPIncBlow*>(hBlow.GetPointer())->GetMPIncValue();
			}
		}
#endif // PRE_FIX_46381

		//최종 -증가분이 현재 남은 마나보다 많으면 마나 모자름..
		if (m_hActor->GetSP() < -(int)fIncManaDelta)
			return true;		
	}
	
	return false;
}

void CDnSkill::AddPrefixBlow(DnActorHandle hActor, int nBlowID)
{
	PREFIX_SKILL_BLOWLIST::iterator findIter = m_PrefixBlowList.find(hActor);
	if (findIter != m_PrefixBlowList.end())
	{
		findIter->second.push_back(nBlowID);
	}
	else
	{
		BLOWLIST blowList;
		blowList.push_back(nBlowID);

		m_PrefixBlowList.insert(PREFIX_SKILL_BLOWLIST::value_type(hActor, blowList));
	}
}

void CDnSkill::RemovePrefixBlow()
{
	PREFIX_SKILL_BLOWLIST::iterator iter = m_PrefixBlowList.begin();
	PREFIX_SKILL_BLOWLIST::iterator endIter = m_PrefixBlowList.end();

	for (; iter != endIter; ++iter)
	{
		DnActorHandle hActor = iter->first;
		if (!hActor)
			continue;

		BLOWLIST& blowList = iter->second;
		for (int i = 0; i < (int)blowList.size(); ++i)
		{
			// [2010/12/13 semozz]
			// 이제는 모든 상태효과는 패킷으로 생성 되므로, 패킷으로 상태효과 제거한다.
			hActor->CmdRemoveStateEffectFromID( blowList[i] );
		}

		blowList.clear();
	}

	m_PrefixBlowList.clear();
}

void CDnSkill::OnInitializeSummonMonsterInfo()
{
	if (!m_hActor)
		return;

	set<string>::iterator iter = m_setUseActionNames.begin();
	set<string>::iterator endIter = m_setUseActionNames.end();

	string actionName;
	CEtActionBase::ActionElementStruct *pActionElement = NULL;

	bool bFindMonsterID = false;

	for (; iter != endIter; ++iter)
	{
		actionName = *iter;
		pActionElement = m_hActor->GetElement(actionName.c_str());
		if (pActionElement)
		{
			CEtActionSignal *pSignal = NULL;
			for( DWORD i=0; i<pActionElement->pVecSignalList.size(); i++ ) 
			{
				pSignal = pActionElement->pVecSignalList[i];

				if (pSignal->GetSignalIndex() == STE_SummonMonster)
				{
					SummonMonsterStruct* pStruct = (SummonMonsterStruct *)pSignal->GetData();

					m_SummonMonsterID = pStruct ? pStruct->MonsterID : -1;

					if (m_SummonMonsterID != -1) 
					{
						bFindMonsterID = true;
						break;
					}
				}
			}
		}

		if (bFindMonsterID)
			break;
	}
	
}
DnActorHandle CDnSkill::FindSummonMonster(int nMonsterID)
{
	DnActorHandle hSummonMonster;

	if (m_hActor && m_hActor->IsPlayerActor())
	{
		const list<DnMonsterActorHandle>& listSummonMonster = m_hActor->GetSummonedMonsterList();

		if( false == listSummonMonster.empty() )
		{
			list<DnMonsterActorHandle>::const_iterator iter = listSummonMonster.begin();
			for( iter; iter != listSummonMonster.end(); ++iter )
			{
				DnMonsterActorHandle hMonster = (*iter);
				if( hMonster && hMonster->GetMonsterClassID() == nMonsterID )
				{
					hSummonMonster = hMonster;
					break;
				}
			}
		}	
	}

	return hSummonMonster;
}

bool CDnSkill::SummonMonsterOff()
{
	DnActorHandle hSummonMonster;

	if (m_SummonMonsterID != -1)
		hSummonMonster = FindSummonMonster(m_SummonMonsterID);

	if (hSummonMonster)
	{
		hSummonMonster->CmdSuicide(false, false);
		return true;
	}
	else
		return false;
}

bool CDnSkill::IsSkipStateBlow(const char* szSkipStateBlows, STATE_BLOW::emBLOW_INDEX blowIndex)
{
	if (szSkipStateBlows == NULL)
		return false;

	std::string stringValue = szSkipStateBlows;
	std::vector<std::string> tokens;
	std::string delimiters = ";";

	TokenizeA(stringValue, tokens, delimiters);

	for (UINT i = 0; i < tokens.size(); ++i)
	{
		STATE_BLOW::emBLOW_INDEX skipStateBlowIndex = (STATE_BLOW::emBLOW_INDEX)(atoi(tokens[i].c_str()));
		if (skipStateBlowIndex == blowIndex)
			return true;
	}

	return false;
}

void CDnSkill::AddProjectile(CDnProjectile* pProjectile)
{
	if (pProjectile)
	{
		LOCAL_TIME startTime = pProjectile->GetSkillStartTime();

		SKILL_PROJECTILE_LIST::iterator findIter = m_ProjectileList.find(startTime);
		
		if (findIter == m_ProjectileList.end())
		{
			PROJECTILE_LIST projectileList;
			projectileList.push_back(pProjectile);

			m_ProjectileList.insert(std::make_pair(startTime, projectileList));
		}
		else
		{
			findIter->second.push_back(pProjectile);
		}
	}
}

void CDnSkill::RemoveProjectile(CDnProjectile* pProjectile)
{
	if (pProjectile == NULL)
		return;

	LOCAL_TIME startTime = pProjectile->GetSkillStartTime();

	SKILL_PROJECTILE_LIST::iterator findIter = m_ProjectileList.find(startTime);
	if (findIter != m_ProjectileList.end())
	{
		PROJECTILE_LIST::iterator iter = findIter->second.begin();
		for ( ; iter != findIter->second.end(); ++iter)
		{
			CDnProjectile* pTemp = *iter;
			if (pTemp == pProjectile)
			{
				iter = findIter->second.erase(iter);

				//리스트가 비었다면 메인 리스트에서 제거한다.
				if (findIter->second.empty() == true)
					m_ProjectileList.erase(findIter);
				
				break;
			}
		}
	}
	
}

int CDnSkill::GetProjectileCount(LOCAL_TIME startTime)
{
	int nListCount = 0;

	SKILL_PROJECTILE_LIST::iterator findIter = m_ProjectileList.find(startTime);
	if (findIter != m_ProjectileList.end())
		nListCount = (int)findIter->second.size();
	
	return nListCount;
}

void CDnSkill::ApplyAddtionalStateInfo()
{
	if( !m_hActor ) return;

	//#52905 [칼리]"중첩 추가 효과"
	//상태효과가 적용 되어 있을때 조건에 맞는 상태효과가 적용 되어 있으면 스킬의 상태효과에 추가 한다..
	if( m_hActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_253) )
	{
		DNVector(DnBlowHandle) vlBlows;
		m_hActor->GatherAppliedStateBlowByBlowIndex(STATE_BLOW::BLOW_253, vlBlows);
		int nListCount = (int)vlBlows.size();

		for (int iIndex = 0; iIndex < nListCount; ++iIndex)
		{
			DnBlowHandle hBlow = vlBlows[iIndex];
			if (hBlow && hBlow->IsEnd() == false)
			{
				CDnAdditionalStateInfoBlow* pAddtionalStateInfoBlow = static_cast<CDnAdditionalStateInfoBlow*>(hBlow.GetPointer());
				if (pAddtionalStateInfoBlow)
				{
					STATE_BLOW::emBLOW_INDEX DestBlowIndex = pAddtionalStateInfoBlow->GetDestStateIndex();
					CDnSkill::StateEffectStruct addStateInfo = pAddtionalStateInfoBlow->GetTargetStateInfo();

					int iNumStateBlow = (int)m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].size();
					for( int i = 0; i < iNumStateBlow; ++i )
					{
						const StateEffectStruct& SE = m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].at( i );
						if( DestBlowIndex == SE.nID)
						{
							addStateInfo.nDurationTime = SE.nDurationTime;	//지속 시간은 조건 상태효과 시간으로 설정한다.

							//추가할 상태효과 리스트를 만든다.
							m_AddtionalStateInfoList.push_back(addStateInfo);

							OutputDebug("추가 상태효과 적용됨.... %d, %s\n", addStateInfo.nID, addStateInfo.szValue.c_str());
						}
					}
				}
			}
		}

		//추가할 상태효과 리스트 순회 하면서 실제 스킬 상태효과 리스트에 추가 한다.
		int nAddStateCount = (int)m_AddtionalStateInfoList.size();
		for (int i = 0; i < nAddStateCount; ++i)
		{
			CDnSkill::StateEffectStruct addStateEffect = m_AddtionalStateInfoList[i];
			 m_vlStateEffectList[m_iSelectedSkillLevelDataApplyType].push_back(addStateEffect);
		}
	}

	if( m_hActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_276) )
	{
		DNVector(DnBlowHandle) vlBlows;
		m_hActor->GatherAppliedStateBlowByBlowIndex(STATE_BLOW::BLOW_276, vlBlows);
		
		for( DWORD i=0; i<vlBlows.size(); i++ )
		{
			if( vlBlows[i] )
			{
				CDnAddStateBySkillGroupBlow* pAddStateBySkillGroupBlow = static_cast<CDnAddStateBySkillGroupBlow*>(vlBlows[i].GetPointer());
				if( pAddStateBySkillGroupBlow ) pAddStateBySkillGroupBlow->ApplyAddtionalStateBlowFromSkill( GetClassID() );
			}
		}
	}
}

void CDnSkill::RemoveAddtionalStateInfo()
{
	//스킬 사용시 추가 상태효과 추가된 것들 제거...
	int nListCount = (int)m_AddtionalStateInfoList.size();
	for (int iIndex = 0; iIndex < nListCount; ++iIndex)
	{
		StateEffectStruct addStateInfo = m_AddtionalStateInfoList[iIndex];

		std::vector<StateEffectStruct>::iterator iter = m_vlStateEffectList[ m_iSelectedSkillLevelDataApplyType ].begin();
		for( ; iter != m_vlStateEffectList[m_iSelectedSkillLevelDataApplyType].end(); ++iter)
		{
			StateEffectStruct SE = (*iter);

			if (SE.nID == addStateInfo.nID &&
				SE.ApplyType == addStateInfo.ApplyType &&
				/*SE.nDurationTime == addStateInfo.nDurationTime &&*/	//지속시간은 가변...
				SE.bAddtionalStateInfo == addStateInfo.bAddtionalStateInfo)
			{
				
				iter = m_vlStateEffectList[m_iSelectedSkillLevelDataApplyType].erase(iter);
				break;
			}			
		}
	}

	m_AddtionalStateInfoList.clear();


	if( m_hActor->IsAppliedThisStateBlow(STATE_BLOW::BLOW_276) )
	{
		DNVector(DnBlowHandle) vlBlows;
		m_hActor->GatherAppliedStateBlowByBlowIndex(STATE_BLOW::BLOW_276, vlBlows);

		for( DWORD i=0; i<vlBlows.size(); i++ )
		{
			if( vlBlows[i] )
			{
				CDnAddStateBySkillGroupBlow* pAddStateBySkillGroupBlow = static_cast<CDnAddStateBySkillGroupBlow*>(vlBlows[i].GetPointer());
				if( pAddStateBySkillGroupBlow )	pAddStateBySkillGroupBlow->RemoveAdditionalStateBlow();
			}
		}
	}
}

#if defined(PRE_FIX_64312)
bool CDnSkill::IsSummonMonsterSkill()
{
	m_bIsSummonMonsterSkill = false;

	//스킬 Checker중에 소환몬스터 체크가 있으면 소환몬스터에 사용 하는 스킬???(기획의견..)
	int iNumChecker = (int)m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].size();

	for( int iChecker = 0; iChecker < iNumChecker; ++iChecker )
	{
		IDnSkillUsableChecker* pChecker = m_vlpUsableCheckers[ m_iSelectedSkillLevelDataApplyType ].at( iChecker );
		if( pChecker && pChecker->GetType() == IDnSkillUsableChecker::SUMMON_CHECKER )
		{
			m_bIsSummonMonsterSkill = true;
			break;
		}
	}

	return m_bIsSummonMonsterSkill;
}

void CDnSkill::AddSummonMonsterEnchantSkill(DnSkillHandle hSkill)
{
	m_SummonMonsterEnchantSkill = hSkill;
}

void CDnSkill::RemoveSummonMonsterEnchantSkill()
{
	m_SummonMonsterEnchantSkill.Identity();
}

bool CDnSkill::ApplySummonMonsterEnchantSkill(DnSkillHandle hSkill)
{
	m_isAppliedSummonMonsterEnchantSkill = true;
	return ApplyEnchantSkill(hSkill);
}
#endif // PRE_FIX_64312

#if defined(PRE_ADD_TOTAL_LEVEL_SKILL)
float CDnSkill::GetOrigDelayTime()
{
	float fDelayTime = 0.0f;

	if( 0.0f < m_fAnotherGlobalSkillCoolTime )
		fDelayTime = m_fAnotherGlobalSkillCoolTime;
	else
		fDelayTime = m_fDelayTime[ m_iSelectedSkillLevelDataApplyType ]; 

	return fDelayTime;
}

void CDnSkill::UpdateGlobalCoolTime(float fRate)
{
	//글로벌 쿨타임이 설정 되어 있고, 쿨타임이 이미 시작 되었을 경우
	if (m_iGlobalSkillGroupID > 0)
	{
		if (m_fLeftDelayTime > 0)
		{
			m_fDeltaGlobalCoolTime += fRate;

			float fOrigDelayTime = GetOrigDelayTime();

			m_fLeftDelayTime -= fOrigDelayTime * fRate;		
		}
	}
}

void CDnSkill::ResetGlobalCoolTime(float fRate)
{
	//글로벌 쿨타임이 설정 되어 있고, 쿨타임이 이미 시작 되었을 경우
	if (m_iGlobalSkillGroupID > 0 )
	{
		//글로벌 쿨타임 변경 수치가 설정 된 경우
		if (m_fDeltaGlobalCoolTime > 0.0)
		{
			float fOrigDelayTime = GetOrigDelayTime();

			//적용된 수치가 지금 리셋 하려는 수치보다 작은 값인 경우
			if (m_fDeltaGlobalCoolTime < fRate)
				fRate = m_fDeltaGlobalCoolTime;

			//적용된 수치는 감소 시켜준다..
			m_fDeltaGlobalCoolTime -= fRate;
			if (m_fDeltaGlobalCoolTime < 0.0f)
				m_fDeltaGlobalCoolTime = 0.0f;

			//현재 쿨타임이 남아 있는 경우
			if (m_fLeftDelayTime > 0)
				m_fLeftDelayTime += fOrigDelayTime * fRate;		
		}
	}
}
#endif // PRE_ADD_TOTAL_LEVEL_SKILL

#if defined(PRE_ADD_65808)
bool CDnSkill::IsSummonMonsterRecall(int& monsterID)
{
	//PlayAniProcess를 이용하고, 해당 동작에 SummonMonster시그널이 존재 하면 true를 리턴..
	CDnPlayAniProcess* pAniProcess = static_cast<CDnPlayAniProcess*>(GetProcessor( IDnSkillProcessor::PLAY_ANI ));
	if (pAniProcess && m_hActor)
	{
		const char* szActionName = pAniProcess->GetActionName();
		if (szActionName == NULL)
			return false;

		CEtActionBase::ActionElementStruct *pStruct = m_hActor->GetElement(szActionName);
		if (pStruct)
		{
			int selectedMonsterID = -1;

			CEtActionSignal *pSignal = NULL;
			for (int i = 0; i < (int)pStruct->pVecSignalList.size(); ++i)
			{
				pSignal = pStruct->pVecSignalList[i];
				if (pSignal == NULL)
					continue;

				int signalIndex = pSignal->GetSignalIndex();
				switch(signalIndex)
				{
				case STE_SummonMonster:
					{
						SummonMonsterStruct* pSummonMonsterInfo = (SummonMonsterStruct *)pSignal->GetData();
						if (pSummonMonsterInfo)
							selectedMonsterID = pSummonMonsterInfo->MonsterID;
					}
					break;
				case STE_SummonMonsterInfo:
					{
						SummonMonsterInfoStruct* pInfo = (SummonMonsterInfoStruct*)pSignal->GetData();
						if (pInfo)
							selectedMonsterID = pInfo->MonsterID;
					}
					break;
				}

				if (selectedMonsterID != -1)
					break;
			}

			if (selectedMonsterID != -1)
			{
				monsterID = selectedMonsterID;
				return true;
			}
		}
	}

	return false;
}
#endif // PRE_ADD_65808


#if defined(_GAMESERVER)
bool CoolTimeInfo::Process(LOCAL_TIME localTime, float fDelta)
{
	switch( m_eDurationType )
	{
	case CDnSkill::DurationTypeEnum::Instantly:
	case CDnSkill::DurationTypeEnum::Buff:
	case CDnSkill::DurationTypeEnum::Debuff:
	case CDnSkill::DurationTypeEnum::SummonOnOff:
	case CDnSkill::DurationTypeEnum::StanceChange:
		{
			if( m_fLeftDelayTime == 0.0f ) return false;

			m_fLeftDelayTime -= fDelta;
			if( m_fLeftDelayTime < 0.f ) 
				m_fLeftDelayTime = 0.f;

			m_fCoolTime = ( 1.0f / (m_fDelayTime*m_fCoolTimeAdjustBlowValue) ) * m_fLeftDelayTime;
		}
		break;

	case CDnSkill::DurationTypeEnum::TimeToggle:
		break;
	case CDnSkill::DurationTypeEnum::ActiveToggle:
	case CDnSkill::DurationTypeEnum::ActiveToggleForSummon:
		break;
	case CDnSkill::DurationTypeEnum::Aura:
		break;
	}

	return (m_fCoolTime != 0.0f && m_fLeftDelayTime > 0.0f);
}

void CoolTimeInfo::OnBeginCoolTime()
{
	m_fCoolTime = (m_fDelayTime == 0.f) ? 0.0f : 1.0f;
	m_fCoolTimeAdjustBlowValue = 1.0f;

	m_fLeftDelayTime = m_fDelayTime * m_fCoolTimeAdjustBlowValue;
}

void CoolTimeInfo::SetInfo(DnSkillHandle &hSkill)
{
	m_nSkillID = hSkill->GetClassID();
	m_hActor = hSkill->GetActor();
	m_eDurationType = hSkill->GetDurationType();

	m_fCoolTimeAdjustBlowValue = 1.0f;

	m_fDelayTime = hSkill->GetDelayTime();
}

#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
void CoolTimeInfo::SetInfo(CDnPrefixSkill* pPrefixSkill)
{
	m_nSkillID = pPrefixSkill->GetSkillType();

	DnSkillHandle hSkill = pPrefixSkill->GetSkillHandle();
	if (hSkill)
	{
		m_hActor = hSkill->GetActor();
		m_eDurationType = hSkill->GetDurationType();

		m_fCoolTimeAdjustBlowValue = 1.0f;

		m_fDelayTime = hSkill->GetDelayTime();
	}
}
#endif // PRE_ADD_PREFIX_SYSTE_RENEW


bool CoolTimeManager::IsCoolTime(int nSkillID)
{
	COOLTIME_LIST::iterator findIter = m_CoolTimeList.find(nSkillID);

	//아직 등록되어 있다면 쿨타임이 끝나지 않았다??
	return (findIter != m_CoolTimeList.end());
}

void CoolTimeManager::AddCoolTime(DnSkillHandle hSkill)
{
	if (!hSkill)
		return;

	int nSkillID = hSkill->GetClassID();
	COOLTIME_LIST::iterator findIter = m_CoolTimeList.find(nSkillID);
	//같은 스킬 ID가 없을때만 등록한다.
	if (findIter == m_CoolTimeList.end())
	{
		CoolTimeInfo *pCoolTimeInfo = new CoolTimeInfo();
		pCoolTimeInfo->SetInfo(hSkill);
		pCoolTimeInfo->OnBeginCoolTime();

		m_CoolTimeList.insert(COOLTIME_LIST::value_type(nSkillID, pCoolTimeInfo));
	}
}

#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)
void CoolTimeManager::AddCoolTime(CDnPrefixSkill* pPrefixSkill)
{
	if (!pPrefixSkill)
		return;

	int nSkillType = pPrefixSkill->GetSkillType();
	COOLTIME_LIST::iterator findIter = m_CoolTimeList.find(nSkillType);
	//같은 스킬 ID가 없을때만 등록한다.
	if (findIter == m_CoolTimeList.end())
	{
		CoolTimeInfo *pCoolTimeInfo = new CoolTimeInfo();
		pCoolTimeInfo->SetInfo(pPrefixSkill);
		pCoolTimeInfo->OnBeginCoolTime();

		m_CoolTimeList.insert(COOLTIME_LIST::value_type(nSkillType, pCoolTimeInfo));
	}
}
#endif // PRE_ADD_PREFIX_SYSTE_RENEW

void CoolTimeManager::RemoveCoolTime(int nSkillID)
{
	COOLTIME_LIST::iterator findIter = m_CoolTimeList.find(nSkillID);
	if (findIter != m_CoolTimeList.end())
	{
		CoolTimeInfo* pCoolTimeInfo = findIter->second;
		if (pCoolTimeInfo)
			delete pCoolTimeInfo;

		m_CoolTimeList.erase(findIter);
	}
}

void CoolTimeManager::Process(LOCAL_TIME localTime, float fDelta)
{
	COOLTIME_LIST::iterator iter = m_CoolTimeList.begin();
	COOLTIME_LIST::iterator endIter = m_CoolTimeList.end();

	std::list<int> removeCoolTimeList;

	for (; iter != endIter; ++iter)
	{
		if (!iter->second->Process(localTime, fDelta))
			removeCoolTimeList.push_back(iter->first);			
	}

	if (!removeCoolTimeList.empty())
	{
		std::list<int>::iterator iter = removeCoolTimeList.begin();
		std::list<int>::iterator endIter = removeCoolTimeList.end();

		for (; iter != endIter; ++iter)
		{
			RemoveCoolTime((*iter));
		}

		removeCoolTimeList.clear();
	}
}

void CoolTimeManager::InitList()
{
	COOLTIME_LIST::iterator iter = m_CoolTimeList.begin();
	COOLTIME_LIST::iterator endIter = m_CoolTimeList.end();

	for (; iter != endIter; ++iter)
	{
		CoolTimeInfo* pCoolTimeInfo = iter->second;
		if (pCoolTimeInfo)
			delete pCoolTimeInfo;
	}

	m_CoolTimeList.clear();
}
#endif // _GAMESERVER


#if defined(PRE_ADD_PREFIX_SYSTE_RENEW)

CDnPrefixSkill::CDnPrefixSkill(int nPrefixType)
{
	m_nPrefixType = nPrefixType;

	m_fProbability = 0.0f;
}

CDnPrefixSkill::~CDnPrefixSkill()
{

}

void CDnPrefixSkill::SetSkillHandle(DnSkillHandle hSkill)
{
	m_hSkill = hSkill;
}

void CDnPrefixSkill::UpdateCandidateSkill()
{
	std::list<DnSkillHandle>::iterator iter = m_SkillList.begin();
	std::list<DnSkillHandle>::iterator endIter = m_SkillList.end();

	float fDelayTime = FLT_MAX;

	DnSkillHandle hSelectedSkill;
	for (; iter != endIter; ++iter)
	{
		DnSkillHandle hSkill = *iter;
		if (!hSkill)
			continue;

		float fSkillDelayTime = hSkill->GetDelayTime();
		if (fSkillDelayTime < fDelayTime)
		{
			hSelectedSkill = hSkill;
			fDelayTime = fSkillDelayTime;
		}
	}

	if (hSelectedSkill)
		SetSkillHandle(hSelectedSkill);
}

void CDnPrefixSkill::AddSkill(DnSkillHandle hSkill)
{
	if (!hSkill) return;

	m_SkillList.push_back(hSkill);

	//해당 스킬의 확률값을 가져온다.
	CDnProbabilityChecker* pProbabilityChecker = static_cast<CDnProbabilityChecker*>(hSkill->GetChecker(IDnSkillUsableChecker::PROB_CHECKER));
	m_fProbability += pProbabilityChecker ? pProbabilityChecker->GetProbability() : 0.0f;

	UpdateCandidateSkill();

	AddStateEffectInfo(hSkill);
}

void CDnPrefixSkill::RemoveSkill(DnSkillHandle hSkill)
{
	std::list<DnSkillHandle>::iterator iter = m_SkillList.begin();
	std::list<DnSkillHandle>::iterator endIter = m_SkillList.end();

	for (; iter != endIter; ++iter)
	{
		if ((*iter) == hSkill)
		{
			//해당 스킬의 확률값을 가져온다.
			CDnProbabilityChecker* pProbabilityChecker = static_cast<CDnProbabilityChecker*>(hSkill->GetChecker(IDnSkillUsableChecker::PROB_CHECKER));
			m_fProbability -= pProbabilityChecker ? pProbabilityChecker->GetProbability() : 0.0f;
			m_SkillList.erase(iter);
			break;
		}
	}

	UpdateCandidateSkill();

	//스킬 제거 될때 스킬 리스트 돌면서 상태효과 다시 적용하도록..
	UpdateStateEffects();
}

void CDnPrefixSkill::UpdateStateEffects()
{
	//1.기존 상태효과 설정 값을 제거..
	m_vlStateEffectList.clear();

	//스킬 리스트 돌면서 상태효과 값 적용.
	std::list<DnSkillHandle>::iterator iter = m_SkillList.begin();
	std::list<DnSkillHandle>::iterator endIter = m_SkillList.end();

	for (; iter != endIter; ++iter)
	{
		DnSkillHandle hSkill = (*iter);
		if (hSkill)
		{
			AddStateEffectInfo(hSkill);
		}
	}
}

void CDnPrefixSkill::AddStateEffectInfo(DnSkillHandle hSkill)
{
	if (m_vlStateEffectList.empty())
	{
		//hSkill의 상태효과 설정값을 그대로 리스트에 추가 한다.
		int nStateEffectCount = hSkill->GetStateEffectCount();
		for (int i = 0; i < nStateEffectCount; ++i)
		{
			CDnSkill::StateEffectStruct* pAddStateEffect = hSkill->GetStateEffectFromIndex(i);

			if (pAddStateEffect)
				m_vlStateEffectList.push_back(*pAddStateEffect);
		}
	}
	else
	{
		//상태효과 갯수가 맞지 않으면 추가 못함..
		if (m_vlStateEffectList.size() != hSkill->GetStateEffectCount())
			return;

		switch(m_nPrefixType)
		{
		case Prefix_000: //파괴의
			AddStateEffectInfo_Prefix_000(hSkill);
			break;
		case Prefix_001: //마법의
			AddStateEffectInfo_Prefix_001(hSkill);
			break;
		case Prefix_002: //곰의 무기
			AddStateEffectInfo_Prefix_002(hSkill);
			break;
		case Prefix_003: //바람의 무기
			AddStateEffectInfo_Prefix_003(hSkill);
			break;
		case Prefix_004: //지혜의 무기
			AddStateEffectInfo_Prefix_004(hSkill);
			break;
		case Prefix_005: //가혹한
			AddStateEffectInfo_Prefix_005(hSkill);
			break;
		case Prefix_006: //어둠의 무기
			AddStateEffectInfo_Prefix_006(hSkill);
			break;
		case Prefix_007: //생명의 무기
			AddStateEffectInfo_Prefix_007(hSkill);
			break;
		case Prefix_008: //마나의 무기
			AddStateEffectInfo_Prefix_008(hSkill);
			break;
		case Prefix_009: //활기의
			AddStateEffectInfo_Prefix_009(hSkill);
			break;
		case Prefix_010: //치명적인
			AddStateEffectInfo_Prefix_010(hSkill);
			break;
		case Prefix_011: //구속의
			AddStateEffectInfo_Prefix_011(hSkill);
			break;
		case Prefix_012: //충격의
			AddStateEffectInfo_Prefix_012(hSkill);
			break;
		case Prefix_013: //용자의
			AddStateEffectInfo_Prefix_013(hSkill);
			break;
		case Prefix_014: //기사의
			AddStateEffectInfo_Prefix_014(hSkill);
			break;
		case Prefix_015: //철벽의 무기
			AddStateEffectInfo_Prefix_015(hSkill);
			break;
		case Prefix_016: //장막의 무기
			AddStateEffectInfo_Prefix_016(hSkill);
			break;
		case Prefix_017: //불의 무기
			AddStateEffectInfo_Prefix_017(hSkill);
			break;
		case Prefix_018: //물의 무기
			AddStateEffectInfo_Prefix_018(hSkill);
			break;
		case Prefix_019: //빛의 무기
			AddStateEffectInfo_Prefix_019(hSkill);
			break;
		case Prefix_020: //철벽의 방어구
			AddStateEffectInfo_Prefix_020(hSkill);
			break;
		case Prefix_021: //장막의 방어구
			AddStateEffectInfo_Prefix_021(hSkill);
			break;
		case Prefix_022: //곰의 방어구
			AddStateEffectInfo_Prefix_022(hSkill);
			break;
		case Prefix_023: //바람의 방어구
			AddStateEffectInfo_Prefix_023(hSkill);
			break;
		case Prefix_024: //지혜의 방어구
			AddStateEffectInfo_Prefix_024(hSkill);
			break;
		case Prefix_025: //건강한
			AddStateEffectInfo_Prefix_025(hSkill);
			break;
		case Prefix_026: //행운의
			AddStateEffectInfo_Prefix_026(hSkill);
			break;
		case Prefix_027: //생명의 방어구
			AddStateEffectInfo_Prefix_027(hSkill);
			break;
		case Prefix_028: //마나의 방어구
			AddStateEffectInfo_Prefix_028(hSkill);
			break;
// 		case Prefix_029: //견고한
// 			AddStateEffectInfo_Prefix_029(hSkill);
// 			break;
		case Prefix_030: //유연한
			AddStateEffectInfo_Prefix_030(hSkill);
			break;
		case Prefix_031: //의지의
			AddStateEffectInfo_Prefix_031(hSkill);
			break;
// 		case Prefix_032: //강인한
// 			AddStateEffectInfo_Prefix_032(hSkill);
// 			break;
// 		case Prefix_033: //불굴의
// 			AddStateEffectInfo_Prefix_033(hSkill);
// 			break;
		case Prefix_034: //불의 방어구
			AddStateEffectInfo_Prefix_034(hSkill);
			break;
		case Prefix_035: //물의 방어구
			AddStateEffectInfo_Prefix_035(hSkill);
			break;
		case Prefix_036: //빛의 방어구
			AddStateEffectInfo_Prefix_036(hSkill);
			break;
		case Prefix_037: //어둠의 방어구
			AddStateEffectInfo_Prefix_037(hSkill);
			break;

		default:
			break;

		}		
	}
}

void CDnPrefixSkill::AddStateEffectInfo( STATE_BLOW::emBLOW_INDEX blowList[], int nCount, DnSkillHandle hSkill )
{
	if (!hSkill)
		return;

	int nAddStateEffectCount = hSkill->GetStateEffectCount();

	//상태효과 갯수가 4개
	if (nAddStateEffectCount != nCount)
	{
		OutputDebug("접두사 스킬 Type[%d]의 상태효과 갯수가 다름...!!\n", m_nPrefixType);
		return;
	}

	for (int i = 0; i < nCount; ++i)
	{
		CDnSkill::StateEffectStruct* pAddStateEffect = hSkill->GetStateEffectFromIndex(i);
		CDnSkill::StateEffectStruct* pOrigStateEffect = &m_vlStateEffectList[i];

		//상태효과 Index가 BLOW_213이 아니면 잘못된거다..
		if ((STATE_BLOW::emBLOW_INDEX)pOrigStateEffect->nID != blowList[i])
		{
			OutputDebug("상태효과 Index가 다름..%d이어야 하는데 %d이네...!!!\n", blowList[i], pOrigStateEffect->nID);
			continue;
		}

		//두개 상태효과 Index가 다르면..
		if (pAddStateEffect->nID != pOrigStateEffect->nID)
		{
			OutputDebug("두 상태효과 Index가 다름..Orig[%d], Add[%d]..!!!\n", pOrigStateEffect->nID, pAddStateEffect->nID);
			continue;
		}

		std::string szNewValue = "";
		CDnCreateBlow::AddStateEffectValue((STATE_BLOW::emBLOW_INDEX)pOrigStateEffect->nID, pOrigStateEffect->szValue.c_str(), pAddStateEffect->szValue.c_str(), szNewValue);
		
		OutputDebug("원래 상태효과 설정값(%s), 추가 되는 상태효과 설정값(%s), 최종 결과(%s)\n", pOrigStateEffect->szValue.c_str(), pAddStateEffect->szValue.c_str(), szNewValue.c_str());

		pOrigStateEffect->szValue = szNewValue;
		//지속 시간은 큰 값으로 변경.
		pOrigStateEffect->nDurationTime = max(pOrigStateEffect->nDurationTime, pAddStateEffect->nDurationTime);
	}
}


void CDnPrefixSkill::AddStateEffectInfo_Prefix_000(DnSkillHandle hSkill) //파괴의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_213,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}

void CDnPrefixSkill::AddStateEffectInfo_Prefix_001(DnSkillHandle hSkill) //마법의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_214,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}

void CDnPrefixSkill::AddStateEffectInfo_Prefix_002(DnSkillHandle hSkill) //곰의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_221,
		STATE_BLOW::BLOW_124,
		STATE_BLOW::BLOW_128,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}

void CDnPrefixSkill::AddStateEffectInfo_Prefix_003(DnSkillHandle hSkill) //바람의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_221,
		STATE_BLOW::BLOW_126,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_004(DnSkillHandle hSkill) //지혜의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_214,
		STATE_BLOW::BLOW_036,
		STATE_BLOW::BLOW_037,
		STATE_BLOW::BLOW_038,
		STATE_BLOW::BLOW_039,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_005(DnSkillHandle hSkill) //가혹한
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_157,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_006(DnSkillHandle hSkill) //어둠의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_035,
		STATE_BLOW::BLOW_182,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_007(DnSkillHandle hSkill) //생명의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_016,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_008(DnSkillHandle hSkill) //마나의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_018,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_009(DnSkillHandle hSkill) //활기의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_014,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_010(DnSkillHandle hSkill) //치명적인
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_158,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_011(DnSkillHandle hSkill) //구속의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_070,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_012(DnSkillHandle hSkill) //충격의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_221,
		STATE_BLOW::BLOW_175,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_013(DnSkillHandle hSkill) //용자의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_079,
	};
	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_014(DnSkillHandle hSkill) //기사의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_076,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_015(DnSkillHandle hSkill) //철벽의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_004,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_016(DnSkillHandle hSkill) //장막의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_094,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_017(DnSkillHandle hSkill) //불의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_032,
		STATE_BLOW::BLOW_182,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_018(DnSkillHandle hSkill) //물의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_033,
		STATE_BLOW::BLOW_182,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_019(DnSkillHandle hSkill) //빛의 무기
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_034,
		STATE_BLOW::BLOW_182,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_020(DnSkillHandle hSkill) //철벽의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_134,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);;
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_021(DnSkillHandle hSkill) //장막의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_135,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_022(DnSkillHandle hSkill) //곰의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_124,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_023(DnSkillHandle hSkill) //바람의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_126,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_024(DnSkillHandle hSkill) //지혜의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_036,
		STATE_BLOW::BLOW_037,
		STATE_BLOW::BLOW_038,
		STATE_BLOW::BLOW_039,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_025(DnSkillHandle hSkill) //건강한
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_124,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_026(DnSkillHandle hSkill) //행운의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_111,
		STATE_BLOW::BLOW_112,
		STATE_BLOW::BLOW_113,
		STATE_BLOW::BLOW_114,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_027(DnSkillHandle hSkill) //생명의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_016,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_028(DnSkillHandle hSkill) //마나의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_018,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_029(DnSkillHandle hSkill) //견고한
{
// 	STATE_BLOW::emBLOW_INDEX blowList[] = 
// 	{
// 	};
// 
// 	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);
// 
// 	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_030(DnSkillHandle hSkill) //유연한
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_076,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_031(DnSkillHandle hSkill) //의지의
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_156,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_032(DnSkillHandle hSkill) //강인한
{
// 	STATE_BLOW::emBLOW_INDEX blowList[] = 
// 	{
// 	};
// 
// 	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);
// 
// 	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_033(DnSkillHandle hSkill) //불굴의
{
// 	STATE_BLOW::emBLOW_INDEX blowList[] = 
// 	{
// 	};
// 
// 	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);
// 
// 	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_034(DnSkillHandle hSkill) //불의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_036,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_035(DnSkillHandle hSkill) //물의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_037,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_036(DnSkillHandle hSkill) //빛의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_038,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
void CDnPrefixSkill::AddStateEffectInfo_Prefix_037(DnSkillHandle hSkill) //어둠의 방어구
{
	STATE_BLOW::emBLOW_INDEX blowList[] = 
	{
		STATE_BLOW::BLOW_039,
	};

	int nCount = sizeof(blowList) / sizeof(STATE_BLOW::emBLOW_INDEX);

	AddStateEffectInfo(blowList, nCount, hSkill);
}
#endif // PRE_ADD_PREFIX_SYSTE_RENEW

void CDnSkill::OnAnotherGlobalSkillBeginCoolTime( DnSkillHandle hSkill )
{
	if( hSkill )
	{
		m_fAnotherGlobalSkillCoolTime = hSkill->GetDelayTime();

		m_nAnotherGlobakSkillID = hSkill->GetClassID();
	}
}