// CharStatus.cpp: implementation of the CCharStatus class.
//
//////////////////////////////////////////////////////////////////////

#define NATION_HUMAN				0
#define NATION_AKHAN				1
#define NATION_UNKNONE				2

//#include <crtdbg.h>
#include "ClientMain.h"
#include "CharStatus.h"
#include "CharacterControl.h"
#include <vector.h>
#include "DataTable.h"
#include "GUIMessageBox.h"

#include "Item\ItemMgr.h"
#include "Skill\SkillMgr.h"

CDataTable g_dtDateTable;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CCharStatus::CCharStatus()
{
	int i, j, k;

	for(k = 0; k < 3; k++)
	{
		for(j = 0; j < 6; j++)
		{
			for(i = 0; i < 6; i++)
			{
				m_aryInven[k][j][i] = ITEM_EMPTY;
			}
		}
	}

	for(j = 0; j < 4; j++)
	{
		for(i = 0; i < 8; i++)
		{
			m_aryExchange[j][i] = ITEM_EMPTY;
			m_aryExchange2[j][i] = ITEM_EMPTY;
		}
	}

	for(k = 0; k < 4; k++)
	{
		for(j = 0; j < 12; j++)
		{
			for(i = 0; i < 8; i++)
			{
				m_aryDeposit[k][j][i] = ITEM_EMPTY;
			}
		}
	}

	for(j = 0; j < 8; j++)
	{
		for(i = 0; i < 8; i++)
		{
			m_aryStreetTrade[j][i] = ITEM_EMPTY;
		}
	}

	m_dwExchangeGold = 0;
	m_dwExchange2Gold = 0;

	m_dwDepositGold = 0;
	m_cSavePass = 0;
	m_dwMaxTab = 0;
	m_dwDepositFlag = 0;
	m_cUsedDeposit = 0;

	for(i = 0; i < 15; i++)
	{
		m_lstEquipment[i] = NULL;
	}

	for(i = 0; i < 20; i++)
	{
		m_lstSkillSlot[i] = NULL;
	}

	for(i = 0; i < 10; i++)
	{
		m_lstQuickSlot[i] = NULL;
	}

	for(i = 0; i < 32; i++)
	{
		m_aryEnchantLevel[i] = 0;
	}

	m_lpQuickSelected = NULL;

	m_PartyInfo.m_cMemberNum = 0;
	m_PartyInfo.m_dwPartyID = 0;
	for(i = 0; i < 10; i++)
	{
		m_PartyInfo.MemberCID[i] = 0;
	}

	m_lPotionCoolDownTime = 0;

	m_bUseChant = FALSE;

	m_lpUpgrade[0] = NULL;
	m_lpUpgrade[1] = NULL;

	m_Info.Class = 0;
}

CCharStatus::~CCharStatus()
{
	list<CItemInstance *>::iterator it;
	CItemInstance *lpItem;
	for(it = m_lstInventory.begin(); it != m_lstInventory.end();)
	{
		lpItem = (*it);
		it = m_lstInventory.erase(it);
		delete lpItem;
	}
	m_lstInventory.clear();

	for(it = m_lstDeposit.begin(); it != m_lstDeposit.end();)
	{
		lpItem = (*it);
		it = m_lstDeposit.erase(it);
		delete lpItem;
	}
	m_lstDeposit.clear();

	for(it = m_lstStreetTrade.begin(); it != m_lstStreetTrade.end();)
	{
		lpItem = (*it);
		it = m_lstStreetTrade.erase(it);
		delete lpItem;
	}
	m_lstStreetTrade.clear();

	list<FriendInfo *>::iterator itFriend;
	FriendInfo *lpFriend;
	for(itFriend = m_lstFriendList.begin(); itFriend != m_lstFriendList.end();)
	{
		lpFriend = (*itFriend);
		itFriend = m_lstFriendList.erase(itFriend);
		delete lpFriend;
	}
	m_lstFriendList.clear();

	list<BanInfo *>::iterator itBan;
	BanInfo *lpBan;
	for(itBan = m_lstBanList.begin(); itBan != m_lstBanList.end();)
	{
		lpBan = (*itBan);
		itBan = m_lstBanList.erase(itBan);
		delete lpBan;
	}
	m_lstBanList.clear();

	int i;
	for(i = 0; i < 10; i++)
	{
		if(m_lstQuickSlot[i])
		{
			delete m_lstQuickSlot[i];
			m_lstQuickSlot[i] = NULL;
		}
	}
	m_lpQuickSelected = NULL;
	for(i = 0; i < 20; i++)
	{
		if(m_lstSkillSlot[i])
		{
			delete m_lstSkillSlot[i];
			m_lstSkillSlot[i] = NULL;
		}
	}
	vector<CItemInstance *>::iterator itSkill;
	for(itSkill = m_lstClassSkill.begin(); itSkill != m_lstClassSkill.end();)
	{
		lpItem = (*itSkill);
		itSkill = m_lstClassSkill.erase(itSkill);
		delete lpItem;
	}
	m_lstClassSkill.clear();
	for(i = 0; i < 15; i++)
	{
		if(m_lstEquipment[i])
		{
			delete m_lstEquipment[i];
			m_lstEquipment[i] = NULL;
		}
	}

	if(m_lpUpgrade[0]) { delete m_lpUpgrade[0]; m_lpUpgrade[0] = NULL; }
	if(m_lpUpgrade[1]) { delete m_lpUpgrade[1]; m_lpUpgrade[1] = NULL; }
}

