#include "stdafx.h"
#include "ModifyCharacter.h"

#include <Network/Dispatch/Dispatch.h>
#include <Network/Protocol/Ryl_AdminMgrProtocol.h>
#include <Network/Packet/PacketStruct/CharStatusPacket.h>
#include <Network/Packet/PacketStruct/CharQuestPacket.h>
#include <Skill/SkillMgr.h>
#include <Item/ItemStructure.h>
#include <Log/ServerLog.h>
#include <Quest/QuestMgr.h>
#include <Creature/Character/CharacterClass.h>
#include <Creature/CreatureStructure.h>

CModifyCharacter::CModifyCharacter()  
: CCharacter(0, 0)
, m_dwServerGroup(0)
, m_byChangedInfo(0)
, m_bScheduleClose(false)
, m_bSave(false)
, m_bIsOwnCopyItem(false)

{
	Initialize(NULL);
	ZeroMemory(&m_ExtraData, sizeof(CHAR_EXTRA_DATA));
	
	m_ModifyCharItemSerialInfo.clear();
	m_OverlapSerialInfo.clear();

	m_cOldServerGroupID = UnifiedConst::Part2Selectable;
}

// 이녀석은 사용하지 말자 Initialize <- 이녀석 캐릭터 생성후 딱~~ 1번만 사용하자
// 그렇지 않으면 메모리 샌다 ㅡ.ㅡ; 
void CModifyCharacter::Reset()
{	
	SetUID(0);
	SetCID(0);

	m_dwServerGroup = 0;
	m_byChangedInfo	= 0;
	m_bScheduleClose = false;

	ZeroMemory(&m_DBData, sizeof(CharacterDBData));	
	Initialize(NULL);
}

unsigned short CModifyCharacter::GetMaxSkillPoint()
{
	// CalculateStatusData가 선행되어야 함.
	return m_CreatureStatus.m_StatusInfo.m_wSkillPoint;
}

