DragonNest/Server/DNGameServer/DnSkillTask.cpp

#include "StdAfx.h"
#include "DnSkillTask.h"
#include "DnProtocol.h"
#include "DNUserSession.h"
#include "DnActor.h"
#include "DNLogConnection.h"
#include "DNMissionSystem.h"
#include "DNDBConnectionManager.h"
#include "DnGameDataManager.h"
#include "DnPlayerActor.h"
#include "DNDBConnection.h"

CDnSkillTask::CDnSkillTask( CDNGameRoom* pRoom ) : CTask( pRoom ), 
												   CMultiSingleton<CDnSkillTask, MAX_SESSION_COUNT>( pRoom )
{
	m_listWaitSkillLevelup.clear();
}

CDnSkillTask::~CDnSkillTask(void)
{
	list<S_SKILL_LEVELUP_INFO*>::iterator iter = m_listWaitSkillLevelup.begin();
	for( iter; iter != m_listWaitSkillLevelup.end(); ++iter )
		delete (*iter);
	m_listWaitSkillLevelup.clear();
}

bool CDnSkillTask::Initialize( void )
{
	//m_SkillTreeSystem.InitializeTable();

	return true;
}

#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
int CDnSkillTask::UnLockSkillByMoney( CDNUserSession* pSession, int nSkillID )
#else
bool CDnSkillTask::UnLockSkillByMoney( CDNUserSession* pSession, int nSkillID )
#endif
{
	CDnPlayerActor * pPlayerActor = pSession->GetPlayerActor();

	_ASSERT( pPlayerActor );

	if( nSkillID <= 0 )
	{
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		return ERROR_SKILL_ACQUIREFAIL;
#else
		pSession->SendAcquireSkill( nSkillID, ERROR_SKILL_ACQUIREFAIL );
		return false;
#endif
	}

	TSkillData * pSkillData = g_pDataManager->GetSkillData( nSkillID );
	if( NULL == pSkillData )
	{
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		return ERROR_SKILL_ACQUIREFAIL;
#else
		pSession->SendAcquireSkill( nSkillID, ERROR_SKILL_ACQUIREFAIL );
		return false;
#endif
	}

	if( pPlayerActor->IsExclusiveSkill( nSkillID, pSkillData->nExclusiveID ) )
	{
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		return ERROR_SKILL_ACQUIRE_FAIL_EXCLUSIVE;
#else
		pSession->SendAcquireSkill( nSkillID, ERROR_SKILL_ACQUIRE_FAIL_EXCLUSIVE );
		return false;
#endif
	}

	bool bAlreadyGlobalSkillAcquired = false;
	if( pPlayerActor->HasSameGlobalIDSkill( pSkillData->nSkillID ) )
		bAlreadyGlobalSkillAcquired = true;

	const INT64 iNowMoney = pSession->GetCoin();
	if( iNowMoney < pSkillData->nUnlockPrice )
	{
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		return ERROR_SKILL_UNLOCK_NOT_ENOUGH_MONEY;
#else
		pSession->SendAcquireSkill( nSkillID, ERROR_SKILL_UNLOCK_NOT_ENOUGH_MONEY );
		return false;
#endif
	}

	DnSkillHandle hSkill = pPlayerActor->FindSkill( nSkillID );
	if( NULL != hSkill.GetPointer() )
	{
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		return ERROR_SKILL_UNLOCK_ALREADY_OPEN;
#else
		pSession->SendAcquireSkill( nSkillID, ERROR_SKILL_UNLOCK_ALREADY_OPEN );
		return false;
#endif
	}

	int nRetCode = ERROR_NONE;
	CDnSkillTreeSystem * pSkillTreeSystem = g_pDataManager->GetSkillTreeSystem();

#ifdef PRE_ADD_ONLY_SKILLBOOK
	if( pSkillTreeSystem )
	{
		bool bExistSkill = false;
		bool bNeedSkillBook = pSkillTreeSystem->IsNeedSkillBook( nSkillID, bExistSkill );
		if( bExistSkill && bNeedSkillBook )
		{
			return ERROR_SKILL_UNLOCK_FAIL;
		}
	}
#endif // PRE_ADD_ONLY_SKILLBOOK

	CDnSkillTreeSystem::S_OUTPUT Output;
	CDnSkillTreeSystem::S_TRY_ACQUIRE TryAcquire( pPlayerActor->GetPossessedSkillInfo() );
	TryAcquire.iCurrentCharLevel = pSession->GetLevel();
	TryAcquire.iTryAcquireSkillID = nSkillID;
	TryAcquire.iHasSkillPoint = pPlayerActor->GetAvailSkillPointByJob( nSkillID );

	pSkillTreeSystem->TryAcquireSkill( TryAcquire, &Output );

#if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)
	std::vector<int> nNeedSPValues;
	pSkillTreeSystem->GetNeedSPValuesByJob( nSkillID, nNeedSPValues );

	std::vector<int> nJobHistorys;
	pPlayerActor->GetJobHistory( nJobHistorys );

	const bool bAvailableSPByJob = IsAvailableSPByJob( nJobHistorys, nNeedSPValues, pPlayerActor );
	if( false == bAvailableSPByJob )
		Output.eResult = CDnSkillTreeSystem::R_NOT_ENOUGH_SKILLPOINT_TO_ACQUIRE;
#endif	// #if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)

	bool bIgnoreParentSkillCondition = ( (CDnSkillTreeSystem::R_DONT_HAVE_PARENT_SKILL == Output.eResult) ||
										(CDnSkillTreeSystem::R_LOCKED_PARENTSKILL == Output.eResult) ||
										(CDnSkillTreeSystem::R_NOT_ENOUGH_PARENT_SKILL_LEVEL == Output.eResult) ) &&
										true == bAlreadyGlobalSkillAcquired;

	if( CDnSkillTreeSystem::R_SUCCESS == Output.eResult || true == bIgnoreParentSkillCondition )
	{
		TSkill Skill;
		SecureZeroMemory( &Skill, sizeof(TSkill) );
		Skill.nSkillID = nSkillID;
		Skill.cSkillLevel = 0;
		Skill.bLock = false;

		CDnSkillTreeSystem::S_POSSESSED_SKILL_INFO SkillInfo;
		SkillInfo.iSkillID = nSkillID;
		SkillInfo.iSkillLevel = 0;
		SkillInfo.bCurrentLock = false;

		// <20><><EFBFBD><EFBFBD> <20><> ȹ<><C8B9>.
		pPlayerActor->UnLockSkill( nSkillID, pSkillData->nUnlockPrice );
		pPlayerActor->AcquireSkill( nSkillID );

		// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
#if !defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		pSession->SendUnlockSkill( nSkillID, ERROR_NONE );
		pSession->SendAcquireSkill( nSkillID, ERROR_NONE );
#endif // #if !defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)		

#if defined( _GAMESERVER )
		g_Log.Log(LogType::_ERROR, pSession, L"SkillTask152 PrevCoin=%I64d ChangeGold=%d PickUpCoin=%I64d \r\n", pSession->GetCoin(), pSkillData->nUnlockPrice, pSession->GetPickUpCoin());
#endif
		pSession->DelCoin( pSkillData->nUnlockPrice, DBDNWorldDef::CoinChangeCode::DoNotDBSave, 0 );
	}
	else
	{
		switch( Output.eResult )
		{
		case CDnSkillTreeSystem::R_NOT_ENOUGH_CHAR_LEVEL:
			nRetCode = ERROR_SKILL_ACQUIRE_FAIL_NOT_ENOUGH_CHAR_LEVEL;
			break;

		case CDnSkillTreeSystem::R_DONT_HAVE_PARENT_SKILL:
			nRetCode = ERROR_SKILL_ACQUIRE_FAIL_DONT_HAVE_PARENT_SKILL;
			break;

		case CDnSkillTreeSystem::R_NOT_ENOUGH_PARENT_SKILL_LEVEL:
			nRetCode = ERROR_SKILL_ACQUIRE_FAIL_NOT_ENOUGH_PARENT_SKILL_LEVEL;
			break;

		case CDnSkillTreeSystem::R_NOT_ENOUGH_SKILLPOINT_TO_ACQUIRE:
			nRetCode = ERROR_SKILL_ACQUIRE_FAIL_NOT_ENOUGH_SKILLPOINT;
			break;

		default:
			nRetCode = ERROR_SKILL_UNLOCK_FAIL;
			break;
		}
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		return nRetCode;
	}
	return ERROR_NONE;
#else
		pSession->SendAcquireSkill( nSkillID, nRetCode );
	}
	return true;