void CCharStatus::StatusUpdate()
{
	m_MaxHP = 0;
	m_MaxMP = 0;

	m_llExpMax = g_dtDateTable.MAXEXPTABLE[m_Info.Level];

	m_lAddMaxHP = 0;
	m_lAddMaxMP = 0;
	m_lAddSTR = 0;
	m_lAddDEX = 0;
	m_lAddCON = 0;
	m_lAddINT = 0;
	m_lAddWIS = 0;

	m_lMinDamage = 0;
	m_lMaxDamage = 0;
	m_lDefensePower = 0;
	m_lAttackRevision = 0;
	m_lDefenseRevision = 0;
	m_lCriticalPercent = 0;
	m_fBlockPercent = 0.0f;
	m_lMagicResistance = 0;

	int i, j;
	unsigned long dwWeaponCount = 0;
	BOOL bDualWeapon = FALSE;

	long lAddMaxHP = 0;
	long lAddMaxMP = 0;
	long lAddSTR = 0;
	long lAddDEX = 0;
	long lAddCON = 0;
	long lAddINT = 0;
	long lAddWIS = 0;

	long lMinDamage = 0;
	long lMaxDamage = 0;
	long lDefensePower = 0;
	long lAttackRevision = 0;
	long lDefenseRevision = 0;
	long lCriticalPercent = 0;
	float fBlockPercent = 0.0f;
	long lMagicResistance = 0;

	for(i = 0; i < 15; i++)
	{
		if((i == Item::EquipmentPos::WEAPON_HAND2 || i == Item::EquipmentPos::SHIELD_HAND2) && m_cWeaponPos == 0) continue;
		if((i == Item::EquipmentPos::WEAPON_HAND1 || i == Item::EquipmentPos::SHIELD_HAND1) && m_cWeaponPos == 1) continue;

		if(m_lstEquipment[i])
		{
			Item::CEquipment *lpEquip = Item::CEquipment::DowncastToEquipment(m_lstEquipment[i]->m_lpItemBase);
			if(lpEquip)
			{
				unsigned long dwType = m_lstEquipment[i]->GetItemType();

				if((dwType == Item::CItemType::SWORD || dwType == Item::CItemType::BLUNT || dwType == Item::CItemType::AXE || dwType == Item::CItemType::DAGGER) &&
					(i == Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos || i == Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos))
				{
					dwWeaponCount++;
					bDualWeapon = TRUE;
				} else
				{
					bDualWeapon = FALSE;
				}

				for(j = 1; j < Item::Attribute::MAX_ATTRIBUTE_NUM; j++)
				{
//					if(lpEquip->GetAttribute((Item::Attribute::Type)j) == 0) break;
					switch(j)
					{
						case Item::Attribute::MIN_DAMAGE:
							if(dwType != Item::CItemType::SKILL_A_ATTACK && dwType != Item::CItemType::SKILL_A_GUARD &&
								dwType != Item::CItemType::SKILL_A_GUN && dwType != Item::CItemType::SKILL_A_KNIFE)
							{
								if(bDualWeapon)
								{
									lMinDamage += lpEquip->GetAttribute((Item::Attribute::Type)j);
								} else
								{
									m_lMinDamage += lpEquip->GetAttribute((Item::Attribute::Type)j);
								}
							}
							break;

						case Item::Attribute::MAX_DAMAGE:
							if(dwType != Item::CItemType::SKILL_A_ATTACK && dwType != Item::CItemType::SKILL_A_GUARD &&
								dwType != Item::CItemType::SKILL_A_GUN && dwType != Item::CItemType::SKILL_A_KNIFE)
							{
								if(bDualWeapon)
								{
									lMaxDamage += lpEquip->GetAttribute((Item::Attribute::Type)j);
								} else
								{
									m_lMaxDamage += lpEquip->GetAttribute((Item::Attribute::Type)j);
								}
							}
							break;

						case Item::Attribute::DEFENCE:
							if(bDualWeapon)
							{
								lDefensePower += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lDefensePower += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::OFFENCE_REVISION:
							if(bDualWeapon)
							{
								lAttackRevision += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lAttackRevision += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::DEFENCE_REVISION:
							if(bDualWeapon)
							{
								lDefenseRevision += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lDefenseRevision += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::CRITICAL_PERCENTAGE:
							if(bDualWeapon)
							{
								lCriticalPercent += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lCriticalPercent += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::BLOCKING_PERCENTAGE:
							if(bDualWeapon)
							{
								fBlockPercent += (lpEquip->GetAttribute((Item::Attribute::Type)j) / 2.0f);
							} else
							{
								m_fBlockPercent += (lpEquip->GetAttribute((Item::Attribute::Type)j) / 2.0f);
							}
							break;

						case Item::Attribute::MAGIC_RESISTANCE:
							if(bDualWeapon)
							{
								lMagicResistance += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lMagicResistance += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::MAX_HP:
							if(bDualWeapon)
							{
								lAddMaxHP += lpEquip->GetAttribute((Item::Attribute::Type)j) * 50;
							} else
							{
								m_lAddMaxHP += lpEquip->GetAttribute((Item::Attribute::Type)j) * 50;
							}
							break;

						case Item::Attribute::MAX_MP:
							if(bDualWeapon)
							{
								lAddMaxMP += lpEquip->GetAttribute((Item::Attribute::Type)j) * 50;
							} else
							{
								m_lAddMaxMP += lpEquip->GetAttribute((Item::Attribute::Type)j) * 50;
							}
							break;

						case Item::Attribute::ADD_STR:
							if(bDualWeapon)
							{
								lAddSTR += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lAddSTR += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::ADD_DEX:
							if(bDualWeapon)
							{
								lAddDEX += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lAddDEX += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::ADD_CON:
							if(bDualWeapon)
							{
								lAddCON += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lAddCON += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::ADD_INT:
							if(bDualWeapon)
							{
								lAddINT += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lAddINT += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;

						case Item::Attribute::ADD_WIS:
							if(bDualWeapon)
							{
								lAddWIS += lpEquip->GetAttribute((Item::Attribute::Type)j);
							} else
							{
								m_lAddWIS += lpEquip->GetAttribute((Item::Attribute::Type)j);
							}
							break;
					}
				}
			}
		}
	}

	if(dwWeaponCount)
	{
		m_lAddMaxHP += lAddMaxHP / dwWeaponCount;
		m_lAddMaxMP += lAddMaxMP / dwWeaponCount;
		m_lAddSTR += lAddSTR / dwWeaponCount;
		m_lAddDEX += lAddDEX / dwWeaponCount;
		m_lAddCON += lAddCON / dwWeaponCount;
		m_lAddINT += lAddINT / dwWeaponCount;
		m_lAddWIS += lAddWIS / dwWeaponCount;

		m_lMinDamage += lMinDamage / dwWeaponCount;
		m_lMaxDamage += lMaxDamage / dwWeaponCount;
		m_lDefensePower += lDefensePower / dwWeaponCount;
		m_lAttackRevision += lAttackRevision / dwWeaponCount;
		m_lDefenseRevision += lDefenseRevision / dwWeaponCount;
		m_lCriticalPercent += lCriticalPercent / dwWeaponCount;
		m_fBlockPercent += fBlockPercent / dwWeaponCount;
		m_lMagicResistance += lMagicResistance / dwWeaponCount;
	}

	BOOL bDex = FALSE;
	if(m_lstEquipment[11 + m_cWeaponPos])
	{
		Item::CEquipment *lpEquip = Item::CEquipment::DowncastToEquipment(m_lstEquipment[11 + m_cWeaponPos]->m_lpItemBase);
		if(lpEquip)
		{
			unsigned long dwType = m_lstEquipment[11 + m_cWeaponPos]->GetItemType();
			if(dwType == Item::CItemType::BOW || dwType == Item::CItemType::CROSSBOW)
			{
				bDex = TRUE;
			}
		}
	}

	if(bDex)
	{
		m_lMinDamage += ((m_Info.DEX + m_lAddDEX) / 2);
		m_lMaxDamage += ((m_Info.DEX + m_lAddDEX) / 2);
	} else
	{
		m_lMinDamage += ((m_Info.STR + m_lAddSTR) / 3);
		m_lMaxDamage += ((m_Info.STR + m_lAddSTR) / 3);
	}

	if(m_Info.Class == 2 || m_Info.Class == 7 || m_Info.Class == 8 || m_Info.Class == 24)
	{
		m_lMinDamage += ((m_Info.DEX + m_lAddDEX) / 6);
		m_lMaxDamage += ((m_Info.DEX + m_lAddDEX) / 6);
	}

	m_lDefensePower += 0;
	switch(m_Info.Class)
	{
		case 1:
		case 5:
		case 6:
			m_lAttackRevision += ((m_Info.STR + m_lAddSTR) / 4);
			m_lDefenseRevision += (((m_Info.STR + m_lAddSTR) / 4.0f) + ((m_Info.DEX + m_lAddDEX) / 5.0f));
			break;

		case 2:
		case 7:
		case 8:
			m_lAttackRevision += ((m_Info.DEX + m_lAddDEX) / 4);
			m_lDefenseRevision += (((m_Info.DEX + m_lAddDEX) / 4.0f) + ((m_Info.DEX + m_lAddDEX) / 5.0f));
			break;

		case 3:
		case 9:
		case 10:
			m_lAttackRevision += ((m_Info.INT + m_lAddINT) / 4);
			m_lDefenseRevision += (((m_Info.INT + m_lAddINT) / 4.0f) + ((m_Info.DEX + m_lAddDEX) / 5.0f));
			break;

		case 4:
		case 11:
		case 12:
			m_lAttackRevision += ((m_Info.WIS + m_lAddWIS) / 2);
			m_lDefenseRevision += ((m_Info.DEX + m_lAddDEX) / 5.0f);/*(((m_Info.WIS + m_lAddWIS) / 4.0f) + ((m_Info.DEX + m_lAddDEX) / 5.0f));*/
			break;

		// ¾ÆÄ­

		case 17:
		case 19:
		case 20:
			m_lAttackRevision += ((m_Info.STR + m_lAddSTR) / 4);
			m_lDefenseRevision += (((m_Info.STR + m_lAddSTR) / 4.0f) + ((m_Info.DEX + m_lAddDEX) / 5.0f));
			break;

		case 18:
		case 24:
			m_lAttackRevision += ((m_Info.DEX + m_lAddDEX) / 4);
			m_lDefenseRevision += (((m_Info.DEX + m_lAddDEX) / 4.0f) + ((m_Info.DEX + m_lAddDEX) / 5.0f));
			break;

		case 21:
			m_lAttackRevision += ((m_Info.DEX + m_lAddDEX) / 2);
			m_lDefenseRevision += ((m_Info.DEX + m_lAddDEX) / 5.0f);
			break;

		case 22:
			m_lAttackRevision += ((m_Info.INT + m_lAddINT) / 4);
			m_lDefenseRevision += (((m_Info.INT + m_lAddINT) / 4.0f) + ((m_Info.DEX + m_lAddDEX) / 5.0f));
			break;

		case 23:
			m_lAttackRevision += ((m_Info.WIS + m_lAddWIS) / 2);
			m_lDefenseRevision += (((m_Info.WIS + m_lAddWIS) / 2.0f) + ((m_Info.DEX + m_lAddDEX) / 5.0f));
			break;
	}
	m_lCriticalPercent += ((m_Info.DEX + m_lAddDEX) / 5);
	m_fBlockPercent += 0.0f;
	m_lMagicResistance += ((m_Info.WIS + m_lAddWIS) / 3);

	long lCON = ((m_Info.CON + m_lAddCON) - 20);		if(lCON < 0 ) lCON = 0;
	long lINT = ((m_Info.INT + m_lAddINT) - 20);		if(lINT < 0 ) lINT = 0;
	long lWIS = ((m_Info.WIS + m_lAddWIS) - 20);		if(lWIS < 0 ) lWIS = 0;

	switch(m_Info.Class)
	{
		case 1:			// Fighter
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 300;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			break;

		case 5:			// Defender
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 800;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			break;

		case 6:			// Warrior
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 550;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			break;

		case 2:			// Rogue
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			break;

		case 7:			// Assasin
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 800;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 800;
			break;

		case 8:			// Archer
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			break;

		case 3:			// Mage
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			if(lINT * m_Info.Level > lWIS * m_Info.Level / 2.0f)
				m_MaxMP += lINT * m_Info.Level + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			break;

		case 9:			// Sorcerer
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			if(lINT * m_Info.Level > lWIS * m_Info.Level / 2.0f)
				m_MaxMP += lINT * m_Info.Level + m_Info.Level * 40 + 800;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 800;
			break;

		case 10:		// Enchanter
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			if(lINT * m_Info.Level > lWIS * m_Info.Level / 2.0f)
				m_MaxMP += lINT * m_Info.Level + m_Info.Level * 40 + 550;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			break;

		case 4:			// Acolyte
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 300;
			if(lINT * m_Info.Level / 2.0f > lWIS * m_Info.Level)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level + m_Info.Level * 40 + 300;
			break;

		case 11:		// Priest
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 800;
			if(lINT * m_Info.Level / 2.0f > lWIS * m_Info.Level)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level + m_Info.Level * 40 + 300;
			break;

		case 12:		// Cleric
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 550;
			if(lINT * m_Info.Level / 2.0f > lWIS * m_Info.Level)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			else
				m_MaxMP += lWIS * m_Info.Level + m_Info.Level * 40 + 550;
			break;

		case 17:			// Combatent
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 300;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			break;

		case 19:			// Templer
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 800;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			break;

		case 20:			// Attacker
			m_MaxHP = lCON * m_Info.Level + m_Info.Level * 40 + 550;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			break;

		case 21:			// Gunner
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 800;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 800;
			break;

		case 18:			// Opiciator
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level + m_Info.Level * 40 + 300;
			break;

		case 22:			// Rune Ope
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			if(lINT * m_Info.Level > lWIS * m_Info.Level / 2.0f)
				m_MaxMP += lINT * m_Info.Level + m_Info.Level * 40 + 800;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 800;
			break;

		case 23:			// Life Ope
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			if(lINT * m_Info.Level / 2.0f > lWIS * m_Info.Level)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 550;
			else
				m_MaxMP += lWIS * m_Info.Level + m_Info.Level * 40 + 550;
			break;

		case 24:			// Shadow Ope
			m_MaxHP = lCON * m_Info.Level / 2.0f + m_Info.Level * 40 + 800;
			if(lINT > lWIS)
				m_MaxMP += lINT * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			else
				m_MaxMP += lWIS * m_Info.Level / 2.0f + m_Info.Level * 40 + 300;
			break;
	}

	for(i = 0; i < 15; i++)
	{
		if(m_lstEquipment[i])
		{
			if(CheckItemByStatus(m_lstEquipment[i]))
			{
				m_lstEquipment[i]->m_bCanUsed = TRUE;
			} else
			{
				m_lstEquipment[i]->m_bCanUsed = FALSE;
			}
		}
	}

	if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
	{
		Item::CEquipment *lpEquip = Item::CEquipment::DowncastToEquipment(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->m_lpItemBase);
		if(lpEquip)
		{
			unsigned long dwType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();
			if(dwType == Item::CItemType::STAFF)
			{
				g_CharacterData.m_dwMaxCombo = 2;
			} else
			{
				g_CharacterData.m_dwMaxCombo = 4;
			}

			if(dwType == Item::CItemType::BOW || dwType == Item::CItemType::CROSSBOW)
			{
				m_bRangedWeapon = TRUE;
			} else
			{
				m_bRangedWeapon = FALSE;
			}
		}
	} else
	{
		g_CharacterData.m_dwMaxCombo = 0;
		m_bRangedWeapon = FALSE;
	}

	unsigned long dwComboCount[7] = { 10, 10, 10, 10, 10, 10, 10 };

	for(i = 0; i < 20; i++)
	{
		if(m_Skill.SSlot[i].SKILLINFO.wSkill)
		{
			const Skill::ProtoType *lpSkill = g_SkillMgr.GetSkillProtoType(m_Skill.SSlot[i].SKILLINFO.wSkill);

			if(lpSkill && lpSkill->m_eSkillType == Skill::Type::PASSIVE)
			{
				switch(m_Skill.SSlot[i].SKILLINFO.wSkill)
				{
					case 0x8102:			// ¼Òµå ¸¶½ºÅ͸®
						if((m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::SWORD ||
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::TWOHANDED_SWORD)) ||
							(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::SWORD ||
							m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::TWOHANDED_SWORD)))
						{
							m_lAttackRevision += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel) * 2;
							m_lMinDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							m_lMaxDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							if(m_Skill.SSlot[i].SKILLINFO.cLockCount == 1) dwComboCount[0] = 5;
							else if(m_Skill.SSlot[i].SKILLINFO.cLockCount > 1) dwComboCount[0] = 6;
							else dwComboCount[0] = 4;
						}
						break;

					case 0x8103:			// ¾×½º ¸¶½ºÅ͸®
						if((m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::AXE ||
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::TWOHANDED_AXE)) ||
							(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::AXE ||
							m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::TWOHANDED_AXE)))
						{
							m_lAttackRevision += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel) * 2;
							m_lMinDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							m_lMaxDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							if(m_Skill.SSlot[i].SKILLINFO.cLockCount == 1) dwComboCount[1] = 5;
							else if(m_Skill.SSlot[i].SKILLINFO.cLockCount > 1) dwComboCount[1] = 6;
							else dwComboCount[1] = 4;
						}
						break;

					case 0x8105:			// ºí·±Æ® ¸¶½ºÅ͸®
						if((m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::BLUNT ||
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::TWOHANDED_BLUNT)) ||
							(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::BLUNT ||
							m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::TWOHANDED_BLUNT)))
						{
							m_lAttackRevision += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel) * 2;
							m_lMinDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							m_lMaxDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							if(m_Skill.SSlot[i].SKILLINFO.cLockCount == 1) dwComboCount[2] = 5;
							else if(m_Skill.SSlot[i].SKILLINFO.cLockCount > 1) dwComboCount[2] = 6;
							else dwComboCount[2] = 4;
						}
						break;

					case 0x8705:			// ´Ü°Å ¸¶½ºÅ͸®
						if((m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos] &&
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::DAGGER) ||
							(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos] &&
							m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::DAGGER))
						{
							m_lAttackRevision += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel) * 2;
							m_lMinDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							m_lMaxDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							if(m_Skill.SSlot[i].SKILLINFO.cLockCount == 1) dwComboCount[3] = 5;
							else if(m_Skill.SSlot[i].SKILLINFO.cLockCount > 1) dwComboCount[3] = 6;
							else dwComboCount[3] = 4;
						}
						break;

/*					case 0x8805:			// ·¹ÀÎÁöµå ¿þÆù
						if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::BOW ||
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::CROSSBOW))
						{
							m_lAttackRevision += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel) * 2;
							m_lMinDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							m_lMaxDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							if(m_Skill.SSlot[i].SKILLINFO.cLockCount == 1) g_CharacterData.m_dwMaxCombo = 5;
							else if(m_Skill.SSlot[i].SKILLINFO.cLockCount > 1) g_CharacterData.m_dwMaxCombo = 6;
						}
						break;*/

					case 0x9102:			// Å©·¯½¬¿þÆù
						if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::COM_BLUNT ||
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::OPP_AXE ||
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::OPP_HAMMER))
						{
							m_lAttackRevision += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel) * 2;
							m_lMinDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							m_lMaxDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							if(m_Skill.SSlot[i].SKILLINFO.cLockCount == 1) dwComboCount[4] = 5;
							else if(m_Skill.SSlot[i].SKILLINFO.cLockCount > 1) dwComboCount[4] = 6;
							else dwComboCount[4] = 4;
						}
						break;

					case 0x9105:			// ºí·¹À̵å
						if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos] &&
							(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::COM_SWORD ||
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::OPP_SLUSHER))
						{
							m_lAttackRevision += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel) * 2;
							m_lMinDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							m_lMaxDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							if(m_Skill.SSlot[i].SKILLINFO.cLockCount == 1) dwComboCount[5] = 5;
							else if(m_Skill.SSlot[i].SKILLINFO.cLockCount > 1) dwComboCount[5] = 6;
							else dwComboCount[5] = 4;
						}
						break;

					case 0x9207:			// Ŭ·Î ¸¶½ºÅ͸®
						if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos] &&
							m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType() == Item::CItemType::OPP_TALON)
						{
							m_lAttackRevision += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel) * 2;
							m_lMinDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							m_lMaxDamage += (m_Skill.SSlot[i].SKILLINFO.cLockCount * 6 + m_Skill.SSlot[i].SKILLINFO.cSkillLevel);
							if(m_Skill.SSlot[i].SKILLINFO.cLockCount == 1) dwComboCount[6] = 5;
							else if(m_Skill.SSlot[i].SKILLINFO.cLockCount > 1) dwComboCount[6] = 6;
							else dwComboCount[6] = 4;
						}
						break;
				}
			}
		}
	}

	unsigned long dwCombo = 10;
	for(i = 0; i < 7; i++)
	{
		if(dwCombo > dwComboCount[i])
		{
			dwCombo = dwComboCount[i];
		}
	}

	if(dwCombo != 10) g_CharacterData.m_dwMaxCombo = dwCombo;

	if(m_lCriticalPercent > 90) m_lCriticalPercent = 90;
	float fSpeedFactor = 1.0f + ((m_Info.DEX + m_lAddDEX) - 20) * 0.005f;
	if(fSpeedFactor > 2.0f) fSpeedFactor = 2.0f;
	g_CharacterData.m_fWalkSpeed = 150.0f * fSpeedFactor;
	g_CharacterData.m_fRunSpeed = 490.0f * fSpeedFactor;

	m_lRealMinDamage = m_lMinDamage;
	m_lRealMaxDamage = m_lMaxDamage;
	m_lRealDefensePower = m_lDefensePower;

	m_fRealBlockPercent = m_fBlockPercent;