// 스킬 추가 및 스킬 레벨 변경 (이미 습득한 스킬을 추가 요청한다면 레벨 수정으로 인식)
unsigned char CModifyCharacter::AppendSkill(unsigned short wSkillID, char cLevel, char cLockCount)
{
	m_DBData.m_Skill.wSkillNum = m_DBData.m_Skill.GetSkillNum();	// 현재 스킬수 재 계산

	const Skill::ProtoType*	lpSkillProtoType = CSkillMgr::GetInstance().GetSkillProtoType(wSkillID);

	short sSlotIndex = GetSkillSlotIndex(wSkillID);

	bool bIsNewSkill = false;	// 새 스킬 습득 여부
	if(-1 == sSlotIndex)	bIsNewSkill = true;
	
	if(NULL == lpSkillProtoType)
	{
		ERRLOG1(g_Log, "스킬 프로토 타입 얻기 실패. 스킬ID: 0x%04x", wSkillID);
		return PktAdminMgr::PktSkillEdit::FAILED_TO_GET_SKILLPROTOTYPE;
	}

	if(CSkillMgr::MAX_SKILL_LOCKCOUNT <= cLockCount)
	{
		ERRLOG1(g_Log, "최대 스킬 락 카운트를 초과하였습니다. 락 카운트: %c", cLockCount);
		return PktAdminMgr::PktSkillEdit::OVERED_MAX_LOCKCOUNT;
	}

	if(CSkillMgr::MAX_SKILL_LEVEL < cLevel)
	{
		ERRLOG1(g_Log, "최대 스킬 레벨을 초과하였습니다. 스킬 레벨: %c", cLevel);
		return PktAdminMgr::PktSkillEdit::OVERED_MAX_SKILL_LEVEL;
	}

	if(lpSkillProtoType[0].m_usSkill_ID != lpSkillProtoType[cLockCount].m_usSkill_ID)
	{
		ERRLOG2(g_Log, "스킬 ID가 다릅니다. 0x%04x : 0x%04x", lpSkillProtoType[0].m_usSkill_ID,
			lpSkillProtoType[cLockCount].m_usSkill_ID);

		return PktAdminMgr::PktSkillEdit::FAILED;
	}

	// 최대 스킬 레벨을 추가할 경우 (다음 단계로 넘어가는 경우)
	if(cLevel == CSkillMgr::MAX_SKILL_LEVEL)
	{	
		// 최종 단계 스킬이 아닌경우 다음 단계 0레벨 스킬로 습득
		if(cLockCount < CSkillMgr::MAX_SKILL_LOCKCOUNT - 1)	// 아직 0~3 단계까지만 사용중
		{
			cLevel = 0;
			++cLockCount;
		}		
	}

	// 새로운 스킬 습득
	if(bIsNewSkill && (m_DBData.m_Skill.wSlotNum < SKILL::MAX_SLOT_NUM))
	{
		sSlotIndex = m_DBData.m_Skill.wSlotNum; // 새 슬롯 얻기
	}		
	else if(m_DBData.m_Skill.wSlotNum == SKILL::MAX_SLOT_NUM)
	{
		ERRLOG0(g_Log, "이미 사용할 수 있는 최대 슬롯을 사용중입니다.");
		return PktAdminMgr::PktSkillEdit::NOT_ENOUGH_SKILLSLOT;
	}
	
	SKILLSLOT TempSkillSlot;
	TempSkillSlot.SKILLINFO.wSkill		= wSkillID;
	TempSkillSlot.SKILLINFO.cSkillLevel = cLevel;
	TempSkillSlot.SKILLINFO.cLockCount  = cLockCount;

	unsigned short cResult = ReadSkill(TempSkillSlot, wSkillID, cLockCount);

	if(PktBase::NO_SERVER_ERR == cResult)	// 사용 가능한 스킬임
	{
		SKILL&		Skill	  = m_DBData.m_Skill;
		SKILLSLOT&	SkillSlot = Skill.SSlot[sSlotIndex];

		ChkEmptySlot(Skill);	// 빈 슬롯을 가지고 있는지 체크

		unsigned short BeforePoint =
			(SkillSlot.SKILLINFO.cLockCount * CSkillMgr::MAX_SKILL_LOCKCOUNT) + SkillSlot.SKILLINFO.cSkillLevel;

		unsigned short AfterPoint =
			(cLockCount * CSkillMgr::MAX_SKILL_LOCKCOUNT) + cLevel;	

		// 기존 스킬 레벨 변경
		if((!bIsNewSkill) && (GetMaxSkillPoint() >= ((GetSkillPoint() - BeforePoint) + AfterPoint)))
		{
			SkillSlot.SKILLINFO.wSkill		= wSkillID;
			SkillSlot.SKILLINFO.cSkillLevel	= cLevel;
			SkillSlot.SKILLINFO.cLockCount	= cLockCount;
		}
		// 새로운 스킬 추가
		else if(bIsNewSkill && (GetMaxSkillPoint() >= (GetSkillPoint() + AfterPoint)))
		{
			SkillSlot.SKILLINFO.wSkill		= wSkillID;
			SkillSlot.SKILLINFO.cSkillLevel	= cLevel;
			SkillSlot.SKILLINFO.cLockCount	= cLockCount;

			++m_DBData.m_Skill.wSlotNum;	// 사용중인 슬롯수 + 1
		}

		UpdateQuickSlotSkill(SkillSlot);
		m_DBData.m_Skill.wSkillNum = m_DBData.m_Skill.GetSkillNum();
	}
	else
	{
		switch(cResult)
		{
		case PktSk::FAIL_NOT_CURRENT_CLASS:
			return PktAdminMgr::PktSkillEdit::NOT_CURRENT_CLASS;
		case PktSk::FAIL_NOT_ENOUGH_STATUS:
			return PktAdminMgr::PktSkillEdit::NOT_ENOUGH_STAT;
		case PktSk::FAIL_MAX_LEVEL:
			return PktAdminMgr::PktSkillEdit::OVERED_MAX_SKILL_LEVEL;
		case PktSk::FAIL_NOT_CURRENT_LOCK_COUNT:
			return PktAdminMgr::PktSkillEdit::FAILED;
		default:
			return PktAdminMgr::PktSkillEdit::FAILED;
		}
	}

	return PktAdminMgr::PktSkillEdit::SUCCESS;
}

