#include "stdafx.h"

#include <Item/Item.h>
#include <Item/ItemMgr.h>
#include <Item/ItemFactory.h>
#include <Item/Container/ExchangeContainer.h>
#include <Item/Container/DepositContainer.h>

#include <Log/ItemLog.h>
#include <Log/LogStruct.h>

#include <Map/FieldMap/Cell.h>
#include <Map/FieldMap/CellManager.h>

#include <Creature/CreatureManager.h>
#include <Creature/NPC/NPC.h>
#include <Creature/Character/Character.h>
#include <Creature/Siege/CampShop.h>
#include <Creature/Siege/SiegeObjectMgr.h>

#include <Network/Dispatch/ParseUtils.h>
#include <Network/Dispatch/DBAgent/DBAgentRequest.h>
#include <Network/Dispatch/DBAgent/DBAgentDispatch.h>
#include <Network/Packet/PacketStruct/CharItemPacket.h>
#include <Network/Packet/PacketStruct/CharLoginOutPacketStruct.h>
#include <Network/Packet/PacketStruct/CharCommunityPacket.h>
#include <Network/Dispatch/GameClient/SendCharCommunity.h>

#include <Community/Party/Party.h>
#include <Community/Guild/Guild.h>
#include <Community/Guild/GuildMgr.h>

#include <Castle/Castle.h>
#include <Castle/CastleConstants.h>
#include <Castle/CastleMgr.h>
#include <Castle/CastleBlessMgr.h>

#include <GameTime/GameTimeConstants.h>
#include <GameTime/GameTimeMgr.h>

#include <Skill/SkillMgr.h>

#include "ParseCharItem.h"
#include "SendCharItem.h"
#include "GameClientDispatch.h"