/*	m_lCriticalPercent;
	m_lAttackRevision;
	m_lDefenseRevision;*/
	// æƮ / ÀÎæƮ ¼öÄ¡ Àû¿ë
	for(i = 0; i < 32; i++)
	{
		if(m_aryEnchantLevel[i])
		{
			switch(i)
			{
				case 0:		// BattleSong
					m_lMinDamage += m_aryEnchantLevel[i];
					m_lMaxDamage += m_aryEnchantLevel[i];
					break;

				case 1:		// MaintenanceChant
					m_lDefensePower += (m_aryEnchantLevel[i] / 2);
					break;

				case 2:		// AccelerationChant
					m_lMinDamage += (m_aryEnchantLevel[i] / 2);
					m_lMaxDamage += (m_aryEnchantLevel[i] / 2);
					break;

				case 3:		// LifeAura
					break;

				case 4:
					break;

				case 5:
					break;

				case 6:
					break;

				case 7:
					break;

				case 8:
					break;

				case 9:
					break;

				case 10:
					break;

				case 11:
					break;

				case 12:
					break;

				case 13:
					break;

				case 14:		// Blaze
					g_CharacterData.m_fWalkSpeed = g_CharacterData.m_fWalkSpeed * 1.5f;
					g_CharacterData.m_fRunSpeed = g_CharacterData.m_fRunSpeed * 1.5f;

					m_lMinDamage += 10;
					m_lMaxDamage += 10;

					m_lDefensePower -= 10;
					m_lMagicResistance += 40;
					break;

				case 15:		// Charging
					g_CharacterData.m_fWalkSpeed = g_CharacterData.m_fWalkSpeed * 1.5f;
					g_CharacterData.m_fRunSpeed = g_CharacterData.m_fRunSpeed * 1.5f;

					m_lDefensePower += 10;
					m_lMagicResistance += 30;
					break;

				case 16:		// Stealth
					if(m_Info.Class == 7 || m_Info.Class == 24)
					{
						g_CharacterData.m_fWalkSpeed = g_CharacterData.m_fWalkSpeed * (0.5f + m_aryEnchantLevel[i] / 20.0f);
						g_CharacterData.m_fRunSpeed = g_CharacterData.m_fRunSpeed * (0.5f + m_aryEnchantLevel[i] / 20.0f);
					} else
					{
						g_CharacterData.m_fWalkSpeed = g_CharacterData.m_fWalkSpeed * (0.5f + m_aryEnchantLevel[i] / 40.0f);
						g_CharacterData.m_fRunSpeed = g_CharacterData.m_fRunSpeed * (0.5f + m_aryEnchantLevel[i] / 40.0f);
					}
					break;

				case 17:		// Mana Shell
					break;

				case 18:		// Encourage
					m_lMinDamage += (m_aryEnchantLevel[i] / 2);
					m_lMaxDamage += (m_aryEnchantLevel[i] / 2);

					m_lDefensePower += (m_aryEnchantLevel[i] / 2);
					break;

				case 19:		// EnchantWeapon
					m_lMinDamage += m_aryEnchantLevel[i];
					m_lMaxDamage += m_aryEnchantLevel[i];
					break;

				case 20:		// BrightArmor
					m_lDefensePower += m_aryEnchantLevel[i];
					break;

				case 21:		// HardenSkin
					m_lDefensePower += m_aryEnchantLevel[i];
					break;

				case 22:		// Flexibility
					break;

				case 23:		// Guard
					m_fBlockPercent = (m_aryEnchantLevel[i] / 2.0f);
					break;

				case 24:		// Hold
					break;

				case 25:		// Stun
					break;

				case 26:		// Frozen
					g_CharacterData.m_fWalkSpeed = g_CharacterData.m_fWalkSpeed / 2.0f;
					g_CharacterData.m_fRunSpeed = g_CharacterData.m_fRunSpeed / 2.0f;
					break;

				case 27:		// Poisoned
					break;

				case 28:		// LowerStrength
					m_lMinDamage -= (m_aryEnchantLevel[i] / 2);
					m_lMaxDamage -= (m_aryEnchantLevel[i] / 2);

					m_lDefensePower -= (m_aryEnchantLevel[i] / 2);
					break;

				case 29:
					break;

				case 30:
					break;

				case 31:
					break;
			}
		}
	}

//	g_CharacterData.m_fWalkSpeed = 150.0f * 5.0f;
//	g_CharacterData.m_fRunSpeed = 490.0f * 5.0f;
}

void CCharStatus::CheckInvenField(unsigned long dwCommand, CItemInstance *lpItem)
{
	const Item::ItemInfo *lpItemInfo = &lpItem->GetItemInfo();
	unsigned char cPosX, cPosY, cTab;
	lpItem->m_lpItemBase->GetPos().GetPos(cPosX, cPosY, cTab);

	for(int j = cPosY; j < cPosY + lpItemInfo->m_DetailData.m_cYSize; j++)
	{
		for(int i = cPosX; i < cPosX + lpItemInfo->m_DetailData.m_cXSize; i++)
		{
			switch(dwCommand)
			{
				case 0:
					m_aryInven[cTab][j][i] = ITEM_EMPTY;
					break;

				case 1:
					m_aryInven[cTab][j][i] = lpItem->m_dwItemUID;
					break;
			}
		}
	}
}

void CCharStatus::CheckDepositField(unsigned long dwCommand, CItemInstance *lpItem)
{
	const Item::ItemInfo *lpItemInfo = &lpItem->GetItemInfo();
	unsigned char cPosX, cPosY, cTab;
	lpItem->m_lpItemBase->GetPos().GetPos(cPosX, cPosY, cTab);

	for(int j = cPosY; j < cPosY + lpItemInfo->m_DetailData.m_cYSize; j++)
	{
		for(int i = cPosX; i < cPosX + lpItemInfo->m_DetailData.m_cXSize; i++)
		{
			switch(dwCommand)
			{
				case 0:
					m_aryDeposit[cTab][j][i] = ITEM_EMPTY;
					break;

				case 1:
					m_aryDeposit[cTab][j][i] = lpItem->m_dwItemUID;
					break;
			}
		}
	}
}

void CCharStatus::CheckExchangeField(unsigned long dwCommand, CItemInstance *lpItem, BOOL bSelf)
{
	const Item::ItemInfo *lpItemInfo = &lpItem->GetItemInfo();
	unsigned char cPosX, cPosY, cTab;
	lpItem->m_lpItemBase->GetPos().GetPos(cPosX, cPosY, cTab);

	for(int j = cPosY; j < cPosY + lpItemInfo->m_DetailData.m_cYSize; j++)
	{
		for(int i = cPosX; i < cPosX + lpItemInfo->m_DetailData.m_cXSize; i++)
		{
			switch(dwCommand)
			{
				case 0:
					if(bSelf)
						m_aryExchange[j][i] = ITEM_EMPTY;
					else
						m_aryExchange2[j][i] = ITEM_EMPTY;
					break;

				case 1:
					if(bSelf)
						m_aryExchange[j][i] = lpItem->m_dwItemUID;
					else
						m_aryExchange2[j][i] = lpItem->m_dwItemUID;
					break;
			}
		}
	}
}

void CCharStatus::CheckStreetTradeField(unsigned long dwCommand, CItemInstance *lpItem)
{
	const Item::ItemInfo *lpItemInfo = &lpItem->GetItemInfo();
	unsigned char cPosX, cPosY, cTab;
	lpItem->m_lpItemBase->GetPos().GetPos(cPosX, cPosY, cTab);

	for(int j = cPosY; j < cPosY + lpItemInfo->m_DetailData.m_cYSize; j++)
	{
		for(int i = cPosX; i < cPosX + lpItemInfo->m_DetailData.m_cXSize; i++)
		{
			switch(dwCommand)
			{
				case 0:
					m_aryStreetTrade[j][i] = ITEM_EMPTY;
					break;

				case 1:
					m_aryStreetTrade[j][i] = lpItem->m_dwItemUID;
					break;
			}
		}
	}
}