// 스킬 삭제 (스킬 포인트 조정 및 해당 스킬 슬롯 정보 초기화)
unsigned char CModifyCharacter::DeleteSkill(unsigned short wSkillID, char cLevel, char cLockCount)
{
	m_DBData.m_Skill.wSkillNum = m_DBData.m_Skill.GetSkillNum();	// 현재 스킬수 재 계산

	short sDelSlotIndex = GetSkillSlotIndex(wSkillID);

	if(-1 != sDelSlotIndex)
	{
		SKILL&		Skill	= m_DBData.m_Skill;
		SKILLSLOT&	DelSlot = Skill.SSlot[sDelSlotIndex];

		ChkEmptySlot(Skill);	// 빈 슬롯을 가지고 있는지 체크

		const Skill::ProtoType*	lpSkillProtoType = CSkillMgr::GetInstance().GetSkillProtoType(wSkillID);
		if(NULL == lpSkillProtoType)
		{
			ERRLOG1(g_Log, "스킬 프로토 타입 얻기 실패. 스킬ID: 0x%04x", wSkillID);
			return PktAdminMgr::PktSkillEdit::FAILED_TO_GET_SKILLPROTOTYPE;
		}

		if(DelSlot.SKILLINFO.wSkill != wSkillID)
		{
			ERRLOG3(g_Log, "삭제 요청 받은 스킬과 삭제 할 슬롯의 스킬이 일치하지 않습니다."
				"슬롯번호: %d , 삭제할 슬롯의 스킬ID: 0x%04x, 삭제 요청 한 스킬ID: 0x%04x",
				sDelSlotIndex, DelSlot.SKILLINFO.wSkill, wSkillID);

			return PktAdminMgr::PktSkillEdit::FAILED;
		}

		if(true == lpSkillProtoType->m_bIsClassSkill)
		{
			ERRLOG0(g_Log, "삭제하려는 스킬이 클래스 스킬입니다.");
			return PktAdminMgr::PktSkillEdit::FAILED;
		}
			
		// 스킬 슬롯 중간이 비면 한칸씩 앞으로 당겨옴 (중간에 비는 슬롯이 없도록!)
		unsigned short sLastSlotIndex = Skill.wSlotNum - 1;

		for(unsigned short sSlotIndex = sDelSlotIndex; sSlotIndex < sLastSlotIndex; ++sSlotIndex)
		{
			Skill.SSlot[sSlotIndex] = Skill.SSlot[sSlotIndex + 1];
		}
		
		Skill.SSlot[sLastSlotIndex].SKILLINFO.wSkill	  = 0;
		Skill.SSlot[sLastSlotIndex].SKILLINFO.cSkillLevel = 0;
		Skill.SSlot[sLastSlotIndex].SKILLINFO.cLockCount  = 0;

		Skill.wSkillNum -=
			(DelSlot.SKILLINFO.cLockCount * CSkillMgr::MAX_SKILL_LEVEL) + DelSlot.SKILLINFO.cSkillLevel;
		
		Skill.wSlotNum  -= 1;
		
		UpdateQuickSlotSkill(DelSlot);

		return PktAdminMgr::PktSkillEdit::SUCCESS;
	}

	return PktAdminMgr::PktSkillEdit::FAILED;
}

