#include "stdafx.h"
#include "QuickManager.h"
#include "ItemIcon.h"
#include "SkillIcon.h"
#include "SkillScript.h"
#include "CommunityScript.h"
#include "ItemManager.h"
#include "CoolTimeManager.h"

#include "Application.h"
#include "SkillManager.h"
#include "SkillExecuter.h"
#include "ObjectManager.h"
#include "hero.h"

#include "GameUIManager.h"
#include "SkillWindow.h"

#include "SoundSystem.h"
#include "TutorialManager.h"
#include "PVPManager.h"

cQuickManager* cQuickManager::mSingleton = 0;

cQuickManager::cQuickManager()
: mTabIndexFS(0)
, mIsRowQuickFS( false )
, mDragIcon(0)
, mIsLockByMonster( false )
{
	assert( mSingleton == 0 && "bad singleton!" );
	mSingleton = this;

	for( unsigned int data = 0; data < QUICKSLOT_TOTAL; ++data )
	{
		mQuick[data] = 0;
	}

	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT; ++i )
	{
		mBindIcon[i].Clear();
	}

	for( unsigned int i = 0; i < QUICKTYPE_COMMON_COUNT; ++i )
		mIsRowQuick[i] = false;
}

cQuickManager::~cQuickManager()
{
}

void cQuickManager::Clear()
{
	mDragIcon = 0;
	mIsLockByMonster = false;

	/// µ¥ÀÌÅÍÃʱâÈ­
	for( unsigned int data = 0; data < QUICKSLOT_TOTAL; ++data )
	{
		mQuick[data] = 0;
	}

	/// ¾ÆÀÌÄÜ ÃʱâÈ­
	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT; ++i )
	{
		mBindIcon[i].Clear();
	}
}

void cQuickManager::Open()
{
	UpdateTutorial( mTabIndexFS );

	UpdateUI();

	/// 
	sPlayerExrInfo* info = HERO->GetPlayerExrInfo();
	if( info )
	{
		ChangeMonster( info->mChgMonsterIdx );
	}
	else
		assert(0);
}

void cQuickManager::SetRowQuick( bool IsRow, int type )
{
	if ( type < QUICKTYPE_COMMON || type > QUICKTYPE_COMMON_EXTRA2  )
	{
		assert(0);
		return;
	}
	
	mIsRowQuick[type] = IsRow;
}

bool cQuickManager::IsRowQuick( int type )
{
	if ( type < QUICKTYPE_COMMON || type > QUICKTYPE_COMMON_EXTRA2  )
	{
		assert(0);
		return false;
	}

	return mIsRowQuick[type];
}

void cQuickManager::SetRowQuickFS( bool IsRow )
{
	mIsRowQuickFS = IsRow;
}

///
bool cQuickManager::IsUseSlot( unsigned int iconId, bool IsFS )
{
	/// ¸ó½ºÅÍ º¯½Å»óÅÂÀÌ°í, 0, 1, 2, ¾ÆÀÌÄÜÀÌ¸é ¸ó½ºÅÍ¿ë ½ºÅ³ ŸÀÔ ¸®ÅÏ
	if( IsFS && mIsLockByMonster && ( iconId >= QUICKSLOT_ICON_MON_BEGIN && iconId <= QUICKSLOT_ICON_MON_END ) )
		return false;

	int dataIndex = iconId;
	if( IsFS == true )
		dataIndex = iconId + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return false;
	}

	/// »ç¿ëÇÏ°í ÀÖÁö ¾ÊÀ½.
	if( mQuick[dataIndex].mType == eSHORTCUT_NONE )
		return false;

	return true;
}

///
eSHORTCUT_TYPE cQuickManager::GetQuickType( unsigned int iconId, bool IsFS )
{
	int dataIndex = -1;

	if( IsFS == false )
	{
		dataIndex = iconId;
	}
	else
	{
		/// ¸ó½ºÅÍ º¯½Å»óÅÂÀÌ°í, 0, 1, 2, ¾ÆÀÌÄÜÀÌ¸é ¸ó½ºÅÍ¿ë ½ºÅ³ ŸÀÔ ¸®ÅÏ
		if( mIsLockByMonster == true && ( iconId >= QUICKSLOT_ICON_MON_BEGIN && iconId <= QUICKSLOT_ICON_MON_END ) )
		{
			dataIndex = QUICKSLOT_MON_BEGIN + (iconId - QUICKSLOT_ICON_MON_BEGIN);
		}
		else
		{
			dataIndex = iconId + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );
		}
	}

	if( dataIndex == -1 )
	{
		assert(0);
		return eSHORTCUT_NONE;
	}

	return (eSHORTCUT_TYPE)mQuick[dataIndex].mType;
}

///
unsigned long cQuickManager::GetItemIndex( unsigned int iconId, bool IsFS )
{
	int dataIndex = iconId;
	if( IsFS == true )
		dataIndex = iconId + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return 0;
	}

	return mQuick[dataIndex].mItemIndex;
}

///
unsigned long cQuickManager::GetSkillIndex( unsigned int iconId, bool IsFS )
{
	int dataIndex = iconId;
	if( IsFS == true )
		dataIndex = iconId + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return 0;
	}

	return mQuick[dataIndex].mSkillIndex;
}

unsigned char cQuickManager::GetSkillStep( unsigned int iconId, bool IsFS )
{
	int dataIndex = iconId;
	if( IsFS == true )
		dataIndex = iconId + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return 0;
	}

	return mQuick[dataIndex].mSkillStep;
}



short cQuickManager::GetMonSkillIndex( unsigned int iconId )
{
	if( iconId < QUICKSLOT_ICON_MON_BEGIN || iconId > QUICKSLOT_ICON_MON_END )
	{
		assert(0);
		return -1;
	}

	int dataIndex = QUICKSLOT_MON_BEGIN + (iconId - QUICKSLOT_ICON_MON_BEGIN);

	return (short)mQuick[dataIndex].mSkillIndex;
}

///
void cQuickManager::OnMouseDown( unsigned int iconId, bool IsFS )
{
	/// ¸ó½ºÅÍ º¯½Å»óŸé,
	if( IsFS && mIsLockByMonster && ( iconId >= QUICKSLOT_ICON_MON_BEGIN && iconId <= QUICKSLOT_ICON_MON_END ) )
		UseMonsterQuickSlot( iconId );
	else
		UseQuickSlot( iconId, IsFS );
}

///
void cQuickManager::OnKeyDown(  int iconID  )
{	
	if( iconID < QUICKSLOT_ICON_COMMON_BEGIN || iconID >= QUICKSLOT_ICON_COUNT )
	{
		assert(0);
		return;
	}

	bool IsFS = false;
	if( iconID >= QUICKSLOT_ICON_FS_BEGIN && iconID <= QUICKSLOT_ICON_FS_END )
		IsFS = true;

	/// ¸ó½ºÅÍ º¯½Å»óŸé,
	if( IsFS && mIsLockByMonster && ( iconID >= QUICKSLOT_ICON_MON_BEGIN && iconID <= QUICKSLOT_ICON_MON_END ) )
		UseMonsterQuickSlot( iconID );
	else
		UseQuickSlot( iconID, IsFS );
}

/// Äü½½·Ô »ç¿ë 
void cQuickManager::UseQuickSlot( unsigned int iconId, bool IsFS )
{
	int dataIndex = iconId;
	if( IsFS == true )
		dataIndex = iconId + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return;
	}
	
	if( mQuick[dataIndex].mType == eSHORTCUT_SKILL )
	{
		HERO->SetWaitMoveFlag( eWAITMOVE_NONE );

		/// ½ºÅ³
		if( mQuick[dataIndex].mSkillIndex < NORMAL_ATTACK_SKILL_MAX )
		{
			if( HERO->GetState() != eOBJECT_STATE_ATTACK )
				SKILLEXECUTER->ExecuteAttack( HERO->GetTargetObject() );
		}
		else
		{
			if( SKILLMAN->IsUsedKeepSkill( mQuick[dataIndex].mSkillIndex, mQuick[dataIndex].mSkillStep ) == true )
				SKILLEXECUTER->ExecuteSkill( mQuick[dataIndex].mSkillIndex, mQuick[dataIndex].mSkillStep );
		}

		UIMAN->HideTip();
	}
	else if( mQuick[dataIndex].mType == eSHORTCUT_ITEM )
	{
		/// ¾ÆÀÌÅÛ
		sItemCount* p = ITEMMAN->GetItemCount( mQuick[dataIndex].mItemIndex );
		unsigned int count = ( p ) ? p->bag : 0;
		if( count > 0 )
		{
			unsigned short slotIndex = ITEMMAN->FindSlotIndex( mQuick[dataIndex].mItemIndex );
			if( slotIndex <= 0 )
			{
				assert(0 && "failed to find slotindex" );
				return;
			}

			/// ¾ÆÀÌÅÛ »ç¿ë 
			ITEMMAN->TryToEquipItem( slotIndex );
			UIMAN->HideTip();
		}
	}
	else if( mQuick[dataIndex].mType == eSHORTCUT_COMMU )
	{
		sCommunitySkillInfo* pInfo = COMMUNITYSCRIPT->GetCommunityInfo( mQuick[dataIndex].mSkillIndex );
		if( pInfo )
		{
			if( pInfo->mType == 1 )
			{
				if( HERO->GetState() == eOBJECT_STATE_IDLE )
				{
					cSkillWindow* win = GAMEUI->GetSkillWindow();
					if( win )
						win->RequestCommuSkill( pInfo->mIndex );
				}
			}
			else
			{
				cSkillWindow* win = GAMEUI->GetSkillWindow();
				if( win )
					win->RequestLifeCommand( pInfo->mIndex, 0, 0 );
			}
		}
	}
}