__int64 CCharStatus::IsCheckItem(CItemInstance *lpItem, unsigned long dwPos, unsigned long dwInvenX, unsigned long dwInvenY, unsigned long dwInvenTab)
{
	const Item::ItemInfo *lpItemInfo = &lpItem->GetItemInfo();
	unsigned char cPosX, cPosY, cTab;
	lpItem->m_lpItemBase->GetPos().GetPos(cPosX, cPosY, cTab);

	switch(dwPos)
	{
		case 0:			// Àκ¥
			{
				if(dwInvenX + lpItemInfo->m_DetailData.m_cXSize > 6) return ITEM_FAILED;
				if(dwInvenY + lpItemInfo->m_DetailData.m_cYSize > 6) return ITEM_FAILED;

				__int64 m_ddExistItem = ITEM_EMPTY;
				for(int j = dwInvenY; j < dwInvenY + lpItemInfo->m_DetailData.m_cYSize; j++)
				{
					for(int i = dwInvenX; i < dwInvenX + lpItemInfo->m_DetailData.m_cXSize; i++)
					{
						if(m_aryInven[dwInvenTab][j][i] != ITEM_EMPTY)
						{
							if(m_ddExistItem == ITEM_EMPTY)
								m_ddExistItem = m_aryInven[dwInvenTab][j][i];
							else if(m_ddExistItem != m_aryInven[dwInvenTab][j][i])
								return ITEM_FAILED;
						}
					}
				}

				return m_ddExistItem;
			}
			break;

		case 4:			// â°í
			{
				if(dwInvenX + lpItemInfo->m_DetailData.m_cXSize > 8) return ITEM_FAILED;
				if(dwInvenY + lpItemInfo->m_DetailData.m_cYSize > 12) return ITEM_FAILED;

				__int64 m_ddExistItem = ITEM_EMPTY;
				for(int j = dwInvenY; j < dwInvenY + lpItemInfo->m_DetailData.m_cYSize; j++)
				{
					for(int i = dwInvenX; i < dwInvenX + lpItemInfo->m_DetailData.m_cXSize; i++)
					{
						if(m_aryDeposit[dwInvenTab][j][i] != ITEM_EMPTY)
						{
							if(m_ddExistItem == ITEM_EMPTY)
								m_ddExistItem = m_aryDeposit[dwInvenTab][j][i];
							else if(m_ddExistItem != m_aryDeposit[dwInvenTab][j][i])
								return ITEM_FAILED;
						}
					}
				}

				return m_ddExistItem;
			}
			break;

		case 5:			// ³ëÁ¡»ó
			{
				if(dwInvenX + lpItemInfo->m_DetailData.m_cXSize > 8) return ITEM_FAILED;
				if(dwInvenY + lpItemInfo->m_DetailData.m_cYSize > 8) return ITEM_FAILED;

				if(lpItem->GetItemPos() != ClientSocket::ItemPos_Inven) return ITEM_FAILED;

				__int64 m_ddExistItem = ITEM_EMPTY;
				for(int j = dwInvenY; j < dwInvenY + lpItemInfo->m_DetailData.m_cYSize; j++)
				{
					for(int i = dwInvenX; i < dwInvenX + lpItemInfo->m_DetailData.m_cXSize; i++)
					{
						if(m_aryStreetTrade[j][i] != ITEM_EMPTY)
						{
							return ITEM_FAILED;
/*							if(m_ddExistItem == ITEM_EMPTY)
								m_ddExistItem = m_aryStreetTrade[j][i];
							else if(m_ddExistItem != m_aryStreetTrade[j][i])
								return ITEM_FAILED;*/
						}
					}
				}

				return m_ddExistItem;
			}
			break;

		case 3:			// ±³È¯
			{
				if(dwInvenX + lpItemInfo->m_DetailData.m_cXSize > 8) return ITEM_FAILED;
				if(dwInvenY + lpItemInfo->m_DetailData.m_cYSize > 4) return ITEM_FAILED;

				__int64 m_ddExistItem = ITEM_EMPTY;
				for(int j = dwInvenY; j < dwInvenY + lpItemInfo->m_DetailData.m_cYSize; j++)
				{
					for(int i = dwInvenX; i < dwInvenX + lpItemInfo->m_DetailData.m_cXSize; i++)
					{
						if(m_aryExchange[j][i] != ITEM_EMPTY)
						{
							if(m_ddExistItem == ITEM_EMPTY)
								m_ddExistItem = m_aryExchange[j][i];
							else if(m_ddExistItem != m_aryExchange[j][i])
								return ITEM_FAILED;
						}
					}
				}

				return m_ddExistItem;
			}
			break;

		case 1:			// Àåºñ
			//// ´É·ÂÄ¡ Á¦ÇÑ
			if(!lpItem->GetIsEquip()) return ITEM_FAILED;
			if(!CheckItemByStatus(lpItem)) return ITEM_FAILED;
			if(!lpItem->GetNowDurability()) return ITEM_FAILED;

/*			{
				if(lpItem->GetItemType() == Item::CItemType::CROSSBOW ||
					lpItem->GetItemType() == Item::CItemType::BOW)
				{
					return ITEM_FAILED;
				}
			}*/

			switch (lpItem->GetItemType())
			{
				// ¹æ¾î±¸
				case Item::CItemType::HELM:
					if(Item::EquipmentPos::HELM == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::HEAD:
					if(m_Info.Nationality == NATION_AKHAN && Item::EquipmentPos::HEAD == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::SHIRT:
					if(Item::EquipmentPos::SHIRT == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::TUNIC:
					if(Item::EquipmentPos::TUNIC == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::BODY:
					if(m_Info.Nationality == NATION_AKHAN && Item::EquipmentPos::BODY == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::ARMOUR:
					if(Item::EquipmentPos::ARMOUR == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::SHIELD:
					if(Item::EquipmentPos::SHIELD_HAND1 == dwInvenX || Item::EquipmentPos::SHIELD_HAND2 == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX])
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
							{
								unsigned char cType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();
								if(cType == Item::CItemType::BOW || cType == Item::CItemType::CROSSBOW)
								{
									return ITEM_FAILED;
								}
							}
							return m_lstEquipment[dwInvenX]->m_dwItemUID;
						}
						else
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
							{
								unsigned char cType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();
								if(cType == Item::CItemType::TWOHANDED_BLUNT ||
									cType == Item::CItemType::TWOHANDED_AXE ||
									cType == Item::CItemType::TWOHANDED_SWORD ||
									cType == Item::CItemType::BOW ||
									cType == Item::CItemType::CROSSBOW ||
									cType == Item::CItemType::STAFF)
								{
									return ITEM_FAILED;
								}
							}
							return ITEM_EMPTY;
						}
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::PELVIS:
					if(m_Info.Nationality == NATION_AKHAN && Item::EquipmentPos::PELVIS == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::PROTECT_A:
					if(m_Info.Nationality == NATION_AKHAN && Item::EquipmentPos::PROTECT_ARM == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::SKILL_A_ATTACK:
				case Item::CItemType::SKILL_A_GUARD:
				case Item::CItemType::SKILL_A_GUN:
				case Item::CItemType::SKILL_A_KNIFE:
					if(m_Info.Nationality == NATION_AKHAN && Item::EquipmentPos::SKILL_ARM == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX])
							return m_lstEquipment[dwInvenX]->m_dwItemUID;
						else
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1])
							{
								if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1]->GetTwoHandItem())
								{
									return ITEM_FAILED;
								}
							}
							return ITEM_EMPTY;
						}
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::CLOAK:
					if(Item::EquipmentPos::CLOAK == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::GLOVE:
					if(Item::EquipmentPos::GLOVE == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::BOOTS:
					if(Item::EquipmentPos::BOOTS == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;
				
				// Àå½Å±¸
				case Item::CItemType::RING:
					if(Item::EquipmentPos::RINGL == dwInvenX || Item::EquipmentPos::RINGR == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::NECKLACE: 
					if(Item::EquipmentPos::NECKLACE == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				// ´Ü°Å¸® ÇѼչ«±â
				case Item::CItemType::SWORD:	case Item::CItemType::BLUNT:	case Item::CItemType::AXE:		
					if(m_Info.Nationality == NATION_HUMAN)
					{
						if((Item::EquipmentPos::WEAPON_HAND1 == dwInvenX || Item::EquipmentPos::WEAPON_HAND2 == dwInvenX))
						{
							if(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos])
							{
								unsigned long dwType = m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType();

								if(dwType == Item::CItemType::ARROW || dwType == Item::CItemType::BOLT ||
									dwType == Item::CItemType::DAGGER)
									return ITEM_FAILED;
							}

							if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
						}
						// À̵µ·ù½Ã Àû¿ë
						 else if(m_Info.Class == 6 && (Item::EquipmentPos::SHIELD_HAND1 == dwInvenX || Item::EquipmentPos::SHIELD_HAND2 == dwInvenX))
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
							{
								unsigned long dwType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();

								if(dwType != Item::CItemType::SWORD && dwType != Item::CItemType::BLUNT && dwType != Item::CItemType::AXE)
									return ITEM_FAILED;
							} else
								return ITEM_FAILED;

							if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
						}/**/ else
							return ITEM_FAILED;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::DAGGER:
					if(m_Info.Nationality == NATION_HUMAN)
					{
						if((Item::EquipmentPos::WEAPON_HAND1 == dwInvenX || Item::EquipmentPos::WEAPON_HAND2 == dwInvenX))
						{
							if(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos])
							{
								unsigned long dwType = m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType();

								if(dwType == Item::CItemType::ARROW || dwType == Item::CItemType::BOLT ||
									dwType == Item::CItemType::SWORD || dwType == Item::CItemType::BLUNT ||
									dwType == Item::CItemType::AXE)
									return ITEM_FAILED;
							}

							if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
						}
						// À̵µ·ù½Ã Àû¿ë
						 else if(m_Info.Class == 7 && (Item::EquipmentPos::SHIELD_HAND1 == dwInvenX || Item::EquipmentPos::SHIELD_HAND2 == dwInvenX))
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
							{
								unsigned long dwType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();

								if(dwType != Item::CItemType::DAGGER)
									return ITEM_FAILED;
							} else
								return ITEM_FAILED;

							if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
						}/**/ else
							return ITEM_FAILED;
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::COM_BLUNT:	case Item::CItemType::COM_SWORD:
				case Item::CItemType::OPP_AXE:	case Item::CItemType::OPP_HAMMER:	case Item::CItemType::OPP_SLUSHER:
				case Item::CItemType::OPP_TALON:
					if(m_Info.Nationality == NATION_AKHAN && Item::EquipmentPos::WEAPON_HAND1 == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX]) return m_lstEquipment[dwInvenX]->m_dwItemUID; else return ITEM_EMPTY;
					} else
						return ITEM_FAILED;
					break;

				// ´Ü°Å¸® ¾ç¼Õ¹«±â
				case Item::CItemType::STAFF:	
				case Item::CItemType::TWOHANDED_BLUNT:
				case Item::CItemType::TWOHANDED_AXE:	
				case Item::CItemType::TWOHANDED_SWORD:
				case Item::CItemType::OPP_SYTHE:
					if(Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX])
						{
							if(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos])
							{
								return ITEM_FAILED;
							}

							return m_lstEquipment[dwInvenX]->m_dwItemUID;
						}
						else
						{
							if(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos])
							{
								return ITEM_FAILED;
							}

							return ITEM_EMPTY;
						}
					} else
					{
						return ITEM_FAILED;
					}
					break;

				// Àå°Å¸®¹«±â 
				case Item::CItemType::BOW:
					if(Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX])
						{
							if(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos])
							{
								unsigned long dwType = m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType();

								if(dwType == Item::CItemType::ARROW)
								{
									return m_lstEquipment[dwInvenX]->m_dwItemUID;
								}

								return ITEM_FAILED;
							}

							return m_lstEquipment[dwInvenX]->m_dwItemUID;
						}
						else
						{
							if(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos])
							{
								unsigned long dwType = m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType();

								if(dwType == Item::CItemType::ARROW)
								{
									return ITEM_EMPTY;
								}

								return ITEM_FAILED;
							}

							return ITEM_EMPTY;
						}
					} else
					{
						return ITEM_FAILED;
					}
					break;

				case Item::CItemType::CROSSBOW:
					if(Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos == dwInvenX)
					{
						if(m_lstEquipment[dwInvenX])
						{
							if(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos])
							{
								unsigned long dwType = m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType();

								if(dwType == Item::CItemType::BOLT)
								{
									return m_lstEquipment[dwInvenX]->m_dwItemUID;
								}

								return ITEM_FAILED;
							}

							return m_lstEquipment[dwInvenX]->m_dwItemUID;
						}
						else
						{
							if(m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos])
							{
								unsigned long dwType = m_lstEquipment[Item::EquipmentPos::SHIELD_HAND1 + m_cWeaponPos]->GetItemType();

								if(dwType == Item::CItemType::BOLT)
								{
									return ITEM_EMPTY;
								}

								return ITEM_FAILED;
							}

							return ITEM_EMPTY;
						}
					} else
					{
						return ITEM_FAILED;
					}
					break;

				case Item::CItemType::BOLT:
					if(m_Info.Nationality == NATION_HUMAN && (Item::EquipmentPos::SHIELD_HAND1 == dwInvenX || Item::EquipmentPos::SHIELD_HAND2 == dwInvenX))
					{
						if(m_lstEquipment[dwInvenX])
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
							{
								unsigned char cType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();
								if(cType != Item::CItemType::CROSSBOW)
								{
									return ITEM_FAILED;
								}
							}
							return m_lstEquipment[dwInvenX]->m_dwItemUID;
						}
						else
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
							{
								unsigned char cType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();
								if(cType == Item::CItemType::CROSSBOW)
								{
									return ITEM_EMPTY;
								}
							}
							return ITEM_FAILED;
						}
					} else
						return ITEM_FAILED;
					break;

				case Item::CItemType::ARROW:
					if(m_Info.Nationality == NATION_HUMAN && (Item::EquipmentPos::SHIELD_HAND1 == dwInvenX || Item::EquipmentPos::SHIELD_HAND2 == dwInvenX))
					{
						if(m_lstEquipment[dwInvenX])
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
							{
								unsigned char cType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();
								if(cType != Item::CItemType::BOW)
								{
									return ITEM_FAILED;
								}
							}
							return m_lstEquipment[dwInvenX]->m_dwItemUID;
						}
						else
						{
							if(m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos])
							{
								unsigned char cType = m_lstEquipment[Item::EquipmentPos::WEAPON_HAND1 + m_cWeaponPos]->GetItemType();
								if(cType == Item::CItemType::BOW)
								{
									return ITEM_EMPTY;
								}
							}
							return ITEM_FAILED;
						}
					} else
						return ITEM_FAILED;
					break;

				default:
					return ITEM_FAILED;
			}
			break;

		case 2:			// Äü½½·Ô
			break;
	}

	return ITEM_EMPTY;
}

unsigned char CCharStatus::GetAbleInven(LPFieldInstance lpFieldInstance, Item::ItemPos &pItemIndex, BOOL bStack)
{
	const Item::ItemInfo *lpProtoType = g_ItemMgr.GetItemInfo(lpFieldInstance->m_dwTypeID);
	unsigned long dwSizeX = lpProtoType->m_DetailData.m_cXSize;
	unsigned long dwSizeY = lpProtoType->m_DetailData.m_cYSize;

//	char strText[MAX_PATH];
/*	sprintf(strText, "0x%08x, %d, %d, %d, %d, %d, %d", lpFieldInstance->m_dwTypeID, pItemIndex.GetXIndex(), pItemIndex.GetYIndex(), pItemIndex.GetZIndex(),
		dwSizeX, dwSizeY, bStack);
	MessageBox(NULL, strText, "abc", MB_OK);*/

	for(int k = 0; k < 3; k++)
	{
		for(int j = 0; j <= 6 - dwSizeY; j++)
		{
			for(int i = 0; i <= 6 - dwSizeX; i++)
			{
				BOOL bAble = TRUE;
				for(int cy = 0; cy < dwSizeY; cy++)
				{
					for(int cx = 0; cx < dwSizeX; cx++)
					{
						if(m_aryInven[k][j + cy][i + cx] != ITEM_EMPTY)
						{
							CItemInstance *lpItem = GetInventoryItem(m_aryInven[k][j + cy][i + cx]);
							unsigned char cPosX, cPosY, cTab;
							lpItem->m_lpItemBase->GetPos().GetPos(cPosX, cPosY, cTab);

							if(bStack && lpProtoType->m_DetailData.m_dwFlags & Item::DetailData::STACKABLE &&				// ½ºÅÃÀÌ °¡´ÉÇÑ°¡ ¾Æ´Ñ°¡...
								(cPosX == i && cPosY == j) && lpItem->GetProtoTypeID() == lpFieldInstance->m_dwTypeID &&						// °°Àº ¾ÆÀÌÅÛÀΰ¡ ¾Æ´Ñ°¡...
								lpItem->GetNowDurability() < lpItem->GetMaxDurability())			// ²Ë Â÷ÀÖ³ª ¾Æ´Ñ°¡...
							{
								if(lpItem->GetMaxDurability() - lpItem->GetNowDurability() < lpFieldInstance->m_cNum)
								{
									bAble = FALSE;
								}
							} else
							{
								bAble = FALSE;
							}
						}
					}
				}

				if(bAble)
				{
					pItemIndex.m_cPos = ClientSocket::ItemPos_Inven;
					pItemIndex.SetPos(i, j, k);
/*					sprintf(strText, "¼º°ø, %d", lpFieldInstance->m_cNum);
//					sprintf(strText, "%x, %d, %d, %d", m_aryInven[k][j][i], i, j, k);
					MessageBox(NULL, strText, "abc", MB_OK);*/

					return lpFieldInstance->m_cNum;
				} else
				{
/*					sprintf(strText, "%d, %d, %d", i, j, k);
//					sprintf(strText, "%x, %d, %d, %d", m_aryInven[k][j][i], i, j, k);
					MessageBox(NULL, strText, "abc", MB_OK);*/
				}
			}
		}
	}

	return 0;
}