bool CModifyCharacter::ChkEmptySlot(SKILL Skill)
{
	CString strEmptySlotIndex;

	for(unsigned short sSlotIndex = 0; sSlotIndex < Skill.wSlotNum; ++sSlotIndex)
	{
		if(0 == Skill.SSlot[sSlotIndex].SKILLINFO.wSkill)
		{
			strEmptySlotIndex.AppendFormat("%d ", sSlotIndex);
		}
	}

	if(!strEmptySlotIndex.IsEmpty())
	{
		ERRLOG3(g_Log, "스킬 슬롯에 빈슬롯이 있습니다. CID: %u, 슬롯수: %d, 빈슬롯: %s",
			GetCID(), Skill.wSlotNum, strEmptySlotIndex);

		return true;
	}

	return false;
}

// 걍 날림 스킬레벨가져오기.. 
// Return : 
// 존재하는 스킬이면 현재 내레벨.. 같은계열의 하위스킬일경우 MaxSkillLevel을...
// 같은 계열스킬중 상위계열이면 0을 리턴..
short CModifyCharacter::GetSkillLevelEX(unsigned short usSkillType, char cLockCount)
{
	const Skill::ProtoType* lpSkillProtoType = CSkillMgr::GetInstance().GetSkillProtoType(usSkillType);

	if(NULL != lpSkillProtoType)
	{
		int nMaxSlotNum = m_DBData.m_Skill.wSlotNum;

		if(SKILL::MAX_SLOT_NUM >= nMaxSlotNum)
		{			
			for( int nSlot = 0; nSlot < nMaxSlotNum; ++ nSlot )
			{
				const SKILLSLOT& SkillSlot = m_DBData.m_Skill.SSlot[ nSlot ];
				if( SkillSlot.SKILLINFO.wSkill == usSkillType )
				{
					if( SkillSlot.SKILLINFO.cLockCount == cLockCount )
					{
						return SkillSlot.SKILLINFO.cSkillLevel;
					}
					else if( SkillSlot.SKILLINFO.cLockCount > cLockCount )
					{
						return SKILL::MAX_SKILL_LEVEL;
					}
					else
					{
						return 0;
					}
				}
			}
		}
	}

	return -1;
}

bool CModifyCharacter::SetGold(unsigned long dwGold)
{
	if(dwGold > ULONG_MAX)
	{
		return false;
	}

	m_DBData.m_Info.Gold = dwGold;

	return true;
}

// 캐릭터를 잡고 있는 관리자의 Session을 리턴~~
CSession* CModifyCharacter::GetCheckSession( unsigned long dwUID )
{
	if( m_dwUID == dwUID )
	{
		if( NULL != m_lpPacketDispatch )
		{
			CSession& lpSession = m_lpPacketDispatch->GetSession( );
			//if( NULL != lpSession ) return lpSession;
			return &lpSession;
		}
	}

	return NULL;
}

// 캐릭터 정보가 변경됬음을 기억해놓자..
void CModifyCharacter::OnChangedInfo( int iMask )
{
	m_byChangedInfo |= iMask;
}

// 캐릭터 변경정보를 지운다..
void CModifyCharacter::OffChangedInfo( int iMask )
{
	m_byChangedInfo &= iMask;
}

// 캐릭터의 Status
void CModifyCharacter::GetModifyCharStatus(PktAdminMgr::CHAR_STATUS_ST& StatusST)
{
	StatusST.m_cFace		= m_DBData.m_Info.Face;
	StatusST.m_cHair		= m_DBData.m_Info.Hair;
	StatusST.m_cLevel		= m_DBData.m_Info.Level;
	StatusST.m_cRace		= m_DBData.m_Info.Race;
	StatusST.m_cSex			= m_DBData.m_Info.Sex;    
	StatusST.m_dwExp		= m_DBData.m_Info.Exp;
	StatusST.m_dwFame		= m_DBData.m_Info.Fame;
	StatusST.m_dwMileage	= m_DBData.m_Info.Mileage;
	StatusST.m_nClass		= m_DBData.m_Info.Class;
	StatusST.m_nCON			= m_DBData.m_Info.CON;
	StatusST.m_nDEX			= m_DBData.m_Info.DEX;
	StatusST.m_nINT			= m_DBData.m_Info.INT;
	StatusST.m_nIP			= m_DBData.m_Info.IP;
	StatusST.m_nSTR			= m_DBData.m_Info.STR;
	StatusST.m_nWIS			= m_DBData.m_Info.WIS;
	StatusST.m_cChance		= m_DBData.m_Info.Chance;
}