#define LOCK_FIFTH_SKILL(SkillType) \
	if(CSkillMgr::MAX_SKILL_LOCKCOUNT - 2 == lpSender->GetSkillLockCount(##SkillType) && CSkillMgr::MAX_SKILL_LEVEL == lpSender->GetSkillLevel(##SkillType))\
	{\
		if (false == lpSender->SkillFifthLock(SkillType))\
		{\
			usError = PktTI::FAIL_MOVE;\
			ERRLOG1(g_Log, "CID:%10u 5´Ü°è½ºÅ³ ¶ô Àåºñ ÀåÂø½Ã 5´Ü°è ½ºÅ³ÀÇ ¶ôÀ» °ÉÁö ¸øÇÏ´Â ¿¡·¯°¡ ¹ß»ý Çß½À´Ï´Ù.", dwCID);\
		}\
	}\

#define UNLOCK_FIFTH_SKILL(SkillType) \
	if(CSkillMgr::MAX_SKILL_LOCKCOUNT - 1 == lpSender->GetSkillLockCount(##SkillType))\
	{\
		if(0 == lpSender->GetSkillLevel(##SkillType))\
		{\
			if (false == lpSender->SkillFifthUnlock(##SkillType))\
			{\
				usError = PktTI::FAIL_MOVE;\
				ERRLOG2(g_Log, "CID:%10u 5´Ü°è½ºÅ³ ¶ô Àåºñ ÇØÁ¦½Ã 0x%8xÀÇ 5´Ü°è ½ºÅ³ ¶ôÀ» Ç®Áö ¸øÇÏ´Â ¿¡·¯°¡ ¹ß»ý Çß½À´Ï´Ù.", dwCID, ##SkillType);\
			}\
		}\
		else if(0 < lpSender->GetSkillLevel(##SkillType))\
		{\
			usError = PktTI::FAIL_MOVE_FIFTHSKILL_LOCKITEM;\
			ERRLOG2(g_Log, "CID:%10u 5´Ü°è½ºÅ³ ¶ô Àåºñ¸¦ ÇØÁ¦ÇÏ·Á¸é 0x%8xÀÇ 5´Ü°è ½ºÅ³ ·¹º§ÀÌ 0À̾î¾ß ÇÕ´Ï´Ù.", dwCID, ##SkillType);\
		}\
	}\

namespace GameClientParsePacket
{

	// ¾ÆÀÌÅÛ Æȱâ ó¸®
	bool ProcessItemSell(CGameClientDispatch& GameClientDispatch, PktTr* lpPktTr);

	// ¾ÆÀÌÅÛ »ç±â ó¸®
	bool ProcessItemBuy(CGameClientDispatch& GameClientDispatch, PktTr* lpPktTr);

	// ¾ÆÀÌÅÛ Áý±â ó¸®
	bool ProcessItemPickUp(CGameClientDispatch& GameClientDispatch, 
		unsigned __int64 nObjectID, Item::ItemPos itemPos, unsigned short& usError);

	inline bool IsPutDeposit(TakeType takeType)
	{
		return (takeType.m_srcPos.m_cPos != TakeType::TS_DEPOSIT && takeType.m_dstPos.m_cPos == TakeType::TS_DEPOSIT);
	}

	inline bool IsPutDeposit(unsigned char cSrc, unsigned char cDst)
	{
		return (cSrc != TakeType::TS_DEPOSIT && cDst == TakeType::TS_DEPOSIT);
	}

	inline unsigned long PutDepositMoney(CCharacter* lpCharacter)
	{
		return lpCharacter->GetStatus().m_nLevel * 20;
	}
}


// ¾ÆÀÌÅÛ À̵¿ ¹× ½ºÅÃ
bool GameClientParsePacket::ParseCharTakeItem(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktTI), GameClientDispatch);

	PktTI*      lpPktTI     = static_cast<PktTI*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned short  usError     = 0;
	TakeType        takeType    = lpPktTI->m_TakeType;    

	unsigned long   dwCID       = lpPktTI->m_dwCharID;
	unsigned long   dwTakeMoney = 0;
	Item::CItem*    lpMoveItem  = lpCharacter->GetItem(takeType.m_srcPos);

	bool bTakeMoney = false;

	if (NULL == lpMoveItem)
	{
		usError = PktTI::FAIL_MOVE;
		ERRLOG5(g_Log, "CID:%10u ¾ÆÀÌÅÛ À̵¿ ½ÇÆÐ Src¿¡ ¾ÆÀÌÅÛÀÌ ¾ø½À´Ï´Ù. SRC:(%2d:0x%04x), DST(%2d:0x%04x)", 
			lpCharacter->GetCID(), takeType.m_srcPos.m_cPos, takeType.m_srcPos.m_cIndex, 
			takeType.m_dstPos.m_cPos, takeType.m_dstPos.m_cIndex);

		Item::CItemContainer* lpItemContainer = lpCharacter->GetItemContainer(takeType.m_srcPos.m_cPos);
		if (NULL != lpItemContainer)
		{
			lpItemContainer->DumpItemInfo();
		}
	}
	else
	{
		bTakeMoney = IsPutDeposit(lpMoveItem->GetRealPos().m_cPos, takeType.m_dstPos.m_cPos);

		if (bTakeMoney)
		{
			if (!lpCharacter->GetDeposit().IsLogin())
			{
				usError = PktTI::FAIL_MOVE;
				ERRLOG1(g_Log, "CID:%10u â°í¿¡ ·Î±×ÀεÇÁö ¾ÊÀº »óÅ¿¡¼­ ¾ÆÀÌÅÛÀ» ¿Å±â·Á ÇÏ¿´½À´Ï´Ù.", dwCID);
			}
			else
			{
				dwTakeMoney = PutDepositMoney(lpCharacter);
				if (lpCharacter->GetGold() < dwTakeMoney)
				{
					usError = PktTI::FAIL_MOVE;
					ERRLOG1(g_Log, "CID:%10u â°í¿¡ ¹°°ÇÀ» ¸Ã±â±â¿¡ µ·ÀÌ ºÎÁ·ÇÕ´Ï´Ù.", dwCID);
				}
			}
		}
	}

	GAMELOG::sMinItemInfo minItemInfo;
	CCharacter* lpSender = CCreatureManager::GetInstance().GetCharacter(lpPktTI->m_dwCharID);

	if (0 == usError)
	{
		if(CServerSetup::GetInstance().UseContents(GameRYL::FIFTHSKILL_LOCKITEM))
		{
			// 5´Ü°è Àåºñ ¾ÆÀÌÅÛ ÇØÁ¦
			if(lpMoveItem && takeType.m_srcPos.m_cPos == TakeType::TS_EQUIP)
			{
				switch(lpMoveItem->GetPrototypeID())
				{
					case 551 : UNLOCK_FIFTH_SKILL(0x8503); break;
					case 552 : UNLOCK_FIFTH_SKILL(0x8603); break;
					case 553 : UNLOCK_FIFTH_SKILL(0x8704); break;
					case 554 : UNLOCK_FIFTH_SKILL(0x8804); break;
					case 555 : UNLOCK_FIFTH_SKILL(0x8902); break;
					case 556 : UNLOCK_FIFTH_SKILL(0x8A05); break;
					case 557 : UNLOCK_FIFTH_SKILL(0x8B04); break;
					case 558 : UNLOCK_FIFTH_SKILL(0x8C02); break;
					case 5351 : UNLOCK_FIFTH_SKILL(0x9302); break;
					case 5352 : UNLOCK_FIFTH_SKILL(0x9402); break;
					case 5353 : UNLOCK_FIFTH_SKILL(0x9502); break;
					case 5354 : UNLOCK_FIFTH_SKILL(0x9606); break;
					case 5355 : UNLOCK_FIFTH_SKILL(0x9603); break;
					case 5356 : UNLOCK_FIFTH_SKILL(0x9706); break;
					case 5357 : UNLOCK_FIFTH_SKILL(0x9804); break;
					default	 : break;
				}
			}
		}

		minItemInfo.InitMinItemInfo(lpMoveItem);

		if (!lpCharacter->MoveItem(takeType))
		{
			ERRLOG5(g_Log, "CID:%10u ¾ÆÀÌÅÛ À̵¿ ½ÇÆÐ. SRC:(%2d:0x%04x), DST(%2d:0x%04x)", 
				lpCharacter->GetCID(), takeType.m_srcPos.m_cPos, takeType.m_srcPos.m_cIndex,
				takeType.m_dstPos.m_cPos, takeType.m_dstPos.m_cIndex);
			usError = PktTI::FAIL_MOVE;
		}
		else 
		{
			if (bTakeMoney)
			{			
				// À̵¿ ¼º°ø½Ã, takeTypeÀÇ src°¡ TakeType::TS_DEPOSITÀÌ ¾Æ´Ï°í, dst°¡ TakeType::TS_DEPOSITÀÏ °æ¿ì¸¸ °ú±ÝÇÑ´Ù.
				unsigned long dwLastGold = lpCharacter->GetGold();
				lpCharacter->DeductGold(dwTakeMoney, false);
				GAMELOG::LogTakeGold(*lpCharacter, dwLastGold, lpCharacter->GetGold(), dwTakeMoney,
					TakeType::TS_INVEN, TakeType::TS_INVEN, GAMELOG::sTakeGoldLogV2::STORE_USE, 0);
			}

			if(CServerSetup::GetInstance().UseContents(GameRYL::FIFTHSKILL_LOCKITEM))
			{
				// 5´Ü°è Àåºñ ¾ÆÀÌÅÛ ÀåÂø
				if(lpMoveItem && takeType.m_dstPos.m_cPos == TakeType::TS_EQUIP)
				{
					switch(lpMoveItem->GetPrototypeID())
					{
						case 551 : LOCK_FIFTH_SKILL(0x8503); break;
						case 552 : LOCK_FIFTH_SKILL(0x8603); break;
						case 553 : LOCK_FIFTH_SKILL(0x8704); break;
						case 554 : LOCK_FIFTH_SKILL(0x8804); break;
						case 555 : LOCK_FIFTH_SKILL(0x8902); break;
						case 556 : LOCK_FIFTH_SKILL(0x8A05); break;
						case 557 : LOCK_FIFTH_SKILL(0x8B04); break;
						case 558 : LOCK_FIFTH_SKILL(0x8C02); break;
						case 5351 : LOCK_FIFTH_SKILL(0x9302); break;
						case 5352 : LOCK_FIFTH_SKILL(0x9402); break;
						case 5353 : LOCK_FIFTH_SKILL(0x9502); break;
						case 5354 : LOCK_FIFTH_SKILL(0x9606); break;
						case 5355 : LOCK_FIFTH_SKILL(0x9603); break;
						case 5356 : LOCK_FIFTH_SKILL(0x9706); break;
						case 5357 : LOCK_FIFTH_SKILL(0x9804); break;
						default	 : break;
					}
				}
			}
		}
	}

	// ¾ÆÀÌÅÛ À̵¿ ·Î±×¸¦ ³²±é´Ï´Ù.
	GAMELOG::LogMoveItem(*lpCharacter, takeType, minItemInfo, usError);

	// µ¥ÀÌÅ͸¦ Àü¼ÛÇÑ´Ù.
	return GameClientSendPacket::SendCharTakeItem(GameClientDispatch.GetSendStream(), 
		lpCharacter->GetCID(), takeType, usError);
}


// ¾ÆÀÌÅÛ ½º¿Ò
bool GameClientParsePacket::ParseCharSwapItem(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktSwI), GameClientDispatch);

	PktSwI*     lpPktSwl     = static_cast<PktSwI*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned short  usError = 0;
	TakeType        swapSrc = lpPktSwl->m_SwapSrc;
	TakeType        swapDst = lpPktSwl->m_SwapDst;

	Item::CItem*    lpSrcItem   = lpCharacter->GetItem(swapSrc.m_srcPos);
	Item::CItem*    lpDstItem   = lpCharacter->GetItem(swapDst.m_srcPos);
	unsigned long   dwTakeMoney = 0;
	unsigned long   dwCID       = lpPktSwl->m_dwCharID;


	if (NULL == lpSrcItem)
	{
		usError = PktSwI::FAIL_SRC_MOVE;
		ERRLOG3(g_Log, "CID:%10u Swap½ÇÆÐ : SrcÀ§Ä¡¿¡¼­ ¾ÆÀÌÅÛÀ» ¾ò¾î¿Ã ¼ö ¾ø½À´Ï´Ù. (%d, 0x%04x)", 
			dwCID, swapSrc.m_srcPos.m_cPos, swapSrc.m_srcPos.m_cIndex);
	}
	else if (NULL == lpDstItem)
	{
		usError = PktSwI::FAIL_DST_MOVE;
		ERRLOG3(g_Log, "CID:%10u Swap½ÇÆÐ : DstÀ§Ä¡¿¡¼­ ¾ÆÀÌÅÛÀ» ¾ò¾î¿Ã ¼ö ¾ø½À´Ï´Ù. (%d, 0x%04x)", 
			dwCID, swapDst.m_srcPos.m_cPos, swapDst.m_srcPos.m_cIndex);
	}
	else
	{
		bool bTakeMoney = IsPutDeposit(lpSrcItem->GetRealPos().m_cPos, swapSrc.m_dstPos.m_cPos) || 
			IsPutDeposit(lpSrcItem->GetRealPos().m_cPos, swapDst.m_dstPos.m_cPos); 

		if (bTakeMoney)
		{
			if (!lpCharacter->GetDeposit().IsLogin())
			{
				usError = PktTI::FAIL_MOVE;
				ERRLOG1(g_Log, "CID:%10u â°í¿¡ ·Î±×ÀεÇÁö ¾ÊÀº »óÅ¿¡¼­ ¾ÆÀÌÅÛÀ» ½º¿ÒÇÏ·Á ÇÏ¿´½À´Ï´Ù.", dwCID);
			}
			else
			{
				dwTakeMoney = PutDepositMoney(lpCharacter);
				if (lpCharacter->GetGold() < dwTakeMoney)
				{
					usError = PktSwI::CANT_SWAP;
					ERRLOG1(g_Log, "CID:%10u â°í¿¡ ¹°°ÇÀ» ¸Ã±â±â¿¡ µ·ÀÌ ºÎÁ·ÇÕ´Ï´Ù.", dwCID);
				}
			}
		}

		if (0 == usError)
		{

			if (!lpCharacter->SwapItem(swapSrc, swapDst)) 
			{
				ERRLOG9(g_Log, "CID:%10u ½º¿Ò ºÒ°¡´É. SRCTake:(%2d:0x%04x)->(%2d:0x%04x), DSTTake(%2d:0x%04x)->(%2d:0x%04x)",
					lpCharacter->GetCID(), 
					swapSrc.m_srcPos.m_cPos, swapSrc.m_srcPos.m_cIndex, swapSrc.m_dstPos.m_cPos, swapSrc.m_dstPos.m_cIndex,
					swapDst.m_srcPos.m_cPos, swapDst.m_srcPos.m_cIndex, swapDst.m_dstPos.m_cPos, swapDst.m_dstPos.m_cIndex);
				usError = PktSwI::CANT_SWAP;
			}
			else
			{
				if (bTakeMoney)
				{
					unsigned long dwLastGold = lpCharacter->GetGold();
					lpCharacter->DeductGold(dwTakeMoney, false);
					GAMELOG::LogTakeGold(*lpCharacter, dwLastGold, lpCharacter->GetGold(), dwTakeMoney,
						TakeType::TS_INVEN, TakeType::TS_INVEN, GAMELOG::sTakeGoldLogV2::STORE_USE, 0);
				}

				if(CServerSetup::GetInstance().UseContents(GameRYL::FIFTHSKILL_LOCKITEM))
				{
					CCharacter* lpSender = CCreatureManager::GetInstance().GetCharacter(lpPktSwl->m_dwCharID);

					if(1 == swapDst.m_srcPos.m_cPos)
					{
						switch(lpDstItem->GetPrototypeID())
						{
							case 551 : UNLOCK_FIFTH_SKILL(0x8503); break;
							case 552 : UNLOCK_FIFTH_SKILL(0x8603); break;
							case 553 : UNLOCK_FIFTH_SKILL(0x8704); break;
							case 554 : UNLOCK_FIFTH_SKILL(0x8804); break;
							case 555 : UNLOCK_FIFTH_SKILL(0x8902); break;
							case 556 : UNLOCK_FIFTH_SKILL(0x8A05); break;
							case 557 : UNLOCK_FIFTH_SKILL(0x8B04); break;
							case 558 : UNLOCK_FIFTH_SKILL(0x8C02); break;
							case 5351 : UNLOCK_FIFTH_SKILL(0x9302); break;
							case 5352 : UNLOCK_FIFTH_SKILL(0x9402); break;
							case 5353 : UNLOCK_FIFTH_SKILL(0x9502); break;
							case 5354 : UNLOCK_FIFTH_SKILL(0x9606); break;
							case 5355 : UNLOCK_FIFTH_SKILL(0x9603); break;
							case 5356 : UNLOCK_FIFTH_SKILL(0x9706); break;
							case 5357 : UNLOCK_FIFTH_SKILL(0x9804); break;
							default	 : break;
						}
					}
					
					if(1 == swapSrc.m_dstPos.m_cPos)
					{
						switch(lpSrcItem->GetPrototypeID())
						{
						case 551 : LOCK_FIFTH_SKILL(0x8503); break;
						case 552 : LOCK_FIFTH_SKILL(0x8603); break;
						case 553 : LOCK_FIFTH_SKILL(0x8704); break;
						case 554 : LOCK_FIFTH_SKILL(0x8804); break;
						case 555 : LOCK_FIFTH_SKILL(0x8902); break;
						case 556 : LOCK_FIFTH_SKILL(0x8A05); break;
						case 557 : LOCK_FIFTH_SKILL(0x8B04); break;
						case 558 : LOCK_FIFTH_SKILL(0x8C02); break;
						case 5351 : LOCK_FIFTH_SKILL(0x9302); break;
						case 5352 : LOCK_FIFTH_SKILL(0x9402); break;
						case 5353 : LOCK_FIFTH_SKILL(0x9502); break;
						case 5354 : LOCK_FIFTH_SKILL(0x9606); break;
						case 5355 : LOCK_FIFTH_SKILL(0x9603); break;
						case 5356 : LOCK_FIFTH_SKILL(0x9706); break;
						case 5357 : LOCK_FIFTH_SKILL(0x9804); break;
						default	 : break;
						}
					}
				}
			}
		}
	}

	// ¾ÆÀÌÅÛ ½º¿Ò ·Î±×
	GAMELOG::LogSwapItem(*lpCharacter, swapSrc, swapDst, lpSrcItem, lpDstItem, usError);

	return GameClientSendPacket::SendCharSwapItem(GameClientDispatch.GetSendStream(), lpCharacter->GetCID(), 
		swapSrc, swapDst, usError);
}


// ¾ÆÀÌÅÛ ¼ö¸®
bool GameClientParsePacket::ParseCharRepairItem(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktRpI), GameClientDispatch);

	PktRpI*     lpPktRpl    = static_cast<PktRpI*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned short  usError = PktBase::NO_SERVER_ERR;

	Item::ItemPos   itemPos     = lpPktRpl->m_itemPos;
	Item::CItem*    lpItem      = lpCharacter->GetItem(itemPos);
	unsigned char   cDurability = (NULL != lpItem) ? lpItem->GetNumOrDurability() : NULL;

	unsigned long dwRepairGold = lpCharacter->RepairItem(lpPktRpl->m_dwCharID, itemPos, usError);

	GAMELOG::LogRepairItem(*lpCharacter, lpItem, dwRepairGold, cDurability, usError);
	return GameClientSendPacket::SendCharRepairItem(GameClientDispatch.GetSendStream(), lpCharacter->GetCID(), 
		dwRepairGold, itemPos, usError);
}

// ¾ÆÀÌÅÛ ¼ö¸® (Àåºñ ¾ÆÀÌÅÛ ¸ðµÎ ¼ö¸®)
bool GameClientParsePacket::ParseCharRepairAllItem(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktRpAI), GameClientDispatch);

	PktRpAI*     lpPktRpAI	= static_cast<PktRpAI*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned short usError = PktBase::NO_SERVER_ERR;

	unsigned long dwRepairGold = lpCharacter->RepairAllItem(lpPktRpAI->m_dwCharID, usError);
/*
	// RepairAllItem ¾ÈÀ¸·Î µé¾î°¬´Ù.
	if (0 != dwRepairGold && usError == PktBase::NO_SERVER_ERR)
	{
		if (dwRepairGold > lpCharacter->GetGold())
		{
			usError = PktRpAI::NOT_ENOUGH_GOLD;
		}
	}
*/
	return GameClientSendPacket::SendCharRepairAllItem(GameClientDispatch.GetSendStream(), 
		lpCharacter->GetCID(), dwRepairGold, usError);
}

// ij½¬ ¾ÆÀÌÅÛ »ç¿ë
bool GameClientParsePacket::ParseCharUseCashItem(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktUI), GameClientDispatch);

	PktUI*      lpPktUI     = static_cast<PktUI*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	Item::ItemPos   itemPos = lpPktUI->m_itemPos;
	Item::CUseItem* lpUseItem = Item::CUseItem::DowncastToUseItem(lpCharacter->GetItem(itemPos));

	CCharacter* lpSender = CCreatureManager::GetInstance().GetCharacter(lpPktUI->m_dwSender);
	CCharacter* lpRecver = CCreatureManager::GetInstance().GetCharacter(lpPktUI->m_dwRecver);

	unsigned short usError = PktBase::NO_SERVER_ERR;

	if (NULL == lpUseItem || NULL == lpSender || NULL == lpRecver || 
		true == lpSender->GetEnchantInfo().GetFlag(Skill::SpellID::Stun) ||
		true == lpSender->GetEnchantInfo().GetFlag(Skill::SpellID::StoneForm) || 
		lpUseItem->GetItemInfo().m_UseItemInfo.m_cLimitRealmPoint > lpSender->GetRealmPoint() || 
		(true == lpUseItem->GetItemInfo().m_UseItemInfo.m_bForStatueWar && 
		!CGameTimeMgr::GetInstance().IsRealmWarTime()) ||
		(true == lpUseItem->GetItemInfo().m_UseItemInfo.m_bForStatueWar && 
		CGameTimeMgr::GetInstance().IsRealmWarTime() && lpSender->GetRealmWarFlag()==Creature::WAR_OFF))
	{
		GAMELOG::LogUseItem(*lpCharacter, itemPos, lpUseItem, PktUI::USE_FAILED);

		return GameClientSendPacket::SendCharUseCashItem(GameClientDispatch.GetSendStream(), 
			lpPktUI->m_dwSender, lpPktUI->m_dwRecver, itemPos, 0, PktUI::USE_FAILED);
	}

	// ¾ÆÀÌÅÛ »ç¿ë½Ã ½ÇÆÐÇÏ¸é ·Î±×¸¦ ³²±â°í ¿À·ù¸¦ ¸®ÅÏ
	if(!lpUseItem->UseCashItem(lpSender, lpRecver, itemPos, usError))
	{
		GAMELOG::LogUseItem(*lpCharacter, itemPos, lpUseItem, usError);

		// ¸®ÅϵǴ ¿¡·¯Áß Á×Àº ij¸¯ÅÍ°¡ ¾ÆÀÌÅÛÀ» »ç¿ëÇÏ·Á°í ÇÒ¶§ 
		// ¿¡·¯´Â 0Àε¥ false °¡ ¸®Åϵɼö°¡ ÀÖ´Ù. 
		// ÀÌ·¯¸é ³»±¸µµ°¡ 0À¸·Î ³¯¶ó°¡±â ¶§¹®¿¡ ¾ÆÀÌÅÛÀ» 0°³·Î È®ÀÎÇØ Áö¿ö¹ö¸°´Ù.
		unsigned char cRemainItemNum = lpUseItem->GetNumOrDurability();

		return GameClientSendPacket::SendCharUseCashItem(GameClientDispatch.GetSendStream(), 
			lpPktUI->m_dwSender, lpPktUI->m_dwRecver, itemPos, cRemainItemNum, usError);
	}

	return true;
}


// ¾ÆÀÌÅÛ »ç¿ë
bool GameClientParsePacket::ParseCharUseItem(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktUI), GameClientDispatch);

	PktUI*      lpPktUI     = static_cast<PktUI*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	Item::ItemPos   itemPos = lpPktUI->m_itemPos;
	Item::CUseItem* lpUseItem = Item::CUseItem::DowncastToUseItem(lpCharacter->GetItem(itemPos));

	CCharacter* lpSender = CCreatureManager::GetInstance().GetCharacter(lpPktUI->m_dwSender);
	CCharacter* lpRecver = CCreatureManager::GetInstance().GetCharacter(lpPktUI->m_dwRecver);

	unsigned short usError = PktBase::NO_SERVER_ERR;

	if (NULL == lpUseItem || NULL == lpSender || NULL == lpRecver || 
		true == lpSender->GetEnchantInfo().GetFlag(Skill::SpellID::Stun) ||
		true == lpSender->GetEnchantInfo().GetFlag(Skill::SpellID::StoneForm) || 
		lpUseItem->GetItemInfo().m_UseItemInfo.m_cLimitRealmPoint > lpSender->GetRealmPoint() || 
		(true == lpUseItem->GetItemInfo().m_UseItemInfo.m_bForStatueWar && 
		!CGameTimeMgr::GetInstance().IsRealmWarTime()) ||
		(true == lpUseItem->GetItemInfo().m_UseItemInfo.m_bForStatueWar && 
		CGameTimeMgr::GetInstance().IsRealmWarTime() && lpSender->GetRealmWarFlag()==Creature::WAR_OFF))
	{
		GAMELOG::LogUseItem(*lpCharacter, itemPos, lpUseItem, PktUI::USE_FAILED);

		return GameClientSendPacket::SendCharUseItem(GameClientDispatch.GetSendStream(), 
			lpPktUI->m_dwSender, lpPktUI->m_dwRecver, itemPos, 0, PktUI::USE_FAILED);
	}

	// ¾ÆÀÌÅÛ »ç¿ë½Ã ½ÇÆÐÇÏ¸é ·Î±×¸¦ ³²±â°í ¿À·ù¸¦ ¸®ÅÏ
	if(!lpUseItem->Use(lpSender, lpRecver, itemPos, usError))
	{
		GAMELOG::LogUseItem(*lpCharacter, itemPos, lpUseItem, usError);

		// ¸®ÅϵǴ ¿¡·¯Áß Á×Àº ij¸¯ÅÍ°¡ ¾ÆÀÌÅÛÀ» »ç¿ëÇÏ·Á°í ÇÒ¶§ 
		// ¿¡·¯´Â 0Àε¥ false °¡ ¸®Åϵɼö°¡ ÀÖ´Ù. 
		// ÀÌ·¯¸é ³»±¸µµ°¡ 0À¸·Î ³¯¶ó°¡±â ¶§¹®¿¡ ¾ÆÀÌÅÛÀ» 0°³·Î È®ÀÎÇØ Áö¿ö¹ö¸°´Ù.
		unsigned char cRemainItemNum = lpUseItem->GetNumOrDurability();

		return GameClientSendPacket::SendCharUseItem(GameClientDispatch.GetSendStream(), 
			lpPktUI->m_dwSender, lpPktUI->m_dwRecver, itemPos, cRemainItemNum, usError);
	}

	// ¾ÆÀÌÅÛ »ç¿ë ·Î±×¸¦ ³²±ä´Ù.
	GAMELOG::LogUseItem(*lpCharacter, itemPos, lpUseItem, usError);

	// ¾ÆÀÌÅÛ °¹¼ö°¡ 0°³ÀÌ¸é ¾ÆÀÌÅÛÀ» »èÁ¦ÇÑ´Ù.
	unsigned char cRemainItemNum = lpUseItem->GetNumOrDurability();
	if (0 == cRemainItemNum)
	{
		if (lpCharacter->RemoveItem(itemPos))
		{
			if (TakeType::TS_STALL == lpUseItem->GetRealPos().m_cPos)
			{
				lpCharacter->GetStall().RemoveItem(lpUseItem->GetRealPos());
			}
		}

		DELITEMLOG(DETLOG1(g_Log, "this:0X%08x ¾ÆÀÌÅÛÀ» »èÁ¦ÇÕ´Ï´Ù.", lpUseItem));	
		DELETE_ITEM(lpUseItem);
	}

	return GameClientSendPacket::SendCharUseItem(GameClientDispatch.GetSendStream(), 
		lpPktUI->m_dwSender, lpPktUI->m_dwRecver, itemPos, cRemainItemNum, usError);
}