CItemInstance *CCharStatus::GetDepositItem(__int64 ddItemUID)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstDeposit.begin(); it != m_lstDeposit.end(); it++)
	{
		if((*it)->m_dwItemUID == ddItemUID) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetDepositItem(Item::ItemPos &pIndex)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstDeposit.begin(); it != m_lstDeposit.end(); it++)
	{
		if((*it)->m_lpItemBase->GetPos() == pIndex) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetDepositItem(unsigned short wIndex)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstDeposit.begin(); it != m_lstDeposit.end(); it++)
	{
		if((*it)->m_lpItemBase->GetPos().m_cIndex == wIndex) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetDepositItemfromID(unsigned short wProtoTypeID)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstDeposit.begin(); it != m_lstDeposit.end(); it++)
	{
		if((*it)->GetProtoTypeID() == wProtoTypeID) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetInventoryItem(__int64 ddItemUID)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstInventory.begin(); it != m_lstInventory.end(); it++)
	{
		if((*it)->m_dwItemUID == ddItemUID) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetInventoryItem(Item::ItemPos &pIndex)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstInventory.begin(); it != m_lstInventory.end(); it++)
	{
		if((*it)->m_lpItemBase->GetPos() == pIndex) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetInventoryItem(unsigned short wIndex)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstInventory.begin(); it != m_lstInventory.end(); it++)
	{
		if((*it)->m_lpItemBase->GetPos().m_cIndex == wIndex) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetInventoryItemfromID(unsigned short wProtoTypeID)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstInventory.begin(); it != m_lstInventory.end(); it++)
	{
		if((*it)->GetProtoTypeID() == wProtoTypeID) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetStreetTradeItem(__int64 ddItemUID)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstStreetTrade.begin(); it != m_lstStreetTrade.end(); it++)
	{
		if((*it)->m_dwItemUID == ddItemUID) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetStreetTradeItem(Item::ItemPos &pIndex)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstStreetTrade.begin(); it != m_lstStreetTrade.end(); it++)
	{
		if((*it)->m_lpItemBase->GetPos() == pIndex) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetStreetTradeItem(unsigned short wIndex)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstStreetTrade.begin(); it != m_lstStreetTrade.end(); it++)
	{
		if((*it)->m_lpItemBase->GetPos().m_cIndex == wIndex) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetStreetTradeItemfromID(unsigned short wProtoTypeID)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstStreetTrade.begin(); it != m_lstStreetTrade.end(); it++)
	{
		if((*it)->GetProtoTypeID() == wProtoTypeID) return (*it);
	}

	return NULL;
}

CItemInstance *CCharStatus::GetExchangeItem(__int64 ddItemUID, BOOL bSelf)
{
	list<CItemInstance *>::iterator it;
	if(bSelf)
	{
		for(it = m_lstExchange.begin(); it != m_lstExchange.end(); it++)
		{
			if((*it)->m_dwItemUID == ddItemUID) return (*it);
		}
	} else
	{
		for(it = m_lstExchange2.begin(); it != m_lstExchange2.end(); it++)
		{
			if((*it)->m_dwItemUID == ddItemUID) return (*it);
		}
	}

	return NULL;
}

CItemInstance *CCharStatus::GetExchangeItem(unsigned short wIndex, BOOL bSelf)
{
	list<CItemInstance *>::iterator it;
	if(bSelf)
	{
		for(it = m_lstExchange.begin(); it != m_lstExchange.end(); it++)
		{
			if((*it)->m_lpItemBase->GetPos().m_cIndex == wIndex) return (*it);
		}
	} else
	{
		for(it = m_lstExchange2.begin(); it != m_lstExchange2.end(); it++)
		{
			if((*it)->m_lpItemBase->GetPos().m_cIndex == wIndex) return (*it);
		}
	}

	return NULL;
}

CItemInstance *CCharStatus::GetExchangeItem(Item::ItemPos &pIndex, BOOL bSelf)
{
	list<CItemInstance *>::iterator it;
	if(bSelf)
	{
		for(it = m_lstExchange.begin(); it != m_lstExchange.end(); it++)
		{
			if((*it)->m_lpItemBase->GetPos() == pIndex) return (*it);
		}
	} else
	{
		for(it = m_lstExchange2.begin(); it != m_lstExchange2.end(); it++)
		{
			if((*it)->m_lpItemBase->GetPos() == pIndex) return (*it);
		}
	}

	return NULL;
}

CItemInstance *CCharStatus::GetExchangeItemfromID(unsigned short wProtoTypeID, BOOL bSelf)
{
	list<CItemInstance *>::iterator it;
	if(bSelf)
	{
		for(it = m_lstExchange.begin(); it != m_lstExchange.end(); it++)
		{
			if((*it)->GetProtoTypeID() == wProtoTypeID) return (*it);
		}
	} else
	{
		for(it = m_lstExchange2.begin(); it != m_lstExchange2.end(); it++)
		{
			if((*it)->GetProtoTypeID() == wProtoTypeID) return (*it);
		}
	}

	return NULL;
}

void CCharStatus::DeleteInventoryItem(CItemInstance *lpDelete)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstInventory.begin(); it != m_lstInventory.end(); it++)
	{
		if((*it) == lpDelete)
		{
			CheckInvenField(0, lpDelete);
			m_lstInventory.erase(it);
			SetQuickSlot(lpDelete);
			break;
		}
	}
}

void CCharStatus::DeleteDepositItem(CItemInstance *lpDelete)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstDeposit.begin(); it != m_lstDeposit.end(); it++)
	{
		if((*it) == lpDelete)
		{
			CheckDepositField(0, lpDelete);
			m_lstDeposit.erase(it);
			break;
		}
	}
}

void CCharStatus::DeleteExchangeItem(CItemInstance *lpDelete, BOOL bSelf)
{
	list<CItemInstance *>::iterator it;
	if(bSelf)
	{
		for(it = m_lstExchange.begin(); it != m_lstExchange.end(); it++)
		{
			if((*it) == lpDelete)
			{
				CheckExchangeField(0, lpDelete, bSelf);
				m_lstExchange.erase(it);
				break;
			}
		}
	} else
	{
		for(it = m_lstExchange2.begin(); it != m_lstExchange2.end(); it++)
		{
			if((*it) == lpDelete)
			{
				CheckExchangeField(0, lpDelete, bSelf);
				m_lstExchange2.erase(it);
				break;
			}
		}
	}
}

void CCharStatus::DeleteStreetTradeItem(CItemInstance *lpDelete)
{
	list<CItemInstance *>::iterator it;
	for(it = m_lstStreetTrade.begin(); it != m_lstStreetTrade.end(); it++)
	{
		if((*it) == lpDelete)
		{
			CheckStreetTradeField(0, lpDelete);
			m_lstStreetTrade.erase(it);
			break;
		}
	}
}

void CCharStatus::AddInventoryItem(CItemInstance *AddItem, BOOL bSound)
{
	CItemInstance *lpItem = GetInventoryItem(AddItem->m_lpItemBase->GetPos().m_cIndex);
	if(lpItem)
	{
		if(lpItem->GetIsEnableStack())
		{
			DeleteInventoryItem(lpItem);
			delete lpItem;
		} else
		{
			return;
		}
	}
	m_lstInventory.push_back(AddItem);
	SetQuickSlot(AddItem);
	CheckInvenField(1, AddItem);

	if(bSound && AddItem->m_lpItemBase &&
		strcmp(AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName, "NONE"))
	{
		CSoundManager &sm = CSoundManager::GetInstance();
		char Temp[MAX_PATH];
		sprintf(Temp, "%s\\Sound\\Item\\%s", g_ClientMain.m_strClientPath, AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName);
		ISoundObject &sb = sm.GetBuffer(Temp, false);
		sb.Play(false);
	}
}

void CCharStatus::AddEquipItem(unsigned long dwPos, CItemInstance *AddItem, BOOL bSound)
{
	m_lstEquipment[dwPos] = AddItem;

	if(bSound && AddItem->m_lpItemBase &&
		strcmp(AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName, "NONE"))
	{
		CSoundManager &sm = CSoundManager::GetInstance();
		char Temp[MAX_PATH];
		sprintf(Temp, "%s\\Sound\\Item\\%s", g_ClientMain.m_strClientPath, AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName);
		ISoundObject &sb = sm.GetBuffer(Temp, false);
		sb.Play(false);
	}
}

void CCharStatus::AddDepositItem(CItemInstance *AddItem, BOOL bSound)
{
	CItemInstance *lpItem = GetDepositItem(AddItem->m_lpItemBase->GetPos().m_cIndex);
	if(lpItem)
	{
		if(lpItem->GetIsEnableStack())
		{
			DeleteDepositItem(lpItem);
			delete lpItem;
		} else
		{
			return;
		}
	}
	m_lstDeposit.push_back(AddItem);
	CheckDepositField(1, AddItem);

	if(bSound && AddItem->m_lpItemBase &&
		strcmp(AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName, "NONE"))
	{
		CSoundManager &sm = CSoundManager::GetInstance();
		char Temp[MAX_PATH];
		sprintf(Temp, "%s\\Sound\\Item\\%s", g_ClientMain.m_strClientPath, AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName);
		ISoundObject &sb = sm.GetBuffer(Temp, false);
		sb.Play(false);
	}
}

void CCharStatus::AddExchangeItem(CItemInstance *AddItem, BOOL bSelf, BOOL bSound)
{
	CItemInstance *lpItem = GetExchangeItem(AddItem->m_lpItemBase->GetPos().m_cIndex, bSelf);
	if(lpItem)
	{
		if(lpItem->GetIsEnableStack())
		{
			DeleteExchangeItem(lpItem, bSelf);
			delete lpItem;
		} else
		{
			return;
		}
	}

	if(bSelf)
	{
		m_lstExchange.push_back(AddItem);
	} else
	{
		m_lstExchange2.push_back(AddItem);
	}
	CheckExchangeField(1, AddItem, bSelf);

	if(bSound && AddItem->m_lpItemBase &&
		strcmp(AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName, "NONE"))
	{
		CSoundManager &sm = CSoundManager::GetInstance();
		char Temp[MAX_PATH];
		sprintf(Temp, "%s\\Sound\\Item\\%s", g_ClientMain.m_strClientPath, AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName);
		ISoundObject &sb = sm.GetBuffer(Temp, false);
		sb.Play(false);
	}
}

void CCharStatus::AddStreetTradeItem(CItemInstance *AddItem, BOOL bSound)
{
	CItemInstance *lpItem = GetStreetTradeItem(AddItem->m_lpItemBase->GetPos().m_cIndex);
	if(lpItem)
	{
		return;
	}
	m_lstStreetTrade.push_back(AddItem);
	CheckStreetTradeField(1, AddItem);

	if(bSound && AddItem->m_lpItemBase &&
		strcmp(AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName, "NONE"))
	{
		CSoundManager &sm = CSoundManager::GetInstance();
		char Temp[MAX_PATH];
		sprintf(Temp, "%s\\Sound\\Item\\%s", g_ClientMain.m_strClientPath, AddItem->m_lpItemBase->GetItemInfo().m_StringData.m_szEffectSoundName);
		ISoundObject &sb = sm.GetBuffer(Temp, false);
		sb.Play(false);
	}
}

SKILLSLOT *CCharStatus::GetSkillSlot(unsigned short wSkill)
{
	for(int i = 0; i < 20; i++)
	{
		if(m_Skill.SSlot[i].SKILLINFO.wSkill == wSkill)
		{
			return &m_Skill.SSlot[i];
		}
	}

	return NULL;
}

void CCharStatus::DestroyParty()
{
	m_Info.Party = 0;
	m_PartyInfo.m_cMemberNum = 0;
	m_PartyInfo.m_dwPartyID = 0;
	m_PartyInfo.m_dwLeaderID = 0;
	for(int i = 0; i < 10; i++)
	{
		m_PartyInfo.ServerID[i] = 0;
		m_PartyInfo.MemberCID[i] = 0;
		strcpy(m_PartyInfo.Name[i], "");
	}
}

void CCharStatus::DeletePartyPlayer(unsigned long dwChrID)
{
	for(int i = 0; i < m_PartyInfo.m_cMemberNum; i++)
	{
		if(m_PartyInfo.MemberCID[i] == dwChrID)
		{
			for(int j = i; j < 9; j++)
			{
				m_PartyInfo.MemberCID[j] = m_PartyInfo.MemberCID[j + 1];
				m_PartyInfo.ServerID[j] = m_PartyInfo.ServerID[j + 1];
				strcpy(m_PartyInfo.Name[j], m_PartyInfo.Name[j + 1]);
			}

			m_PartyInfo.m_cMemberNum--;
			m_PartyInfo.MemberCID[9] = 0;
			m_PartyInfo.ServerID[9] = 0;
			strcpy(m_PartyInfo.Name[9], "");

			CCreature *lpCreature = g_CharacterData.GetCreature(dwChrID);
			if(lpCreature)
			{
				lpCreature->m_dwPartyID = 0;
			}
			break;
		}
	}
}