#endif
}

bool CDnSkillTask::UseSkillBook( CDNUserSession* pSession, int nItemID )
{
	_ASSERT( pSession->GetPlayerActor() );
	CDnSkillTreeSystem* pSkillTreeSystem = g_pDataManager->GetSkillTreeSystem();
	if (!pSkillTreeSystem){
		pSession->SendAcquireSkill( 0, ERROR_SKILL_UNLOCK_FAIL );
		return false;
	}

	// <20>̹<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20>ִ<EFBFBD> <20><>ų<EFBFBD><C5B3><EFBFBD><EFBFBD> üũ
	int iSkillIDToUnLock = pSkillTreeSystem->FindSkillBySkillBook( nItemID );

	// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3>.
	DnActorHandle hActor = pSession->GetActorHandle();
	CDnPlayerActor* pPlayerActor = static_cast<CDnPlayerActor*>(hActor.GetPointer());
	TSkillData* pSkillData = g_pDataManager->GetSkillData( iSkillIDToUnLock );
	if( pPlayerActor->IsExclusiveSkill( iSkillIDToUnLock, pSkillData->nExclusiveID ) )
	{
		pSession->SendAcquireSkill( 0, ERROR_SKILL_ACQUIRE_FAIL_EXCLUSIVE );
		return false;
	}

	DnSkillHandle hAlreadyHasSkill = pSession->GetActorHandle()->FindSkill( iSkillIDToUnLock );
	int nRetCode = ERROR_NONE;
	int nResultSkillID = 0;
	if( !hAlreadyHasSkill )
	{
		CDnSkillTreeSystem::S_OUTPUT Output;

		//CDnSkillTreeSystem::S_CURRENT_USERSKILL_INFO CurrentSkillInfo( pPlayerActor->GetPossessedSkillInfo() );
		CDnSkillTreeSystem::S_TRY_UNLOCK CurrentSkillInfo;
		CurrentSkillInfo.iTryUnlockSkillID = iSkillIDToUnLock;
		CurrentSkillInfo.iCurrentCharLevel = pPlayerActor->GetLevel();
		CurrentSkillInfo.iSkillBookItemID = nItemID;

		DNTableFileFormat* pSkillTable = GetDNTable( CDnTableDB::TSKILL );
		int iNeedJob = pSkillTable->GetFieldFromLablePtr( iSkillIDToUnLock, "_NeedJob" )->GetInteger();
		if( pSession->GetPlayerActor()->IsPassJob( iNeedJob ) )
		{
			//CurrentSkillInfo.iJobID = iNeedJob;

			pSkillTreeSystem->TryUnLockSkill( CurrentSkillInfo, &Output );

#if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)
			CDnPlayerActor * pPlayerActor = pSession->GetPlayerActor();
			if( NULL != pPlayerActor )
			{
				std::vector<int> nNeedSPValues;
				pSkillTreeSystem->GetNeedSPValuesByJob(iSkillIDToUnLock, nNeedSPValues);

				std::vector<int> jobHistory;
				pPlayerActor->GetJobHistory( jobHistory );

				bool bAvailableSPByJob = IsAvailableSPByJob(jobHistory, nNeedSPValues, pPlayerActor);

				if (bAvailableSPByJob == false)
					Output.eResult = CDnSkillTreeSystem::R_NOT_ENOUGH_SKILLPOINT_TO_ACQUIRE;
			}
#endif // PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP

			// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE> <20>뺸.
			if( CDnSkillTreeSystem::R_SUCCESS == Output.eResult )
			{
				// <20><><EFBFBD><EFBFBD>.
				nResultSkillID = iSkillIDToUnLock;

				// <20><><EFBFBD><EFBFBD> <20><>ų<EFBFBD><C5B3> <20>ִ<EFBFBD><D6B4><EFBFBD> Ȯ<><C8AE>
				_ASSERT( pPlayerActor );

				if( pPlayerActor )
				{
					nRetCode = pPlayerActor->CanAcquireSkillIfUnlock( nResultSkillID );
					if( ERROR_NONE == nRetCode )
					{
						// <20><><EFBFBD><EFBFBD> <20><> ȹ<><C8B9>.
						pPlayerActor->UnLockSkill( nResultSkillID );
						pPlayerActor->AcquireSkill( nResultSkillID );

						// Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
						pSession->SendUnlockSkill( nResultSkillID, ERROR_NONE );
						pSession->SendAcquireSkill( nResultSkillID, nRetCode );

						return true;
					}
				}
			}
			else if ( CDnSkillTreeSystem::R_NOT_ENOUGH_SKILLPOINT_TO_ACQUIRE == Output.eResult )
				nRetCode = ERROR_SKILL_ACQUIRE_FAIL_NOT_ENOUGH_SKILLPOINT;
			else
				nRetCode = ERROR_SKILL_UNLOCK_FAIL;
		}
		else
		{
			nRetCode = ERROR_SKILL_UNLOCK_MISMATCH_JOB;
		}
	}
	else
	{
		nRetCode = ERROR_SKILL_UNLOCK_ALREADY_OPEN;
	}

	pSession->SendAcquireSkill( nResultSkillID, nRetCode );
	
	return false;
}