void cQuickManager::UseMonsterQuickSlot( unsigned int iconId )
{
	/// ¸ó½ºÅÍ º¯½ÅÀÌ ¾ÈµÇ¾îÀÖÀ¸¸é ¸®ÅÏ
	if( HERO->IsTransformMonster() == false )
		return;

	if( iconId < QUICKSLOT_ICON_MON_BEGIN || iconId > QUICKSLOT_ICON_MON_END )
	{
		assert(0);
		return;
	}

	int dataIndex = QUICKSLOT_MON_BEGIN + (iconId - QUICKSLOT_ICON_MON_BEGIN);
	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return;
	}

	/// ¿¬°áµÈ ¸ó½ºÅÍ ½ºÅ³ÀÌ ¾ø´Â °æ¿ì ¸®ÅÏ
	if( mQuick[dataIndex].mSkillIndex < eMONSTERATTACK_SKILL1 || 
		mQuick[dataIndex].mSkillIndex >= eMONSTERATTACK_MAX )
		return;


	cIcon* icon = mBindIcon[iconId].mColumnIcon;
	if( !icon ) 
	{
		assert(0);
		return;
	}

	if( icon->IsActive() == true )
		return;

	HERO->SetWaitMoveFlag( eWAITMOVE_NONE );

	if( SKILLMAN->IsUsedMonsterSkill( mQuick[dataIndex].mSkillIndex ) == true )
		SKILLEXECUTER->ExecuteSkill( mQuick[dataIndex].mSkillIndex, mQuick[dataIndex].mSkillStep );


	UIMAN->HideTip();
}

/// ÅÇ Ã¼ÀÎÁö 
void cQuickManager::ChangeTabFS( unsigned int tabindex )
{
	mTabIndexFS = tabindex;

	/// FS Äü½½·Ô
	unsigned int slot = QUICKSLOT_FS1_BEGIN + (mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );
	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT_FOR_EACH; ++i )
	{
		int iconId = QUICKSLOT_ICON_FS_BEGIN + i;
		UpdateIcon( slot + i, iconId, true );
	}
	
	/// ¸ó½ºÅß º¯½ÅÀÏ°æ¿ì FSÄü½½·Ô Àç¼¼ÆÃ
	if( mIsLockByMonster == true )
	{
		for( int i = 0; i < QUICKSLOT_COUNT_MON; ++i )
		{
			mBindIcon[ QUICKSLOT_ICON_MON_BEGIN+i ].Clear();

			/// Äü½½·Ô ¾ÆÀÌÄÜ ¼¼ÆÃ
			mBindIcon[ QUICKSLOT_ICON_MON_BEGIN+i ].ShowNumber( false );
			mBindIcon[ QUICKSLOT_ICON_MON_BEGIN+i ].SetColor( mQuick[QUICKSLOT_MON_BEGIN+i].mColor );
			mBindIcon[ QUICKSLOT_ICON_MON_BEGIN+i ].SetParam( UIMAN->GetIconParam(MONICON_PARAMINDEX + i) );
			mBindIcon[ QUICKSLOT_ICON_MON_BEGIN+i ].SetAniParam( mQuick[QUICKSLOT_MON_BEGIN+i].mAniParam );
			mBindIcon[ QUICKSLOT_ICON_MON_BEGIN+i ].SetTipType( mQuick[QUICKSLOT_MON_BEGIN+i].mTipType );
		}
	}

	/// ÄðŸÀÓ ·Îµù
	LoadCoolTime();
	LoadCoolTimeMon();
}

//
void cQuickManager::UpdateTutorial( unsigned int tabindexfs )
{
	if( TUTORIALMAN->IsTutorialMode() == false )
		return;

	if( HERO )
	{
		// ¼ÂÆÃ
		eWEAPON_STATE weaponState = HERO->GetWeaponState();

		// Á¤·ÄÀ» À§ÇÔ
		typedef tList<unsigned long> cSortList;
		cSortList sortList;

		typedef tPointerHashMap<unsigned long, void*> cSkillMap;
		cSkillMap* skillMap = SKILLMAN->GetKeepSkillMap();
		if( skillMap )
		{
			cSkillMap::cIterator i = skillMap->Begin();
			cSkillMap::cIterator end = skillMap->End();
			for( ; i != end; ++i )
			{
				unsigned long skillIndex = (unsigned long)(i->mFirst);
				sKeepSkill*   keepSkill  = (sKeepSkill*)(i->mSecond);
				if( !keepSkill )
				{
					assert(0);
					return;
				}

				sPlayerSkillBaseInfo* pInfo = SKILLSCRIPT->GetPlayerSkillInfo( skillIndex );
				if( pInfo )
				{
					// Æнúê´Â ³Ñ±è
					if( pInfo->mType == eSKILLTYPE_PASSIVE )
						continue;

					if( pInfo->mUseEquipment )
					{
						/// Âø¿ë Àåºñ üũ
						switch( pInfo->mUseEquipment )
						{
						case eEQUIPTYPE_SWORD:
							if( weaponState != eWEAPON_STATE_SWORD &&
								weaponState != eWEAPON_STATE_SWORD_SHEILD )
								continue;
							break;
						case eEQUIPTYPE_LONGSWORD:
							if( weaponState != eWEAPON_STATE_LONGSWORD )
								continue;
							break;
						case eEQUIPTYPE_DOUBLESWORD:
							if( weaponState != eWEAPON_STATE_DOUBLESWORD )
								continue;
							break;
						case eEQUIPTYPE_SHORTSWORD:
							if( weaponState != eWEAPON_STATE_SHORTSWORD )
								continue;
							break;
						case eEQUIPTYPE_GUN:
							if( weaponState != eWEAPON_STATE_GUN )
								continue;
							break;
						case eEQUIPTYPE_STAFF:
							if( weaponState != eWEAPON_STATE_STAFF )
								continue;
							break;
						case eEQUIPTYPE_SHIELD:
							if( weaponState != eWEAPON_STATE_SHEILD &&
								weaponState != eWEAPON_STATE_SWORD_SHEILD )
								continue;
							break;
						case eEQUIPTYPE_SWORD_LONGSWORD:
							if( weaponState != eWEAPON_STATE_SWORD &&
								weaponState != eWEAPON_STATE_SWORD_SHEILD &&
								weaponState != eWEAPON_STATE_LONGSWORD )
								continue;
							break;
						case eEQUIPTYPE_SWORD_DOUBLESWORD:
							if( weaponState != eWEAPON_STATE_SWORD &&
								weaponState != eWEAPON_STATE_SWORD_SHEILD &&
								weaponState != eWEAPON_STATE_DOUBLESWORD )
								continue;
							break;
						case eEQUIPTYPE_LONGSWORD_DOUBLESWORD:
							if( weaponState != eWEAPON_STATE_LONGSWORD &&
								weaponState != eWEAPON_STATE_DOUBLESWORD )
								continue;
							break;
						case eEQUIPTYPE_SWORD_LONGSWORD_DOUBLESWORD:
							if( weaponState != eWEAPON_STATE_SWORD &&
								weaponState != eWEAPON_STATE_SWORD_SHEILD &&
								weaponState != eWEAPON_STATE_LONGSWORD &&
								weaponState != eWEAPON_STATE_DOUBLESWORD )
								continue;
							break;
						case eEQUIPTYPE_SHORTSWORD_GUN:
							if( weaponState != eWEAPON_STATE_SHORTSWORD &&
								weaponState != eWEAPON_STATE_GUN )
								continue;
							break;
						}
					}

					sortList.PushBack( skillIndex );
				}
			}
		}

		// ÃʱâÈ­
		for( int i = QUICKSLOT_FS1_BEGIN; i <= QUICKSLOT_FS2_END; ++i )
		{
			mQuick[i] = 0;
		}

		// Á¤·Ä µ¥ÀÌÅÍ ´ã±â
		unsigned int slot = ( tabindexfs * QUICKSLOT_ICON_COUNT_FOR_EACH ) + QUICKSLOT_FS1_BEGIN;
		unsigned int count = 0;

		// sort
		sortList.Sort();

		cSortList::cIterator si = sortList.Begin();
		cSortList::cIterator send = sortList.End();
		for( ; si != send; ++si, ++count )
		{
			if( count >= QUICKSLOT_ICON_COUNT_FOR_EACH )
				break;
	
			unsigned long skillIndex = (unsigned long)(*si);

			/// Äü½½·Ô Á¤º¸ ¼¼Æà 
			mQuick[slot].mType = eSHORTCUT_SKILL;
			mQuick[slot].mSkillIndex = skillIndex;
			mQuick[slot].mDBIndex = 0;
			mQuick[slot].mItemIndex = 0;
			
			slot++;	
		}
	}
}

void cQuickManager::DragIcon( cIcon* icon )
{
	if( icon )
	{
		mDragIcon = icon;
		mDragIcon->ShowGauge( false );
		mDragIcon->SetColor( 0.5f, 0.5f, 0.5f, 1.0f );
	}
}

///
void cQuickManager::UnDragIcon()
{
	if( mDragIcon )
	{
		cUIContainer* fromParent = mDragIcon->GetParent();
		if( !fromParent )
		{
			assert(0);
			return;
		}

		/// fs ½½·Ô¿¡¼­ ¿Â°ÇÁö ÆǺ°
		bool fromIsFS = false;
		if( fromParent->GetID() == eUIID_ROW_QUICKSLOT_FS || fromParent->GetID() == eUIID_COLUMN_QUICKSLOT_FS ) 
			fromIsFS = true;

		int dataIndex = mDragIcon->GetID();
		if( fromIsFS == true )
			dataIndex = mDragIcon->GetID() + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );
		
		/// ±âÁ¸ ÀúÀåµÇ¾îÀÖ´ø Ä÷¯·Î º¯È¯ 
		mDragIcon->ShowGauge( true );
		mDragIcon->SetColor( mQuick[dataIndex].mColor );
	}
}