void CCharStatus::AddPartyPlayer(unsigned long dwChrID, unsigned long dwServerID, char *strName)
{
	for(int i = 0; i < 10; i++)
	{
		if(!m_PartyInfo.MemberCID[i])
		{
			m_PartyInfo.MemberCID[i] = dwChrID;
			m_PartyInfo.ServerID[i] = dwServerID;
			strcpy(m_PartyInfo.Name[i], strName);
			m_PartyInfo.m_cMemberNum++;

			CCreature *lpCreature = g_CharacterData.GetCreature(dwChrID);
			if(lpCreature)
			{
				lpCreature->m_dwPartyID = m_PartyInfo.m_dwPartyID;
			}
			break;
		}
	}
}

char *CCharStatus::LoginPartyPlayer(unsigned long dwChrID, unsigned long dwServerID)
{
	for(int i = 0; i < 10; i++)
	{
		if(m_PartyInfo.MemberCID[i] == dwChrID)
		{
			m_PartyInfo.ServerID[i] = dwServerID;
			return m_PartyInfo.Name[i];
		}
	}

	return NULL;
}

char *CCharStatus::LogoutPartyPlayer(unsigned long dwChrID)
{
	for(int i = 0; i < 10; i++)
	{
		if(m_PartyInfo.MemberCID[i] == dwChrID)
		{
			m_PartyInfo.ServerID[i] = 0;
			return m_PartyInfo.Name[i];
		}
	}

	return NULL;
}

BOOL CCharStatus::GetIsInstallSocket(CItemInstance *lpEquipItem, CItemInstance *lpSocketItem)
{
	// ¼ÒÄÏ ¹Û±â
	if(lpEquipItem->GetIsEquip())
	{
		Item::CEquipment *lpEquip = Item::CEquipment::DowncastToEquipment(lpEquipItem->m_lpItemBase);
		if(lpEquip)
		{
			if(lpSocketItem->GetNowDurability() == 1)
			{
				if(lpSocketItem->GetItemType() == Item::CItemType::GEM)
				{
					int sn;
					for(sn = 0; sn < lpEquip->m_cMaxSocket; sn++)
					{
						if(!lpEquip->m_cSocket[sn]) break;
					}

					if(sn < lpEquip->m_cMaxSocket)
					{
						return TRUE;
					}
				} else if(lpSocketItem->GetItemType() == Item::CItemType::RUNE)
				{
					if(!lpEquip->m_usRuneSocket)
					{
						return TRUE;
					}
				}
			}
		}
	}

	return FALSE;
}

BOOL CCharStatus::CheckPartyMember(unsigned long dwChrID)
{
	for(int i = 0; i < 10; i++)
	{
		if(m_PartyInfo.MemberCID[i] == dwChrID) return TRUE;
	}

	return FALSE;
}

BOOL CCharStatus::IsCheckStatusforSkill(unsigned short wSkill)
{
	const Skill::ProtoType *lpSkill = g_SkillMgr.GetSkillProtoType(wSkill);

	if(!lpSkill) return FALSE;

	SKILLSLOT *lpSkillSlot = GetSkillSlot(lpSkill->m_usSkill_ID);
	unsigned long dwValue;

	for(int i = 0; i < 2; i++)
	{
		if(lpSkill->m_StatusLimitType[i])
		{
			if(lpSkillSlot)
				dwValue = (lpSkillSlot->SKILLINFO.cLockCount * 6 + lpSkillSlot->SKILLINFO.cSkillLevel + 1) * lpSkill->m_StatusLimitValue[i];
			else
				dwValue = lpSkill->m_StatusLimitValue[i];

			switch(lpSkill->m_StatusLimitType[i])
			{
				case Skill::StatusLimit::STR:
					if(m_Info.STR < dwValue) return FALSE;
					break;
				case Skill::StatusLimit::DEX:
					if(m_Info.DEX < dwValue) return FALSE;
					break;
				case Skill::StatusLimit::CON:
					if(m_Info.CON < dwValue) return FALSE;
					break;
				case Skill::StatusLimit::INT:
					if(m_Info.INT < dwValue) return FALSE;
					break;
				case Skill::StatusLimit::WIS:
					if(m_Info.WIS < dwValue) return FALSE;
					break;
			}
		}
	}

	return TRUE;
}

unsigned long CCharStatus::IsCheckClassforSkill(unsigned short wSkill)
{
	unsigned char cSkillClass = (unsigned char)(((wSkill & 0xFF00) >> 8) - 0x80);

	if(m_Info.Nationality == NATION_HUMAN)
	{
		if(1 <= m_Info.Class && m_Info.Class <= 4)
		{
			if(m_Info.Class == cSkillClass) return 1;
			if(1 <= cSkillClass && cSkillClass <= 4) return 2;

			switch(m_Info.Class)
			{
				case 1:
					if(cSkillClass == 5 || cSkillClass == 6) return 3;
					break;

				case 2:
					if(cSkillClass == 7 || cSkillClass == 8) return 3;
					break;

				case 3:
					if(cSkillClass == 9 || cSkillClass == 10) return 3;
					break;

				case 4:
					if(cSkillClass == 11 || cSkillClass == 12) return 3;
					break;
			}
		} else if(4 < m_Info.Class && m_Info.Class <= 12)
		{
			if(cSkillClass == 1 || cSkillClass == 2 || cSkillClass == 3 || cSkillClass == 4)
				return 1;

			if(m_Info.Class == cSkillClass) return 1;
		}
	} else if(m_Info.Nationality == NATION_AKHAN)
	{
		if(17 <= m_Info.Class && m_Info.Class <= 18)
		{
			if(m_Info.Class == cSkillClass) return 1;
			if(17 <= cSkillClass && cSkillClass <= 18) return 2;

			switch(m_Info.Class)
			{
				case 17:
					if(cSkillClass == 19 || cSkillClass == 20 || cSkillClass == 21) return 3;
					break;

				case 18:
					if(cSkillClass == 22 || cSkillClass == 23 || cSkillClass == 24) return 3;
					break;
			}
		} else if(18 < m_Info.Class && m_Info.Class <= 24)
		{
			if(cSkillClass == 17 || cSkillClass == 18)
				return 1;

			if(m_Info.Class == cSkillClass) return 1;
		}
	}

	return 0;
}