void CDnSkillTask::Process( LOCAL_TIME LocalTime, float fDelta )
{
	if( m_pBaseRoom && static_cast<CDNGameRoom*>(m_pBaseRoom)->GetRoomState() != _GAME_STATE_PLAY )
		return;

	if( !m_listWaitSkillLevelup.empty() )
	{
		list<S_SKILL_LEVELUP_INFO*>::iterator iter = m_listWaitSkillLevelup.begin();
		for( iter; iter != m_listWaitSkillLevelup.end(); )
		{
			S_SKILL_LEVELUP_INFO* pInfo = *iter;
			if( pInfo->hActor && pInfo->hSkill )
			{
				// <20><>Ƽ<EFBFBD><C6BC> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD><EFBFBD>.
				// <20><><EFBFBD><EFBFBD> <20>нú<D0BD> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD> <20>ߵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> <20><><EFBFBD>쿡 <20><>ų <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ<EFBFBD><C5B6> ó<><C3B3><EFBFBD>ؼ<EFBFBD> Ŭ<><C5AC><EFBFBD><EFBFBD> <20>뺸.
				if( (/*(pInfo->hSkill->GetSkillType() == CDnSkill::Active) &&*/ (pInfo->hActor->GetProcessSkill() != pInfo->hSkill)) ||
					((pInfo->hSkill->GetSkillType() == CDnSkill::AutoPassive) && (false == pInfo->hActor->IsProcessingAutoPassive(pInfo->hSkill->GetClassID()))) )
				{
					SkillLevelUp( pInfo->pSession, pInfo->nSkillID, pInfo->cUseSkillPoint );
					delete (*iter);
					iter = m_listWaitSkillLevelup.erase( iter );
					continue;
				}
			}
			else
			{
				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ü<EFBFBD><C3BC> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
				delete (*iter);
				iter = m_listWaitSkillLevelup.erase( iter );
				continue;
			}
			 
			++iter;
		}
	}
}

int CDnSkillTask::OnDispatchMessage( CDNUserSession * pSession, int nMainCmd, int nSubCmd, char* pData, int nLen )
{
	switch( nMainCmd )
	{
		case CS_SKILL: 
			return OnRecvSkillMessage( pSession, nSubCmd, pData, nLen );
	}

	return ERROR_NONE;
}