/// ¼­¹ö·ÎºÎÅÍ ±âÁ¸ÀÇ Äü½½·Ô Á¤º¸¸¦ ¹Þ¾Æ ¼¼ÆÃ
void cQuickManager::NetSetData( unsigned int dataIndex, const sShortcut& shortcut )
{
	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex>= QUICKSLOT_TOTAL )
	{
		assert(0);
		return;
	}

	if( mQuick[dataIndex].mType != eSHORTCUT_NONE )
	{
		assert(0 && "already exist");
	}

	/// Äü½½·Ô Á¤º¸ ¼¼Æà 
	mQuick[dataIndex].mType = shortcut.mType;
	
	if( shortcut.mType == eSHORTCUT_ITEM )
	{
		mQuick[dataIndex].mItemIndex = shortcut.mIndex;
		mQuick[dataIndex].mDBIndex = shortcut.mExData;
	}
	else if( shortcut.mType == eSHORTCUT_SKILL )
	{
		mQuick[dataIndex].mSkillIndex = shortcut.mIndex;
		mQuick[dataIndex].mSkillStep = (unsigned char)shortcut.mExData;
	}
	else if( shortcut.mType == eSHORTCUT_COMMU )
	{
		mQuick[dataIndex].mSkillIndex = shortcut.mIndex;
	}
}	

///
void cQuickManager::NetUpdateData()
{
	if( TUTORIALMAN->IsTutorialMode() == true ) 
		return;

	/// ¼­¹ö¿¡ Äü½½·Ô Á¤º¸ º¸³»±â
	MSG_REQ_PLAYER_SHORTCUT_UPDATE msg;
	msg.Category = NM_PLAYER;
	msg.Protocol = NM_PLAYER_SHORTCUT_UPDATE_REQ;

	/// º¯½Å»óÅ ½ºÅ³Àº µî·ÏÇÒ ÇÊ¿ä¾ø´Ù!
	for( unsigned int i = 0; i < QUICKSLOT_COUNT; ++i )
	{
		msg.mShortcut[i].mType = mQuick[i].mType;
		
		if( mQuick[i].mItemIndex > 0 )
		{
			msg.mShortcut[i].mIndex = mQuick[i].mItemIndex;
			msg.mShortcut[i].mExData = mQuick[i].mDBIndex; 
		}
		else if( mQuick[i].mSkillIndex > 0 )
		{
			msg.mShortcut[i].mIndex = mQuick[i].mSkillIndex;
			msg.mShortcut[i].mExData = mQuick[i].mSkillStep; 
		}
	}

	NETWORK->SendNetworkMsg( (char*)&msg, sizeof(msg) );
}

void cQuickManager::SkillReset()
{
	/// º¯½Å»óÅ ½ºÅ³Àº µî·ÏÇÒ ÇÊ¿ä¾ø´Ù!
	for( unsigned int i = 0; i < QUICKSLOT_COUNT; ++i )
	{
		if( mQuick[i].mType == eSHORTCUT_SKILL )
		{
			/// µ¥ÀÌÅÍÃʱâÈ­
			mQuick[i] = 0;
		}
	}

	UpdateUI();

	/// 
	if( mIsLockByMonster == true )
	{
		for( int i = 0; i < QUICKSLOT_COUNT_MON; ++i )
		{
			unsigned int dataIndex = QUICKSLOT_MON_BEGIN      + i;
			unsigned int iconId	   = QUICKSLOT_ICON_MON_BEGIN + i;

			/// ÃʱâÈ­
			mQuick[dataIndex] = 0;
			mBindIcon[iconId].Clear();

			sMonsterSkillScript* skill = SKILLSCRIPT->GetMonsterSkillInfo( HERO->GetTransMonsterClassIdx(), (eMONSTERATTACK_TYPE)(eMONSTERATTACK_SKILL1 + i) );
			if( skill )
			{
				mQuick[dataIndex].mType = eSHORTCUT_MONSKILL;
				mQuick[dataIndex].mSkillIndex = eMONSTERATTACK_SKILL1 + i;

				if( UsableMonSkillIcon( mQuick[dataIndex].mSkillIndex ) == true )
				{
					mQuick[dataIndex].mColor = NiColorA::WHITE;
				}
				else
				{
					mQuick[dataIndex].mColor = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
				}
			}
			else
			{
				mQuick[dataIndex].mType = eSHORTCUT_MONSKILL;
				mQuick[dataIndex].mSkillIndex = ULONG_MAX;
				mQuick[dataIndex].mColor = NiColorA( 0.5f, 0.5f, 0.5f, 1.0f );
			}

			/// Äü½½·Ô ¾ÆÀÌÄÜ ¼¼ÆÃ
			mBindIcon[iconId].ShowNumber( false );
			mBindIcon[iconId].SetColor( mQuick[dataIndex].mColor );
			mBindIcon[iconId].SetParam( UIMAN->GetIconParam(MONICON_PARAMINDEX + i) );
			mBindIcon[iconId].SetColor( mQuick[dataIndex].mColor );
			mBindIcon[iconId].SetTipType( mQuick[dataIndex].mTipType );
		}

		LoadCoolTimeMon();
	}
}

///
void cQuickManager::AddData( unsigned int iconId, cIcon* srcIcon, bool toIsFS )
{
	int dataIndex = iconId;
	if( toIsFS == true )
		dataIndex = iconId + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

	/// ¹üÀ§ üũ
	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return;
	}

	if( iconId < QUICKSLOT_ICON_COMMON_BEGIN || iconId >= QUICKSLOT_ICON_COUNT )
	{
		assert(0);
		return;
	}

	if( srcIcon == NULL )
	{
		assert(0);
		return;
	}

	/// ºñ¾îÀÖÀ¸¸é µî·Ï
	unsigned int type = srcIcon->GetIconType();
	switch( type )
	{
	case eICON_ITEM:
		{
			cItemIcon* itemIcon = (cItemIcon*)srcIcon;
			cItemDefine* itemDefine = ITEMMAN->GetItemDefine( itemIcon->GetItemIndex() );
			if( !itemDefine )
			{
				assert(0);
				return;
			}

			// ºÀÀÎµÈ ¾ÆÀÌÅÛÀº µî·ÏÀÌ ¾ÈµÊ.
			if( itemIcon->IsSeal() == true )
				return;

			/// ÀÏÁ¤ ŸÀÔ¸¸ µî·ÏµÊ
			unsigned char type = itemDefine->GetType();	
			unsigned char subtype = itemDefine->GetSubType();
			if( type == ITEM_ETC1 || type == ITEM_MONSTER || (type == ITEM_CARD && subtype == ITEM_CARD_COMMON) 
				|| (type == ITEM_MATERIAL && subtype == ITEM_MATERIAL_MAP)
				|| (type == ITEM_MATERIAL && subtype == ITEM_MATERIAL_VEHICLE) )
			{
				/// ÀÚ¸®°Ë»ç - ±âÁ¸µ¥ÀÌÅÍ°¡ ÀÖÀ¸¸é »èÁ¦ ó¸®
				if( mQuick[dataIndex].mType != eSHORTCUT_NONE )
					DeleteData( iconId, dataIndex );

				mQuick[dataIndex].mType		= eSHORTCUT_ITEM;
				mQuick[dataIndex].mDBIndex	= itemIcon->GetDBIndex();
				mQuick[dataIndex].mItemIndex= itemIcon->GetItemIndex();
				mQuick[dataIndex].mAniParam	= itemIcon->GetAniParam();
				mQuick[dataIndex].mTipType	= itemIcon->GetTipType();

				/// ÃÑ °¹¼ö ¼³Á¤
				sItemCount* p = ITEMMAN->GetItemCount( mQuick[dataIndex].mItemIndex );
				unsigned int count = ( p ) ? p->bag : 0;
				if( count <= 0 )
				{
					mQuick[dataIndex].mColor = NiColorA( 0.5f, 0.5f, 0.5f, 1.0f );
				}
				else
				{
					int ret0 = ITEMMAN->CheckLimit( mQuick[dataIndex].mItemIndex );
					int ret1 = ITEMMAN->CheckLimitEtc( mQuick[dataIndex].mItemIndex );

					NiColorA color = NiColorA::WHITE;
					if( ret0 != ITEMLIMIT_SUCCESS || ret1 != ITEMLIMIT_SUCCESS )
					{
						color = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
					}
					mQuick[dataIndex].mColor = color;
				}

				/// ¾ÆÀÌÄܼ¼ÆÃ
				mBindIcon[iconId].Clear();

				mBindIcon[iconId] = *srcIcon;
				mBindIcon[iconId].SetAniParam( itemIcon->GetAniParam() );
				mBindIcon[iconId].SetTipType( itemIcon->GetTipType() );
				mBindIcon[iconId].SetCount( count );
				mBindIcon[iconId].ShowNumber( true );
				mBindIcon[iconId].SetColor( mQuick[dataIndex].mColor );
				//mBindIcon[iconId].SetColor( mQuick[i].mColor );

				/// ¾ÆÀÌÅÛ Ãß°¡ ½Ã »ç¿îµå Àç»ý
				ITEMMAN->PlayIconSettingSound( itemIcon->GetSlotIndex() );
			}
		}
		break;
	case eICON_SKILL:
		{
			/// ÀÚ¸®°Ë»ç /// ±âÁ¸µ¥ÀÌÅÍ°¡ ÀÖÀ¸¸é »èÁ¦ ó¸®
			if( mQuick[dataIndex].mType != eSHORTCUT_NONE )
				DeleteData( iconId, dataIndex );

			cSkillIcon* skillIcon = (cSkillIcon*)srcIcon;
			mQuick[dataIndex].mType = eSHORTCUT_SKILL;
			mQuick[dataIndex].mSkillIndex = skillIcon->GetSkillIdx();
			mQuick[dataIndex].mSkillStep = skillIcon->GetSkillStep();
			mQuick[dataIndex].mAniParam = skillIcon->GetAniParam();
			mQuick[dataIndex].mTipType = eTOOLTIP_NONE;


			/// ¾ÆÀÌÄܼ¼ÆÃ
			mBindIcon[iconId].Clear();

			mBindIcon[iconId] = *srcIcon;
			mBindIcon[iconId].SetAniParam( skillIcon->GetAniParam() );
			mBindIcon[iconId].SetTipType( eTOOLTIP_NONE );
			mBindIcon[iconId].SetCount( skillIcon->GetSkillStep()+1 );

			// ¿À¶ó ŸÀÔÀ̸é
			sPlayerSkillBaseInfo* info = SKILLSCRIPT->GetPlayerSkillInfo( mQuick[dataIndex].mSkillIndex );
			if( info && info->mShotType == eSHOTTYPE_AURA )
			{
				mQuick[dataIndex].mSkillStep = 0;

				sKeepSkill* p = SKILLMAN->GetKeepInfo( mQuick[dataIndex].mSkillIndex );
				if( p )
					mQuick[dataIndex].mSkillStep = p->mStep;
				else
					assert(0);
			}


			/// 
			eWEAPON_STATE wstate = HERO->GetWeaponState();
			if( UsableSkillIcon( wstate, skillIcon->GetSkillIdx(), skillIcon->GetSkillStep() ) == true )
			{
				//mQuick[dataIndex].mColor =  NiColorA::WHITE;
				mQuick[dataIndex].mColor =  NiColorA::WHITE;
				mBindIcon[iconId].SetColor( NiColorA::WHITE );
			}
			else
			{
				//mQuick[dataIndex].mColor = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
				mQuick[dataIndex].mColor = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
				mBindIcon[iconId].SetColor( NiColorA( 1.0f, 0.0f, 0.0f, 1.0f ) );
			}

			/// Äü½½·Ô Ãß°¡ ½Ã »ç¿îµå(ÀâÈ­,±âŸ) Àç»ý
			SOUNDSYS->Play2DSound( 3036 );
		}
		break;
	case eICON_COMMUNITY:
		{
			if( mQuick[dataIndex].mType != eSHORTCUT_NONE )
				DeleteData( iconId, dataIndex );

			/// 
			cCommunityIcon* comIcon = (cCommunityIcon*)srcIcon;
			mQuick[dataIndex].mType = eSHORTCUT_COMMU;
			mQuick[dataIndex].mSkillIndex = comIcon->GetCommunityIndex();
			mQuick[dataIndex].mColor =  NiColorA::WHITE;


			/// ¾ÆÀÌÄܼ¼ÆÃ
			mBindIcon[iconId].Clear();

			mBindIcon[iconId] = *srcIcon;
			mBindIcon[iconId].ShowNumber( false );
			mBindIcon[iconId].SetColor( NiColorA::WHITE );

			/// Äü½½·Ô Ãß°¡ ½Ã »ç¿îµå(ÀâÈ­,±âŸ) Àç»ý
			SOUNDSYS->Play2DSound( 3036 );
		}
		break;
	default:
		assert(0);
		return;
	}

	NetUpdateData();
}