long CCharStatus::GetUseIP(unsigned long dwKindStatus)
{
	switch(m_Info.Class)
	{
		case 1:
			if(dwKindStatus == STATUS_STR || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		case 2:
			if(dwKindStatus == STATUS_DEX || dwKindStatus == STATUS_STR) return 2; else return 1;
			break;

		case 3:
			if(dwKindStatus == STATUS_INT || dwKindStatus == STATUS_DEX) return 2; else return 1;
			break;

		case 4:
			if(dwKindStatus == STATUS_WIS || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		case 5:
			if(dwKindStatus == STATUS_STR || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		case 6:
			if(dwKindStatus == STATUS_STR || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		case 7:
			if(dwKindStatus == STATUS_DEX || dwKindStatus == STATUS_STR) return 2; else return 1;
			break;

		case 8:
			if(dwKindStatus == STATUS_DEX || dwKindStatus == STATUS_STR) return 2; else return 1;
			break;

		case 9:
			if(dwKindStatus == STATUS_INT || dwKindStatus == STATUS_DEX) return 2; else return 1;
			break;

		case 10:
			if(dwKindStatus == STATUS_INT || dwKindStatus == STATUS_DEX) return 2; else return 1;
			break;

		case 11:
			if(dwKindStatus == STATUS_WIS || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		case 12:
			if(dwKindStatus == STATUS_WIS || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		// ¾ÆÄ­

		case 17:
			if(dwKindStatus == STATUS_STR || dwKindStatus == STATUS_CON || dwKindStatus == STATUS_DEX) return 2; else return 1;
			break;

		case 18:
			if(dwKindStatus == STATUS_STR || dwKindStatus == STATUS_INT || dwKindStatus == STATUS_WIS || dwKindStatus == STATUS_DEX) return 2; else return 1;
			break;

		case 19:
			if(dwKindStatus == STATUS_STR || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		case 20:
			if(dwKindStatus == STATUS_STR || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		case 21:
			if(dwKindStatus == STATUS_DEX || dwKindStatus == STATUS_CON) return 2; else return 1;
			break;

		case 22:
			if(dwKindStatus == STATUS_INT || dwKindStatus == STATUS_DEX) return 2; else return 1;
			break;

		case 23:
			if(dwKindStatus == STATUS_WIS || dwKindStatus == STATUS_DEX) return 2; else return 1;
			break;

		case 24:
			if(dwKindStatus == STATUS_STR || dwKindStatus == STATUS_DEX) return 2; else return 1;
			break;
	}

	return 0;
}

unsigned long CCharStatus::CheckUseSkillBook(CItemInstance *lpItem)
{
	long lINT = (((m_Info.INT + m_lAddINT) - 20) / 10.0f);		if(lINT < 0 ) lINT = 0;

	if(m_Skill.wSkillNum < (m_Info.Level + lINT))
	{
		//// Ŭ·¡½º ±¸ºÐ
		unsigned short wSkill = lpItem->GetSkillID();

		unsigned long dwClassResult = IsCheckClassforSkill(wSkill);
		if(dwClassResult != 1)
		{
			switch(dwClassResult)
			{
				case 0:
					return 7;

				case 2:
					return 8;

				case 3:
					return 9;
			}

			return 0;
		}

		LPSKILLSLOT lpSkillSlot = GetSkillSlot(wSkill);
		if(lpSkillSlot)
		{
			if(lpSkillSlot->SKILLINFO.cLockCount == lpItem->m_lpItemBase->GetItemInfo().m_UseItemInfo.m_usSkill_LockCount)
			{
				if(lpSkillSlot->SKILLINFO.cSkillLevel < 6)
				{
					if(IsCheckStatusforSkill(wSkill))
					{
						return 1;
					} else
					{
						return 2;
/*						CGUIMessageBox *lpMessageBox;
						lpMessageBox = new CGUIMessageBox;
						lpMessageBox->Create("´É·ÂÄ¡°¡ Àû¾î ¿Ü¿ï ¼ö ¾ø½À´Ï´Ù.");*/
					}
				} else
				{
					return 3;
/*					CGUIMessageBox *lpMessageBox;
					lpMessageBox = new CGUIMessageBox;
					lpMessageBox->Create("½ºÅ³ÀÌ ²Ë á½À´Ï´Ù.");
					// ½ºÅ³ÀÌ ²Ë á´Ù.*/
				}
			} else
			{
				return 4;
/*				// ¿Ü¿ï ¼ö ÀÖ´Â ½ºÅ³ºÏÀÌ ¾Æ´Ï´Ù.
				CGUIMessageBox *lpMessageBox;
				lpMessageBox = new CGUIMessageBox;
				lpMessageBox->Create("¿Ü¿ï ¼ö ÀÖ´Â ½ºÅ³ÀÌ ¾Æ´Õ´Ï´Ù.");*/
			}
		} else
		{
			if(m_Skill.wSlotNum < 20)
			{
				if(lpItem->m_lpItemBase->GetItemInfo().m_UseItemInfo.m_usSkill_LockCount == 0)
				{
					if(IsCheckStatusforSkill(wSkill))
					{
						return 1;
					} else
					{
						return 2;
					}
				} else
				{
					return 4;
				}
			} else
			{
				return 5;
/*				// Ä­ÀÌ ¾ø´Ù.
				CGUIMessageBox *lpMessageBox;
				lpMessageBox = new CGUIMessageBox;
				lpMessageBox->Create("½ºÅ³ ½½·ÔÀÌ ²Ë á½À´Ï´Ù.");*/
			}
		}
	} else
	{
		return 6;
/*		// ·¹º§ÀÌ µþ·Á ½½·ÔÀÌ ¾ø´Ù.
		CGUIMessageBox *lpMessageBox;
		lpMessageBox = new CGUIMessageBox;
		lpMessageBox->Create("·¹º§ÀÌ ³Ê¹« ³·½À´Ï´Ù.");*/
	}
}

unsigned long CCharStatus::CheckUsePotion(CItemInstance *lpItem)
{
	// Äð´Ù¿î ŸÀÓÀ» üũÇÑ ÈÄ »ç¿ë À¯¹«¸¦ °áÁ¤ÇÑ´Ù.
	if(m_lPotionCoolDownTime <= 0)
	{
		return 1;
	}

	return 0;
}

BOOL CCharStatus::SetQuickSlotItemNumber(CItemInstance *lpItem)
{
	list<CItemInstance *>::iterator it;
	unsigned long dwItemNumber = 0;
	for(it = m_lstInventory.begin(); it != m_lstInventory.end(); it++)
	{
		if(lpItem->GetProtoTypeID() == (*it)->GetProtoTypeID())
		{
			dwItemNumber += (*it)->GetNowDurability();
		}
	}

	if(dwItemNumber == 0) return FALSE;

	if(dwItemNumber > 99)
		lpItem->SetNowDurability(99);
	else
		lpItem->SetNowDurability(dwItemNumber);

	return TRUE;
}

void CCharStatus::SetQuickSlot(CItemInstance *lpItem)
{
	if(!lpItem->m_lpItemBase->IsSet(Item::DetailData::QUICKSLOT_IN)) return;

	for(int i = 0; i < 10; i++)
	{
		if(m_lstQuickSlot[i])
		{
			if(m_lstQuickSlot[i]->GetProtoTypeID() == lpItem->GetProtoTypeID())
			{
				if(!SetQuickSlotItemNumber(m_lstQuickSlot[i]))
				{
					g_ClientMain.m_Network.SendQuickSlotMove(m_lstQuickSlot[i], ClientSocket::ItemPos_None, i);
				}
			}
		}
	}
}

BOOL CCharStatus::CheckItemByStatus(CItemInstance *lpItem)
{
	const Item::UseLimit *lpLimit = &lpItem->GetItemInfo().m_UseLimit;

	if(m_Info.Level < lpLimit->m_nStatusLimit[Item::StatusLimit::LEVEL]) return FALSE;
	if(m_Info.STR < lpLimit->m_nStatusLimit[Item::StatusLimit::STR]) return FALSE;
	if(m_Info.DEX < lpLimit->m_nStatusLimit[Item::StatusLimit::DEX]) return FALSE;
	if(m_Info.CON < lpLimit->m_nStatusLimit[Item::StatusLimit::CON]) return FALSE;
	if(m_Info.INT < lpLimit->m_nStatusLimit[Item::StatusLimit::INT]) return FALSE;
	if(m_Info.WIS < lpLimit->m_nStatusLimit[Item::StatusLimit::WIS]) return FALSE;

/*	if(lpLimit->m_nCanUseRace != Item::Race::ALL)
	{
		switch(lpLimit->m_nCanUseRace)
		{
			case Item::Race::HUMAN:
				if(m_Info.Nationality != NATION_HUMAN) return FALSE;
				break;
			case Item::Race::AKHAN:
				if(m_Info.Nationality != NATION_AKHAN) return FALSE;
				break;
		}
	}*/

	if(!(lpLimit->m_dwClassLimit & (0x00000001 << (m_Info.Class - 1))))
	{
		return FALSE;
	}

	return TRUE;
}

BOOL CCharStatus::GetExistExchangeItem()
{
	if(m_lstExchange.size() || m_lstExchange2.size() || m_dwExchangeGold || m_dwExchange2Gold)
		return TRUE;
	else
		return FALSE;
}

BOOL CCharStatus::CheckUseSkill()
{
/*	int nResult = CSceneManager::GetCharacterEvent(g_CharacterData.m_lstCharData[g_CharacterData.m_nFocusCharacter]->m_lpChrModel, EVENT_JUST);
	if(nResult)
	{
//		Skill::LPProtoType lpSkill = g_SkillMgr.GetSkillProtoType(m_lpQuickSelected->GetProtoTypeID());
		// ¿©±â¼­ ½ºÅ³ÀÌ ¿¬µ¿µÇ´ÂÁö üũ
		// ¿¬µ¿ÀÌ µÇÁö ¾Ê°Å³ª, ¿¬µ¿ µÇ´õ¶óµµ ¸¶Áö¸·Å¸À̸é FALSE
/*		unsigned long dwMotion = g_CharacterData.m_lstCharData[g_CharacterData.m_nFocusCharacter]->m_dwUpperChrAction;
		if(dwMotion == CA_OVERBASH1)
		{
			unsigned char cFrame = (unsigned char)g_CharacterData.m_lstCharData[g_CharacterData.m_nFocusCharacter]->m_lpChrModel->GetMotionCurrentFrame(0);
			if(lpSkill->m_cMinRange <= cFrame && cFrame <= lpSkill->m_cMaxRange)
			{*/
//				return TRUE;
//			}
//		}
//	}

	if(m_lpQuickSelected)
	{
		const Skill::ProtoType *lpSkill = g_SkillMgr.GetSkillProtoType(m_lpQuickSelected->GetProtoTypeID());

		if(m_lpQuickSelected->m_lCoolDownTimeCount <= 0 || (lpSkill->m_bGauge && g_CharacterData.m_bComboSuccess))
		{
			g_CharacterData.m_bComboSuccess = FALSE;
			return TRUE;
		}
	}

	g_CharacterData.m_bComboSuccess = FALSE;
	return FALSE;
}


void CCharStatus::SetActivateSkill(CItemInstance *lpUseSkill)
{
	m_lpQuickSelected = lpUseSkill;
	g_CharacterData.m_lstCharData[g_CharacterData.m_nFocusCharacter]->m_dwSkillComboCount = 0;
	g_CharacterData.m_lstCharData[g_CharacterData.m_nFocusCharacter]->m_bSkillCombo = FALSE;

	if(g_CharacterData.m_lpButtonNormal)
	{
		CSceneManager::m_EffectManager.DeleteInterfaceScript(g_CharacterData.m_lpButtonNormal);
		g_CharacterData.m_lpButtonNormal = NULL;
		g_CharacterData.m_bComboSuccess = FALSE;

		CEffScript *test_script;
//		_ASSERTE(_CrtCheckMemory());
		test_script = new CEffScript;
		test_script->SetInterfaceSet(true);
		test_script->GetScriptBinData("inter_fasthit_button_4.esf");
		CSceneManager::m_EffectManager.AddInterfaceScript(test_script);
	}
}

BOOL CCharStatus::CheckStatus()
{
	long TIP = m_Info.IP;

	switch(m_Info.Class)
	{
		case 1:							// ÆÄÀÌÅÍ
			TIP += (m_Info.STR - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 2:							// ·Î±×
			TIP += (m_Info.STR - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.DEX - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 3:							// ¸ÞÀÌÁö
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 4:							// ¾îÄݶóÀÌÆ®
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20 - (m_Info.Level - 1)) * 2;
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 5:							// µðÆæ´õ
			TIP += (m_Info.STR - 20 - int((m_Info.Level - 1) * 1.5)) * 2;
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - int((m_Info.Level - 1) * 1.5 + 0.5)) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 6:							// ¿ö¸®¾î
			TIP += (m_Info.STR - 20 - (m_Info.Level - 1) * 2) * 2;
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - (m_Info.Level - 1) * 1) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 7:							// ¾î½Ø½Å
			TIP += (m_Info.STR - 20 - (m_Info.Level - 1) * 1) * 2;
			TIP += (m_Info.DEX - 20 - (m_Info.Level - 1) * 2) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 8:							// ¾ÆÃÄ
			TIP += (m_Info.STR - 20 - (int)((m_Info.Level - 1) * 1.5 + 0.5)) * 2;
			TIP += (m_Info.DEX - 20 - (int)((m_Info.Level - 1) * 1.5)) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 9:							// ¼Ò¼­·¯
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20 - (m_Info.Level - 1) * 1) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20 - (m_Info.Level - 1) * 2) * 2;
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 10:						// ÀÎæÅÍ
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20 - (int)((m_Info.Level - 1) * 1.5 + 0.5)) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20 - (int)((m_Info.Level - 1) * 1.5)) * 2;
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 11:						// ÇÁ¸®½ºÆ®
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - (int)((m_Info.Level - 1) * 1.5 + 0.5)) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20 - (int)((m_Info.Level - 1) * 1.5)) * 2;
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 12:						// Ŭ·¹¸¯
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - (m_Info.Level - 1) * 1) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20 - (m_Info.Level - 1) * 2) * 2;
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 17:						// ÄĹèÅÏÆ®
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > 10)
				return FALSE;
			break;

		case 18:						// ¿ÀÇǼ¼ÀÌÅÍ
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20 - (m_Info.Level - 1)) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > 10)
				return FALSE;
			break;

		case 19:						// ÅÛÇ÷¯
			TIP += (m_Info.STR - 20 - (int)((m_Info.Level - 1) * 1.5)) * 2;
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - (int)((m_Info.Level - 1) * 1.5 + 0.5)) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 20:						// ¾îÅÂÄ¿
			TIP += (m_Info.STR - 20 - (m_Info.Level - 1) * 2) * 2;
			TIP += (m_Info.DEX - 20);
			TIP += (m_Info.CON - 20 - (m_Info.Level - 1) * 1) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 21:						// °Å³Ê
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20 - (int)((m_Info.Level - 1) * 1.5)) * 2;
			TIP += (m_Info.CON - 20 - (int)((m_Info.Level - 1) * 1.5 + 0.5)) * 2;
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 22:						// ·é ¿ÀÇÁ
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20 - (m_Info.Level - 1) * 1) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20 - (m_Info.Level - 1) * 2) * 2;
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 23:						// ¶óÀÌÇÁ ¿ÀÇÁ
			TIP += (m_Info.STR - 20);
			TIP += (m_Info.DEX - 20 - (m_Info.Level - 1) * 1) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20 - (m_Info.Level - 1) * 2) * 2;
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;

		case 24:						// ½¦µµ¿ì ¿ÀÇÁ
			TIP += (m_Info.STR - 20 - (int)((m_Info.Level - 1) * 1.5 + 0.5)) * 2;
			TIP += (m_Info.DEX - 20 - (int)((m_Info.Level - 1) * 1.5)) * 2;
			TIP += (m_Info.CON - 20);
			TIP += (m_Info.INT - 20);
			TIP += (m_Info.WIS - 20);
			if(TIP > (10 + (m_Info.Level - 1) * 2))
				return FALSE;
			break;
	}

/*	if(m_Info.Class && (long)g_CharacterData.m_fWalkSpeed != 0 && (long)g_CharacterData.m_fRunSpeed != 0)
	{
		float fWalkSpeed, fRunSpeed;
		float fSpeedFactor = 1.0f + ((m_Info.DEX + m_lAddDEX) - 20) * 0.005f;
		if(fSpeedFactor > 2.0f) fSpeedFactor = 2.0f;
		fWalkSpeed = 150.0f * fSpeedFactor;
		fRunSpeed = 490.0f * fSpeedFactor;

		// æƮ / ÀÎæƮ ¼öÄ¡ Àû¿ë
		for(unsigned long i = 0; i < 32; i++)
		{
			if(m_aryEnchantLevel[i])
			{
				switch(i)
				{
					case 16:		// Stealth
						fWalkSpeed = fWalkSpeed * (0.5f + m_aryEnchantLevel[i] / 20.0f);
						fRunSpeed = fRunSpeed * (0.5f + m_aryEnchantLevel[i] / 20.0f);
						break;

					case 26:		// Frozen
						fWalkSpeed = fWalkSpeed / 2.0f;
						fRunSpeed = fRunSpeed / 2.0f;
						break;
				}
			}
		}

		if((long)fWalkSpeed != (long)g_CharacterData.m_fWalkSpeed) return FALSE;
		if((long)fRunSpeed != (long)g_CharacterData.m_fRunSpeed) return FALSE;
	}*/

	return TRUE;
}

void CCharStatus::Destroy()
{
	int i, j, k;

	for(k = 0; k < 3; k++)
	{
		for(j = 0; j < 6; j++)
		{
			for(i = 0; i < 6; i++)
			{
				m_aryInven[k][j][i] = ITEM_EMPTY;
			}
		}
	}

	for(k = 0; k < 4; k++)
	{
		for(j = 0; j < 12; j++)
		{
			for(i = 0; i < 8; i++)
			{
				m_aryDeposit[k][j][i] = ITEM_EMPTY;
			}
		}
	}

	for(j = 0; j < 4; j++)
	{
		for(i = 0; i < 8; i++)
		{
			m_aryExchange[j][i] = ITEM_EMPTY;
			m_aryExchange2[j][i] = ITEM_EMPTY;
		}
	}

	for(j = 0; j < 8; j++)
	{
		for(i = 0; i < 8; i++)
		{
			m_aryStreetTrade[j][i] = ITEM_EMPTY;
		}
	}

	m_dwExchangeGold = 0;
	m_dwExchange2Gold = 0;

	m_dwDepositGold = 0;
	m_cSavePass = 0;
	m_dwMaxTab = 0;
	m_dwDepositFlag = 0;
	m_cUsedDeposit = 0;

	for(i = 0; i < 32; i++)
	{
		m_aryEnchantLevel[i] = 0;
	}

	m_PartyInfo.m_cMemberNum = 0;
	m_PartyInfo.m_dwPartyID = 0;
	for(i = 0; i < 10; i++)
	{
		m_PartyInfo.MemberCID[i] = 0;
	}

	m_lPotionCoolDownTime = 0;

	list<CItemInstance *>::iterator it;
	CItemInstance *lpItem;
	for(it = m_lstInventory.begin(); it != m_lstInventory.end();)
	{
		lpItem = (*it);
		it = m_lstInventory.erase(it);
		delete lpItem;
	}
	m_lstInventory.clear();

	for(it = m_lstDeposit.begin(); it != m_lstDeposit.end();)
	{
		lpItem = (*it);
		it = m_lstDeposit.erase(it);
		delete lpItem;
	}
	m_lstDeposit.clear();

	for(it = m_lstStreetTrade.begin(); it != m_lstStreetTrade.end();)
	{
		lpItem = (*it);
		it = m_lstStreetTrade.erase(it);
		delete lpItem;
	}
	m_lstStreetTrade.clear();

	list<FriendInfo *>::iterator itFriend;
	FriendInfo *lpFriend;
	for(itFriend = m_lstFriendList.begin(); itFriend != m_lstFriendList.end();)
	{
		lpFriend = (*itFriend);
		itFriend = m_lstFriendList.erase(itFriend);
		delete lpFriend;
	}
	m_lstFriendList.clear();

	list<BanInfo *>::iterator itBan;
	BanInfo *lpBan;
	for(itBan = m_lstBanList.begin(); itBan != m_lstBanList.end();)
	{
		lpBan = (*itBan);
		itBan = m_lstBanList.erase(itBan);
		delete lpBan;
	}
	m_lstBanList.clear();

	for(i = 0; i < 32; i++)
	{
		m_aryEnchantLevel[i] = 0;
	}

	m_bUseChant = FALSE;

	for(i = 0; i < 10; i++)
	{
		if(m_lstQuickSlot[i])
		{
			delete m_lstQuickSlot[i];
			m_lstQuickSlot[i] = NULL;
		}
	}
	m_lpQuickSelected = NULL;
	for(i = 0; i < 20; i++)
	{
		if(m_lstSkillSlot[i])
		{
			delete m_lstSkillSlot[i];
			m_lstSkillSlot[i] = NULL;
		}
	}
	vector<CItemInstance *>::iterator itSkill;
	for(itSkill = m_lstClassSkill.begin(); itSkill != m_lstClassSkill.end();)
	{
		lpItem = (*itSkill);
		itSkill = m_lstClassSkill.erase(itSkill);
		delete lpItem;
	}
	for(i = 0; i < 15; i++)
	{
		if(m_lstEquipment[i])
		{
			delete m_lstEquipment[i];
			m_lstEquipment[i] = NULL;
		}
	}

	if(m_lpUpgrade[0]) { delete m_lpUpgrade[0]; m_lpUpgrade[0] = NULL; }
	if(m_lpUpgrade[1]) { delete m_lpUpgrade[1]; m_lpUpgrade[1] = NULL; }
}