// 캐릭터 Status변경.. 
bool CModifyCharacter::UpdataStatus(PktAdminMgr::CHAR_STATUS_ST& StatusST)
{
	CHAR_INFOST OrgCharInfo;

	CopyMemory(&OrgCharInfo, &m_DBData.m_Info, sizeof(CHAR_INFOST));

	m_DBData.m_Info.Sex			= StatusST.m_cSex;	
	m_DBData.m_Info.Hair		= StatusST.m_cHair;			
	m_DBData.m_Info.Face		= StatusST.m_cFace;		
	m_DBData.m_Info.Race		= StatusST.m_cRace;
	m_DBData.m_Info.Class		= StatusST.m_nClass;		

	m_DBData.m_Info.Fame		= StatusST.m_dwFame;		
	m_DBData.m_Info.Mileage		= StatusST.m_dwMileage;	

	m_DBData.m_Info.Level		= StatusST.m_cLevel;
	m_DBData.m_Info.Exp			= StatusST.m_dwExp;

	m_DBData.m_Info.IP			= StatusST.m_nIP;			

	m_DBData.m_Info.STR			= StatusST.m_nSTR;			
	m_DBData.m_Info.CON			= StatusST.m_nCON;			
	m_DBData.m_Info.DEX			= StatusST.m_nDEX;			
	m_DBData.m_Info.INT			= StatusST.m_nINT;			
	m_DBData.m_Info.WIS			= StatusST.m_nWIS;
	m_DBData.m_Info.Chance		= StatusST.m_cChance;

	m_CreatureStatus.m_nExp		= StatusST.m_dwExp;
	m_CreatureStatus.m_nLevel	= StatusST.m_cLevel;

	// Status 계산식을 넣자
	if(!CalculateStatusData(false))
	{
		// 잘못된 Status값
		CopyMemory(&m_DBData.m_Info, &OrgCharInfo, sizeof(CHAR_INFOST));
		return false;
	}

	return true;
}

// 캐릭터가 소지하고 있는 아이템을 UID로 검색하여 리턴한다..
// 해당 아이템이 없으면 NULL
Item::CItem* CModifyCharacter::UIDbyItem(unsigned __int64 ItemUID, unsigned char cTakeType)
{	
	Item::CItemContainer::iterator	Itr;

	if(cTakeType == TakeType::TS_INVEN)			// 인벤토리 아이템
	{		
		Item::CArrayContainer& ArrayContainer = GetInventory();		
		Itr = ArrayContainer.begin();

		for(;Itr != ArrayContainer.end(); ++Itr)
		{
			if(NULL !=  (*Itr))
			{
				if((*Itr)->GetUID() == ItemUID)		return (*Itr);
			}
		}		
	}
	else if( cTakeType == TakeType::TS_EQUIP )		// 장비창 아이템
	{		
		Item::CEquipmentsContainer& EquipContainer	= GetEquipments( );
		Itr											= EquipContainer.begin( );
		
		for(;Itr != EquipContainer.end(); ++Itr )
		{
			if(NULL != (*Itr))
			{				
				if((*Itr)->GetUID() == ItemUID)	return (*Itr);
			}
		}
	}
	else if(cTakeType == TakeType::TS_DEPOSIT)	// 창고 아이템
	{
		Item::CDepositContainer& DepositContainer = GetDeposit();
	
		for (unsigned char cTab = 0; cTab < DepositContainer.GetMaxTabNum(); ++cTab)
		{
			Item::CItemContainer* DepositTabContainer = DepositContainer.GetTab(cTab);
			Itr = DepositTabContainer->begin();
			for(; Itr != DepositTabContainer->end( ); ++Itr )
			{
				if( NULL != ( *Itr ) )
				{
					if( ( *Itr )->GetUID( ) == ItemUID ) return ( *Itr );
				}
			}
		}
	}

	return NULL;
}