// ¾ÆÀÌÅÛ °Å·¡
bool GameClientParsePacket::ParseCharTradeItem(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	/*	
	// 'TRC_BUY_EQUIP' ¸í·ÉÀÇ °æ¿ì °¡º¯±æÀÌ ¾ÆÀÌÅÛÀÌ ºÙÀ» ¼ö ÀÖÀ¸¹Ç·Î ÆÐŶ Å©±â °Ë»ç¸¦ ÇÏÁö ¾Ê½À´Ï´Ù.
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktTr), GameClientDispatch);
	*/

	PktTr* lpPktTr = static_cast<PktTr*>(lpPktBase);

	switch (lpPktTr->m_cCmd)
	{
	case PktTr::TRC_BUY_WITH_GOLD:
	case PktTr::TRC_BUY_WITH_MILEAGE:
	case PktTr::TRC_BUY_EQUIP:
	case PktTr::TRC_BUY_WITH_SKILL_COUPON:
		return ProcessItemBuy(GameClientDispatch, lpPktTr);

	case PktTr::TRC_SELL:
		return ProcessItemSell(GameClientDispatch, lpPktTr);
	}

	return false;
}

// NPC Àåºñ »óÁ¡ Á¤º¸
bool GameClientParsePacket::ParseCharEquipShopInfo(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktEquipShopInfo), GameClientDispatch);

	// Àåºñ»óÀÇ ±âȹÀÌ ¿ÏÀü ·£´ýÀ¸·Î º¯°æµÊ¿¡ µû¶ó ÀÌ ÆÐŶÀº »ç¿ëÇÏÁö ¾Ê½À´Ï´Ù. (2004-07-26 by ·Îµò)
	ERRLOG0(g_Log, "Ŭ¶óÀ̾ðÆ®°¡ ´õÀÌ»ó »ç¿ëÇÏÁö ¾Ê´Â Àåºñ»ó Á¤º¸ ¿äû ÆÐŶÀ» º¸³Â½À´Ï´Ù.");
	return true;

	/*
	PktEquipShopInfo*	lpPktEquipShopInfo	= static_cast<PktEquipShopInfo *>(lpPktBase);
	CCharacter*			lpCharacter			= GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned long 	dwCharID	= lpPktEquipShopInfo->m_dwCharID;
	unsigned long 	dwNPCID		= lpPktEquipShopInfo->m_dwNPCID;

	unsigned char 	cRace		= lpPktEquipShopInfo->m_cRace;
	unsigned char 	cTabPage	= lpPktEquipShopInfo->m_cTabPage;

	unsigned short	wError		= PktBase::NO_SERVER_ERR;

	unsigned short	aryItemID[UCHAR_MAX]	= { 0, };
	unsigned char	aryItemGrade[UCHAR_MAX]	= { 0, };

	CNPC* lpNPC = CCreatureManager::GetInstance().GetNPC(dwNPCID);
	unsigned char cNum = lpNPC->GetEquipShopInfo(cRace, cTabPage, aryItemID, aryItemGrade);
	unsigned long dwDisplayTime = lpNPC->GetDisplayTime();

	if (0 == cNum)
	{
	wError = PktBase::SERVER_ERROR;
	}

	return GameClientSendPacket::SendCharEquipShopInfo(GameClientDispatch.GetSendStream(), 
	dwCharID, dwNPCID, dwDisplayTime, cRace, cTabPage, cNum, aryItemID, aryItemGrade, wError);
	*/
}