int CDnSkillTask::OnRecvSkillMessage( CDNUserSession* pSession, int nSubCmd, char *pData, int nLen )
{
	switch( nSubCmd )
	{
		case eSkill::CS_UNLOCKSKILL_BY_MONEY_REQ:
			return OnRecvUnlockSkillByMoneyReq( pSession, (CSUnlockSkillByMoneyReq*)pData );
		case eSkill::CS_SKILLLEVELUP_REQ:
			return OnRecvSkillLevelUpReq( pSession, (CSSkillLevelUpReq*)pData );

		case eSkill::CS_ACQUIRESKILL_REQ:
			return OnRecvAcquireSkillReq( pSession, (CSAcquireSkillReq*)pData );			
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		case eSkill::CS_RESERVATION_SKILL_LIST_REQ:
			return OnRecvReservationSkillListReq( pSession, (CSReservationSkillListReq*)pData );
#endif
#ifdef PRE_ADD_PRESET_SKILLTREE
		case eSkill::CS_LIST_SKILLSET:
			{
				if (nLen != 0)
					return ERROR_INVALIDPACKET;

				return OnRecvSkillSetList( pSession );
			}
			break;

		case eSkill::CS_SAVE_SKILLSET:
			{
				CSSaveSkillSet * pPacket = (CSSaveSkillSet*)pData;

				if (sizeof(CSSaveSkillSet) - sizeof(pPacket->SKills) + (sizeof(TSkillSetPartialData) * pPacket->cCount) != nLen)
					return ERROR_INVALIDPACKET;

				return OnRecvSaveSkillSet( pSession, pPacket );
			}
			break;

		case eSkill::CS_DELETE_SKILLSET:
			{
				if (sizeof(CSDeleteSkillSet) != nLen)
					return ERROR_INVALIDPACKET;

				return OnRecvDeleteSkillSet( pSession, (CSDeleteSkillSet*)pData );
			}
			break;
#endif		//#ifdef PRE_ADD_PRESET_SKILLTREE
		default:
			return ERROR_UNKNOWN_HEADER;
	}
}

int CDnSkillTask::OnRecvSkillLevelUpReq( CDNUserSession* pSession, CSSkillLevelUpReq* pPacket )
{
	return SkillLevelUp(pSession, pPacket->nSkillID, pPacket->cUseSkillPoint);	
}

int CDnSkillTask::OnRecvAcquireSkillReq( CDNUserSession* pSession, CSAcquireSkillReq* pPacket )
{
	return AcquireSkill(pSession, pPacket->nSkillID);	
}

int CDnSkillTask::OnRecvUnlockSkillByMoneyReq( CDNUserSession* pSession, CSUnlockSkillByMoneyReq* pPacket )
{
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
	if( ERROR_NONE != UnLockSkillByMoney( pSession, pPacket->nSkillID ) )
#else
	if( false == UnLockSkillByMoney( pSession, pPacket->nSkillID ) )
#endif
		return ERROR_SKILL_UNLOCK_FAIL;

	return ERROR_NONE;
}

int CDnSkillTask::AcquireSkill(CDNUserSession* pSession, int nSkillID)
{
	// <20><><EFBFBD><EFBFBD> <20><>ų<EFBFBD><C5B3> <20>ִ<EFBFBD><D6B4><EFBFBD> Ȯ<><C8AE>
	CDnPlayerActor* pPlayerActor = pSession->GetPlayerActor();
	_ASSERT( pPlayerActor );

	if( pPlayerActor )
	{
		// #26902 <20>ӽ<EFBFBD> <20><>ų<EFBFBD><C5B3> <20>߰<EFBFBD><DFB0><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>. Ŭ<>󿡼<EFBFBD> UI <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ <20><> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> ó<><C3B3>.
		if( pPlayerActor->IsTempSkillAdded() )
			return ERROR_GENERIC_INVALIDREQUEST;

		int nRetCode = pPlayerActor->AcquireSkill( nSkillID );
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
		return nRetCode;
#else
		pSession->SendAcquireSkill( nSkillID, nRetCode );
#endif
	}
	return ERROR_GENERIC_INVALIDREQUEST;
}