/// fromIsFS: ½ÃÀÛ ÁöÁ¡ ¾ÆÀÌÄÜÀÌ fs ½½·ÔÀÎÁö ¿©ºÎ
/// toIsFS: µµÂø ÁöÁ¡ ¾ÆÀÌÄÜÀÌ fs ½½·ÔÀÎÁö ¿©ºÎ
void cQuickManager::MoveData( unsigned int toIconID, cIcon* srcIcon, bool toIsFS )
{
	if( mDragIcon == 0 || srcIcon == 0 )
	{
		assert(0);
		return;
	}

	cUIContainer* fromParent = mDragIcon->GetParent();
	if( !fromParent )
	{
		assert(0);
		return;
	}

	bool fromIsFS = false;
	if( fromParent->GetID() == eUIID_ROW_QUICKSLOT_FS || fromParent->GetID() == eUIID_COLUMN_QUICKSLOT_FS ) 
		fromIsFS = true;

	int fromDataIndex = mDragIcon->GetID();
	if( fromIsFS == true )
		fromDataIndex = mDragIcon->GetID() + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );
	
	int toDataIndex = toIconID;
	if( toIsFS )
		toDataIndex = toIconID + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

	/// ¹üÀ§ üũ
	if( toIconID < QUICKSLOT_ICON_COMMON_BEGIN || toIconID >= QUICKSLOT_ICON_COUNT )
	{
		assert(0);
		return;
	}

	if( fromDataIndex < QUICKSLOT_COMMON_BEGIN || fromDataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return;
	}

	if( toDataIndex < QUICKSLOT_COMMON_BEGIN || toDataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return;
	}


	/// ÀÚ¸®°Ë»ç 
	if( mQuick[toDataIndex].mType != eSHORTCUT_NONE )
	{
		/// ´Ù¸¥µ¥ÀÌÅÍ°¡ ÀÖÀ¸¸é ½º¿Ò
		cQuickData temp = mQuick[fromDataIndex];
		mQuick[fromDataIndex] = mQuick[toDataIndex];
		mQuick[toDataIndex] = temp;

		/// ¾ÆÀÌÄÜ Á¤º¸ ½º¿Ò
		cBindIcon tempIcon;
		tempIcon.mColumnIcon = srcIcon;
		tempIcon.mRowIcon = srcIcon;
		
		int fromIconID = mDragIcon->GetID();
	
		tempIcon = mBindIcon[toIconID];
		mBindIcon[toIconID] = mBindIcon[fromIconID];
		mBindIcon[fromIconID] = tempIcon;

		/// »ö º¯°æ
		mBindIcon[toIconID].SetColor( mQuick[toDataIndex].mColor );
		mBindIcon[fromIconID].SetColor( mQuick[fromDataIndex].mColor );

		/// ¾Ö´Ï¸ÞÀÌ¼Ç ¼¼ÆÃ
		mBindIcon[toIconID].SetAniParam( mQuick[toDataIndex].mAniParam );
		mBindIcon[fromIconID].SetAniParam( mQuick[fromDataIndex].mAniParam );

		/// ·¹¾îµµÅ¸ÀÔ ¼¼ÆÃ
		mBindIcon[toIconID].SetTipType( mQuick[toDataIndex].mTipType );
		mBindIcon[fromIconID].SetTipType( mQuick[fromDataIndex].mTipType );
	}
	else
	{
		/// ¾øÀ¸¸é À̵¿ 
		mQuick[toDataIndex] = mQuick[fromDataIndex];

		/// ¾ÆÀÌÄÜ ¼¼ÆÃ
		mBindIcon[toIconID] = *mDragIcon;
		mBindIcon[toIconID].SetColor( mQuick[toDataIndex].mColor );
		mBindIcon[toIconID].SetAniParam( mQuick[toDataIndex].mAniParam );
		mBindIcon[toIconID].SetTipType( mQuick[toDataIndex].mTipType );

		/// »èÁ¦ 
		int fromIconID = mDragIcon->GetID();
		
		DeleteData( fromIconID, fromDataIndex );
	}

	NetUpdateData();

	/// ½½·Ô ¼ÂÆà ½Ã »ç¿îµå Àç»ý
	switch( mQuick[toDataIndex].mType )
	{
	case eSHORTCUT_ITEM:
		{
			unsigned short slotIndex = ITEMMAN->FindSlotIndex( mQuick[toDataIndex].mItemIndex );
			if( slotIndex >= INVENTORY_BAG0_BEGIN && slotIndex <= HERO->GetBagEndSlot() )
			{
				ITEMMAN->PlayIconSettingSound( slotIndex );
			}
			else 
			{
				/// ¾ÆÀÌÅÛÀ» ´Ù ¼Ò¸ðÇÑ °æ¿ì ¼Ò¸® ³ªÁö ¾Ê±â
				break;
			}
		}
		break;
	default:
		{
			/// ¾ÆÀÌÅÛÀÌ ¾Æ´Ñ °ÍÀº ÀâÈ­(±âŸ) »ç¿îµå Àç»ý
			SOUNDSYS->Play2DSound( 3036 );
		}
		break;
	}
}

void cQuickManager::UpdateSkillStep( unsigned long skillIndex, unsigned char step )
{
	bool netUpdate = false;
	for( unsigned int i = 0; i < QUICKSLOT_COUNT; ++i )
	{
		/// ½ºÅ³ ¾ÆÀÌÄܸ¸ ¼¼ÆÃ
		if( mQuick[i].mType != eSHORTCUT_SKILL )
			continue;

		// µ¿ÀϽºÅ³ÀÇ Á¤º¸ °»½Å
		if( mQuick[i].mSkillIndex == skillIndex )
		{
			sPlayerSkillBaseInfo* info = SKILLSCRIPT->GetPlayerSkillInfo( skillIndex );
			if( info )
			{
				if( mQuick[i].mSkillStep >= info->mStepCount )
				{
					assert(0);
					mQuick[i] = 0;
					continue;
				}

				// ¿À¶ó ŸÀÔÀ̸é
				if( info->mShotType == eSHOTTYPE_AURA )
				{
					mQuick[i].mSkillStep = step;
				}
				else
				{
					if( mQuick[i].mSkillStep + 1 == step )
					{
						mQuick[i].mSkillStep = step;
					}
				}

				netUpdate = true;
			}
			else
				assert(0);
		}
	}

	// ¾ÆÀÌÄܸ¸ °»½Å
	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT; ++i )
	{
		/// ¸ó½ºÅÍ º¯½Å»óÅÂÀΰæ¿ì,
		if( mIsLockByMonster )
		{
			if( i >= QUICKSLOT_ICON_MON_BEGIN && i <= QUICKSLOT_ICON_MON_END )
				continue;
		}

		unsigned int dataIndex = i;
		/// FS ½½·Ô
		if( i >= QUICKSLOT_ICON_FS_BEGIN )
			dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

		if( mQuick[dataIndex].mType != eSHORTCUT_SKILL )
			continue;

		if( mQuick[dataIndex].mSkillIndex != skillIndex )
			continue;

		mBindIcon[i].Clear();

		// UI °»½Å
		sPlayerSkillBaseInfo* info = SKILLSCRIPT->GetPlayerSkillInfo( skillIndex );
		if( info )
		{
			cIconParam* param = UIMAN->GetIconParam( info->mIconIdx );
			if( param )
			{
				/// ¼¼ÆÃ
				mBindIcon[i].SetParam( param );
				mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
				mBindIcon[i].SetAniParam( mQuick[dataIndex].mAniParam );
				mBindIcon[i].SetTipType( mQuick[dataIndex].mTipType );
				mBindIcon[i].SetCount( mQuick[dataIndex].mSkillStep+1 );
				mBindIcon[i].ShowNumber( true );
			}
		}
	}

	if( netUpdate == true )
		NetUpdateData();

	// ÄðŸÀÓ ·Îµù
	LoadCoolTime();
	LoadCoolTimeMon();
}