void CModifyCharacter::ChangeName(char* szName)
{
	strncpy(m_DBData.m_Info.Name, szName, CHAR_INFOST::MAX_NAME_LEN);
}

// 캐릭터를 편집중인 관리자 계정을 저장한다.
void CModifyCharacter::SetModifyAdmin(char* Account, int Length)
{
	strncpy(m_szModifyAdmin, Account, Length);
}

void CModifyCharacter::ParseQuestData()
{
	Quest::ExecutingQuest* aryExecutingQuest = GetExecutingQuest();
	unsigned short* aryHistoryQuest = GetHistoryQuest();

	// 수행중인 퀘스트 목록
	int nIndex = 0;

	PktQuestDB::ExecutingQuest* lpExecuteQuestPos = 
		reinterpret_cast<PktQuestDB::ExecutingQuest*>(m_ExtraData.m_Quest.Data);

	PktQuestDB::ExecutingQuest* lpExecuteQuestEnd = 
		reinterpret_cast<PktQuestDB::ExecutingQuest*>(m_ExtraData.m_Quest.Data) + 
		(m_ExtraData.m_Quest.dwSize / sizeof(PktQuestDB::ExecutingQuest));

	for(; lpExecuteQuestPos != lpExecuteQuestEnd; ++lpExecuteQuestPos)
	{
		Quest::QuestNode* lpQuest = CQuestMgr::GetInstance().GetQuestNode(lpExecuteQuestPos->m_wQuestID);

		if (0 != lpQuest && false == lpQuest->CheckNationDependent(GetUserNation()))
		{
			aryExecutingQuest[nIndex] = Quest::ExecutingQuest(lpExecuteQuestPos->m_wQuestID, 
				lpExecuteQuestPos->m_cPhase, lpExecuteQuestPos->m_cTriggerCount);

			++nIndex;
		}		
	}

	nIndex = 0;

	// 완료 퀘스트 목록
	unsigned short* lpHistoryQuestPos = 
		reinterpret_cast<unsigned short*>(m_ExtraData.m_History.Data);

	unsigned short* lpHistoryQuestEnd = 
		reinterpret_cast<unsigned short*>(m_ExtraData.m_History.Data) + 
		(m_ExtraData.m_History.dwSize / sizeof(unsigned short));

	for (; lpHistoryQuestPos != lpHistoryQuestEnd; ++lpHistoryQuestPos)
	{
		Quest::QuestNode* lpQuest = CQuestMgr::GetInstance().GetQuestNode(*lpHistoryQuestPos);

		if (0 != lpQuest && false == lpQuest->CheckNationDependent(GetUserNation()))
		{	
			aryHistoryQuest[nIndex] = *lpHistoryQuestPos;
			++nIndex;
		}
	}

	// 퀘스트에 의해 받는 영향을 계산
	CalculateStatusData(false);
}