int CDnSkillTask::SkillLevelUp(CDNUserSession* pSession, int nSkillID, BYTE cUseSkillPoint)
{
	// TODO: <20><><EFBFBD>Ŀ<EFBFBD> <20><><EFBFBD>Ӽ<EFBFBD><D3BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> DB <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>޶<EFBFBD><DEB6><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>⵵ <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> DB<44><42> <20><><EFBFBD>Ӽ<EFBFBD><D3BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˾Ƽ<CBBE> <20><><EFBFBD><EFBFBD>.
	int nError = -1;
	char cLevel = 0;

	// <20>ش<EFBFBD> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD><D6B4><EFBFBD> üũ
	// <20><>ų <20><> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD>쿣 <20>ʱ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ͱ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˾Ƴ<CBBE><C6B3><EFBFBD>.
	DnActorHandle hActor = pSession->GetActorHandle();
	if( !hActor )
		return ERROR_GENERIC_INVALIDREQUEST;

	// <20>ӽ<EFBFBD> <20><>ų<EFBFBD><C5B3> <20>߰<EFBFBD><DFB0><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>. Ŭ<>󿡼<EFBFBD> UI <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ŷ <20><> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> ó<><C3B3>.
	if( pSession->GetPlayerActor() &&
		pSession->GetPlayerActor()->IsTempSkillAdded() )
		return ERROR_GENERIC_INVALIDREQUEST;

	DnSkillHandle hFindedSkill = hActor->FindSkill( nSkillID );

	if( hFindedSkill )
	{
		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>߰<EFBFBD><DFB0><EFBFBD> <20><>ų<EFBFBD><C5B3> <20>ƿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ұ<EFBFBD><D2B0><EFBFBD>.
		if( hFindedSkill->IsEquipItemSkill() )
			nError = ERROR_SKILL_LEVELUPFAIL_EQUIPITEMSKILL;
		else
		// <20><><EFBFBD><EFBFBD>/<2F><><EFBFBD>۸<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ұ<EFBFBD><D2B0><EFBFBD>.
		if( hFindedSkill->IsToggleOn() || hFindedSkill->IsAuraOn() )
			nError = ERROR_SKILL_LEVELUPFAIL_INVALID_SKILLPOINT;
		else
		{
			// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ų, Ȥ<><C8A4> <20><><EFBFBD><EFBFBD> <20>нú<D0BD> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ٷȴٰ<C8B4> ó<><C3B3>..
			CDnSkill::SkillTypeEnum eSkillType = hFindedSkill->GetSkillType();
			if( (/*(eSkillType == CDnSkill::Active) &&*/ (hFindedSkill == hActor->GetProcessSkill())) ||
				((eSkillType == CDnSkill::AutoPassive) && (hActor->IsProcessingAutoPassive(nSkillID))) )
			{
				// <20><><EFBFBD><EFBFBD> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>û<EFBFBD><C3BB> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
				list<S_SKILL_LEVELUP_INFO*>::iterator iter = m_listWaitSkillLevelup.begin();
				for( iter; m_listWaitSkillLevelup.end() != iter; ++iter )
				{
					if( (*iter)->nSkillID == nSkillID )
						return ERROR_NONE;
				}

				S_SKILL_LEVELUP_INFO* pSkillLevelupInfo = new S_SKILL_LEVELUP_INFO;
				pSkillLevelupInfo->hActor = hActor;
				pSkillLevelupInfo->hSkill = hFindedSkill;
				pSkillLevelupInfo->nSkillID = nSkillID;
				pSkillLevelupInfo->cUseSkillPoint = cUseSkillPoint;
				pSkillLevelupInfo->pSession = pSession;

				m_listWaitSkillLevelup.push_back( pSkillLevelupInfo );

				return ERROR_NONE;
			}

			int iLevelFrom = hFindedSkill->GetLevel();
			
			//<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
			int nLevelUpValue = hFindedSkill->GetLevelUpValue();
			iLevelFrom -= nLevelUpValue;

			DNTableFileFormat* pSkillLevelTable = GetDNTable( CDnTableDB::TSKILLLEVEL );

			vector<int> vlSkillLevelList;
			//if( pSkillLevelTable->GetItemIDListFromField( "_SkillIndex", pPacket->nSkillID, vlSkillLevelList ) == 0 ) 
			GetSkillLevelList( nSkillID, vlSkillLevelList, CDnSkill::PVE );
			if( vlSkillLevelList.empty() )
			{
				_ASSERT( "<EFBFBD><EFBFBD>ų <20><><EFBFBD>̺<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>" );
				nError = ERROR_SKILL_LEVELUPFAIL_INVALID_SKILLPOINT;
			}

#if defined(PRE_FIX_NEXTSKILLINFO)
			int nLevelUpCount = 1;	// <20><>ų<EFBFBD><C5B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1<><31> <20>ø<EFBFBD><C3B8><EFBFBD> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD><EFBFBD>.

			SKILL_LEVEL_TABLE_IDS::iterator findIter;
			SKILL_LEVEL_INFO* pTableInfo = g_pDataManager->GetSkillLevelTableIDList(hFindedSkill->GetClassID(), hFindedSkill->GetSelectedLevelDataType());

			int nNeedSkillPoint = 0;
			bool bValidPacket = false;
			if( NULL != pTableInfo )
			{
				int nSkillLevel = iLevelFrom + nLevelUpCount;
				findIter = pTableInfo->_SkillLevelTableIDs.find(nSkillLevel);

				int SkillLevelTableID = -1;
				if (findIter != pTableInfo->_SkillLevelTableIDs.end())
					SkillLevelTableID = findIter->second;

				if( -1 != SkillLevelTableID )
				{
					nNeedSkillPoint = pSkillLevelTable->GetFieldFromLablePtr( SkillLevelTableID, "_NeedSkillPoint" )->GetInteger();
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
					if( nNeedSkillPoint > 0)
#else
					if( nNeedSkillPoint == cUseSkillPoint )
#endif // #if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
						bValidPacket = true;
				}
			}

			if( false == bValidPacket )
			{
				// <20><>Ŷ<EFBFBD><C5B6> <20><><EFBFBD><EFBFBD><EFBFBD>Ͱ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٸ<EFBFBD><D9B8>Ƿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
				return ERROR_SKILL_LEVELUPFAIL_INVALID_SKILLPOINT;
#else
				pSession->SendSkillLevelUp(nSkillID, cLevel, ERROR_SKILL_LEVELUPFAIL_INVALID_SKILLPOINT);	// <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> <20>̹<EFBFBD> <20>־ <20><><EFBFBD>ɷ<EFBFBD> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~
				return ERROR_NONE;
#endif //#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
			}
#else
			int iSkillLevelTableID = -1;
			for( int i = 0; i < (int)vlSkillLevelList.size(); ++i )
			{
				int iNowLevel = pSkillLevelTable->GetFieldFromLablePtr( vlSkillLevelList.at(i), "_SkillLevel" )->GetInteger();
				if( iNowLevel == iLevelFrom )
				{
					iSkillLevelTableID = vlSkillLevelList.at( i );
					break;
				}
			}

			int nNeedSkillPoint = 0;
			int nLevelUpCount = 0;
			while( cUseSkillPoint != nNeedSkillPoint && 0 < iSkillLevelTableID )
			{
				++nLevelUpCount;
				nNeedSkillPoint += pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID+nLevelUpCount, "_NeedSkillPoint" )->GetInteger();

				if( cUseSkillPoint < nNeedSkillPoint )
				{
					// Note: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD>̺<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ٸ<EFBFBD>. <20><>ŷ<EFBFBD><C5B7> <20><><EFBFBD>ɼ<EFBFBD><C9BC><EFBFBD> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.
					nError = ERROR_SKILL_LEVELUPFAIL_INVALID_SKILLPOINT;
					break;
				}
			}

#endif // PRE_FIX_NEXTSKILLINFO

#if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)
			bool bAvailableSPByJob = false;

			std::vector<int> nNeedSPValues;
			GetNeedSPValuesByJob(nSkillID, nNeedSPValues);
			
			std::vector<int> jobHistory;
			CDnPlayerActor* pPlayerActor = pSession->GetPlayerActor();
			if (pPlayerActor)
				pPlayerActor->GetJobHistory(jobHistory);

			bAvailableSPByJob = IsAvailableSPByJob(jobHistory, nNeedSPValues, pPlayerActor);
			
			if (bAvailableSPByJob == false)
				nError = ERROR_SKILL_LEVELUPFAIL_INVALID_SKILLPOINT;
#endif // PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP
			


			int iAvailSPByJob = pSession->GetPlayerActor()->GetAvailSkillPointByJob( nSkillID );
#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
			if( nNeedSkillPoint <= iAvailSPByJob )
#else
			if( nNeedSkillPoint <= iAvailSPByJob && nNeedSkillPoint == cUseSkillPoint )
#endif
			{
				// <20><>ų <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> üũ <20><> <20><><EFBFBD><EFBFBD> SP üũ
#if defined(PRE_FIX_NEXTSKILLINFO)
				
				int iLevelTableIDToUp = -1;
				int iMaxLevelTableID = -1;
				int nSkillLevelUp = iLevelFrom + nLevelUpCount;

				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><>ų <20><><EFBFBD>̺<EFBFBD> ID
				findIter = pTableInfo->_SkillLevelTableIDs.find(nSkillLevelUp);
				if (findIter != pTableInfo->_SkillLevelTableIDs.end())
					iLevelTableIDToUp = findIter->second;

				//MaxLevel <20><><EFBFBD>̺<EFBFBD>
				findIter = pTableInfo->_SkillLevelTableIDs.find(pTableInfo->_MaxLevel);
				if (findIter != pTableInfo->_SkillLevelTableIDs.end())
					iMaxLevelTableID = findIter->second;

				if (nSkillLevelUp <= pTableInfo->_MaxLevel)
#else
				int iLevelTableIDToUp = hFindedSkill->GetSkillLevelID() + nLevelUpCount;
				int iMaxLevelTableID = hFindedSkill->GetSkillLevelID() - (hFindedSkill->GetLevel()-1) + hFindedSkill->GetMaxLevel()-1;
				if( iLevelTableIDToUp <= iMaxLevelTableID )
#endif // PRE_FIX_NEXTSKILLINFO
				{
					int iLevelLimit = pSkillLevelTable->GetFieldFromLablePtr( iLevelTableIDToUp, "_LevelLimit" )->GetInteger();

					if( iLevelLimit <= hActor->GetLevel() )
					{
						// HP, SP <20>÷<EFBFBD><C3B7>ִ<EFBFBD> <20>нú<D0BD> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD><EFBFBD>Ǹ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> HP SP <20><> <20><><EFBFBD><EFBFBD> HP/SP<53><50>
						// Ŭ<><C5AC><EFBFBD><EFBFBD> <20>ǰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20≯<EFBFBD> <20>޾Ƶ״ٰ<D7B4> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>..
						INT64 iHP = hActor->GetHP();
						int iSP = hActor->GetSP();

						float fElapsedDelayTime = hFindedSkill->GetElapsedDelayTime();
						bool bRemoveSuccess = hActor->RemoveSkill( nSkillID );
						//_ASSERT( bRemoveSuccess && "CDnSkillTask::OnRecvSkillLevelUpReq() -> <20><><EFBFBD>Ͱ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ϸ<EFBFBD> <20>մϴ<D5B4>." );

						if( bRemoveSuccess )
						{
							if( 0 < pSession->GetSkillPoint() /*&&
								pPacket->cUseSkillPoint <= pUserData->Attribute.wSkillPoint*/ )
							{
								int iNewLevel = iLevelFrom + nLevelUpCount;
								hActor->AddSkill( nSkillID, iNewLevel );
								DnSkillHandle hNewSkill = hActor->FindSkill( nSkillID );
								hNewSkill->SetElapsedDelayTime( fElapsedDelayTime );

								hActor->SetHP( iHP );
								hActor->SetSP( iSP );

								pSession->ChangeSkillPoint(-nNeedSkillPoint, nSkillID, false, 0 );
								pSession->GetDBConnection()->QueryModSkillLevel( pSession, nSkillID, iNewLevel, (int)( fElapsedDelayTime * 1000.f ), -nNeedSkillPoint, DBDNWorldDef::SkillChangeCode::Use);	// db<64><62><EFBFBD><EFBFBD>: <20><>ų<EFBFBD><C5B3><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
								
								cLevel = (char)iNewLevel;

								CDnPlayerActor * pPlayerActor = (CDnPlayerActor *)hActor.GetPointer();
								pPlayerActor->ReplacementGlyph( hNewSkill );

								pSession->GetEventSystem()->OnEvent( EventSystem::OnSkillLevelUp, 2, EventSystem::SkillID, nSkillID, EventSystem::SkillLevel, cLevel );
								nError = ERROR_NONE;
							}
							else
							{
								// <20><>ų <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. ERROR_SK_LEVELUP_NOT_ENOUGH_POINT Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
								nError = ERROR_SKILL_LEVELUPFAIL_INSUFFICIENCY_SKILLPOINT;
							}
						}
					}
					else
					{
						//TODO: ij<><C4B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>۽<EFBFBD><DBBD>ϴ<EFBFBD>..
						nError = ERROR_SKILL_LEVELUPFAIL_INSUFFICIENCY_CHARACTERLEVEL;
					}
				}
				else
				{
					//TODO: <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD> <20>̻<EFBFBD><CCBB><EFBFBD> <20>ø<EFBFBD><C3B8><EFBFBD><EFBFBD><EFBFBD> <20><>..
					nError = ERROR_SKILL_LEVELUPFAIL_ALREADY_MAX;
				}
			}
			else
			{
				// TODO: <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ų<EFBFBD><C5B3><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD>ų<EFBFBD> <20><><EFBFBD>̺<EFBFBD><CCBA><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ϳ<EFBFBD> <20>ٸ<EFBFBD>.
				nError = ERROR_SKILL_LEVELUPFAIL_INVALID_SKILLPOINT;
			}
		}
	}
	else
	{
		// <20>ش<EFBFBD> <20><>ų <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>. ERROR_SK_LEVELUP_NOT_EXIST_FAIL Ŭ<><C5AC><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
		nError = ERROR_SKILL_ISNOT_YOURS;
	}
	