void cQuickManager::UpdateUI()
{
	// ¸ó½ºÅÍ º¯½Å »óÅ¿¡¼­ ½ºÅ³À» ¹è¿ì´õ¶óµµ Äü½½·ÔÀ» °»½ÅÇÏÁö ¾Ê´Â´Ù.
	if( mIsLockByMonster )
		return;

	mTabIndexFS = ITEMMAN->GetActiveWeapon();

	/// 090216 PKH 
	bool netUpdate = false;

	/// ÀÏ¹Ý Äü½½·Ô
	for( unsigned int i = QUICKSLOT_COMMON_BEGIN; i <= QUICKSLOT_COMMON_EXTRA2_END; ++i )
	{
		int iconId = QUICKSLOT_ICON_COMMON_BEGIN + i;
		if( UpdateIcon( i, iconId, true ) == true )
			netUpdate = true;
	}

	/// FS Äü½½·Ô
	unsigned int slot = QUICKSLOT_FS1_BEGIN + (mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );
	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT_FOR_EACH; ++i )
	{
		int iconId = QUICKSLOT_ICON_FS_BEGIN + i;
		if( UpdateIcon( slot + i, iconId, true ) == true )
			netUpdate = true;
	}

	if( netUpdate == true )
		NetUpdateData();

	/// ÄðŸÀÓ ·Îµù
	LoadCoolTime();
	LoadCoolTimeMon();
}

/// Äü½½·Ô »ý¼ºÈÄ OnShow ½Ã ÀÚµ¿È£Ãâ
/// ÇöÀç ÅÇÀ妽º¸¦ ±â¹ÝÀ¸·Î Äü½½·Ô Á¤º¸ ¾÷µ¥ÀÌÆ® 
bool cQuickManager::UpdateIcon( int i, int iconId, bool countCheck )
{
	if( i < QUICKSLOT_COMMON_BEGIN || i >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return false;
	}

	if( iconId < QUICKSLOT_ICON_COMMON_BEGIN || iconId >= QUICKSLOT_ICON_COUNT )
	{
		assert(0);
		return false;
	}

	/// ÃʱâÈ­
	/// 0 ÀÌµÇ¸é ¾ÆÀÌÄÜ ¾È¿¡¼­ ¾Æ¹«°Íµµ ±×¸®Áö ¾ÊÀ¸¹Ç·Î °¹¼öµµ ¾È±×·ÁÁø´Ù.
	mBindIcon[iconId].Clear();

	/// ½ºÅ³ ¾ÆÀÌÄÜ ¼¼ÆÃ
	if( mQuick[i].mType == eSHORTCUT_SKILL )
	{
		sKeepSkill* p = SKILLMAN->GetKeepInfo( mQuick[i].mSkillIndex );
		if( p == NULL )
		{
			/// 090216 PKH 
			mQuick[i] = 0;
			return true;
		}
		
		sPlayerSkillBaseInfo* info = SKILLSCRIPT->GetPlayerSkillInfo( mQuick[i].mSkillIndex );
		if( info )
		{
			if( mQuick[i].mSkillStep >= info->mStepCount )
			{
				assert(0);
				mQuick[i] = 0;
				return true;
			}

			// ¿À¶ó ŸÀÔÀ̸é
			if( info->mShotType == eSHOTTYPE_AURA )
			{
				mQuick[i].mSkillStep = p->mStep;
			}

			cIconParam* param = UIMAN->GetIconParam( info->mIconIdx );
			if( param )
			{
				/// ¼¼ÆÃ
				mBindIcon[iconId].SetParam( param );
				mBindIcon[iconId].SetColor( mQuick[i].mColor );
				mBindIcon[iconId].SetAniParam( mQuick[i].mAniParam );
				mBindIcon[iconId].SetTipType( mQuick[i].mTipType );
				mBindIcon[iconId].SetCount( mQuick[i].mSkillStep+1 );
				mBindIcon[iconId].ShowNumber( true );
			}
		}
		else
		{
			assert(0);
		}
	}
	else if( mQuick[i].mType == eSHORTCUT_COMMU )
	{
		sCommunitySkillInfo* pInfo = COMMUNITYSCRIPT->GetCommunityInfo( mQuick[i].mSkillIndex );
		if( pInfo )
		{
			cIconParam* param = UIMAN->GetIconParam( pInfo->mIconIndex );
			if( param )
			{
				/// ¼¼ÆÃ
				mBindIcon[iconId].ShowNumber( false );
				mBindIcon[iconId].SetParam( param );
				mBindIcon[iconId].SetColor( mQuick[i].mColor );
				mBindIcon[iconId].SetAniParam( mQuick[i].mAniParam );
				mBindIcon[iconId].SetTipType( mQuick[i].mTipType );
			}
		}
		else
		{
			assert(0);
		}
	}
	/// ¾ÆÀÌÅÛ ¾ÆÀÌÄÜ ¼¼Æà 
	else if( mQuick[i].mType == eSHORTCUT_ITEM )
	{
		cItemDefine* itemDefine = ITEMMAN->GetItemDefine( mQuick[i].mItemIndex );
		if( itemDefine )
		{
			cIconParam* param = itemDefine->GetIconParam();
			if( param )
			{
				/// ¼¼ÆÃ
				mBindIcon[iconId].SetParam( param );

				/// °¹¼ö °Ë»ç¸¦ ÇؾßÇÒ¶§¸¸ÇÑ´Ù
				if( countCheck )
				{
					sItemCount* p = ITEMMAN->GetItemCount( mQuick[i].mItemIndex );
					unsigned int count = ( p ) ? p->bag : 0;
					if( count <= 0 )
					{
						mQuick[i].mColor = NiColorA( 0.5f, 0.5f, 0.5f, 1.0f );
					}
					else
					{
						int ret0 = ITEMMAN->CheckLimit( mQuick[i].mItemIndex );
						int ret1 = ITEMMAN->CheckLimitEtc( mQuick[i].mItemIndex );

						NiColorA color = NiColorA::WHITE;
						if( ret0 != ITEMLIMIT_SUCCESS || ret1 != ITEMLIMIT_SUCCESS )
						{
							 color = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
						}
						mQuick[i].mColor = color;
					}

					mBindIcon[iconId].SetCount( count );
					mBindIcon[iconId].ShowNumber( true );
				}
				/// °¹¼ö °Ë»ç üũ¾ÈÇϸé 
				else
				{
					int ret0 = ITEMMAN->CheckLimit( mQuick[i].mItemIndex );
					int ret1 = ITEMMAN->CheckLimitEtc( mQuick[i].mItemIndex );

					NiColorA color = NiColorA::WHITE;
					if( ret0 != ITEMLIMIT_SUCCESS || ret1 != ITEMLIMIT_SUCCESS )
					{
						color = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
					}
					mQuick[i].mColor = color;
				}

				///
				mQuick[i].mTipType = (unsigned int)itemDefine->GetTipType();
				mBindIcon[iconId].SetAniParam( mQuick[i].mAniParam );
				mBindIcon[iconId].SetTipType( mQuick[i].mTipType );
				mBindIcon[iconId].SetColor( mQuick[i].mColor );
			}
		}
		else
		{
			assert(0);
		}
	}		

	return false;
}

/// µ¥ÀÌÅÍ»èÁ¦
void cQuickManager::DeleteData()
{
	if( mDragIcon )
	{
		cUIContainer* fromParent = mDragIcon->GetParent();
		if( !fromParent )
		{
			assert(0);
			return;
		}

		/// fs ½½·Ô¿¡¼­ ¿Â°ÇÁö ÆǺ°
		bool fromIsFS = false;
		if( fromParent->GetID() == eUIID_ROW_QUICKSLOT_FS || fromParent->GetID() == eUIID_COLUMN_QUICKSLOT_FS ) 
			fromIsFS = true;
		
		int dataIndex = mDragIcon->GetID();
		if( fromIsFS == true )
			dataIndex = mDragIcon->GetID() + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

		DeleteData( mDragIcon->GetID(), dataIndex );

		NetUpdateData();
	}
}

///
void cQuickManager::DeleteData( unsigned int iconId, unsigned int dataIndex )
{
	if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
	{
		assert(0);
		return;
	}
	
	if( iconId < QUICKSLOT_ICON_COMMON_BEGIN || iconId >= QUICKSLOT_ICON_COUNT )
	{
		assert(0);
		return;
	}

	/// µ¥ÀÌÅÍÃʱâÈ­
	mQuick[dataIndex] = 0;

	/// ¾ÆÀÌÄÜ ÃʱâÈ­
	mBindIcon[iconId].Clear();
}

/// ÅÇüÀÎÁö½Ã, °¢ ÄðŸÀÓ µ¥ÀÌÅÍ ·Îµå
void cQuickManager::LoadCoolTime()
{
	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT; ++i )
	{
		/// ¸ó½ºÅÍ º¯½Å»óÅÂÀΰæ¿ì,
		if( mIsLockByMonster )
		{
			/// FS ½½·ÔÀÎ °æ¿ì Á¦¿Ü
			if( i >= QUICKSLOT_ICON_FS_BEGIN && i <= QUICKSLOT_ICON_FS_BEGIN + QUICKSLOT_COUNT_MON )
				continue;
		}

		unsigned int dataIndex = i;

		/// FS ½½·ÔÀÎ °æ¿ì µ¥ÀÌÅÍ À妽º¸¦ ÇöÀç ¼±ÅÃµÈ FS ½½·Ô¿¡ ¸Â°Ô ¼ÂÆÃ
		if( i >= QUICKSLOT_ICON_FS_BEGIN )
			dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

		if( dataIndex < QUICKSLOT_COMMON_BEGIN || dataIndex >= QUICKSLOT_TOTAL )
		{
			assert(0);
			continue;
		}

		if( mQuick[dataIndex].mType == eSHORTCUT_SKILL )
		{
			sKeepSkill* keepSkill = SKILLMAN->GetKeepInfo( mQuick[dataIndex].mSkillIndex );
			if( keepSkill && keepSkill->mRestTime > 0 )
			{
				unsigned long accumTime = THEAPP->GetWorldAccumTime();

				cIcon* colIcon = mBindIcon[i].mColumnIcon;
				colIcon->UpdateGauge( accumTime, keepSkill->mTotalTime - keepSkill->mRestTime, keepSkill->mTotalTime, true );

				cIcon* rowIcon = mBindIcon[i].mRowIcon;
				rowIcon->UpdateGauge( accumTime, keepSkill->mTotalTime - keepSkill->mRestTime, keepSkill->mTotalTime, true );
			}
		}
		else if( mQuick[dataIndex].mType == eSHORTCUT_ITEM )
		{
			sCoolTime* coolTime = COOLMAN->GetProcessData( mQuick[dataIndex].mItemIndex );
			if( coolTime )
			{
				cIcon* colIcon = mBindIcon[i].mColumnIcon;
				colIcon->UpdateGauge( coolTime->startTime, 0, coolTime->restTime, true );

				cIcon* rowIcon = mBindIcon[i].mRowIcon;
				rowIcon->UpdateGauge( coolTime->startTime, 0, coolTime->restTime, true );
			}
		}
	}
}