// ¾ÆÀÌÅÛ Áý±â
bool GameClientParsePacket::ParseCharPickUp(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktPU), GameClientDispatch);

	PktPU*      lpPktPU     = static_cast<PktPU*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned long		dwCID	    = lpCharacter->GetCID();
	unsigned __int64	nObjectID	= lpPktPU->m_nObjectID;  
	Item::ItemPos		itemPos     = lpPktPU->m_itemPos;
	unsigned short		usError		= PktBase::NO_SERVER_ERR;

	return ProcessItemPickUp(GameClientDispatch, nObjectID, itemPos, usError);
}


// ¾ÆÀÌÅÛ ¶³±¸±â
bool GameClientParsePacket::ParseCharPullDown(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktPD), GameClientDispatch);

	PktPD*      lpPktPD     = static_cast<PktPD*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned long   dwCID       = lpPktPD->m_dwCharID;
	Item::ItemPos   itemPos     = lpPktPD->m_itemPos;    
	unsigned short  usError     = 0;
	unsigned char   cNum        = lpPktPD->m_cNum;

	CCell::ItemInfo itemInfo;

	if (TakeType::TS_DEPOSIT == itemPos.m_cPos || TakeType::TS_EXCHANGE == itemPos.m_cPos)
	{
		usError = PktPDAck::FAIL_DROP_FIELD; 
		ERRLOG3(g_Log, "CID:%10u â°í¿¡¼­ ¹Ù·Î ¶¥À¸·Î ¹ö¸± ¼ö ¾ø½À´Ï´Ù. (%2d,0x%04x)", 
			dwCID, itemPos.m_cPos, itemPos.m_cIndex);
	}
	else
	{
		// ¼¿ ¾ò±â
		CCell* lpCell = lpCharacter->GetCellPos().m_lpCell;
		if (NULL == lpCell) 
		{
			usError = PktPDAck::FAIL_GET_CELL; 
			ERRLOG1(g_Log, "CID:%10u ¼¿ ¾ò±â ½ÇÆÐ", dwCID);
		}
		else
		{
			// Àκ¥/Àåºñ ·ÎºÎÅÍ ¾ò±â
			Item::CItem* lpItem = lpCharacter->Drop(itemPos, cNum);
			if (NULL == lpItem) 
			{
				usError = PktPDAck::FAIL_DROP_INVEN;
				ERRLOG4(g_Log, "CID:%10u Àκ¥/Àåºñ·Î ºÎÅÍ ¶³±¸±â ½ÇÆÐ (%2d:0x%04x)(%2d)",
					dwCID, itemPos.m_cPos, itemPos.m_cIndex, cNum);		    
			}
			else
			{
				// ½ºÅà ¾ÆÀÌÅÛÀÌ ÀÌ»óÇÕ´Ï´Ù.(0°³)
				if (lpItem->IsSet(Item::DetailData::STACKABLE) && 0 == lpItem->GetNumOrDurability())
				{
					usError = PktPDAck::FAIL_ZERO_ITEM;

					DELETE_ITEM(lpItem);
				}
				else
				{
					// ¾ÆÀÌÅÛ Çʵ忡 ¶³±¸±â
					lpCell->SetItem(lpCharacter->GetCurrentPos(), lpItem, 0, dwCID, CCell::NONE, itemInfo);

					// Äù½ºÆ® Æ®¸®°Å üũ
					lpCharacter->CheckTrigger(Quest::TRIGGER_PUTON, lpItem->GetPrototypeID(), lpCharacter->GetCurrentPos(), 1);
				}
			}
		}
	}

	// ¾ÆÀÌÅÛ ¶³±¸±â º¸³¿
	GAMELOG::LogDropItem(*lpCharacter, itemPos, itemInfo.m_lpItem, 0, usError);
	return GameClientSendPacket::SendCharPullDown(GameClientDispatch.GetSendStream(),
		dwCID, itemPos, itemInfo, usError);        
}

// ¾ÆÀÌÅÛ ³ª´©±â
bool GameClientParsePacket::ParseCharSplitItem(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktSplt), GameClientDispatch);

	PktSplt*    lpPktSplt   = static_cast<PktSplt*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	TakeType        takeType    = lpPktSplt->m_TakeType;
	unsigned long   dwCID       = lpCharacter->GetCID();
	unsigned long   dwTakeMoney = 0;
	unsigned short  usError     = 0;

	Item::CItem* lpSrcItem = lpCharacter->GetItem(takeType.m_srcPos);
	Item::CItem* lpSplitItem = NULL;

	ERRLOG(
		const int   MAX_ERROR_BUFFER = 4096;
	char        szErrorBuffer[MAX_ERROR_BUFFER] = "";
	int         nLength = 0;
	);

	if (NULL == lpSrcItem)
	{
		usError = PktSpItAck::FAIL_SPLIT;
		ERRLOG(nLength = _snprintf(szErrorBuffer, MAX_ERROR_BUFFER, 
			"CID:%10u ¾ÆÀÌÅÛ ½ºÇø´ ½ÇÆÐ : (%d, %d) À§Ä¡¿¡¼­ ¾ÆÀÌÅÛÀ» ¾ò¾î¿Ã ¼ö ¾ø½À´Ï´Ù.",
			dwCID, takeType.m_srcPos.m_cPos, takeType.m_srcPos.m_cIndex));        
	}
	else
	{
		bool bTakeMoney = IsPutDeposit(lpSrcItem->GetRealPos().m_cPos, takeType.m_dstPos.m_cPos);

		if (bTakeMoney)
		{
			if (!lpCharacter->GetDeposit().IsLogin())
			{
				usError = PktTI::FAIL_MOVE;
				ERRLOG(nLength = _snprintf(szErrorBuffer, MAX_ERROR_BUFFER, 
					"CID:%10u â°í¿¡ ·Î±×ÀεÇÁö ¾ÊÀº »óÅ¿¡¼­ ¾ÆÀÌÅÛÀ» ³ª´©·Á ÇÏ¿´½À´Ï´Ù.", dwCID));
			}
			else
			{
				dwTakeMoney = PutDepositMoney(lpCharacter);
				if (lpCharacter->GetGold() < dwTakeMoney)
				{
					usError = PktSpItAck::FAIL_SPLIT;
					ERRLOG(nLength = _snprintf(szErrorBuffer, MAX_ERROR_BUFFER, 
						"CID:%10u â°í¿¡ ¹°°ÇÀ» ¸Ã±â±â¿¡ µ·ÀÌ ºÎÁ·ÇÕ´Ï´Ù.", dwCID));
				}
			}
		}

		if (0 == usError)
		{
			if (!lpSrcItem->IsSet(Item::DetailData::STACKABLE)) 
			{
				usError = PktSpItAck::FAIL_SPLIT;
				ERRLOG(nLength = _snprintf(szErrorBuffer, MAX_ERROR_BUFFER, 
					"CID:%10u ¾ÆÀÌÅÛ ½ºÇø´ ½ÇÆÐ : ³ª´­ ¼ö ¾ø´Â ¾ÆÀÌÅÛ(½ºÅà ºÒ°¡)ÀÔ´Ï´Ù. Á¾·ù ID : %d",
					dwCID, lpSrcItem->GetPrototypeID()));		    

			}
			else if (lpSrcItem->GetNumOrDurability() <= takeType.m_cNum)
			{
				usError = PktSpItAck::FAIL_SPLIT;
				ERRLOG(nLength = _snprintf(szErrorBuffer, MAX_ERROR_BUFFER, 
					"CID:%10u ¾ÆÀÌÅÛ ½ºÇø´ ½ÇÆÐ : Source¿¡ ÀÖ´Â ¾ÆÀÌÅÛÀÇ °³¼ö°¡ ³ª´©·Á°í ÇÏ´Â ¾ÆÀÌÅÛÀÇ °³¼öº¸´Ù À۰ųª °°½À´Ï´Ù."
					"SourceÀÇ ÇöÀç ¾ÆÀÌÅÛ °³¼ö %d, ³ª´©·Á°í ÇÏ´Â ¾ÆÀÌÅÛÀÇ °³¼ö %d",
					dwCID, lpSrcItem->GetNumOrDurability(), takeType.m_cNum));		        
			}
			else
			{
				// ¾ÆÀÌÅÛ »ý¼ºÇÔ.
				lpSplitItem = Item::CItemFactory::GetInstance().CreateItem(lpSrcItem->GetItemInfo());

				if (NULL == lpSplitItem) 
				{
					usError = PktSpItAck::FAIL_SPLIT;
					ERRLOG(nLength = _snprintf(szErrorBuffer, MAX_ERROR_BUFFER, 
						"CID:%10u ¾ÆÀÌÅÛ ½ºÇø´ ½ÇÆÐ : ¾ÆÀÌÅÛÀ» »ý¼ºÇÒ ¼ö ¾ø½À´Ï´Ù.", dwCID));
				}
				else
				{
					lpSplitItem->SetNumOrDurability(takeType.m_cNum);

					// ¾ÆÀÌÅÛ ³õ±â
					if (!lpCharacter->SetItem(takeType.m_dstPos, lpSplitItem)) 
					{
						usError = PktSpItAck::FAIL_SPLIT;
						ERRLOG(nLength = _snprintf(szErrorBuffer, MAX_ERROR_BUFFER, 
							"CID:%10u ¾ÆÀÌÅÛ ½ºÇø´ ½ÇÆÐ : (%d, %d)ÂÉ°³¼­ ³»·Á³õ°íÀÚ ÇÏ´Â ÀÚ¸®¿¡, ¾ÆÀÌÅÛÀ» ³»·Á ³õÀ» ¼ö ¾ø½À´Ï´Ù.",
							dwCID, takeType.m_dstPos.m_cPos, takeType.m_dstPos.m_cIndex));

						DELETE_ITEM(lpSplitItem);
					}
					else 
					{
						// ÃÖÁ¾ ¼º°ø
						lpSrcItem->SetNumOrDurability(lpSrcItem->GetNumOrDurability() - takeType.m_cNum);

						if (bTakeMoney)
						{
							unsigned long dwLastGold = lpCharacter->GetGold();
							lpCharacter->DeductGold(dwTakeMoney, false);
							GAMELOG::LogTakeGold(*lpCharacter, dwLastGold, lpCharacter->GetGold(), dwTakeMoney,
								TakeType::TS_INVEN, TakeType::TS_INVEN, GAMELOG::sTakeGoldLogV2::STORE_USE, 0);
						}
					}
				}                
			}
		}
	}

	ERRLOG(if (0 < nLength) { ERRLOG0(g_Log, szErrorBuffer); });

	// ¾ÆÀÌÅÛ ½ºÇø´ ·Î±× ³²±â±â
	GAMELOG::LogSplitItem(*lpCharacter, takeType, lpSrcItem, lpSplitItem, usError);
	return GameClientSendPacket::SendCharSplitItem(GameClientDispatch.GetSendStream(), 
		dwCID, lpSplitItem, takeType, usError);
}