#if !defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
	pSession->SendSkillLevelUp(nSkillID, cLevel, nError);	// <20><><EFBFBD><EFBFBD><EFBFBD>ִ<EFBFBD> <20>Լ<EFBFBD><D4BC><EFBFBD> <20>̹<EFBFBD> <20>־ <20><><EFBFBD>ɷ<EFBFBD> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~
#endif
	
	//hActor->ReplacementSkill( pPacket->nSkillID, cLevel );

	if (nError != ERROR_NONE)
		return ERROR_NONE;

	// Note: <20>нú<D0BD> <20><><EFBFBD><EFBFBD> <20><>ų<EFBFBD><C5B3> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ȭ<EFBFBD><C8AD> <20><><EFBFBD>ؼ<EFBFBD> <20>ٸ<EFBFBD> <20>÷<EFBFBD><C3B7>̾<EFBFBD><CCBE>鿡<EFBFBD>Ե<EFBFBD> <20>˷<EFBFBD><CBB7><EFBFBD><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
	DWORD dwNumPartyMember = pSession->GetGameRoom()->GetUserCount();
	if( 0 < nSkillID && 1 < dwNumPartyMember )
	{
		int iPartyMemberIndex = -1;
		for (DWORD i = 0; i < dwNumPartyMember; i++)
		{
			CDNGameRoom::PartyStruct *pStruct = pSession->GetGameRoom()->GetPartyData(i);
			if( pStruct == NULL ) continue;
			if( pStruct->pSession == pSession )
				iPartyMemberIndex = i;
		}
		
		_ASSERT( -1 != iPartyMemberIndex );
		if( -1 != iPartyMemberIndex )
		{
			for (DWORD i = 0; i < dwNumPartyMember; i++)
			{
				CDNGameRoom::PartyStruct *pStruct = pSession->GetGameRoom()->GetPartyData(i);
				if( pStruct == NULL ) continue;
				if( pStruct->pSession != pSession )
					pStruct->pSession->SendOtherPlayerSkillLevelUp( iPartyMemberIndex, nSkillID, cLevel );
			}
		}
	}
	return ERROR_NONE;
}