void CModifyCharacter::SetQuestData()
{
	const int MAX_BUFFER =
		sizeof(PktQuestDB) + PktQuestDB::MAX_EXECUTING_QUEST * sizeof(PktQuestDB::ExecutingQuest) + 
		PktQuestDB::MAX_HISTORY_QUEST * sizeof(unsigned short);

	char szBuffer[MAX_BUFFER];

	PktQuestDB*	lpPktQuestDB = reinterpret_cast<PktQuestDB*>(szBuffer);

	lpPktQuestDB->m_dwUID = GetUID(); 
	lpPktQuestDB->m_dwCID = GetCID();
	lpPktQuestDB->m_wExecuteQuestSize = 0;
	lpPktQuestDB->m_wHistoryQuestSize = 0;

	Quest::ExecutingQuest* ExecutingQuest = GetExecutingQuest();
	unsigned short *wHistoryQuest = GetHistoryQuest();

	int nIndex = 0;
	for (nIndex = 0; nIndex < PktQuestDB::MAX_EXECUTING_QUEST; ++nIndex)
	{
		if (NULL == ExecutingQuest[nIndex].m_QuestNode) 
		{ 
			break; 
		}

		PktQuestDB::ExecutingQuest* ExecuteQuest = 
			reinterpret_cast<PktQuestDB::ExecutingQuest*>
			(szBuffer + sizeof(PktQuestDB) + lpPktQuestDB->m_wExecuteQuestSize);

		ExecuteQuest->m_wQuestID = ExecutingQuest[nIndex].m_QuestNode->m_wQuestID;
		ExecuteQuest->m_cPhase = ExecutingQuest[nIndex].m_cPhase;
		memcpy(ExecuteQuest->m_cTriggerCount, ExecutingQuest[nIndex].m_cTriggerCount,
			sizeof(unsigned char) * PktQuestDB::MAX_TRIGGER);

		lpPktQuestDB->m_wExecuteQuestSize += sizeof(PktQuestDB::ExecutingQuest);;
	}

	for (nIndex = 0; nIndex < PktQuestDB::MAX_HISTORY_QUEST; nIndex++)
	{
		if (0 == wHistoryQuest[nIndex])
		{
			break;
		}

		unsigned short* wHistoryQuestForPkt = 
			reinterpret_cast<unsigned short *>(szBuffer + sizeof(PktQuestDB) + 
			lpPktQuestDB->m_wExecuteQuestSize + lpPktQuestDB->m_wHistoryQuestSize);

		*wHistoryQuestForPkt = wHistoryQuest[nIndex];

		lpPktQuestDB->m_wHistoryQuestSize += sizeof(unsigned short);
	}

    memset(&m_ExtraData.m_Quest, 0, sizeof(QUEST));
    m_ExtraData.m_Quest.dwSize = lpPktQuestDB->m_wExecuteQuestSize;
    memcpy(m_ExtraData.m_Quest.Data, lpPktQuestDB + 1, lpPktQuestDB->m_wExecuteQuestSize);

    memset(&m_ExtraData.m_History, 0, sizeof(HISTORY));
    m_ExtraData.m_History.dwSize = lpPktQuestDB->m_wHistoryQuestSize;
    memcpy(m_ExtraData.m_History.Data, reinterpret_cast<char*>(lpPktQuestDB + 1) + lpPktQuestDB->m_wExecuteQuestSize, 
        lpPktQuestDB->m_wHistoryQuestSize);
}

void CModifyCharacter::RevisionQuestNation()
{
	using namespace Creature;

	// 양국체제에선 무조건 휴먼은 카르테란트, 아칸은 메르카디아! (퀘스트 파싱할때 필요)
	switch(GetRace())
	{
	case CClass::RaceType::HUMAN:
		m_cQuestNation = Creature::KARTERANT;
		break;
	case CClass::RaceType::AKHAN:
		m_cQuestNation = Creature::MERKADIA;
		break;
	default:
		m_cQuestNation = Creature::MAX_NATION;
		break;
	}
}

// class CModifyItem Down_Cast ----------------------------------------------------------------------------------------------------------------------------------

void CModifyItem::SetUID(unsigned __int64 UID)
{
	m_ItemData.m_dwUID = UID;
}

void CModifyItem::SetPrototoypID(unsigned short PrototypeID)
{
	m_ItemData.m_usProtoTypeID = PrototypeID;
}