// µ· ´Ù·ç±â
bool GameClientParsePacket::ParseCharTakeGold(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktTG), GameClientDispatch);

	PktTG*      lpPktTG     = static_cast<PktTG*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned long   dwCID   = lpCharacter->GetCID();
	unsigned long   dwGold  = lpPktTG->m_dwGold;
	unsigned short  usError = 0;
	unsigned char   cSrcPos = lpPktTG->m_cSrcPos;
	unsigned char   cDstPos = lpPktTG->m_cDstPos;

	if ((cSrcPos == TakeType::TS_DEPOSIT || cDstPos == TakeType::TS_DEPOSIT) &&
		!lpCharacter->GetDeposit().IsLogin())
	{
		ERRLOG3(g_Log, "CID:%10u µ· À̵¿ ½ÇÆÐ. â°í¿¡ ·Î±×ÀÎ ¾ÊÀº »óÅÂÀÔ´Ï´Ù. (%2d,%2d)",
			dwCID, cSrcPos, cDstPos);            
		usError = PktTG::FAIL_MOVE;
	}
	else if (!lpCharacter->MoveGold(dwGold, cSrcPos, cDstPos, usError)) 
	{
		// ¿¡·¯ ÄÚµå´Â ¾È¿¡¼­ SetÇÔ.
		ERRLOG6(g_Log, "CID:%10u µ· À̵¿ ½ÇÆÐ. (Pos/Gold) Src:(%d/%d), Dst:(%d/%d), À̵¿ ±Ý¾×:%d", 
			dwCID, cSrcPos, lpCharacter->GetGold(cSrcPos), cDstPos, lpCharacter->GetGold(cDstPos), dwGold);		
	}

	GAMELOG::LogTakeGold(*lpCharacter, lpCharacter->GetGold(cSrcPos), lpCharacter->GetGold(cDstPos), 
		dwGold, cSrcPos, cDstPos, GAMELOG::sTakeGoldLogV2::MOVE_GOLD, usError);

	return GameClientSendPacket::SendCharTakeGold(GameClientDispatch.GetSendStream(),
		dwCID, dwGold, cSrcPos, cDstPos, usError);
}


bool GameClientParsePacket::ParseCharDepositCmd(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktDeposit), GameClientDispatch);

	PktDeposit* lpPktDeposit    = static_cast<PktDeposit*>(lpPktBase);
	CCharacter* lpCharacter     = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	Item::CDepositContainer& Deposit = lpCharacter->GetDeposit();
	unsigned long   dwCID   = lpCharacter->GetCID();
	char*           szData  = lpPktDeposit->m_szData;
	unsigned short  usError = 0;


	switch(lpPktDeposit->m_cCmd)
	{
	case PktDeposit::LOGIN:

		if (!Deposit.Login(szData, Deposit::PASSWORD_LENGTH, szData[Deposit::PASSWORD_LENGTH]))
		{
			usError = PktDeposit::AUTH_FAILED;
		}
		break;

	case PktDeposit::BUY_TAB:

		{
			const unsigned int  MAX_TAB = 4;
			const unsigned long dwTabBuyPrice[MAX_TAB] = { 0, 100000, 1000000, 5000000 };
			const unsigned long dwLastGold = lpCharacter->GetGold();

			const unsigned char cTabNum = szData[0];

			if (MAX_TAB <= cTabNum)
			{
				usError = PktDeposit::INVALID_ARGUMENT;
				ERRLOG2(g_Log, "CID:%10u ÅÇ ¹øÈ£°¡ ÀÌ»óÇÕ´Ï´Ù. TabNum:%d", dwCID, cTabNum);
			}
			else if (dwLastGold < dwTabBuyPrice[cTabNum])
			{
				usError = PktDeposit::INSUFFICIENT_MONEY;
				ERRLOG3(g_Log, "CID:%10u µ·ÀÌ ºÎÁ·ÇÕ´Ï´Ù. CurrentGold:%d, TabBuyPrice:%d",
					dwCID, dwLastGold, dwTabBuyPrice[cTabNum]);
			}
			else if (!Deposit.BuyTab(cTabNum))
			{
				usError = PktDeposit::INVALID_ARGUMENT;
				ERRLOG2(g_Log, "CID:%10u ÅÇ ¹øÈ£°¡ ÀÌ»óÇÕ´Ï´Ù. TabNum:%d", dwCID, cTabNum);
			}
			else
			{                
				lpCharacter->DeductGold(dwTabBuyPrice[cTabNum], false);
				GAMELOG::LogTakeGold(*lpCharacter, dwLastGold, lpCharacter->GetGold(), dwTabBuyPrice[cTabNum],
					TakeType::TS_DEPOSIT, TakeType::TS_DEPOSIT, GAMELOG::sTakeGoldLogV2::BUY_STORE_TAB, 0);
			}

		} break;

	case PktDeposit::LOGOUT:

		if (!Deposit.IsLogin())
		{
			usError = PktDeposit::SERVER_ERROR;
		}
		else
		{
			lpCharacter->DBUpdateForce(DBUpdateData::UPDATE);
			Deposit.Logout();
		}
		break;

	case PktDeposit::CHANGE_PASS:

		// Æнº¿öµå ¹Ù²Þ.
		if (Deposit.ChangePassword(szData, Deposit::PASSWORD_LENGTH, 
			szData + Deposit::PASSWORD_LENGTH, Deposit::PASSWORD_LENGTH))
		{
			GET_SINGLE_DISPATCH(lpDBAgentDispatch, 
				CDBAgentDispatch, CDBAgentDispatch::GetDispatchTable());

			if (0 != lpDBAgentDispatch)
			{
				if (!GameClientSendPacket::SendCharDepositPasswordToDBAgent(lpDBAgentDispatch->GetSendStream(), 
					GameClientDispatch.GetUID(), szData + Deposit::PASSWORD_LENGTH, Deposit::PASSWORD_LENGTH))
				{
					usError = PktDeposit::SERVER_ERROR;
					ERRLOG1(g_Log, "CID:%10u DBAgent¿¡ â°í ¾ÏÈ£¸¦ ÀúÀåÇÒ ¼ö ¾ø½À´Ï´Ù.", dwCID);
				}                
			}
			else
			{
				usError = PktDeposit::SERVER_ERROR;
				ERRLOG1(g_Log, "CID:%10u DBAgent¼¼¼ÇÀ» ¾òÀ» ¼ö ¾ø½À´Ï´Ù.", dwCID);
			}
		}
		else
		{
			usError = PktDeposit::AUTH_FAILED;
			ERRLOG1(g_Log, "CID:%10u â°í ¾ÏÈ£¸¦ ¹Ù²Ü ¼ö ¾ø½À´Ï´Ù. ¾ÏÈ£°¡ ´Ù¸¨´Ï´Ù.", dwCID);
		}
		break;
	};

	return GameClientSendPacket::SendCharDepositCmd(GameClientDispatch.GetSendStream(), lpPktDeposit->m_cCmd, 0, 0, usError);
}


// ¿ÀÅä ·çÆÃ
bool GameClientParsePacket::ParseCharAutoRouting(CGameClientDispatch& GameClientDispatch, PktBase* lpPktBase)
{
	CHECK_FIXED_PACKETSIZE(lpPktBase, sizeof(PktAutoRouting), GameClientDispatch);

	PktAutoRouting* lpPktAR = static_cast<PktAutoRouting*>(lpPktBase);
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();

	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktBase->GetCmd());

	unsigned __int64    nObjectID = lpPktAR->m_nObjectID;
	unsigned long       dwCID   = lpPktAR->m_dwCharID;

	unsigned short      wItemID = lpPktAR->m_wItemID;
	Item::ItemPos       itemPos = lpPktAR->m_itemPos;

	unsigned short      usError = PktBase::NO_SERVER_ERR;
	unsigned char       cCmd    = lpPktAR->m_cCmd;

	if (PktAutoRouting::ARC_POSSIBLE == cCmd)
	{
		const bool bResult = ProcessItemPickUp(GameClientDispatch, nObjectID, itemPos, usError);
		if (false == bResult || PktBase::NO_SERVER_ERR != usError)
		{
			cCmd = PktAutoRouting::ARC_IMPOSSIBLE;
		}
	}

	CCharacterParty* lpParty = reinterpret_cast<CCharacterParty* >(lpCharacter->GetParty());
	if (NULL != lpParty)
	{
		lpParty->SendAutoRouting(dwCID, wItemID, cCmd);
		return true;
	}

	return true;
}