/// ¸ó½ºÅÍ ÄðŸÀÓ ¼¼ÆÃ
void cQuickManager::LoadCoolTimeMon()
{
	/// ¸ó½ºÅÍ º¯½Å½Ã
	if( !mIsLockByMonster )
		return;

	for( unsigned int i = 0; i < QUICKSLOT_COUNT_MON; ++i )
	{
		unsigned int dataIndex = QUICKSLOT_MON_BEGIN + i;
		unsigned int iconId = QUICKSLOT_ICON_FS_BEGIN + i;

		if( mQuick[dataIndex].mType == eSHORTCUT_MONSKILL )
		{
			sKeepSkill* keepSkill = SKILLMAN->GetCoolTimeMon( mQuick[dataIndex].mSkillIndex );
			if( keepSkill && keepSkill->mRestTime > 0 )
			{
				unsigned long accumTime = THEAPP->GetWorldAccumTime();

				cIcon* colIcon = mBindIcon[iconId].mColumnIcon;
				colIcon->UpdateGauge( accumTime, keepSkill->mTotalTime - keepSkill->mRestTime, keepSkill->mTotalTime, true );

				cIcon* rowIcon = mBindIcon[iconId].mRowIcon;
				rowIcon->UpdateGauge( accumTime, keepSkill->mTotalTime - keepSkill->mRestTime, keepSkill->mTotalTime, true );
			}
		}
	}
}


/// ½ºÅ³ »ç¿ë½Ã È£Ãâ
void cQuickManager::StartSkillCoolTime( unsigned long skillIndex, unsigned long cool )
{
	if( skillIndex <= 0 )
	{
		assert(0);
		return;
	}

	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT; ++i )
	{
		unsigned int dataIndex = i;

		/// FS ½½·Ô
		if( i >= QUICKSLOT_ICON_FS_BEGIN )
			dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

		if( mQuick[dataIndex].mType == eSHORTCUT_SKILL )
		{
			if( mQuick[dataIndex].mSkillIndex == skillIndex )
			{
				/// ¾ÆÀÌÄÜ ¼¼ÆÃ
				mBindIcon[i].mColumnIcon->StartDelay( cool );
				mBindIcon[i].mRowIcon->StartDelay( cool );
			}
		}
	}

}

void cQuickManager::StartMonSkillCoolTime( short skillIdx, unsigned long cool )
{
	if( cool <= 0 )
		return;

	int i = skillIdx - eMONSTERATTACK_SKILL1;

	if( i >= 0 && i < QUICKSLOT_COUNT_MON )
	{
		mBindIcon[QUICKSLOT_ICON_FS_BEGIN+i].mColumnIcon->StartDelay( cool );
		mBindIcon[QUICKSLOT_ICON_FS_BEGIN+i].mRowIcon->StartDelay( cool );
	}
	else
	{
		assert(0);
	}
}


void cQuickManager::SetSkillAniAura( unsigned long skillIndex, sAniParam* param )
{
	for( unsigned int i = 0; i < QUICKSLOT_COUNT; ++i )
	{
		if( mQuick[i].mType != eSHORTCUT_SKILL )
			continue;

		/// ¾ÆÀÌÄÜ ¾Ö´Ï¸ÞÀÌ¼Ç ¼¼ÆÃ
		if( mQuick[i].mSkillIndex == skillIndex )
			mQuick[i].mAniParam = param;
	}

	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT; ++i )
	{
		unsigned int dataIndex = i;

		/// FS ½½·Ô
		if( i >= QUICKSLOT_ICON_FS_BEGIN )
			dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

		if( mQuick[dataIndex].mType == eSHORTCUT_SKILL )
		{
			/// ¾ÆÀÌÄÜ ¾Ö´Ï¸ÞÀÌ¼Ç ¼¼ÆÃ
			if( mQuick[dataIndex].mSkillIndex == skillIndex )
				mBindIcon[i].SetAniParam( param );
		}
	}
}	

void cQuickManager::CheckAllIcon()
{
	/// HERO °¡ Âø¿ëÇÑ ¹«±â ŸÀÔ 
	eWEAPON_STATE wstate = HERO->GetWeaponState();

	/// ÀÏ¹Ý Äü½½·Ô üũ
	for( unsigned int i = 0; i < QUICKSLOT_COUNT; ++i )
	{
		char type = mQuick[i].mType;

		if( type == eSHORTCUT_SKILL )
		{
			/// ½ºÅ³À̸é,
			if( UsableSkillIcon( wstate, mQuick[i].mSkillIndex, mQuick[i].mSkillStep) == true )
			{
				mQuick[i].mColor = NiColorA::WHITE;
			}
			else
			{
				mQuick[i].mColor = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
			}
		}
		else if( type == eSHORTCUT_ITEM )
		{
			/// ¾ÆÀÌÅÛÀ̸é,
			sItemCount* p = ITEMMAN->GetItemCount( mQuick[i].mItemIndex );
			unsigned int count = ( p ) ? p->bag : 0;
			if( count <= 0 )
			{
				mQuick[i].mColor = NiColorA( 0.5f, 0.5f, 0.5f, 1.0f );
			}
			else
			{
				int ret0 = ITEMMAN->CheckLimit( mQuick[i].mItemIndex );
				int ret1 = ITEMMAN->CheckLimitEtc( mQuick[i].mItemIndex );

				NiColorA color = NiColorA::WHITE;
				if( ret0 != ITEMLIMIT_SUCCESS || ret1 != ITEMLIMIT_SUCCESS )
				{
					color = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
				}
				mQuick[i].mColor = color;
			}
		}
	}

	/// ÀÏ¹Ý 
	for( int i = 0; i <= QUICKSLOT_ICON_COMMON_EXTRA2_END; ++i )
	{
		unsigned int dataIndex = i;
		char type = mQuick[dataIndex].mType;

		if( type == eSHORTCUT_SKILL )
		{
			mBindIcon[i].ShowNumber( true );
			mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
		}
		else if( type == eSHORTCUT_ITEM )
		{
			sItemCount* p = ITEMMAN->GetItemCount( mQuick[dataIndex].mItemIndex );
			unsigned int count = ( p ) ? p->bag : 0;

			mBindIcon[i].SetCount( count );

			mBindIcon[i].ShowNumber( true );
			mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
		}
	}

	// FS
	for( int i = QUICKSLOT_ICON_FS_BEGIN; i <= QUICKSLOT_ICON_FS_END; ++i )
	{
		unsigned int dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );
		char type = mQuick[dataIndex].mType;

		if( type == eSHORTCUT_SKILL )
		{
			mBindIcon[i].ShowNumber( true );
			mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
		}
		else if( type == eSHORTCUT_ITEM )
		{
			sItemCount* p = ITEMMAN->GetItemCount( mQuick[dataIndex].mItemIndex );
			unsigned int count = ( p ) ? p->bag : 0;
			mBindIcon[i].SetCount( count );

			mBindIcon[i].ShowNumber( true );
			mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
		}
	}

	/// ¸ó½ºÅÍ º¯½ÅÀÏ°æ¿ì FSÄü½½·Ô Àç¼¼ÆÃ
	if( mIsLockByMonster == true )
	{
		for( int i = 0; i < QUICKSLOT_COUNT_MON; ++i )
		{
			mBindIcon[ QUICKSLOT_ICON_FS_BEGIN+i ].SetColor( mQuick[QUICKSLOT_MON_BEGIN+i].mColor );
			mBindIcon[ QUICKSLOT_ICON_FS_BEGIN+i ].SetCount( 0 );
			mBindIcon[ QUICKSLOT_ICON_FS_BEGIN+i ].ShowNumber( false );
		}
	}
}