#if defined(PRE_ADD_SKILL_LEVELUP_RESERVATION)
int CDnSkillTask::OnRecvReservationSkillListReq( CDNUserSession* pSession, CSReservationSkillListReq* pUnlockSkillByMoneyReq )
{
	if( pUnlockSkillByMoneyReq->nCount <= 0 )
		return ERROR_GENERIC_UNKNOWNERROR;	

	SCReservationSkillListAck ReservationSkillAck;
	memset(&ReservationSkillAck, 0, sizeof(SCReservationSkillListAck));

	for( int i=0; i<pUnlockSkillByMoneyReq->nCount; ++i)
	{
		memcpy(&ReservationSkillAck.tReservationSkillAck[i].tReservationSkill, &pUnlockSkillByMoneyReq->tReservationSkill[i], sizeof(TReservationSkillReq));
		if(pUnlockSkillByMoneyReq->tReservationSkill[i].cType == ReservationSKillList::Type::UnLock)
		{			
			ReservationSkillAck.tReservationSkillAck[i].nResult = UnLockSkillByMoney( pSession, pUnlockSkillByMoneyReq->tReservationSkill[i].nSkillID);
		}
		else if(pUnlockSkillByMoneyReq->tReservationSkill[i].cType == ReservationSKillList::Type::Acquire)
		{		
			ReservationSkillAck.tReservationSkillAck[i].nResult = AcquireSkill(pSession, pUnlockSkillByMoneyReq->tReservationSkill[i].nSkillID);
		}
		else if(pUnlockSkillByMoneyReq->tReservationSkill[i].cType == ReservationSKillList::Type::LevelUp)
		{
			int nResult = ERROR_NONE;
			DnActorHandle hActor = pSession->GetActorHandle();
			if( hActor )
			{
				DnSkillHandle hFindedSkill = hActor->FindSkill( pUnlockSkillByMoneyReq->tReservationSkill[i].nSkillID );
				if( hFindedSkill )
				{
					int nCurLevel = hFindedSkill->GetLevel();

					//<2F><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
					int nLevelUpValue = hFindedSkill->GetLevelUpValue();
					nCurLevel -= nLevelUpValue;				
					if( nCurLevel >= pUnlockSkillByMoneyReq->tReservationSkill[i].nLevel)
					{
						nResult = ERROR_GENERIC_UNKNOWNERROR;
					}
					else
					{
						for( int j=nCurLevel;j<pUnlockSkillByMoneyReq->tReservationSkill[i].nLevel;++j)
						{
							nResult = SkillLevelUp(pSession, pUnlockSkillByMoneyReq->tReservationSkill[i].nSkillID, 0);
							if( nResult != ERROR_NONE)
								break;
						}
					}
				}
				else
					nResult = ERROR_GENERIC_UNKNOWNERROR;			
			}
			else
				nResult = ERROR_GENERIC_UNKNOWNERROR;
			ReservationSkillAck.tReservationSkillAck[i].nResult = nResult;			
		}
		else
			break;
		++ReservationSkillAck.nCount;
		if(ReservationSkillAck.tReservationSkillAck[i].nResult != ERROR_NONE ) // <20><><EFBFBD>߿<EFBFBD> 1<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>׳<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>..
			break;
	}
	int nLen = sizeof(SCReservationSkillListAck) - sizeof(ReservationSkillAck.tReservationSkillAck) + (sizeof(TReservationSkillAck)*ReservationSkillAck.nCount);
	pSession->AddSendData(SC_SKILL, eSkill::SC_RESERVATION_SKILL_LIST_ACK, (char*)&ReservationSkillAck, nLen);
	return ERROR_NONE;
}
#endif