bool GameClientParsePacket::ProcessItemSell(CGameClientDispatch& GameClientDispatch, PktTr* lpPktTr)
{
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();
	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktTr->GetCmd());

	unsigned long   dwGold      = 0;
	unsigned long   dwCID       = lpPktTr->m_dwCustomerID;
	unsigned long   dwNPCID     = lpPktTr->m_dwOwnerID;

	unsigned short  usError     = 0;
	Item::ItemPos   itemPos     = lpPktTr->m_TakeType.m_srcPos;
	unsigned char   cNum        = lpPktTr->m_TakeType.m_cNum;

	Item::CItem*    lpItem      = lpCharacter->GetItem(itemPos);
	bool            bEraseItem  = false;

	if (NULL != lpItem)
	{
		bool bStackable = lpItem->IsSet(Item::DetailData::STACKABLE);
		unsigned char cNumOrDurability = lpItem->GetNumOrDurability();

		// ½ºÅà °¡´ÉÇÑ ¾ÆÀÌÅÛÀÎ °æ¿ì, °³¼öÁ¦ÇÑ È®ÀÎ
		if (!(bStackable && (cNumOrDurability < cNum)))
		{
			// ½ºÅÃÀÌ ºÒ°¡´ÉÇϰųª, ÀüºÎ ÆÄ´Â °æ¿ì¿¡´Â ¾ÆÀÌÅÛ Á¦°Å
			if (!bStackable || (bStackable && (cNum == lpItem->GetNumOrDurability())))
			{
				bEraseItem = true;
			}

			dwGold = lpItem->GetSellPrice(false) * (bStackable ? cNum : 1);
			const unsigned long dwOriginalGold = dwGold;

			// ±æµå ¿ä»õ »óÁ¡¿¡ ÆǸÅÇÏ´Â °æ¿ì ¼¼À²ÀÌ Àû¿ëµÈ´Ù.
			if (Creature::CT_SIEGE_OBJECT == Creature::GetCreatureType(dwNPCID))
			{
				CCampShop* lpCampShop = reinterpret_cast<CCampShop*>(CCreatureManager::GetInstance().GetSiegeObject(dwNPCID));
				if (NULL != lpCampShop)
				{
					unsigned long dwTax = static_cast<unsigned long>(dwOriginalGold * (lpCampShop->GetTax() / 100.0f));
					dwGold -= dwTax;

					// CASTLE_TODO : ¼ºÀÌ ±æµå ¼ÒÀ¯°¡ ¾Æ´Ï¹Ç·Î ¸·¾ÆµÐ´Ù.
/*
					// edith ¼¼±Ý ºÎºÐ Ãß°¡ (ÁÖ¼®Ã³¸® »°À½)
					// ±æµå ¿ä»õ°¡ ¼ºÀÇ Ãູ ¿µ¿ª¿¡ µé¾îÀÖ´Ù¸é, Ãູ º¸³Ê½º¿Í ¼¼±Ý 󸮸¦ ÇÑ´Ù.
					Castle::CCastle* lpCastle = Castle::CCastleMgr::GetInstance().GetCastleInBlessArea(lpCampShop->GetPosition());
					if (NULL != lpCastle && 0 != lpCastle->GetGID())
					{
						Guild::CGuild* lpGuild = Guild::CGuildMgr::GetInstance().GetGuild( lpCampShop->GetGID() );
						if (NULL != lpGuild && false == lpGuild->IsEnemyGuild(lpCastle->GetGID()))
						{
							unsigned char cBlessBonus = Castle::CCastleBlessMgr::GetInstance().GetBonusPercent(
								lpCastle->GetTotalGainTaxCount(), lpCastle->GetUpgradeStep());

							// ¼ºÀÇ Ãູ º¸³Ê½º ¸¸Å­ ´õ ÇØÁØ´Ù.
							unsigned long dwBlessBonusTax = static_cast<unsigned long>(dwOriginalGold * (cBlessBonus / 100.0f));
							dwTax += dwBlessBonusTax;

							// ¼º¿¡ ±æµå ¿ä»õ Gold ¼¼±ÝÀ» ³½´Ù.
							unsigned long dwCastleTax = static_cast<unsigned long>(dwOriginalGold * (lpCastle->GetTax(Castle::CAMP_GOLD_TAX) / 100.0f));
							dwCastleTax = std::min(dwCastleTax, dwTax);
							
							if (dwCastleTax > 0)
							{
								lpCastle->AddTempTaxMoney(Castle::CAMP_GOLD_TAX, dwCastleTax);
								dwTax -= dwCastleTax;
							}
						}
					}
					//
*/
					lpCampShop->AddGold(dwTax);
				}
			}
			// ¼º¿¡ ¼ÓÇÑ NPC ¶ó¸é °Å·¡ ¼¼À² Àû¿ë
			else if (Creature::CT_NPC == Creature::GetCreatureType(dwNPCID))
			{
				CNPC* lpNPC = CCreatureManager::GetInstance().GetNPC(dwNPCID);
				if (NULL != lpNPC && lpNPC->IsBelongToCastle())
				{
					Castle::CCastle* lpCastle = Castle::CCastleMgr::GetInstance().GetCastleByNameID(lpNPC->GetCastleNameID());
					if (lpCastle)
					{
						const unsigned long dwTradeTax = static_cast<unsigned long>(dwOriginalGold * (lpCastle->GetTax(Castle::TRADE_TAX) / 100.0f));

						if (dwTradeTax > 0)
						{
							lpCastle->AddTempTaxMoney(Castle::TRADE_TAX, dwTradeTax);
							dwGold -= dwTradeTax;
						}
					}
				}
			}

			// edith 2010.01.02 ±æµå Àû¸³±Ý º¸³Ê½º 󸮷çƾ. ¿ì¼± ¸Å¹ø µ·À» ³Ö°í. È®ÀÎÇÑ´Ù.
			CGuild* lpGuild = Guild::CGuildMgr::GetInstance().GetGuild(lpCharacter->GetGID());
			if (0 != lpGuild)
			{
				float fD = lpGuild->GetGuildBonus(lpCharacter->GetRealmPoint(), 2.0f);

				unsigned long dwGuildGold = lpGuild->GetGuildMiles() + (int)(dwGold * fD);
				// ±æµå¿¡ ±ÝÈ­¸¦ Àû¸³ÇÑ´Ù. ÇöÀç ·ÎÁ÷ ÀÛ¾÷ ¾ÈµÊ.

				if(dwGuildGold >= 100000 && lpCharacter->GetGuildSafe() == -1 && lpGuild->GetGuildSafe() == -1)
				{
					unsigned short wError	= PktBase::NO_SERVER_ERR;

					// dwCharGold : ÆÐŶÀ» º¸³½ ´ë»óÀÇ µ·
					// dwGold : Ŭ¶óÀ̾ðÆ®°¡ º¸³»¿Â ±Ý¾×
					lpCharacter->SetGuildSafe(PktGuildSafe::SC_DEPOSIT);
					lpGuild->SetGuildSafe(PktGuildSafe::SC_DEPOSIT);

					// Á¤»ó ó¸®
					GET_SINGLE_DISPATCH(lpDBAgentDispatch, 
						CDBAgentDispatch, CDBAgentDispatch::GetDispatchTable());

					if (0 != lpDBAgentDispatch)				
					{
						GameClientSendPacket::SendCharGuildSafe(lpDBAgentDispatch->GetSendStream(), 
							lpCharacter->GetCID(), lpGuild->GetGID(), 0, dwGuildGold, PktGuildSafe::SC_BONUS, 
							"GuildMiles", wError);

						lpGuild->SetGuildMiles(0); 
					}
				}
				else 
					lpGuild->SetGuildMiles(dwGuildGold);

			}

			float fd = lpCharacter->GetAbilityValue(Skill::Type::AB_SHOP_MEMBERSHIP)/100.0f;
			dwGold += static_cast<unsigned long>((float)dwGold*fd);

			lpCharacter->AddGold(dwGold, false);

			lpItem->SetNumOrDurability(cNumOrDurability - cNum);
		}
		else
		{
			usError = PktTr::FAIL_DROP_INVEN;
			ERRLOG5(g_Log, "CID:%10u (%2d, 0x%04x)ÀÇ ¾ÆÀÌÅÛ °³¼ö : %d°³ ÆÈ·Á´Â ¾ÆÀÌÅÛ °³¼ö : %d°³", 
				dwCID, itemPos.m_cPos, itemPos.m_cIndex, cNumOrDurability, cNum);
		}
	}
	else
	{
		usError = PktTr::FAIL_DROP_INVEN;
		ERRLOG3(g_Log, "CID:%10u ¾ÆÀÌÅÛÀÌ (%2d, 0x%04x)¿¡ ¾ø½À´Ï´Ù", dwCID, itemPos.m_cPos, itemPos.m_cIndex);            
	}

	// °Å·¡ ¾ÆÀÌÅÛ º¸³»±â ( Æȱâ )
	GAMELOG::LogTradeItem(*lpCharacter, dwNPCID, dwGold, lpItem, itemPos, PktTr::TRC_SELL, usError);

	if (true == bEraseItem)
	{
		if (true == lpCharacter->RemoveItem(itemPos))
		{
			DELITEMLOG(DETLOG2(g_Log, "this:0X%08x CID:%10uÀÇ ¾ÆÀÌÅÛÀ» »èÁ¦ÇÕ´Ï´Ù.", lpItem, m_dwCID));

			DELETE_ITEM(lpItem);
		}
		else
		{
			ERRLOG3(g_Log, "CID:%10u ¾ÆÀÌÅÛÀ» (%2d, 0x%04x)À§Ä¡·ÎºÎÅÍ Áö¿ì´Â µ¥ ½ÇÆÐÇß½À´Ï´Ù.", 
				dwCID, itemPos.m_cPos, itemPos.m_cIndex);
		}
	}

	return GameClientSendPacket::SendCharTradeItem(GameClientDispatch.GetSendStream(), lpCharacter, 
		dwNPCID, Item::ItemPos(), NULL, itemPos, cNum, usError);
}