void cQuickManager::CheckItemIcon()
{
	/// ÀÏ¹Ý 
	for( int i = 0; i <= QUICKSLOT_ICON_COMMON_EXTRA2_END; ++i )
	{
		unsigned int dataIndex = i;
		char type = mQuick[dataIndex].mType;

		if( type == eSHORTCUT_ITEM )
		{
			sItemCount* p = ITEMMAN->GetItemCount( mQuick[dataIndex].mItemIndex );
			unsigned int count = ( p ) ? p->bag : 0;
			if( count <= 0 )
			{
				mQuick[dataIndex].mColor = NiColorA( 0.5f, 0.5f, 0.5f, 1.0f );
			}
			else
			{
				int ret0 = ITEMMAN->CheckLimit( mQuick[dataIndex].mItemIndex );
				int ret1 = ITEMMAN->CheckLimitEtc( mQuick[dataIndex].mItemIndex );

				NiColorA color = NiColorA::WHITE;
				if( ret0 != ITEMLIMIT_SUCCESS || ret1 != ITEMLIMIT_SUCCESS )
				{
					color = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
				}
				mQuick[dataIndex].mColor = color;
			}

			mBindIcon[i].ShowNumber( true );
			mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
		}
	}

	// FS
	for( int i = QUICKSLOT_ICON_FS_BEGIN; i <= QUICKSLOT_ICON_FS_END; ++i )
	{
		unsigned int dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );
		char type = mQuick[dataIndex].mType;

		if( type == eSHORTCUT_ITEM )
		{
			sItemCount* p = ITEMMAN->GetItemCount( mQuick[dataIndex].mItemIndex );
			unsigned int count = ( p ) ? p->bag : 0;
			if( count <= 0 )
			{
				mQuick[dataIndex].mColor = NiColorA( 0.5f, 0.5f, 0.5f, 1.0f );
			}
			else
			{
				int ret0 = ITEMMAN->CheckLimit( mQuick[dataIndex].mItemIndex );
				int ret1 = ITEMMAN->CheckLimitEtc( mQuick[dataIndex].mItemIndex );

				NiColorA color = NiColorA::WHITE;
				if( ret0 != ITEMLIMIT_SUCCESS || ret1 != ITEMLIMIT_SUCCESS )
				{
					color = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
				}
				mQuick[dataIndex].mColor = color;
			}

			mBindIcon[i].ShowNumber( true );
			mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
		}
	}

	/// ¸ó½ºÅÍ º¯½ÅÀÏ°æ¿ì FSÄü½½·Ô Àç¼¼ÆÃ
	if( mIsLockByMonster == true )
	{
		for( int i = 0; i < QUICKSLOT_COUNT_MON; ++i )
		{
			mBindIcon[ QUICKSLOT_ICON_FS_BEGIN+i ].SetColor( mQuick[QUICKSLOT_MON_BEGIN+i].mColor );
			mBindIcon[ QUICKSLOT_ICON_FS_BEGIN+i ].SetCount( 0 );
			mBindIcon[ QUICKSLOT_ICON_FS_BEGIN+i ].ShowNumber( false );
		}

	}
}

void cQuickManager::CheckSkillIcon()
{
	/// HERO °¡ Âø¿ëÇÑ ¹«±â ŸÀÔ 
	eWEAPON_STATE wstate = HERO->GetWeaponState();

	sChargeInfo chargeInfo = SKILLEXECUTER->GetCurrentChargeSkill(); 

	/// Äü½½·Ô Àüü °Ë»ç
	for( unsigned int slot = 0; slot < QUICKSLOT_COUNT; ++slot )
	{
		if( mQuick[slot].mType != eSHORTCUT_SKILL )
			continue;

		if( UsableSkillIcon( wstate, mQuick[slot].mSkillIndex, mQuick[slot].mSkillStep ) == true )
		{
			if( chargeInfo.mSkillIdx == mQuick[slot].mSkillIndex && chargeInfo.mSkillStep == mQuick[slot].mSkillStep )
			{
				mQuick[slot].mColor = NiColorA( 0.78f, 0.77f, 0.12f, 1.0f );
			}
			else
				mQuick[slot].mColor = NiColorA::WHITE;
		}
		else
		{
			mQuick[slot].mColor = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
		}
	}

	/// ¸ó½ºÅÍ º¯½Å»óÅÂÀΰæ¿ì.
	if( mIsLockByMonster == true )
	{
		for( unsigned int slot = 0; slot < QUICKSLOT_COUNT_MON; ++slot )
		{
			unsigned int dataIndex = QUICKSLOT_MON_BEGIN + slot;
			if( mQuick[dataIndex].mSkillIndex == ULONG_MAX )
				continue;

			if( UsableMonSkillIcon( mQuick[dataIndex].mSkillIndex ) == true )
			{
				if( chargeInfo.mSkillIdx == mQuick[dataIndex].mSkillIndex )
				{
					mQuick[dataIndex].mColor = NiColorA( 0.78f, 0.77f, 0.12f, 1.0f );
				}
				else
					mQuick[dataIndex].mColor = NiColorA::WHITE;
			}
			else
			{
				mQuick[dataIndex].mColor = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
			}
		}
	}

	/// ÀÏ¹Ý ½½·Ô ¾ÆÀÌÄÜ °»½Å
	for( unsigned int i = 0; i <= QUICKSLOT_ICON_COMMON_EXTRA2_END; ++i )
	{
		unsigned int dataIndex = i;
		if( mQuick[dataIndex].mType == eSHORTCUT_SKILL )
			mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
	}

	/// FS ½½·Ô ¾ÆÀÌÄÜ °»½Å
	for( unsigned int i = QUICKSLOT_ICON_FS_BEGIN; i <= QUICKSLOT_ICON_FS_END; ++i )
	{
		unsigned int dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

		/// ¸ó½ºÅÍ º¯½ÅÀΰæ¿ì,
		if( mIsLockByMonster == true && i < QUICKSLOT_ICON_FS_BEGIN + QUICKSLOT_COUNT_MON )
			dataIndex = i + QUICKSLOT_MON_BEGIN - QUICKSLOT_ICON_FS_BEGIN;

		if( mQuick[dataIndex].mType == eSHORTCUT_SKILL || 
			mQuick[dataIndex].mType == eSHORTCUT_MONSKILL )
		{
			mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
		}
	}
}

bool cQuickManager::UsableMonSkillIcon( unsigned long skillindex )
{
	if( HERO->IsCantSkill( skillindex ) == true )
		return false;

	unsigned long monIdx = HERO->GetTransMonsterClassIdx();
	sMonsterSkillScript* skill = SKILLSCRIPT->GetMonsterSkillInfo( monIdx, (eMONSTERATTACK_TYPE)skillindex );
	if( !skill )
	{
		assert(0);
		return false;
	}

	/// ¼Ò¸ð MP ·® °Ë»ç
	unsigned long curMP = HERO->GetMP();
	unsigned long totalUseMP = HERO->CalcUseMPExt( skill->mUseMP );
	if( curMP < totalUseMP )
		return false;
	return true;
}

bool cQuickManager::UsableSkillIcon( eWEAPON_STATE heroWeaponState, unsigned long skillindex, unsigned char skillstep )
{
	///
	if( HERO->IsTransformMonster() )
		return false;

	if( HERO->IsCantSkill( skillindex ) == true )
		return false;

	/// µ¿ÀÏÇÑ ½ºÅ³À» ¸ðµÎ ¼¼ÆÃ.
	sPlayerSkillBaseInfo* pInfo = SKILLSCRIPT->GetPlayerSkillInfo( skillindex );
	if( pInfo == 0 )
	{
		assert(0);
		return false;
	}

	if( skillstep >= pInfo->mStepCount )
	{
		assert(0);
		return false;
	}
	sPlayerSkillStepInfo* pStepInfo = &pInfo->mpSetpInfoArray[skillstep];

	/// use item check
	if( pInfo->mUseItem )
	{
		sItemCount* p = ITEMMAN->GetItemCount( pInfo->mUseItem );
		unsigned int count = ( p ) ? p->bag : 0;
		if( count < pStepInfo->mUseItemCount )
			return false;
	}

	/// »ç¿ë »óÅ°¡ ¸Â´ÂÁö üũ
	if( pInfo->mUseState )
	{
		switch( pInfo->mUseState )
		{
		case eSKILL_USE_STATE_HP_PER_UP: // hp up
			{
				unsigned long hp = HERO->GetHP();
				unsigned long maxHP = HERO->GetMaxHP();
				if( maxHP == 0 )
				{
					assert(0);
					return false;
				}

				if( pStepInfo->mUseStateValue > (hp * 100 / maxHP) )
					return false;
			}
			break;
		case eSKILL_USE_STATE_HP_PER_DOWN: // hp down
			{
				unsigned long hp = HERO->GetHP();
				unsigned long maxHP = HERO->GetMaxHP();
				if( maxHP == 0 )
				{
					assert(0);
					return false;
				}

				if( pStepInfo->mUseStateValue < (hp * 100 / maxHP) )
					return false;
			}
			break;
		case eSKILL_USE_STATE_MP_PER_UP: // mp up
			{
				unsigned long mp = HERO->GetMP();
				unsigned long maxMP = HERO->GetMaxMP();
				if( maxMP == 0 )
				{
					assert(0);
					return false;
				}

				if( pStepInfo->mUseStateValue > (mp * 100 / maxMP) )
					return false;
			}
			break;
		case eSKILL_USE_STATE_MP_PER_DOWN: // mp down
			{
				unsigned long mp = HERO->GetMP();
				unsigned long maxMP = HERO->GetMaxMP();
				if( maxMP == 0 )
				{
					assert(0);
					return false;
				}

				if( pStepInfo->mUseStateValue < (mp * 100 / maxMP) )
					return false;
			}
			break;
		case eSKILL_USE_STATE_SELF_BUFF:
			{
				/// º¸À¯ÁßÀÎ È¿°ú¿¡¼­ ÇØ´ç È¿°ú°¡ ÀÖ´ÂÁö üũ
				if( HERO->IsHaveApplyBuffType( pStepInfo->mUseStateValue ) == false )
					return false;
			}
			break;
		case eSKILL_USE_STATE_SELF_DEBUFF:
			{
				/// º¸À¯ÁßÀÎ È¿°ú¿¡¼­ ÇØ´ç È¿°ú°¡ ÀÖ´ÂÁö üũ
				if( HERO->IsHaveApplyDeBuffType( pStepInfo->mUseStateValue ) == false )
					return false;
			}
			break;
		default:
			{
				assert(0);
				return false;
			}
		}
	}

	/// ÇöÀç HP·®
	unsigned long curHp = HERO->GetHP();
	if( curHp < pStepInfo->mUseHP )
		return false;

	/// ÇöÀç MP·®
	unsigned long curMP = HERO->GetMP();
	unsigned long totalUseMP = HERO->CalcUseMPExt( pStepInfo->mUseMP );
	if( curMP <  totalUseMP )
		return false;
	if( pStepInfo->mUseMPPer > 0 )
	{
		unsigned long currentUseMP = HERO->GetOriMpMax();
		currentUseMP = (unsigned long)((currentUseMP * pStepInfo->mUseMPPer) / 100);
		totalUseMP = HERO->CalcUseMPExt( currentUseMP );
		if( curMP < totalUseMP )
			return false;
	}

	if( pInfo->mUseEquipment )
	{
		/// Âø¿ë Àåºñ üũ
		switch( pInfo->mUseEquipment )
		{
		case eEQUIPTYPE_SWORD:
			if( heroWeaponState != eWEAPON_STATE_SWORD &&
				heroWeaponState != eWEAPON_STATE_SWORD_SHEILD )
				return false;
			break;
		case eEQUIPTYPE_LONGSWORD:
			if( heroWeaponState != eWEAPON_STATE_LONGSWORD )
				return false;
			break;
		case eEQUIPTYPE_DOUBLESWORD:
			if( heroWeaponState != eWEAPON_STATE_DOUBLESWORD )
				return false;
			break;
		case eEQUIPTYPE_SHORTSWORD:
			if( heroWeaponState != eWEAPON_STATE_SHORTSWORD )
				return false;
			break;
		case eEQUIPTYPE_GUN:
			if( heroWeaponState != eWEAPON_STATE_GUN )
				return false;
			break;
		case eEQUIPTYPE_STAFF:
			if( heroWeaponState != eWEAPON_STATE_STAFF )
				return false;
			break;
		case eEQUIPTYPE_SHIELD:
			if( heroWeaponState != eWEAPON_STATE_SHEILD &&
				heroWeaponState != eWEAPON_STATE_SWORD_SHEILD )
				return false;
			break;
		case eEQUIPTYPE_SWORD_LONGSWORD:
			if( heroWeaponState != eWEAPON_STATE_SWORD &&
				heroWeaponState != eWEAPON_STATE_SWORD_SHEILD &&
				heroWeaponState != eWEAPON_STATE_LONGSWORD )
				return false;
			break;
		case eEQUIPTYPE_SWORD_DOUBLESWORD:
			if( heroWeaponState != eWEAPON_STATE_SWORD &&
				heroWeaponState != eWEAPON_STATE_SWORD_SHEILD &&
				heroWeaponState != eWEAPON_STATE_DOUBLESWORD )
				return false;
			break;
		case eEQUIPTYPE_LONGSWORD_DOUBLESWORD:
			if( heroWeaponState != eWEAPON_STATE_LONGSWORD &&
				heroWeaponState != eWEAPON_STATE_DOUBLESWORD )
				return false;
			break;
		case eEQUIPTYPE_SWORD_LONGSWORD_DOUBLESWORD:
			if( heroWeaponState != eWEAPON_STATE_SWORD &&
				heroWeaponState != eWEAPON_STATE_SWORD_SHEILD &&
				heroWeaponState != eWEAPON_STATE_LONGSWORD &&
				heroWeaponState != eWEAPON_STATE_DOUBLESWORD )
				return false;
			break;
		case eEQUIPTYPE_SHORTSWORD_GUN:
			if( heroWeaponState != eWEAPON_STATE_SHORTSWORD &&
				heroWeaponState != eWEAPON_STATE_GUN )
				return false;
			break;
		}
	}

	if( pInfo->mApplyType == eAPPLYTYPE_DIEBUDDY )
	{
		if( PVPMAN->IsEnableBattle() )
			return false;
	}
	return true;
}