void CCharStatus::PayDepositPrice(unsigned short wSrcPos, unsigned short wDstPos)
{
	if(wDstPos == ClientSocket::ItemPos_Deposit)
	{
		if(wSrcPos != ClientSocket::ItemPos_Deposit)
		{
			m_Info.Gold -= (m_Info.Level * 20);
		}
	}
}

void CCharStatus::ChantDisable()
{
	for(unsigned long i = 0; i < 20; i++)
	{
		if(g_ClientMain.m_csStatus.m_Skill.SSlot[i].SKILLINFO.wSkill)
		{
			const Skill::ProtoType *lpSkillProtoType = g_SkillMgr.GetSkillProtoType(g_ClientMain.m_csStatus.m_Skill.SSlot[i].SKILLINFO.wSkill);

			if(lpSkillProtoType && lpSkillProtoType->m_cEndCoolDown)
			{
				g_ClientMain.SetSkillCoolDown(g_ClientMain.m_csStatus.m_Skill.SSlot[i].SKILLINFO.wSkill);
			}
		}
	}
}

BOOL CCharStatus::GetCorrectClass(unsigned long dwClassFlag)
{
	if(dwClassFlag & (0x00000001 << (m_Info.Class - 1)))
	{
		return TRUE;
	}

	return FALSE;
}

BOOL QuestInstance::StartPhase(unsigned long dwPhase)
{
	// Trigger_Start¸¦ ã¾Æ¼­ À̺¥Æ®¸¦ ¼öÇà½ÃŲ´Ù.
	m_lstTriggerCount.clear();

	m_lpPhaseScript = m_lpQuestScript->GetPhase(dwPhase);

	if(m_lpPhaseScript)
	{
		// ÆäÀÌÁ ¼öÇàÇÑ´Ù. 
		m_dwPresentPhase = dwPhase;

		vector<LPTriggerNode>::iterator it;
		for(it = m_lpPhaseScript->m_lstTrigger.begin(); it != m_lpPhaseScript->m_lstTrigger.end(); it++)
		{
			m_lstTriggerCount.push_back((*it)->m_dwMaxCount);
		}
	}

	return TRUE;
}

BOOL QuestInstance::StartTrigger(LPTriggerNode lpTrigger, BOOL bSuccess)
{
	vector<LPEventNode>::iterator it;
	if(bSuccess)
	{
		for(it = lpTrigger->m_lstEvent.begin(); it != lpTrigger->m_lstEvent.end(); it++)
		{
			switch((*it)->m_dwEventKind)
			{
				case EVENT_MSGBOX:
					EventMsgBox((*it)->m_strWord);
					break;

				case EVENT_PHASE:
					EventPhase((*it)->m_dwEventNumber);
					break;

				case EVENT_END:
					return FALSE;
			}
		}
	} else
	{
		for(it = lpTrigger->m_lstFalseEvent.begin(); it != lpTrigger->m_lstFalseEvent.end(); it++)
		{
			switch((*it)->m_dwEventKind)
			{
				case EVENT_MSGBOX:
					EventMsgBox((*it)->m_strWord);
					break;

				case EVENT_PHASE:
					EventPhase((*it)->m_dwEventNumber);
					break;

				case EVENT_END:
					return FALSE;
			}
		}
	}

	return TRUE;
}

LPQuestInstance CCharStatus::GetProcessQuest(unsigned short wQuestID)
{
	list<LPQuestInstance>::iterator it;
	for(it = m_lstQuest.begin(); it != m_lstQuest.end(); it++)
	{
		if((unsigned short)(*it)->m_dwQuestID == wQuestID) return (*it);
	}

	return NULL;
}

BOOL QuestInstance::EventMsgBox(char *strWord)
{
	CGUIMessageBox *lpMessageBox = new CGUIMessageBox;
	lpMessageBox->Create(strWord);

	return TRUE;
}

BOOL QuestInstance::EventPhase(unsigned long dwPhase)
{
	StartPhase(dwPhase);

	return TRUE;
}

LPTriggerNode CCharStatus::GetTriggertoTalk(LPQuestInstance &lpQuest, unsigned long *dwCount, unsigned long dwChrID)
{
	list<LPQuestInstance>::iterator itQuest;
	unsigned long dwTriggerCount;
	for(itQuest = m_lstQuest.begin(); itQuest != m_lstQuest.end(); itQuest++)
	{
		for(dwTriggerCount = 0; dwTriggerCount < (*itQuest)->m_lpPhaseScript->m_lstTrigger.size(); dwTriggerCount++)
		{
			if((*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount]->m_dwTriggerKind == TRIGGER_TALK &&
				(*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount]->m_dwTriggerID == dwChrID)
			{
				*dwCount = dwTriggerCount;
				lpQuest = (*itQuest);

				return (*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount];
			}
		}
	}

	return NULL;
}

static BOOL GetInSphere(vector3 vecCenter, float fRadius, vector3 vecPos)
{
	vector3 vecRay = vecPos - vecCenter;
	if(vecRay.GetLens() <= fRadius) return TRUE;

	return FALSE;
}

LPTriggerNode CCharStatus::GetTriggertoGeton(LPQuestInstance lpQuest, unsigned long *dwCount, vector3 vecPos)
{
	list<LPQuestInstance>::iterator itQuest;
	unsigned long dwTriggerCount;
	vector3 vecCenter;
	for(itQuest = m_lstQuest.begin(); itQuest != m_lstQuest.end(); itQuest++)
	{
		for(dwTriggerCount = 0; dwTriggerCount < (*itQuest)->m_lpPhaseScript->m_lstTrigger.size(); dwTriggerCount++)
		{
			if((*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount]->m_dwTriggerKind == TRIGGER_GETON)
			{
				vecCenter.x = (*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount]->m_fPosX;
				vecCenter.y = (*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount]->m_fPosY;
				vecCenter.z = (*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount]->m_fPosZ;
				if(GetInSphere(vecCenter, (*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount]->m_fDistance, vecPos))
				{
					*dwCount = dwTriggerCount;
					lpQuest = (*itQuest);

					return (*itQuest)->m_lpPhaseScript->m_lstTrigger[dwTriggerCount];
				}
			}
		}
	}

	return NULL;
}

BOOL CCharStatus::AddFriend(unsigned long dwChrID, char *strName)
{
	if(!GetIsFriend(dwChrID))
	{
		FriendInfo *lpFriend = new FriendInfo;
		lpFriend->m_dwCID = dwChrID;
		strcpy(lpFriend->m_szName, strName);
		lpFriend->SetLoginStatus(true);
		g_ClientMain.m_csStatus.m_lstFriendList.push_back(lpFriend);

		return TRUE;
	}

	return FALSE;
}

BOOL CCharStatus::AddBan(unsigned long dwChrID, char *strName)
{
	if(!GetIsBan(dwChrID))
	{
		BanInfo *lpBan = new BanInfo;
		lpBan->m_dwCID = dwChrID;
		strcpy(lpBan->m_szName, strName);
		g_ClientMain.m_csStatus.m_lstBanList.push_back(lpBan);

		return TRUE;
	}

	return FALSE;
}

BOOL CCharStatus::DeleteFriend(unsigned long dwChrID)
{
	list<FriendInfo *>::iterator it;
	for(it = m_lstFriendList.begin(); it != m_lstFriendList.end(); it++)
	{
		if((*it)->m_dwCID == dwChrID)
		{
			FriendInfo *lpFriend = (*it);
			m_lstFriendList.erase(it);
			delete lpFriend;

			return TRUE;
		}
	}

	return FALSE;
}

BOOL CCharStatus::DeleteBan(unsigned long dwChrID)
{
	list<BanInfo *>::iterator it;
	for(it = m_lstBanList.begin(); it != m_lstBanList.end(); it++)
	{
		if((*it)->m_dwCID == dwChrID)
		{
			BanInfo *lpBan = (*it);
			m_lstBanList.erase(it);
			delete lpBan;

			return TRUE;
		}
	}

	return FALSE;
}

BOOL CCharStatus::GetIsFriend(unsigned long dwChrID)
{
	list<FriendInfo *>::iterator it;
	for(it = m_lstFriendList.begin(); it != m_lstFriendList.end(); it++)
	{
		if((*it)->m_dwCID == dwChrID) return TRUE;
	}

	return FALSE;
}

BOOL CCharStatus::GetIsBan(unsigned long dwChrID)
{
	list<BanInfo *>::iterator it;
	for(it = m_lstBanList.begin(); it != m_lstBanList.end(); it++)
	{
		if((*it)->m_dwCID == dwChrID) return TRUE;
	}

	return FALSE;
}

FriendInfo *CCharStatus::GetFriend(unsigned long dwChrID)
{
	list<FriendInfo *>::iterator it;
	for(it = m_lstFriendList.begin(); it != m_lstFriendList.end(); it++)
	{
		if((*it)->m_dwCID == dwChrID) return (*it);
	}

	return NULL;
}

FriendInfo *CCharStatus::GetFriendtoNum(unsigned long dwNum)
{
	list<FriendInfo *>::iterator it;
	unsigned long dwCount;
	for(it = m_lstFriendList.begin(), dwCount = 0; it != m_lstFriendList.end(); it++, dwCount++)
	{
		if(dwCount < dwNum) continue;

		return (*it);
	}

	return NULL;
}

BanInfo *CCharStatus::GetBantoNum(unsigned long dwNum)
{
	list<BanInfo *>::iterator it;
	unsigned long dwCount;
	for(it = m_lstBanList.begin(), dwCount = 0; it != m_lstBanList.end(); it++, dwCount++)
	{
		if(dwCount < dwNum) continue;

		return (*it);
	}

	return NULL;
}

BOOL CCharStatus::DeleteQuest(LPQuestInstance lpDeleteQuest)
{
	list<LPQuestInstance>::iterator it;
	for(it = m_lstQuest.begin(); it != m_lstQuest.end(); it++)
	{
		if((*it) == lpDeleteQuest)
		{
			LPQuestInstance lpDelete = (*it);
			it = m_lstQuest.erase(it);
			delete lpDelete;

			return TRUE;
		}
	}

	return FALSE;
}

unsigned short CCharStatus::GetSkillIDbyChantID(unsigned char cChant)
{
	unsigned short wSkill;

	vector<CItemInstance *>::iterator it;
	for(it = m_lstClassSkill.begin(); it != m_lstClassSkill.end(); it++)
	{
		wSkill = (*it)->GetSkillIDbyChantID(cChant);
		if(wSkill)
		{
			return wSkill;
		}
	}

	for(int i = 0; i < 20; i++)
	{
		if(g_ClientMain.m_csStatus.m_lstSkillSlot[i])
		{
			wSkill = g_ClientMain.m_csStatus.m_lstSkillSlot[i]->GetSkillIDbyChantID(cChant);
			if(wSkill)
			{
				return wSkill;
			}
		}
	}

	return 0;
}

void CCharStatus::SetClassSkill(void)
{
	unsigned short wClassSkill[20];
	unsigned char cSkillNum;

	vector<CItemInstance *>::iterator itSkill;
	CItemInstance *lpSkill;
	for(itSkill = m_lstClassSkill.begin(); itSkill != m_lstClassSkill.end();)
	{
		lpSkill = (*itSkill);
		itSkill = m_lstClassSkill.erase(itSkill);
		delete lpSkill;
	}
	m_lstClassSkill.clear();

	g_SkillMgr.GetClassSkill(m_Info.Class, wClassSkill, &cSkillNum);

	if(cSkillNum)
	{
		unsigned long i;
		for(i = 0; i < cSkillNum; i++)
		{
			if(wClassSkill[i])
			{
				CItemInstance *lpClassSkill = new CItemInstance;
				lpClassSkill->SetSkillInfo(wClassSkill[i], 0, 1, ClientSocket::ItemPos_SSlot, m_lstClassSkill.size(), 0);
				m_lstClassSkill.push_back(lpClassSkill);
			}
		}
	}
}