bool GameClientParsePacket::ProcessItemBuy(CGameClientDispatch& GameClientDispatch, PktTr* lpPktTr)
{
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();
	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, lpPktTr->GetCmd());

	unsigned long   dwCustomerID	= lpPktTr->m_dwCustomerID;
	unsigned long   dwOwnerID		= lpPktTr->m_dwOwnerID;

	unsigned char	cCmd			= lpPktTr->m_cCmd;

	unsigned short	wBuyItemID		= lpPktTr->m_wBuyItemID;
	TakeType		takeType		= lpPktTr->m_TakeType;

	Item::ItemPos	CouponPos		= lpPktTr->m_CouponPos;

	Item::CItem*	lpCoupon		= NULL;
	unsigned short	wCouponID		= 0;

	unsigned long   dwPrice			= 0;
	unsigned short  usError     	= 0;

	Item::ItemPos	itemPos;

	Item::CItem*    lpItem			= NULL;
	CCreature*		lpCreature		= CCreatureManager::GetInstance().GetCreature(dwOwnerID);

	if (NULL != lpCreature)
	{  
		// ±æµåÀü ½Ã°£¿¡ Àý´ë ±æµå ¿ä»õ »óÁ¡¿¡ ÀÖ´Â ¾ÆÀÌÅÛÀº ±¸¸ÅÇÒ¼ö ¾ø´Ù.
		if (CGameTimeMgr::GetInstance().IsGuildWarTime())
		{
			if(lpCharacter->GetGID()!=lpCreature->GetGID())
			{
				if(lpCharacter->GetGID() && lpCreature->GetGID())
				{
					Guild::CGuild* lpGuild = Guild::CGuildMgr::GetInstance().GetGuild(lpCharacter->GetGID());						

					if(lpGuild)
					{							
						if (lpGuild->IsEnemyGuild(lpCreature->GetGID()))
						{
							// Àû´ë ±æµå ¿ä»õ »óÁ¡.
							usError = PktTr::FAIL_ENEMY_ITEM;
							goto SEND_PACKET;
						}
					}
				}
			}				
		}

		// ·£´ý ¿É¼ÇÀÌ ºÙÀº Àåºñ ±¸ÀÔ
		if (PktTr::TRC_BUY_EQUIP == cCmd)
		{
			if (0 == lpPktTr->m_wSize)
			{
				ERRLOG2(g_Log, "CID:%10u ÆǸÅÀÚID:0x%08x ¾ÆÀÌÅÛ Á¤º¸¸¦ º¸³»Áö ¾Ê°í ¿É¼ÇÀÌ ´Þ¸° Àåºñ¸¦ ±¸¸ÅÇÏ·Á ÇÕ´Ï´Ù.", 
					dwCustomerID, dwOwnerID);

				usError = PktTr::FAIL_ITEM_BUY;
				goto SEND_PACKET;
			}
			else
			{
				Item::CItemFactory& itemFactory = Item::CItemFactory::GetInstance();

				size_t nItemSize = lpPktTr->m_wSize;
				lpItem = itemFactory.CreateItem(reinterpret_cast<char *>(lpPktTr + 1), nItemSize);

				Item::CEquipment* lpEquip = Item::CEquipment::DowncastToEquipment(lpItem);
				if (NULL != lpEquip)
				{
					lpEquip->SetUID(itemFactory.GetNewItemUID());
					lpEquip->SetNewEquip();
				}

				// ÀÌÈÄ¿£ µ·À¸·Î ±¸ÀÔÇÏ´Â °Í°ú µ¿ÀÏ
				cCmd = PktTr::TRC_BUY_WITH_GOLD;
			}
		}

		// »óÀ§ Æ®·¹À̳ʿ¡°Ô ÄíÆùÀ¸·Î ½ºÅ³ºÏ ±¸ÀÔ
		if (PktTr::TRC_BUY_WITH_SKILL_COUPON == cCmd)
		{
			// ½ºÅ³ºÏ ÄíÆù
			lpCoupon = lpCharacter->GetItem(CouponPos);
			if (NULL == lpCoupon)
			{
				ERRLOG3(g_Log, "CID:%10u ¾ÆÀÌÅÛ ±¸ÀÔ ½ÇÆÐ : ¿äûÇÑ À§Ä¡¿¡ ½ºÅ³ºÏ ÄíÆùÀÌ ¾ø½À´Ï´Ù. Pos:%d, Index:%d", 
					lpCharacter->GetCID(), CouponPos.m_cPos, CouponPos.m_cIndex);

				usError = PktTr::FAIL_ITEM_BUY;
				goto SEND_PACKET;
			}

			wCouponID = lpCoupon->GetPrototypeID();
		}

		// ÇöÀç ¼ÒÁö±Ý°ú, ¾ÆÀÌÅÛ Á¾·ù, °³¼ö¸¦ ¹Þ¾Æ¼­ ¾ÆÀÌÅÛ »ý¼º
		lpItem = lpCreature->SellToCharacter(lpCharacter, wBuyItemID, takeType, lpItem, dwPrice, wCouponID, usError);
		if(0 != usError)
		{
			ERRLOG1(g_Log, "CID:%10u ¾ÆÀÌÅÛ ±¸ÀÔ ½ÇÆÐ : ÇØÅ· ÀÇ½É ÆÐŶ.", lpCharacter->GetCID());

			// ±¸¸Å¿¡ ½ÇÆÐÇÏ¿´À¸¹Ç·Î -1 ¼­¹ö¿¡·¯¸¦ º¸³½´Ù.
			GameClientSendPacket::SendCharTradeItem(GameClientDispatch.GetSendStream(), lpCharacter, dwOwnerID, CouponPos, 
				lpItem, itemPos, takeType.m_cNum, 1);

			// °­Á¦·Î ·Î±×¾Æ¿ô ½ÃŲ´Ù.
			GameClientDispatch.Disconnect();
			GameClientDispatch.Disconnected();
			return true;
		}

		if (NULL != lpItem)
		{
			Item::CInventoryContainer* lpInvenContainer = 
				reinterpret_cast<Item::CInventoryContainer*>(lpCharacter->GetItemContainer(TakeType::TS_INVEN));
			if (NULL == lpInvenContainer)
			{
				ERRLOG1(g_Log, "CID:%10u ¾ÆÀÌÅÛ ±¸ÀÔ ½ÇÆÐ : Àκ¥Å丮 ÄÁÅ×À̳ʸ¦ ¾òÀ» ¼ö ¾ø½À´Ï´Ù.", lpCharacter->GetCID());

				usError = PktTr::FAIL_ITEM_BUY;
				goto SEND_PACKET;
			}			

			Item::CItem* lpPrevItem = NULL;
			itemPos = lpInvenContainer->GetBlankPos(lpItem->GetPrototypeID(), takeType.m_cNum, false, &lpPrevItem);
			if (TakeType::TS_INVEN == itemPos.m_cPos)
			{
				bool bResult = true;

				switch (cCmd)
				{
				case PktTr::TRC_BUY_WITH_GOLD:
					if(!lpCharacter->DeductGold(dwPrice, false))
					{
						bResult = false;
						dwPrice = 0;
						usError = PktTr::FAIL_ITEM_BUY;
						goto SEND_PACKET;
					}
					break;

				case PktTr::TRC_BUY_WITH_MILEAGE:
					if(!lpCharacter->DeductMileage(dwPrice, false))
					{
						bResult = false;
						dwPrice = 0;
						usError = PktTr::FAIL_ITEM_BUY;
						goto SEND_PACKET;
					}
					break;

				case PktTr::TRC_BUY_WITH_SKILL_COUPON:
					{
						if (takeType.m_cNum <= lpCoupon->GetNumOrDurability())
						{
							lpCoupon->SetNumOrDurability(lpCoupon->GetNumOrDurability() - takeType.m_cNum);
						}
						else
						{
							ERRLOG3(g_Log, "CID:%10u ¾ÆÀÌÅÛ ±¸ÀÔ ½ÇÆÐ : ½ºÅ³ºÏ ÄíÆùÀÇ °¹¼ö°¡ ÀÌ»óÇÕ´Ï´Ù. Pos:%d, Index:%d", 
								lpCharacter->GetCID(), CouponPos.m_cPos, CouponPos.m_cIndex);

							DELITEMLOG(ERRLOG2(g_Log, "this:0X%08x CID:%10u ÀÇ ¾ÆÀÌÅÛÀ» »èÁ¦ÇÕ´Ï´Ù.", lpItem, dwCustomerID));

							DELETE_ITEM(lpItem);				

							bResult = false;
							dwPrice = 0;
							usError = PktTr::FAIL_ITEM_BUY;
							goto SEND_PACKET;
						}

						if (0 == lpCoupon->GetNumOrDurability())
						{
							if (lpCharacter->RemoveItem(CouponPos))
							{
								DELETE_ITEM(lpCoupon);
							}
							else
							{
								ERRLOG3(g_Log, "CID:%10u ¾ÆÀÌÅÛ ±¸ÀÔ ½ÇÆÐ : ½ºÅ³ºÏ ÄíÆùÀ» Á¦°ÅÇÒ ¼ö ¾ø½À´Ï´Ù. Pos:%d, Index:%d", 
									lpCharacter->GetCID(), CouponPos.m_cPos, CouponPos.m_cIndex);
								bResult = false;
								break;
							}
						}
						break;
					}

				default:
					ERRLOG2(g_Log, "CID:%10u ¾ÆÀÌÅÛ »ç±âÀÇ ¸í·ÉÀÌ ÀÌ»óÇÕ´Ï´Ù. Cmd:%d", lpCharacter->GetCID(), cCmd);
					bResult = false;
					break;
				}

				if (true == bResult)
				{
					bResult = lpCharacter->SetItem(itemPos, lpItem);
				}

				if (false == bResult)
				{
					lpInvenContainer->DumpItemInfo();

					ERRLOG4(g_Log, "CID:%10u ¾ÆÀÌÅÛ Á¾·ù:%d¸¦ (%2d:%2d)¿¡ ¾ÆÀÌÅÛ ³Ö±â ½ÇÆÐ.", 
						dwCustomerID, wBuyItemID, itemPos.m_cPos, itemPos.m_cIndex);

					DELITEMLOG(ERRLOG2(g_Log, "this:0X%08x CID:%10u ÀÇ ¾ÆÀÌÅÛÀ» »èÁ¦ÇÕ´Ï´Ù.", lpItem, dwCustomerID));

					DELETE_ITEM(lpItem);				

					dwPrice = 0;
					usError = PktTr::FAIL_PUT_INVEN;
				}
			}
			else
			{
				// ÃæºÐÈ÷ ¹ß»ýÇÒ ¼ö ÀÖ´Â »óȲÀ¸·Î ·Î±×¸¦ ÂïÀ» ÇÊ¿ä´Â ¾ø´Ù.
				usError = PktTr::FAIL_FULL_INVEN;
			}
		}
		else
		{
			if (Creature::CT_PC == Creature::GetCreatureType(lpCreature->GetCID()) &&
				reinterpret_cast<CCharacter*>(lpCreature)->GetGold() > ULONG_MAX - dwPrice)
			{
				usError = PktTr::FAIL_GOLD_OVERFLOW;
			}
			else
			{
				usError = PktTr::FAIL_ITEM_BUY;
				ERRLOG2(g_Log, "CID:%10u ÆǸÅÀÚID:0x%08x NPC¶Ç´Â ³ëÁ¡»óÀÌ ¾ÆÀÌÅÛÀ» ÆǸÅÇÒ ¼ö ¾ø½À´Ï´Ù.", 
					dwCustomerID, dwOwnerID);
			}
		}
	}
	else
	{
		usError = PktTr::FAIL_WRONG_NPC;
		ERRLOG2(g_Log, "CID:%10u Á¸ÀçÇÏÁö ¾ÊÀº »óÀÎÀÔ´Ï´Ù. »ç±â ½ÇÆÐ. CID:%10u", dwCustomerID, dwOwnerID);   
	}