void cQuickManager::SetCharge( unsigned long skillIndex, bool charge )
{
	if( HERO->IsTransformMonster() == true )
	{
		assert(0);
		return;
	}

	eWEAPON_STATE wstate = HERO->GetWeaponState();

	sPlayerSkillBaseInfo* pInfo = SKILLSCRIPT->GetPlayerSkillInfo( skillIndex );
	if( pInfo )
	{
		/// »ç¿ë °¡´É ¹«±â°¡ ¾Æ´Ï¸é ¸®ÅÏ
		if( wstate != pInfo->mUseEquipment )
			return;
	}

	/// Äü½½·Ô Àüü °Ë»ç
	bool update = false;
	for( unsigned int slot = 0; slot < QUICKSLOT_COUNT; ++slot )
	{
		if( mQuick[slot].mType != eSHORTCUT_SKILL )
			continue;

		/// Çش罺ųÀ̸é íÁö
		if( mQuick[slot].mSkillIndex == skillIndex )
		{
			update = true;

			if( charge == true )
				mQuick[slot].mColor = NiColorA( 0.78f, 0.77f, 0.12f, 1.0f );
			else
			{
				/// charge°¡ Ç®¸±¶§ »óÅ°˻ç
				eWEAPON_STATE wstate = HERO->GetWeaponState();
				if( UsableSkillIcon( wstate, mQuick[slot].mSkillIndex, mQuick[slot].mSkillStep ) == true )
					mQuick[slot].mColor =  NiColorA::WHITE;
				else
					mQuick[slot].mColor = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
			}
		}
	}

	if( update == true )
	{
		for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT; ++i )
		{
			unsigned int dataIndex = i;

			/// FS ½½·Ô 
			if( i >= QUICKSLOT_ICON_FS_BEGIN )
				dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

			if( mQuick[dataIndex].mType == eSHORTCUT_SKILL )
				mBindIcon[i].SetColor( mQuick[dataIndex].mColor );
		}

	}
}

/// ¸ó½ºÅÍ ½ºÅ³ íÁö
void cQuickManager::SetMonCharge( unsigned long skillIndex, bool charge )
{
	for( unsigned int slot = 0; slot < QUICKSLOT_COUNT_MON; ++slot )
	{
		int dataIndex = QUICKSLOT_MON_BEGIN + slot;
		if( mQuick[dataIndex].mSkillIndex == ULONG_MAX )
			continue;

		if( mQuick[dataIndex].mSkillIndex == skillIndex )
		{
			if( charge == true )
				mQuick[dataIndex].mColor = NiColorA( 0.78f, 0.77f, 0.12f, 1.0f );
			else
			{
				if( UsableMonSkillIcon( skillIndex ) == true )
					mQuick[dataIndex].mColor = NiColorA::WHITE;
				else
					mQuick[dataIndex].mColor = NiColorA( 1.0f, 0.0f, 0.0f, 1.0f );
			}

			mBindIcon[QUICKSLOT_ICON_FS_BEGIN + slot].SetColor( mQuick[dataIndex].mColor );
		}
	}
}

void cQuickManager::ChangeMonster( unsigned long monIndex )
{
	/// ¸ó½ºÅÍ º¯½Å
	if( monIndex > 0 )
	{	
		mIsLockByMonster = true;

		/// ¼¼ÆÃ
		for( int i = 0; i < QUICKSLOT_COUNT_MON; ++i )
		{
			unsigned int dataIndex = QUICKSLOT_MON_BEGIN + i;
			unsigned int iconId = QUICKSLOT_ICON_FS_BEGIN + i;

			/// ÃʱâÈ­
			mQuick[dataIndex] = 0;
			mBindIcon[iconId].Clear();

			sMonsterSkillScript* skill = SKILLSCRIPT->GetMonsterSkillInfo( monIndex, (eMONSTERATTACK_TYPE)(eMONSTERATTACK_SKILL1 + i) );
			if( skill )
			{
				mQuick[dataIndex].mType = eSHORTCUT_MONSKILL;
				mQuick[dataIndex].mSkillIndex = eMONSTERATTACK_SKILL1 + i;
				mQuick[dataIndex].mColor = NiColorA::WHITE;
			}
			else
			{
				mQuick[dataIndex].mType = eSHORTCUT_MONSKILL;
				mQuick[dataIndex].mSkillIndex = ULONG_MAX;
				mQuick[dataIndex].mColor = NiColorA( 0.5f, 0.5f, 0.5f, 1.0f );
			}

			/// Äü½½·Ô ¾ÆÀÌÄÜ ¼¼ÆÃ
			mBindIcon[iconId].ShowNumber( false );
			mBindIcon[iconId].SetColor( mQuick[dataIndex].mColor );
			mBindIcon[iconId].SetParam( UIMAN->GetIconParam(MONICON_PARAMINDEX + i) );
			mBindIcon[iconId].SetColor( mQuick[dataIndex].mColor );
			mBindIcon[iconId].SetTipType( mQuick[dataIndex].mTipType );
		}
	}
	/// º¯½Å ÇØÁ¦
	else
	{
		mIsLockByMonster = false; 

		/// FS Äü½½·Ô Àç¼¼Æà - ¾Õ¿¡¼­ºÎÅÍ 3°³¸¸ ¸®¼Â
		unsigned int slot = (mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH) + QUICKSLOT_FS1_BEGIN;
		for ( unsigned int i = 0; i < QUICKSLOT_COUNT_MON; ++i )
		{
			UpdateIcon( slot + i , QUICKSLOT_ICON_FS_BEGIN + i );
		}

		LoadCoolTime();
		LoadCoolTimeMon();
	}
}

/// ½ºÅ³ »ç¿ë½Ã È£Ãâ
void cQuickManager::ClearCoolTime( unsigned long exceptSkillIdx )
{
	if( exceptSkillIdx <= 0 )
	{
		assert(0);
		return;
	}

	for( unsigned int i = 0; i < QUICKSLOT_ICON_COUNT; ++i )
	{
		unsigned int dataIndex = i;

		/// FS ½½·Ô
		if( i >= QUICKSLOT_ICON_FS_BEGIN )
			dataIndex = i + ( mTabIndexFS * QUICKSLOT_ICON_COUNT_FOR_EACH );

		if( mQuick[dataIndex].mType == eSHORTCUT_SKILL )
		{
			if( mQuick[dataIndex].mSkillIndex > 0 && mQuick[dataIndex].mSkillIndex != exceptSkillIdx )
			{
				/// ¾ÆÀÌÄÜ ¼¼ÆÃ
				if( mBindIcon[i].mColumnIcon && mBindIcon[i].mColumnIcon->IsActive() )
					mBindIcon[i].mColumnIcon->ClearCooltime();

				if( mBindIcon[i].mRowIcon && mBindIcon[i].mRowIcon->IsActive() )
					mBindIcon[i].mRowIcon->ClearCooltime();
			}
		}
	}
}