#if defined(PRE_ADD_PRESET_SKILLTREE)
int CDnSkillTask::OnRecvSkillSetList( CDNUserSession* pSession )
{
	if (pSession->GetDBConnection())
		pSession->GetDBConnection()->QueryGetSkillPresetList(pSession);

	return ERROR_NONE;
}

int CDnSkillTask::OnRecvSaveSkillSet( CDNUserSession* pSession, CSSaveSkillSet *pPacket )
{
	if (wcslen(pPacket->wszSetName) <= 0)
		return ERROR_GENERIC_UNKNOWNERROR;

	if (pPacket->cIndex < 0 || pPacket->cIndex >= SKILLPRESETMAX)
		return ERROR_GENERIC_UNKNOWNERROR;

	if (pSession->GetDBConnection())
		pSession->GetDBConnection()->QueryAddSkillPreset(pSession, pPacket);

	return ERROR_NONE;
}

int CDnSkillTask::OnRecvDeleteSkillSet( CDNUserSession* pSession, CSDeleteSkillSet *pPacket )
{
	if (pSession->GetDBConnection())
		pSession->GetDBConnection()->QueryDelSkillPreset(pSession, pPacket->cIndex);

	return ERROR_NONE;
}
#endif	// #if defined(PRE_ADD_PRESET_SKILLTREE)

void CDnSkillTask::GetSkillLevelList( int iSkillID, vector<int>& vlSkillLevelList, int iLevelDataType )
{
	DNTableFileFormat* pSkillLevelTable = GetDNTable( CDnTableDB::TSKILLLEVEL );

	pSkillLevelTable->GetItemIDListFromField( "_SkillIndex", iSkillID, vlSkillLevelList );

	// pve, pvp <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ȯ<><C8AE><EFBFBD>Ͽ<EFBFBD> <20>ɷ<EFBFBD><C9B7><EFBFBD>.
	vector<int>::iterator iterLevelList = vlSkillLevelList.begin();
	for( iterLevelList; iterLevelList != vlSkillLevelList.end(); )
	{
		int iSkillLevelTableID = *iterLevelList;
		int iApplyType = pSkillLevelTable->GetFieldFromLablePtr( iSkillLevelTableID, "_ApplyType" )->GetInteger();
		if( iApplyType != iLevelDataType )
			iterLevelList = vlSkillLevelList.erase( iterLevelList );
		else
			++iterLevelList;
	}
}

#if defined(PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP)
bool CDnSkillTask::IsAvailableSPByJob(std::vector<int>& jobHistory, vector<int>& needSPValues, CDnPlayerActor * pPlayerActor)
{
	bool isAvailableSPByJob = true;

	int nJobCount = (int)jobHistory.size();
	int nJobID = -1;

	for (int i = 0; i < nJobCount; ++i)
	{
		if (IsAvailableSPByJob(jobHistory, needSPValues, i, pPlayerActor) == false)
		{
			isAvailableSPByJob = false;
			break;
		}
	}

	return isAvailableSPByJob;
}

bool CDnSkillTask::IsAvailableSPByJob(std::vector<int>& jobHistory, vector<int>& needSPValues, int nIndex, CDnPlayerActor * pPlayerActor)
{
	bool isAvailableSPByJob = false;

	int nJobCount = (int)jobHistory.size();

	int nNeedSPValue = 0;
	int nSPValueCount = (int)needSPValues.size();
	if (nIndex >= 0 && nIndex < nSPValueCount)
		nNeedSPValue = needSPValues[nIndex];

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>??
	if (nIndex >= nJobCount)
	{
		if (nNeedSPValue <= 0)
			return true;
		else
			return false;
	}

	int nJobID = -1;

	nJobID = jobHistory[nIndex];
	int iUsedSkillPointInThisJob = pPlayerActor->GetUsedSkillPointInThisJob( nJobID );

	//<2F>ش<EFBFBD> JobID<49><44> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> SP<53><50><EFBFBD><EFBFBD> Ȯ<>ο<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ŀ<><C4BF> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>..
	if (iUsedSkillPointInThisJob >= nNeedSPValue)
		isAvailableSPByJob = true;

	return isAvailableSPByJob;
}

void CDnSkillTask::GetNeedSPValuesByJob(int nSkillID, std::vector<int>& nNeedSPValues)
{
	CDnSkillTreeSystem* pSkillTreeSystem = g_pDataManager->GetSkillTreeSystem();
	if (pSkillTreeSystem)
		pSkillTreeSystem->GetNeedSPValuesByJob(nSkillID, nNeedSPValues);
}
#endif // PRE_ADD_SKILL_LEVELUP_LIMIT_BY_SP