SEND_PACKET:

	GAMELOG::LogTradeItem(*lpCharacter, dwOwnerID, dwPrice, lpItem, itemPos, cCmd, usError);
	return GameClientSendPacket::SendCharTradeItem(GameClientDispatch.GetSendStream(), lpCharacter, dwOwnerID, CouponPos, 
		lpItem, itemPos, takeType.m_cNum, usError);
}



bool GameClientParsePacket::ProcessItemPickUp(CGameClientDispatch& GameClientDispatch, 
											  unsigned __int64 nObjectID, Item::ItemPos itemPos, unsigned short& usError)
{
	CCharacter* lpCharacter = GameClientDispatch.GetCharacter();
	CHECK_CHARACTER_PTR(lpCharacter, GameClientDispatch, 0);

	unsigned long	dwCID		= lpCharacter->GetCID();
	Item::CItem*    lpItem      = NULL;
	unsigned long   dwGold      = 0;
	unsigned char   cNum        = 0;
	unsigned char   cCreatedItemNumOrDurability = 0;

	// TS_NONEÀº µ·ÀÎ °æ¿ì
	if (TakeType::TS_NONE != itemPos.m_cPos && TakeType::TS_INVEN != itemPos.m_cPos)
	{
		usError = PktPUAck::FAIL_PICKUP_INVEN;
		ERRLOG1(g_Log, "CID:%10u Àκ¥Å丮°¡ ¾Æ´Ñ °÷À¸·Î ¾ÆÀÌÅÛÀ» ÁýÀ¸·Á Çß½À´Ï´Ù.", dwCID);
	}
	else
	{
		// ¼¿ ¾ò±â
		CCell* lpCell = CCellManager::GetInstance().GetCell(nObjectID);
		if (NULL == lpCell) 
		{
			usError = PktPUAck::FAIL_GET_CELL;		
			ERRLOG2(g_Log, "CID:%10u ¼¿ ¾ò±â ½ÇÆÐ. OID:0x%08x", dwCID, nObjectID);	
		}
		else
		{
			// Çʵå·Î ºÎÅÍ ¾ÆÀÌÅÛ ¾ò±â
			CCell::ErrorCode eErrorCode = lpCell->GetItem(dwCID, nObjectID, &lpItem, dwGold);

			switch (eErrorCode)
			{
			case CCell::S_SUCCESS:
				{
					if (0 != dwGold)
					{
						// µ· Ãß°¡
						lpCharacter->AddGold(dwGold, false);
					}
					else if (NULL != lpItem)		    
					{
						// Àκ¥/Àåºñ¿¡ ³Ö±â
						cNum = lpItem->IsSet(Item::DetailData::STACKABLE) ? lpItem->GetNumOrDurability() : 1;
						cCreatedItemNumOrDurability = lpItem->GetNumOrDurability();

						if (false == lpCharacter->GiveItem(lpItem))
						{
							cNum = 0;
							usError = PktPUAck::FAIL_PICKUP_INVEN;
							ERRLOG1(g_Log, "CID:%10u Àκ¥¿¡ ³Ö±â ½ÇÆÐ", dwCID);
						}
						else
						{
//							SERLOG4(g_Log, "[PickUpItem]CID:%10u, itempPos:%2u , ItemUID: %d, usError:%d",
//								lpCharacter->GetCID(), itemPos.m_cPos, lpItem->GetUID(), usError);

							GAMELOG::LogPickupItem(*lpCharacter, itemPos, lpItem, dwGold, usError);

							// GievItem À¸·Î ½ºÅÃµÈ °æ¿ì
							if (lpItem->IsSet(Item::DetailData::STACKABLE) && 0 == lpItem->GetNumOrDurability())
							{
								DELETE_ITEM(lpItem);
							}

							return true;
						}

						// ¼­¹ö¿¡¼­ ºó °ø°£À» üũÇϵµ·Ï ·çƾ º¯°æ (2005-04-28 by ·Îµò)
						/*
						if (false == lpCharacter->Pickup(lpItem, itemPos)) 
						{
						cNum = 0;
						usError = PktPUAck::FAIL_PICKUP_INVEN;
						ERRLOG3(g_Log, "CID:%10u Àκ¥¿¡ ³Ö±â ½ÇÆÐ. (%2d, 0x%04x)", dwCID, itemPos.m_cPos, itemPos.m_cIndex);
						}
						*/
					}
					break;
				}

			case CCell::S_AUTO_ROUTING:			// ¿ÀÅä·çÆõÊ
				usError = PktPUAck::FAIL_AUTO_ROUTING;
				break;

			case CCell::E_NOT_ENOUGH_MEMORY:		
				usError = PktBase::SERVER_ERROR;
				ERRLOG2(g_Log, "CID:%10u ¸Þ¸ð¸®°¡ ÃæºÐÇÏÁö ¾Ê½À´Ï´Ù. OID:0x%08x", dwCID, nObjectID);
				break;

			case CCell::E_NOT_OWNER_OF_ITEM:    // ¼ÒÀ¯±ÇÀÌ ¾øÀ½
				usError = PktPUAck::FAIL_NOT_OWNER_OF_ITEM;
				//					DETLOG2(g_Log, "CID:%10u ¾ÆÀÌÅÛ ¾ò±â ½ÇÆÐ. ¾ÆÀÌÅÛ ¼ÒÀ¯±ÇÀÌ ¾ø½À´Ï´Ù. OID:0x%08x", dwCID, nObjectID);
				break;

			case CCell::E_NOT_ITEM:             // ¾ÆÀÌÅÛÀÌ ¾øÀ½ 
				usError = PktPUAck::FAIL_NOT_ITEM;
				//					DETLOG2(g_Log, "CID:%10u ¾ÆÀÌÅÛ ¾ò±â ½ÇÆÐ. ´Ù¸¥ »ç¶÷ÀÌ ¸ÕÀú Áý¾úÀ» ¼ö ÀÖ½À´Ï´Ù. OID:0x%08x", dwCID, nObjectID);
				break;

			case CCell::E_CREATE_ITEM_FAIL:     // ¾ÆÀÌÅÛ »ý¼º ½ÇÆÐ
				usError = PktPUAck::FAIL_CREATE_ITEM;
				ERRLOG3(g_Log, "CID:%10u ¾ÆÀÌÅÛ »ý¼º ½ÇÆÐ. OID:0x%08x, ErrorCode = %d", dwCID, nObjectID, usError);
				break;	

			case CCell::E_GOLD_OVERFLOW:		// µ·À» ÁÖÀ¸¸é ÃÖ´ë ¼ÒÁö±Ý¾×À» ÃÊ°úÇÒ °æ¿ì
				usError = PktPUAck::FAIL_GOLD_OVERFLOW;
				break;

			default:
				usError = PktPUAck::FAIL_GET_ITEM;
				ERRLOG3(g_Log, "CID:%10u ¾ÆÀÌÅÛ ¾ò±â ½ÇÆÐ. OID:0x%08x, ErrorCode = %d", dwCID, nObjectID, usError);
				break;
			}
		}

		if (PktPUAck::FAIL_NOT_OWNER_OF_ITEM != usError && PktPUAck::FAIL_NOT_ITEM != usError)
		{   
			unsigned char cCurrentNumOrDurability = 0;

			if (NULL != lpItem)
			{
				cCurrentNumOrDurability = lpItem->GetNumOrDurability();

				if (0 == cCurrentNumOrDurability)
				{
					// ¾ÆÀÌÅÛÀÌ ½ºÅõǾ Á¦°ÅµÇ´Â °æ¿ì, ·Î±×¿¡ °³¼ö°¡ Á¦´ë·Î ³²°Ô Çϱâ À§Çؼ­ °³¼ö Á¶ÀÛ.
					lpItem->SetNumOrDurability(cCreatedItemNumOrDurability);
				}
			}

			// ¾ÆÀÌÅÛ Áý±â ·Î±× ³²±è - ¼ÒÀ¯±Ç ¾øÀ½°ú ¾ÆÀÌÅÛ ¾øÀ½ ¿¡·¯´Â ÀÚÁÖ ¹ß»ýÇÒ ¼ö ÀÖ´Ù.
			GAMELOG::LogPickupItem(*lpCharacter, itemPos, lpItem, dwGold, usError);

			if (NULL != lpItem && 0 == cCurrentNumOrDurability)
			{
				// ¾ÆÀÌÅÛÀÌ ½ºÅõǾ Á¦°ÅµÇ´Â °æ¿ì¿´À¸¹Ç·Î, Á¦°ÅÇÒ ¼ö ÀÖµµ·Ï °³¼ö¸¦ 0À¸·Î ÇÔ.
				lpItem->SetNumOrDurability(0);
			}
		}

		if (NULL != lpItem)
		{
			if (lpItem->IsSet(Item::DetailData::STACKABLE) && 0 == lpItem->GetNumOrDurability())
			{
				DELITEMLOG(DETLOG1(g_Log, "this:0X%08x ¾ÆÀÌÅÛÀ» »èÁ¦ÇÕ´Ï´Ù.", lpItem));

				DELETE_ITEM(lpItem);
			}

			if (PktPUAck::NO_SERVER_ERR != usError && 
				PktPUAck::FAIL_AUTO_ROUTING != usError)
			{
				CCell::ItemInfo itemInfo;
				lpCell->SetItem(lpCharacter->GetCurrentPos(), lpItem, 0, 0, CCell::NONE, itemInfo);
			}
		}
	}

	// Çʵå À§ ¾ÆÀÌÅÛ Áý±â º¸³¿
	return GameClientSendPacket::SendCharPickUp(GameClientDispatch.GetSendStream(), 
		dwCID, nObjectID, dwGold, lpItem, itemPos, cNum, usError);
}