#include "stdafx.h"
#include "DnScriptAPI.h"
#include "DNUserSession.h"
#include "DNUserSessionManager.h"
#include "DNFieldManager.h"
#include "DNNpcObject.h"
#include "DNNpcObjectManager.h"
#include "DNUserItem.h"
#include "DNGameDataManager.h"

#include "DNLogConnection.h"
#include "DnLuaAPIDefine.h"
#include "DNReplaceString.h"
#include "EtUIXML.h"

#include "DNMasterConnection.h"
#include "DNPartyManager.h"
#include "DNQuestManager.h"
#include "TimeSet.h"
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
#include "ReputationSystemRepository.h"
#include "NpcReputationProcessor.h"
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
#if defined( PRE_ADD_SECONDARY_SKILL )
#include "SecondarySkillRepository.h"
#endif // #if defined( PRE_ADD_SECONDARY_SKILL )
#include "DNGuildSystem.h"
#if !defined(_FINAL_BUILD)
extern CLog g_ScriptLog;
#endif	// #if !defined(_FINAL_BUILD)
#include "DNGuildWarManager.h"
#include "DNGuildVillage.h"
#include "DNPeriodQuestSystem.h"
#include "DNScriptAPICommon.h"

int CheckInvenForQuestReward(CDNUserBase* pUser, const TQuestReward& QuestReward, const bool bSelectedArray[])
{
	return DNScriptAPI::CheckInvenForQuestReward(pUser, QuestReward, bSelectedArray);
}

void DefAllAPIFunc(lua_State* pLuaState)
{
	DefineLuaAPI(pLuaState);

	LUA_TINKER_DEF(pLuaState, api_npc_NextTalk);
	LUA_TINKER_DEF(pLuaState, api_npc_NextScript);
	
	LUA_TINKER_DEF(pLuaState, api_npc_SetParamString);
	LUA_TINKER_DEF(pLuaState, api_npc_SetParamInt);
	LUA_TINKER_DEF(pLuaState, api_log_AddLog);
	LUA_TINKER_DEF(pLuaState, api_log_UserLog);
	LUA_TINKER_DEF(pLuaState, api_quest_DumpQuest);
	
	LUA_TINKER_DEF(pLuaState, api_quest_AddHuntingQuest);
	LUA_TINKER_DEF(pLuaState, api_quest_AddQuest);
	LUA_TINKER_DEF(pLuaState, api_quest_UserHasQuest);
	LUA_TINKER_DEF(pLuaState, api_quest_GetPlayingQuestCnt);
	
	LUA_TINKER_DEF(pLuaState, api_quest_CompleteQuest);
	LUA_TINKER_DEF(pLuaState, api_quest_MarkingCompleteQuest);
	LUA_TINKER_DEF(pLuaState, api_quest_IsMarkingCompleteQuest);
	
	
	LUA_TINKER_DEF(pLuaState, api_npc_GetNpcIndex);
	LUA_TINKER_DEF(pLuaState, api_quest_SetQuestStepAndJournalStep);
	LUA_TINKER_DEF(pLuaState, api_quest_SetQuestStep);
	LUA_TINKER_DEF(pLuaState, api_quest_GetQuestStep);
	LUA_TINKER_DEF(pLuaState, api_quest_SetJournalStep);
	LUA_TINKER_DEF(pLuaState, api_quest_GetJournalStep);
	LUA_TINKER_DEF(pLuaState, api_quest_SetQuestMemo);
	LUA_TINKER_DEF(pLuaState, api_quest_GetQuestMemo);
	LUA_TINKER_DEF(pLuaState, api_quest_CancelQuest);
	

	LUA_TINKER_DEF(pLuaState, api_quest_SetCountingInfo);
	LUA_TINKER_DEF(pLuaState, api_quest_ClearCountingInfo);
	LUA_TINKER_DEF(pLuaState, api_quest_IsAllCompleteCounting);
	LUA_TINKER_DEF(pLuaState, api_user_CheckInvenForAddItem);
	LUA_TINKER_DEF(pLuaState, api_user_CheckInvenForAddItemList);
	LUA_TINKER_DEF(pLuaState, api_user_AddItem);
	LUA_TINKER_DEF(pLuaState, api_user_DelItem);
	LUA_TINKER_DEF(pLuaState, api_user_AllDelItem);
	LUA_TINKER_DEF(pLuaState, api_user_HasItem);

	LUA_TINKER_DEF(pLuaState, api_user_GetUserClassID);
	LUA_TINKER_DEF(pLuaState, api_user_GetUserJobID);
	LUA_TINKER_DEF(pLuaState, api_user_GetUserLevel);
	LUA_TINKER_DEF(pLuaState, api_user_GetUserInvenBlankCount);
	LUA_TINKER_DEF(pLuaState, api_quest_GetUserQuestInvenBlankCount);
	
	LUA_TINKER_DEF(pLuaState, api_user_AddExp);
	LUA_TINKER_DEF(pLuaState, api_user_AddCoin);
	LUA_TINKER_DEF(pLuaState, api_user_PlayCutScene);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenWareHouse);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenShop);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenSkillShop);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenMarket);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenCompoundEmblem);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenUpgradeJewel);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenMailBox);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenUpgradeItem);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenDisjointItem);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenCompoundItem);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenCashShop);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenGuildMgrBox);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenGacha_JP);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenGiveNpcPresent);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenDarkLairRankBoard);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenPvPLadderRankBoard);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenGlyphLift);
#ifdef PRE_ADD_OPEN_QUEST_TEXTURE_DIALOG
	LUA_TINKER_DEF(pLuaState, api_ui_OpenTextureDialog);
	LUA_TINKER_DEF(pLuaState, api_ui_CloseTextureDialog);
#endif
	LUA_TINKER_DEF(pLuaState, api_user_UserMessage);
	LUA_TINKER_DEF(pLuaState, api_quest_AddSymbolItem);
	LUA_TINKER_DEF(pLuaState, api_quest_DelSymbolItem);
	LUA_TINKER_DEF(pLuaState, api_quest_HasSymbolItem);
	
	LUA_TINKER_DEF(pLuaState, api_quest_CheckQuestInvenForAddItem);
	LUA_TINKER_DEF(pLuaState, api_quest_CheckQuestInvenForAddItemList);
	LUA_TINKER_DEF(pLuaState, api_quest_AddQuestItem);
	LUA_TINKER_DEF(pLuaState, api_quest_DelQuestItem);
	LUA_TINKER_DEF(pLuaState, api_quest_AllDelQuestItem);
	LUA_TINKER_DEF(pLuaState, api_quest_HasQuestItem);

	LUA_TINKER_DEF(pLuaState, api_ui_OpenGuildCreate);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenQuestReward);
	LUA_TINKER_DEF(pLuaState, api_quest_RewardQuestUser);

	LUA_TINKER_DEF(pLuaState, api_user_ChangeChannel);
	LUA_TINKER_DEF(pLuaState, api_user_ChangeMap);
	LUA_TINKER_DEF(pLuaState, api_user_GetPartymemberCount);
	LUA_TINKER_DEF(pLuaState, api_user_IsPartymember);

	LUA_TINKER_DEF(pLuaState, api_user_RequestEnterPVP);

	LUA_TINKER_DEF(pLuaState, api_user_GetStageConstructionLevel);
	LUA_TINKER_DEF(pLuaState, api_user_GetMapIndex);
	LUA_TINKER_DEF(pLuaState, api_user_GetLastStageClearRank);
	LUA_TINKER_DEF(pLuaState, api_user_EnoughCoin );
	LUA_TINKER_DEF(pLuaState, api_user_GetCoin);
	LUA_TINKER_DEF(pLuaState, api_user_DelCoin);
	LUA_TINKER_DEF(pLuaState, api_user_IsMissionGained);
	LUA_TINKER_DEF(pLuaState, api_user_IsMissionAchieved);
	LUA_TINKER_DEF(pLuaState, api_user_HasItemWarehouse);
	LUA_TINKER_DEF(pLuaState, api_user_HasItemEquip);
	LUA_TINKER_DEF(pLuaState, api_guild_GetGuildMemberRole);
	LUA_TINKER_DEF(pLuaState, api_quest_IncQuestMemo);
	LUA_TINKER_DEF(pLuaState, api_quest_DecQuestMemo);
	LUA_TINKER_DEF(pLuaState, api_user_SetUserJobID);
	LUA_TINKER_DEF(pLuaState, api_user_IsJobInSameLine);
	LUA_TINKER_DEF(pLuaState, api_user_HasCashItem);
	LUA_TINKER_DEF(pLuaState, api_user_HasCashItemEquip);
	LUA_TINKER_DEF(pLuaState, api_quest_IncCounting);
	LUA_TINKER_DEF(pLuaState, api_quest_IsPlayingQuestMaximum);
	LUA_TINKER_DEF(pLuaState, api_quest_ForceCompleteQuest);
	LUA_TINKER_DEF(pLuaState, api_quest_ResetSkill);

	LUA_TINKER_DEF(pLuaState, api_quest_GetWorldEventStep);
	LUA_TINKER_DEF(pLuaState, api_quest_GetWorldEventCount);
	LUA_TINKER_DEF(pLuaState, api_quest_ReturnItemToNpc);
	LUA_TINKER_DEF(pLuaState, api_quest_OpenScoreWorldEvent);
	LUA_TINKER_DEF(pLuaState, api_quest_OpenFarmAreaList);

	LUA_TINKER_DEF(pLuaState, api_user_ChangePos);

	LUA_TINKER_DEF(pLuaState, api_npc_GetFavorPoint);
	LUA_TINKER_DEF(pLuaState, api_npc_GetMalicePoint);
	LUA_TINKER_DEF(pLuaState, api_npc_GetFavorPercent);
	LUA_TINKER_DEF(pLuaState, api_npc_GetMalicePercent);
	LUA_TINKER_DEF(pLuaState, api_npc_AddFavorPoint);
	LUA_TINKER_DEF(pLuaState, api_npc_AddMalicePoint);
	LUA_TINKER_DEF(pLuaState, api_npc_SendSelectedPresent);
	LUA_TINKER_DEF(pLuaState, api_npc_Rage);
	LUA_TINKER_DEF(pLuaState, api_npc_Disappoint);

	LUA_TINKER_DEF(pLuaState, api_user_ResetSkill);
	LUA_TINKER_DEF(pLuaState, api_npc_CreateSecondarySkill );
	LUA_TINKER_DEF(pLuaState, api_npc_CheckSecondarySkill );
	LUA_TINKER_DEF(pLuaState, api_ui_OpenGuildWareHouse );
	LUA_TINKER_DEF(pLuaState, api_guild_HasGuildWare );

	LUA_TINKER_DEF(pLuaState, api_ui_OpenMovieBrowser);

	LUA_TINKER_DEF(pLuaState, api_guildwar_IsPreparation );
	LUA_TINKER_DEF(pLuaState, api_guildwar_GetStep );
	LUA_TINKER_DEF(pLuaState, api_guildwar_GetTrialCurrentState );
	LUA_TINKER_DEF(pLuaState, api_guildWar_GetTrialStats );
	LUA_TINKER_DEF(pLuaState, api_guildWar_GetMatchList );
	LUA_TINKER_DEF(pLuaState, api_guildWar_GetPopularityVote );	
	LUA_TINKER_DEF(pLuaState, api_guildWar_GetFinalProgress );	

	LUA_TINKER_DEF(pLuaState, api_ui_OpenCompound2Item);
	LUA_TINKER_DEF(pLuaState, api_ui_OpenBrowser);

#if defined (PRE_ADD_DONATION)
	LUA_TINKER_DEF(pLuaState, api_ui_OpenDonation);
#endif // #if defined (PRE_ADD_DONATION)
	LUA_TINKER_DEF(pLuaState, api_ui_OpenInventory);
	LUA_TINKER_DEF(pLuaState, api_user_GetPCCafe);
	LUA_TINKER_DEF(pLuaState, api_user_SetPCCafeItem);
#if defined(PRE_ADD_REPAIR_NPC)
	LUA_TINKER_DEF(pLuaState, api_user_RepairItem);
#endif
#ifdef PRE_ADD_EXCHANGE_ENCHANT
	LUA_TINKER_DEF(pLuaState, api_ui_OpenExchangeEnchant);
#endif
#if defined(PRE_ADD_CHALLENGE_DARKLAIR)
	LUA_TINKER_DEF(pLuaState, api_env_CheckCloseGateByTime);
#endif
#ifdef PRE_ADD_COSRANDMIX_ACCESSORY
	LUA_TINKER_DEF(pLuaState, api_ui_OpenCostumeRandomMix);
#endif
#if defined( PRE_DRAGONBUFF )
	LUA_TINKER_DEF(pLuaState, api_quest_WorldBuffCheck);
	LUA_TINKER_DEF(pLuaState, api_quest_ApplyWorldBuff);
#endif
#if defined( PRE_ADD_DWC )
	LUA_TINKER_DEF(pLuaState, api_ui_OpenCreateDwcTeamDlg);
#endif

	LUA_TINKER_DEF(pLuaState, api_ui_OpenJobChange);
}

CDNUserSession* __GetUserObj(UINT nUserObjectID)
{
	return g_pUserSessionManager->FindUserSessionByObjectID(nUserObjectID);
}

// desc : Àκ¥Å丮ÀÇ Æ¯Á¤ ºó½½·Ô¿¡ ¾ÆÀÌÅÛÀ» ¼¼Æà (P.S.> api_user_CheckInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
bool __SetBlankInventorySlot(TInvenItemCnt pTempInven[INVENTORYMAX], const TItem& Item, int iIndex)
{
	DN_ASSERT(NULL != pTempInven,	"Invalid!");
	DN_ASSERT(0 != Item.nItemID,			"Invalid!");
	DN_ASSERT(0 < Item.wCount,			"Invalid!");
	DN_ASSERT(-1 < iIndex,			"Invalid!");

	if (pTempInven[iIndex].nItemID != 0) {
		return false;
	}

	pTempInven[iIndex].Set( Item.nItemID, Item.wCount, Item.bSoulbound, Item.cSealCount );

	return true;
}

// desc : Àκ¥Å丮ÀÇ ºó½½·Ôµé¿¡ ¾ÆÀÌÅÛÀ» ƯÁ¤ °³¼ö¸¸Å­ ¼¼Æà (P.S.> api_user_CheckInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
bool __SetBlankInventorySlotCount(TInvenItemCnt pTempInven[INVENTORYMAX], const TItem& Item, int nOverlapCount, int nCount /* ä¿ï ½½·Ô°³¼ö */)
{
	DN_ASSERT(NULL != pTempInven,	"Invalid!");
	DN_ASSERT(0 != Item.nItemID,			"Invalid!");
	DN_ASSERT(0 < Item.wCount,			"Invalid!");
	DN_ASSERT(0 < nOverlapCount,	"Invalid!");
	DN_ASSERT(0 < nCount,			"Invalid!");

	// !!! ÁÖÀÇ - º» ÇÔ¼ö È£Ãâ Àü¿¡ üũ°¡ È®½ÇÈ÷ µÇ¾úÀ½À» ÀüÁ¦ÇÏ°í ¼¼ÆÃÇÏ´Â ºÎºÐ¸¸ ¼öÇà

	int nBundle = Item.wCount / nOverlapCount;
	int nRemain = Item.wCount % nOverlapCount;

	for (int iIndex = 0 ; INVENTORYMAX > iIndex ; ++iIndex) 
	{
		if (0 < nBundle) {
			if (pTempInven[iIndex].nItemID == 0) 
			{
				pTempInven[iIndex].Set( Item.nItemID, nOverlapCount, Item.bSoulbound, Item.cSealCount );
				--nBundle;
				continue;
			}
		}

		if (0 < nRemain) 
		{
			if( CDNUserItem::bIsSameItem( &Item, &pTempInven[iIndex] ) && nOverlapCount >= pTempInven[iIndex].wCount + nRemain )
			{
				pTempInven[iIndex].wCount += nRemain;
				nRemain = 0;
				continue;
			}
		}
	}

	if (0 < nBundle) 
	{
		return false;
	}
	if (0 < nRemain) 
	{
		for (int iIndex = 0 ; INVENTORYMAX > iIndex ; ++iIndex) 
		{
			if (pTempInven[iIndex].nItemID == 0) {
				pTempInven[iIndex].Set( Item.nItemID, nRemain, Item.bSoulbound, Item.cSealCount );
				nRemain = 0;
				break;
			}
		}
	}
	if (0 < nRemain) 
	{
		return false;
	}

	return true;
}

// desc : Àκ¥Å丮ÀÇ Æ¯Á¤ ½½·Ô¿¡ ¾ÆÀÌÅÛÀ» Áßø ¼¼Æà (P.S.> api_user_CheckInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
bool __SetOverlapInventorySlot(TInvenItemCnt pTempInven[INVENTORYMAX], const TItem& Item, int nOverlapCount, int iIndex)
{
	DN_ASSERT(NULL != pTempInven,	"Invalid!");
	DN_ASSERT(0 != Item.nItemID,			"Invalid!");
	DN_ASSERT(0 < Item.wCount,			"Invalid!");
	DN_ASSERT(0 < nOverlapCount,	"Invalid!");
	DN_ASSERT(-1 < iIndex,			"Invalid!");

	if ( CDNUserItem::bIsDifferentItem( &Item, &pTempInven[iIndex] ) || nOverlapCount < pTempInven[iIndex].wCount + Item.wCount )
	{
		return false;
	}

	pTempInven[iIndex].wCount += Item.wCount;

	return true;
}

// desc : Àκ¥Å丮¿¡ ºó½½·Ô ã±â (P.S.> api_user_CheckInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
int __FindBlankInventorySlot(TInvenItemCnt pTempInven[INVENTORYMAX], int nTempInvenCount)
{
	DN_ASSERT(NULL != pTempInven,								"Invalid!");
	DN_ASSERT(CHECK_RANGE(nTempInvenCount, 0, INVENTORYMAX),	"Invalid!");

	for (int iIndex = 0 ; nTempInvenCount > iIndex ; ++iIndex) {
		if (pTempInven[iIndex].nItemID == 0) {
			return iIndex;
		}
	}

	return -1;
}

// desc : Àκ¥Å丮¿¡ ºó½½·ÔÀÌ ¸î °³³ª ÀÖ´ÂÁö °³¼ö ã±â (P.S.> api_user_CheckInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
int __FindBlankInventorySlotCount(TInvenItemCnt pTempInven[INVENTORYMAX], int nTempInvenCount)
{
	DN_ASSERT(NULL != pTempInven,								"Invalid!");
	DN_ASSERT(CHECK_RANGE(nTempInvenCount, 0, INVENTORYMAX),	"Invalid!");

	int nCount = 0;
	for (int iIndex = 0 ; nTempInvenCount > iIndex ; ++iIndex) {
		if (pTempInven[iIndex].nItemID == 0) {
			++nCount;
		}
	}

	return nCount;
}

// desc : Àκ¥Å丮¿¡ ¼¿ ¼ö ÀÖ´Â ¾ÆÀÌÅÛ Áß ³²Àº °ø°£¿¡ wCount ³ÖÀ» ¼ö ÀÖ´Â Index ã±â (P.S.> api_user_CheckInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
int __FindOverlapInventorySlot(TInvenItemCnt pTempInven[INVENTORYMAX], int nTempInvenCount, const TItem& Item)
{
	DN_ASSERT(NULL != pTempInven,								"Invalid!");
	DN_ASSERT(CHECK_RANGE(nTempInvenCount, 0, INVENTORYMAX),	"Invalid!");

	if ((Item.nItemID <= 0) || (Item.wCount <= 0)) DN_RETURN(-1);

	TItemData *pItemData = NULL;
	for (int iIndex = 0 ; nTempInvenCount > iIndex ; ++iIndex) {
		if (pTempInven[iIndex].nItemID == 0) {
			// ºóÄ­À̸é Æнº
			continue;
		}

		pItemData = g_pDataManager->GetItemData(pTempInven[iIndex].nItemID);
		if (!pItemData) continue;

		if (pItemData->nOverlapCount == 1) continue;			// °ãÄ¡Áö ¾ÊÀ¸¸é Æнº
		if( CDNUserItem::bIsDifferentItem( &Item, &pTempInven[iIndex] ) ) continue;	// °°Àº ¾ÆÀÌÅÛÀÌ ¾Æ´Ô

		if (pItemData->nOverlapCount >= pTempInven[iIndex].wCount + Item.wCount) {
			return iIndex;
		}
	}

	return -1;
}

// desc : Àκ¥Å丮¿¡ ¾ÆÀÌÅÛÀ» ³ÖÀ» ¼ö ÀÖ´Â °ø°£ÀÌ ÃæºÐÇÑÁö °Ë»ç (P.S.> api_user_CheckInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
bool __IsValidSpaceInventorySlotAndSet(TInvenItemCnt pTempInven[INVENTORYMAX], int nTempInvenCount, const TItem& Item )
{
	DN_ASSERT(NULL != pTempInven,								"Invalid!");
	DN_ASSERT(CHECK_RANGE(nTempInvenCount, 0, INVENTORYMAX),	"Invalid!");

	if ((Item.nItemID <= 0) || (Item.wCount <= 0)) 
		DN_RETURN(false);

	TItemData *pItem = g_pDataManager->GetItemData(Item.nItemID);
	if (!pItem) return false;

	if (ITEMTYPE_QUEST == pItem->nType) {
		return false;
	}

	int nCount = 0;
	if (pItem->nOverlapCount == 1){		// °ãÄ¡Áö ¾Ê´Â ¾ÆÀÌÅÛ
		nCount = __FindBlankInventorySlotCount(pTempInven, nTempInvenCount);
		if (Item.wCount > nCount) {
			// ºó½½·ÔÀ̶û ºñ±³Çϱâ
			return false;
		}

		return(__SetBlankInventorySlotCount(pTempInven, Item, 1, nCount));
	}
	else {
		// °ãÃÄÁö´Â ¾ÆÀÌÅÛ (Àκ¥¿¡ µ¿ÀÏ ¾ÆÀÌÅÛµéÀÌ ¸î°³¾¿ ³²¾ÆÀ־ ½Å°æ¾È¾²°í ±ò²ûÇÏ°Ô ³Ö´Â °æ¿ì¸¸ »ý°¢ÇÏÀð)
		if (pItem->nOverlapCount < Item.wCount){		// Çѹø¿¡ °ãÄ¡´Â ¾çº¸´Ù ¸¹À»°æ¿ì
			int nBundle = Item.wCount / pItem->nOverlapCount;
			if ((Item.wCount % pItem->nOverlapCount) > 0) nBundle++;

			nCount = __FindBlankInventorySlotCount(pTempInven, nTempInvenCount);
			if (nBundle > nCount) {
				// ¹­À½À̶û ºó½½·ÔÀ̶û ºñ±³Çϱâ
				return false;
			}

			return(__SetBlankInventorySlotCount(pTempInven, Item, pItem->nOverlapCount, nCount));
		}
		else {
			int nBlank = __FindOverlapInventorySlot(pTempInven, nTempInvenCount, Item );	// ±âÁ¸ ¾ÆÀÌÅÛÁß¿¡ Çѹ濡 µé¾î°¥ ¾ÆÀÌÅÛÀÌ ÀÖ´ÂÁö 
			if (nBlank < 0){
				nBlank = __FindBlankInventorySlot(pTempInven, nTempInvenCount);
				if (nBlank < 0) {
					return false;
				}

				return(__SetBlankInventorySlot(pTempInven, Item, nBlank));
			}

			return(__SetOverlapInventorySlot(pTempInven, Item, pItem->nOverlapCount, nBlank));
		}
	}

	return true;
}

// desc : Äù½ºÆ® Àκ¥Å丮ÀÇ Æ¯Á¤ ºó½½·Ô¿¡ ¾ÆÀÌÅÛÀ» ¼¼Æà (P.S.> api_quest_CheckQuestInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
bool __SetBlankQuestInventorySlot(TQuestItemCnt pTempQuestInven[QUESTINVENTORYMAX], int nItemID, short wCount, int iIndex)
{
	DN_ASSERT(NULL != pTempQuestInven,	"Invalid!");
	DN_ASSERT(0 != nItemID,				"Invalid!");
	DN_ASSERT(0 < wCount,				"Invalid!");
	DN_ASSERT(-1 < iIndex,				"Invalid!");

	if (pTempQuestInven[iIndex].nItemID != 0) {
		return false;
	}

	pTempQuestInven[iIndex].Set(nItemID, wCount);

	return true;
}

// desc : Äù½ºÆ® Àκ¥Å丮ÀÇ ºó½½·Ôµé¿¡ ¾ÆÀÌÅÛÀ» ƯÁ¤ °³¼ö¸¸Å­ ¼¼Æà (P.S.> api_quest_CheckQuestInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
bool __SetBlankQuestInventorySlotCount(TQuestItemCnt pTempQuestInven[QUESTINVENTORYMAX], int nItemID, short wCount, int nOverlapCount, int nCount /* ä¿ï ½½·Ô°³¼ö */)
{
	DN_ASSERT(NULL != pTempQuestInven,	"Invalid!");
	DN_ASSERT(0 != nItemID,				"Invalid!");
	DN_ASSERT(0 < wCount,				"Invalid!");
	DN_ASSERT(0 < nOverlapCount,		"Invalid!");
	DN_ASSERT(0 < nCount,				"Invalid!");

	// !!! ÁÖÀÇ - º» ÇÔ¼ö È£Ãâ Àü¿¡ üũ°¡ È®½ÇÈ÷ µÇ¾úÀ½À» ÀüÁ¦ÇÏ°í ¼¼ÆÃÇÏ´Â ºÎºÐ¸¸ ¼öÇà

	int nBundle = wCount / nOverlapCount;
	int nRemain = wCount % nOverlapCount;

	for (int iIndex = 0 ; QUESTINVENTORYMAX > iIndex ; ++iIndex) {
		if (0 < nBundle) {
			if (pTempQuestInven[iIndex].nItemID == 0) {
				pTempQuestInven[iIndex].Set(nItemID, nOverlapCount);
				--nBundle;
				continue;
			}
		}

		if (0 < nRemain) {
			if (pTempQuestInven[iIndex].nItemID == nItemID &&
				nOverlapCount >= pTempQuestInven[iIndex].wCount + nRemain
				)
			{
				pTempQuestInven[iIndex].wCount += nRemain;
				nRemain = 0;
				continue;
			}
		}
	}

	if (0 < nBundle) {
		return false;
	}
	if (0 < nRemain) {
		for (int iIndex = 0 ; QUESTINVENTORYMAX > iIndex ; ++iIndex) {
			if (pTempQuestInven[iIndex].nItemID == 0) {
				pTempQuestInven[iIndex].Set(nItemID, nRemain);
				nRemain = 0;
				break;
			}
		}
	}
	if (0 < nRemain) {
		return false;
	}

	return true;
}

// desc : Äù½ºÆ® Àκ¥Å丮ÀÇ Æ¯Á¤ ½½·Ô¿¡ ¾ÆÀÌÅÛÀ» Áßø ¼¼Æà (P.S.> api_quest_CheckQuestInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
bool __SetOverlapQuestInventorySlot(TQuestItemCnt pTempQuestInven[QUESTINVENTORYMAX], int nItemID, short wCount, int nOverlapCount, int iIndex)
{
	DN_ASSERT(NULL != pTempQuestInven,	"Invalid!");
	DN_ASSERT(0 != nItemID,				"Invalid!");
	DN_ASSERT(0 < wCount,				"Invalid!");
	DN_ASSERT(0 < nOverlapCount,		"Invalid!");
	DN_ASSERT(-1 < iIndex,				"Invalid!");

	if (pTempQuestInven[iIndex].nItemID != nItemID || 
		nOverlapCount < pTempQuestInven[iIndex].wCount + wCount
		)
	{
		return false;
	}

	pTempQuestInven[iIndex].wCount += wCount;

	return true;
}

// desc : Äù½ºÆ® Àκ¥Å丮¿¡ ºó½½·ÔÀÌ ¸î °³³ª ÀÖ´ÂÁö °³¼ö ã±â (P.S.> api_quest_CheckQuestInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
int __FindBlankQuestInventorySlotCount(TQuestItemCnt pTempQuestInven[QUESTINVENTORYMAX])
{
	DN_ASSERT(NULL != pTempQuestInven,	"Invalid!");

	int nCount = 0;
	for (int iIndex = 0 ; QUESTINVENTORYMAX > iIndex ; ++iIndex) {
		if (pTempQuestInven[iIndex].nItemID == 0) {
			++nCount;
		}
	}

	return nCount;
}

// desc : Äù½ºÆ® Àκ¥Å丮¿¡ ºó½½·Ô ã±â (P.S.> api_quest_CheckQuestInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
int __FindBlankQuestInventorySlot(TQuestItemCnt pTempQuestInven[QUESTINVENTORYMAX])
{
	DN_ASSERT(NULL != pTempQuestInven,	"Invalid!");

	for (int iIndex = 0 ; QUESTINVENTORYMAX > iIndex ; ++iIndex) {
		if (pTempQuestInven[iIndex].nItemID == 0) {
			return iIndex;
		}
	}

	return -1;
}

// desc : Äù½ºÆ® Àκ¥Å丮¿¡ ¼¿ ¼ö ÀÖ´Â ¾ÆÀÌÅÛ Áß ³²Àº °ø°£¿¡ wCount ³ÖÀ» ¼ö ÀÖ´Â Index ã±â (P.S.> api_quest_CheckQuestInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
int __FindOverlapQuestInventorySlot(TQuestItemCnt pTempQuestInven[QUESTINVENTORYMAX], int nItemID, short wCount)
{
	DN_ASSERT(NULL != pTempQuestInven,	"Invalid!");

	if ((nItemID <= 0) || (wCount <= 0)) DN_RETURN(-1);

	bool boFlag = false;
	TItemData *pQuestItem = NULL;
	for (int iIndex = 0 ; QUESTINVENTORYMAX > iIndex ; ++iIndex) {
		if (pTempQuestInven[iIndex].nItemID == 0) continue;	// ºóÄ­À̸é Æнº

		pQuestItem = g_pDataManager->GetItemData(pTempQuestInven[iIndex].nItemID);
		if (!pQuestItem) continue;

		if (pQuestItem->nOverlapCount == 1) continue;				// °ãÄ¡Áö ¾ÊÀ¸¸é Æнº
		if (pTempQuestInven[iIndex].nItemID != nItemID) continue;	// °°Àº ¾ÆÀÌÅÛÀÌ ¾Æ´Ï´Ù

		if (pQuestItem->nOverlapCount >= pTempQuestInven[iIndex].wCount + wCount){
			return iIndex;
		}
	}

	return -1;
}

// desc : Äù½ºÆ® Àκ¥Å丮¿¡ ¾ÆÀÌÅÛÀ» ³ÖÀ» ¼ö ÀÖ´Â °ø°£ÀÌ ÃæºÐÇÑÁö °Ë»ç (P.S.> api_quest_CheckQuestInvenForAddItemList ¿¡¼­ »ç¿ëµÊ)
bool __IsValidSpaceQuestInventorySlotAndSet(TQuestItemCnt pTempQuestInven[QUESTINVENTORYMAX], int nItemID, short wCount)
{
	DN_ASSERT(NULL != pTempQuestInven,	"Invalid!");

	if ((nItemID <= 0) || (wCount <= 0)) DN_RETURN(false);

	TItemData *pItem = g_pDataManager->GetItemData(nItemID);
	if (!pItem) return false;

	if (ITEMTYPE_QUEST != pItem->nType) {
		return false;
	}

	int nCount = 0;
	if (pItem->nOverlapCount == 1){		// °ãÄ¡Áö ¾Ê´Â ¾ÆÀÌÅÛ
		nCount = __FindBlankQuestInventorySlotCount(pTempQuestInven);
		if (wCount > nCount) {
			// ºó½½·ÔÀ̶û ºñ±³Çϱâ
			return false;
		}

		return(__SetBlankQuestInventorySlotCount(pTempQuestInven, nItemID, wCount, 1, nCount));
	}
	else {	// °ãÄ¡´Â ¾ÆÀÌÅÛ
		int nRemain = 0, nBlank = 0, nBundle = 0;

		int nCount = __FindBlankQuestInventorySlotCount(pTempQuestInven);	// ºó ½½·Ô°³¼ö

		if (pItem->nOverlapCount >= wCount){
			nRemain = wCount;
		}
		else {
			nBundle = wCount / pItem->nOverlapCount;
			nRemain = wCount % pItem->nOverlapCount;

			if (nBundle > nCount) return false;	// °ø°£ºÎÁ·
		}

		if (nRemain > 0){
			nBlank = __FindOverlapQuestInventorySlot(pTempQuestInven, nItemID, nRemain);	// Â¥Åõ¸®°¡ µé¾î°¥ °ø°£ÀÌ ÀÖ´ÂÁö
			if (nBlank < 0){	// Â¥Åõ¸® °ø°£Àº ¾ø´Ù
				if ((nBundle + 1) > nCount) return false;	// ÇÑÄ­ÀÇ ¿©À¯°¡ ´õ ÀÖ´ÂÁö...
			}
		}

		return(__SetBlankQuestInventorySlotCount(pTempQuestInven, nItemID, wCount, pItem->nOverlapCount, nCount));
	}

	return true;
}

void api_log_AddLog(const char* szLog)
{
	DNScriptAPI::api_log_AddLog(szLog);
}

void api_log_UserLog(UINT nUserObjectID, const char* szLog)
{
#ifndef _FINAL_BUILD
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return;

	DNScriptAPI::api_log_UserLog(pUser, szLog);
#endif // _FINAL_BUILD
}

void api_quest_DumpQuest(UINT nUserObjectID)
{
#ifndef _FINAL_BUILD
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return;

	DNScriptAPI::api_quest_DumpQuest(pUser);
#endif // _FINAL_BUILD
}

void api_npc_NextTalk(UINT nUserObjectID, UINT nNpcObjectID , const char* szTalkIndex, const char* szTargetFile)
{
	CDNUserBase* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return;

	DNScriptAPI::api_npc_NextTalk(pUser, nNpcObjectID, szTalkIndex, szTargetFile);
}

void api_npc_NextScript(UINT nUserObjectID, UINT nNpcObjectID, const char* szTalkIndex, const char* szTargetFile)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser)
	{
		g_Log.Log(LogType::_ERROR, pUser, L"[CS_NPCTALK] (5-1) UID:%d, PAK:%d/%s/%s\n", nUserObjectID, nNpcObjectID, szTalkIndex,szTargetFile);
		return;
	}
	
	CDNNpcObject* pNpc = g_pFieldManager->GetNpcObjectByNpcObjID(pUser->GetChannelID(), nNpcObjectID);
	if ( !pNpc ) return;

	DNScriptAPI::api_npc_NextScript(pUser, pNpc, nNpcObjectID, szTalkIndex, szTargetFile);
}

int api_npc_SetParamString(UINT nUserObjectID, const char* szParamKey, int nParamID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_npc_SetParamString(pUser, szParamKey, nParamID);
}

int api_npc_SetParamInt(UINT nUserObjectID, const char* szParamKey, int nValue)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_npc_SetParamInt(pUser, szParamKey, nValue);
}

int api_quest_AddHuntingQuest(UINT nUserObjectID, int nQuestID, int nQuestStep, int nJournalStep, int nCountingSlot, int nCountingType, int nCountingIndex, int nTargetCnt)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_quest_AddHuntingQuest(pUser, nQuestID, nQuestStep, nJournalStep, nCountingSlot, nCountingType, nCountingIndex, nTargetCnt);
}

// nQuestType : »ç¿ëÇÏÁö ¾Ê´Â ¸Å°³º¯¼öÀÓ.
int api_quest_AddQuest(UINT nUserObjectID, int nQuestID, int nQuestType)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_quest_AddQuest(pUser, nQuestID, nQuestType);
}

int api_quest_CompleteQuest(UINT nUserObjectID, int nQuestID, bool bDelPlayList, bool bRepeat)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_quest_CompleteQuest(pUser, nQuestID, bDelPlayList);
}

int api_quest_MarkingCompleteQuest(UINT nUserObjectID, int nQuestID)
{
	// º¸»óÄù½ºÆ®ÀÇ ¸¶Å·À» api_quest_CompleteQuestÀ¸·Î ÅëÇÕÇϱâ À§ÇØ ´õÀÌ»ó ÀÌ API´Â »ç¿ëÇÏÁö ¾Ê´Â´Ù.
	return 1;
}

int api_quest_IsMarkingCompleteQuest(UINT nUserObjectID, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_IsMarkingCompleteQuest(pUser, nQuestID);
}

int api_quest_UserHasQuest(UINT nUserObjectID, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_UserHasQuest(pUser, nQuestID);
}

int api_quest_GetPlayingQuestCnt(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_GetPlayingQuestCnt(pUser);
}

int api_npc_GetNpcIndex(UINT nUserObjectID, UINT nNpcObjID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	CDNNpcObject* pNpc = g_pFieldManager->GetNpcObjectByNpcObjID(pUser->GetChannelID(), nNpcObjID);
	if ( !pNpc ) 
		return -2;

	return DNScriptAPI::api_npc_GetNpcIndex(pNpc);
}

int api_quest_SetQuestStepAndJournalStep(UINT nUserObjectID, int nQuestID, short nQuestStep, int nJournalStep)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_quest_SetQuestStepAndJournalStep(pUser, nQuestID, nQuestStep, nJournalStep);
}

int api_quest_SetQuestStep(UINT nUserObjectID, int nQuestID, short nQuestStep)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_SetQuestStep(pUser, nQuestID, nQuestStep);
}

int api_quest_GetQuestStep(UINT nUserObjectID, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_GetQuestStep(pUser, nQuestID);
}

int api_quest_SetJournalStep(UINT nUserObjectID, int nQuestID, int nJournalStep)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_SetJournalStep(pUser, nQuestID, nJournalStep);
}

int api_quest_GetJournalStep(UINT nUserObjectID, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_GetJournalStep(pUser, nQuestID);
}

int api_quest_SetQuestMemo(UINT nUserObjectID, int nQuestID, char nMemoIndex, TP_QUESTMEMO nVal)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) {
		return -1;
	}

	return DNScriptAPI::api_quest_SetQuestMemo(pUser, nQuestID, nMemoIndex, nVal);
}

int api_quest_GetQuestMemo(UINT nUserObjectID, int nQuestID, char nMemoIndex)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) {
		return -1;
	}

	return DNScriptAPI::api_quest_GetQuestMemo(pUser, nQuestID, nMemoIndex);
}

int api_quest_SetCountingInfo(UINT nUserObjectID, int nQuestID, int nSlot, int nCountingType, int nCountingIndex, int nTargetCnt)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_SetCountingInfo(pUser, nQuestID, nSlot, nCountingType, nCountingIndex, nTargetCnt);
}

int api_quest_ClearCountingInfo(UINT nUserObjectID, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_ClearCountingInfo(pUser, nQuestID);
}

int api_quest_IsAllCompleteCounting(UINT nUserObjectID, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_IsAllCompleteCounting(pUser, nQuestID);
}

int api_quest_CancelQuest(UINT nUserObjectID, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;
#if defined(_CH)
	if (pUser->GetFCMState() != FCMSTATE_NONE){
		pUser->SendQuestResult(ERROR_QUEST_FCM);
		return -1;
	}
#endif

	pUser->GetQuest()->OnCancelQuest(nQuestID);

	return 1;
}

int api_user_CheckInvenForAddItem(UINT nUserObjectID, int nItemIndex, int nItemCnt)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_user_CheckInvenForAddItem(pUser, nItemIndex, nItemCnt);
}

int api_user_CheckInvenForAddItemList(UINT nUserObjectID, lua_tinker::table ItemTable)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_CheckInvenForAddItemList(pUser, ItemTable);
}

int api_user_AddItem(UINT nUserObjectID, int nItemIndex, int nItemCnt, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_user_AddItem(pUser, nItemIndex, nItemCnt, nQuestID);
}

int api_user_DelItem(UINT nUserObjectID, int nItemIndex, int nItemCnt, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_user_DelItem(pUser, nItemIndex, nItemCnt, nQuestID);
}

int api_user_AllDelItem(UINT nUserObjectID, int nItemIndex)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_user_AllDelItem(pUser, nItemIndex);
}

int api_user_HasItem(UINT nUserObjectID, int nItemIndex, int nItemCnt)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_user_HasItem(pUser, nItemIndex, nItemCnt);
}

int api_user_GetUserClassID(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_user_GetUserClassID(pUser);
}

int api_user_GetUserJobID(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_user_GetUserJobID(pUser);
}

int api_user_GetUserLevel(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_user_GetUserLevel(pUser);
}

int api_user_GetUserInvenBlankCount(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_user_GetUserInvenBlankCount(pUser);
}

int api_quest_GetUserQuestInvenBlankCount(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_GetUserQuestInvenBlankCount(pUser);
}

/*
desc   : À¯Àú¿¡°Ô °æÇèÄ¡¸¦ Ãß°¡ÇÑ´Ù.
param  : À¯ÀúÀ妽º, °æÇèÄ¡
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 
*/
int api_user_AddExp(UINT nUserObjectID, int nQuestID, int nAddExp)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#if defined(_CH)
	if (pUser->GetFCMState() != FCMSTATE_NONE){
		pUser->SendQuestResult(ERROR_QUEST_FCM);
		return -1;
	}
#endif

	pUser->ChangeExp(nAddExp, DBDNWorldDef::CharacterExpChangeCode::Quest, nQuestID);

	int nExp = pUser->GetExp();

#ifndef _FINAL_BUILD
	std::wstring wszMsg;
	wszMsg = FormatW( L"°æÇèÄ¡Ãß°¡ : %d ÃÖÁ¾ : %d" , nAddExp, nExp);
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszMsg.size()*sizeof(WCHAR), L"", (WCHAR*)wszMsg.c_str());
#endif
	
	return 1;
}

/*
desc   : À¯Àú¿¡°Ô µ·À» Ãß°¡ÇÑ´Ù.
param  : À¯ÀúÀ妽º, µ·
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 
*/
int api_user_AddCoin(UINT nUserObjectID, int nAddCoin, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#if defined(_CH)
	if (pUser->GetFCMState() != FCMSTATE_NONE){
		pUser->SendQuestResult(ERROR_QUEST_FCM);
		return -1;
	}
#endif

	if (!pUser->AddCoin(nAddCoin, DBDNWorldDef::CoinChangeCode::QuestReward, nQuestID))
		return -1;

	INT64 nCoin = pUser->GetCoin();

#ifndef _FINAL_BUILD
	std::wstring wszMsg;
	wszMsg = FormatW( L"ÄÚÀÎÃß°¡ : %d ÃÖÁ¾ : %lld" , nAddCoin, nCoin);
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszMsg.size()*sizeof(WCHAR), L"", (WCHAR*)wszMsg.c_str());
#endif

	return 1;
}

int api_user_PlayCutScene(UINT nUserObjectID, UINT nNpcObjectID, int nCutSceneTableID, bool bIgnoreFadeIn)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_user_PlayCutScene(pUser, nNpcObjectID, nCutSceneTableID, bIgnoreFadeIn);
}

int api_ui_OpenWareHouse(UINT nUserObjectID, int iItemID/*=0*/ )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenWareHouse(pUser,iItemID);
}

/*
desc   : À¯Àú¿¡°Ô »óÁ¡¸¦ ¿­¶ó°í ¾Ë¸°´Ù.
param  : À¯ÀúÀ妽º, »óÁ¡ ID
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, -2 ¸é ¼¥ÀÌ ¾øÀ½. 1ÀÌ¸é ¼º°ø
*/
int api_ui_OpenShop(UINT nUserObjectID, int nShopID, Shop::Type::eCode Type/*=Shop::Type::Normal*/ )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;
#if defined (PRE_MOD_GAMESERVERSHOP)
	return DNScriptAPI::api_ui_OpenShop(pUser, nShopID, Type);
#else

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"¼¥¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	TShopData *pShopData = g_pDataManager->GetShopData(nShopID);
	if ( !pShopData )
	{
		if( false == g_pDataManager->IsCombinedShop( nShopID ) )
			return -2;
	}

#if defined(PRE_ADD_REMOTE_OPENSHOP)
	pUser->m_bRemoteShopOpen = false;
#endif	// #if defined(PRE_ADD_REMOTE_OPENSHOP)
	pUser->m_nShopID = nShopID;
	pUser->SendShopOpen(nShopID,Type);
	pUser->SetShopType( Type );
	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ

	return 1;
#endif
}



/*
desc   : À¯Àú¿¡°Ô ½ºÅ³ »óÁ¡¸¦ ¿­¶ó°í ¾Ë¸°´Ù.
param  : À¯ÀúÀ妽º, ½ºÅ³ »óÁ¡ ID
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, -2 ¸é ¼¥ÀÌ ¾øÀ½. 1ÀÌ¸é ¼º°ø
*/
int api_ui_OpenSkillShop( UINT nUserObjectID )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#if defined (PRE_MOD_GAMESERVERSHOP)
	return DNScriptAPI::api_ui_OpenSkillShop(pUser);
#else
	pUser->SendSkillShopOpen();
	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ

	return 1;
#endif
}

/*
desc   : À¯Àú¿¡°Ô ¹«ÀλóÁ¡À» ¿­¶ó°í ¾Ë¸°´Ù.
param  : À¯ÀúÀ妽º
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, -2 ¸é ¼¥ÀÌ ¾øÀ½. 1ÀÌ¸é ¼º°ø
*/
int api_ui_OpenMarket(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"¹«ÀλóÁ¡ ¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	pUser->SendMarketList(NULL, 0, 0, ERROR_NONE);
	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ

	return 1;
}

int api_ui_OpenCompoundEmblem(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenCompoundEmblem(pUser);
}

int api_ui_OpenUpgradeJewel(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenUpgradeJewel(pUser);
}

int api_ui_OpenGlyphLift(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenGlyphLift(pUser);
}

int api_ui_OpenMailBox(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenMailBox(pUser);
}

/*
desc   : À¯Àú¿¡°Ô ¾ÆÀÌÅÛ °­È­Ã¢À» ¿­¶ó°í ½ÃŲ´Ù.
param  : À¯ÀúÀ妽º
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 1ÀÌ¸é ¼º°ø
*/

int api_ui_OpenUpgradeItem(UINT nUserObjectID,int iItemID/*=0*/ )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"¾ÆÀÌÅÛ °­È­Ã¢ ¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	pUser->SendOpenUpgradeItem( iItemID );

	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ

	pUser->SetRemoteEnchantItemID(iItemID);
	return 1;
}

int api_ui_OpenDisjointItem(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenDisjointItem(pUser);
}

int api_ui_OpenCompoundItem(UINT nUserObjectID, int nCompoundShopID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenCompoundItem(pUser, nCompoundShopID);
}

int api_ui_OpenCompound2Item(UINT nUserObjectID, int nCompoundGroupID, int iItemID/*=0*/ )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"¾ÆÀÌÅÛ ÇÕ¼ºÃ¢ ¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	pUser->SendOpenCompound2Item(nCompoundGroupID, iItemID );

	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ

	pUser->SetRemoteItemCompoundItemID( iItemID );

	return 1;
}

int api_ui_OpenCashShop(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenCashShop(pUser);
}

int api_ui_OpenGuildMgrBox(UINT nUserObjectID, int nGuildMgrNo)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenGuildMgrBox(pUser, nGuildMgrNo);
}

int api_ui_OpenGacha_JP( UINT nUserObjectID, int nGachaShopID )
{
#ifdef PRE_ADD_GACHA_JAPAN
	CDNUserSession* pUser = __GetUserObj( nUserObjectID );
	if( !pUser )
		return -1;

	return DNScriptAPI::api_ui_OpenGacha_JP(pUser, nGachaShopID);
#else
	return -3;
#endif // PRE_ADD_GACHA_JAPAN
}

int api_ui_OpenGiveNpcPresent( UINT nUserObjectID, int nNpcID )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj( nUserObjectID );
	if( !pUser )
		return -1;

	return DNScriptAPI::api_ui_OpenGiveNpcPresent(pUser, nNpcID);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

/*
desc   : ´ÙÅ©·¹¾î·©Å·°Ô½ÃÆÇ ´ÙÀ̾ó·Î±×¸¦ ¿¬´Ù.
param  : ´ëÈ­ÁßÀÎ Npc ID 
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½. 1 ÀÌ¸é ¼º°ø.
*/
int api_ui_OpenDarkLairRankBoard( UINT nUserObjectID, int nNpcID, int iMapIndex, int iPlayerCount )
{
	CDNUserSession* pUser = __GetUserObj( nUserObjectID );
	if( !pUser )
		return -1;

	_ASSERT( iPlayerCount > 0 && iPlayerCount <= PARTYCOUNTMAX );

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"´ÙÅ©·¹¾î·©Å·°Ô½ÃÆÇ UI ¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	// Ŭ¶óÀ̾ðÆ®ÇÑÅ× npc ¿¡°Ô ¼±¹°Çϱâ UI ¶ç¿ì¶ó°í ÆÐŶ º¸³¿.
	pUser->SendOpenDarkLairRankBoard( nNpcID, iMapIndex, iPlayerCount );

	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ
	// ±×·¸Áö¸¸ npc ¼±¹°Çϱâ´Â °è¼Ó ´ëÈ­°¡ À̾îÁö¹Ç·Î ±×³É ³öµÐ´Ù. À̰ŠȣÃâÇÏ¸é ´ëÈ­ ´ÙÀ̾ó·Î±×°¡ ¹Ù·Î ´ÝÈù´Ù.
	pUser->SetCalledNpcResponse( true, false );

	return 1;
}


/*
desc   : PvP·¡´õ·©Å·°Ô½ÃÆÇ ´ÙÀ̾ó·Î±×¸¦ ¿¬´Ù.
param  : ´ëÈ­ÁßÀÎ Npc ID 
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½. 1 ÀÌ¸é ¼º°ø.
*/
int api_ui_OpenPvPLadderRankBoard( UINT nUserObjectID, int nNpcID, int iPvPLadderCode )
{
	CDNUserSession* pUser = __GetUserObj( nUserObjectID );
	if( !pUser )
		return -1;

	_ASSERT( LadderSystem::bIsServiceMatchType( static_cast<LadderSystem::MatchType::eCode>(iPvPLadderCode) ) == true );

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"PvP·¡´õ·©Å·°Ô½ÃÆÇ UI ¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	// Ŭ¶óÀ̾ðÆ®ÇÑÅ× npc ¿¡°Ô ¼±¹°Çϱâ UI ¶ç¿ì¶ó°í ÆÐŶ º¸³¿.
	pUser->SendOpenPvPLadderRankBoard( nNpcID, static_cast<LadderSystem::MatchType::eCode>(iPvPLadderCode) );

	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ
	// ±×·¸Áö¸¸ npc ¼±¹°Çϱâ´Â °è¼Ó ´ëÈ­°¡ À̾îÁö¹Ç·Î ±×³É ³öµÐ´Ù. À̰ŠȣÃâÇÏ¸é ´ëÈ­ ´ÙÀ̾ó·Î±×°¡ ¹Ù·Î ´ÝÈù´Ù.
	pUser->SetCalledNpcResponse( true, false );

	return 1;
}

#if defined(PRE_ADD_OPEN_QUEST_TEXTURE_DIALOG)
int api_ui_OpenTextureDialog(UINT nUserObjectID, int nFileIndex, float fX, float fY, int nPos, int nTime, int nDialogIndex, bool bAutoCloseDialog)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if(!pUser)
	{
		return -1;
	}
	
	SCOpenTextureDialog sDlgData;
	sDlgData.fX = fX;
	sDlgData.fY = fY;
	sDlgData.nTime = nTime;
	sDlgData.nPosition = nPos;
	sDlgData.nFileIndex = nFileIndex;
	sDlgData.nDialogIndex = nDialogIndex;
	sDlgData.bAutoCloseDialog = bAutoCloseDialog;

	return DNScriptAPI::api_Open_Texture_Dialog(pUser, sDlgData);
}

int api_ui_CloseTextureDialog(UINT nUserObjectID, int nDlgID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if(!pUser)
	{
		return -1;
	}

	return DNScriptAPI::api_Close_Texture_Dialog(pUser, nDlgID);
}
#endif

int api_user_UserMessage(UINT nUserObjectID, int nType, int nBaseStringIdx, lua_tinker::table ParamTable)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser )
	{
		return -1;
	}

	return DNScriptAPI::api_user_UserMessage(pUser, nType, nBaseStringIdx, ParamTable);
}

int api_quest_AddSymbolItem(UINT nUserObjectID, int nItemID, short wCount)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_AddSymbolItem(pUser, nItemID, wCount);
}

int api_quest_DelSymbolItem(UINT nUserObjectID, int nItemID, short wCount)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_DelSymbolItem(pUser, nItemID, wCount);
}

int api_quest_HasSymbolItem(UINT nUserObjectID, int nItemIndex, int nItemCnt)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_HasSymbolItem(pUser, nItemIndex, nItemCnt);
}

int api_quest_CheckQuestInvenForAddItem(UINT nUserObjectID, int nItemIndex, int nItemCnt)
{

	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_quest_CheckQuestInvenForAddItem(pUser, nItemIndex, nItemCnt);
}

int api_quest_CheckQuestInvenForAddItemList(UINT nUserObjectID, lua_tinker::table ItemTable)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_quest_CheckQuestInvenForAddItemList(pUser, ItemTable);
}

int api_quest_AddQuestItem(UINT nUserObjectID, int nItemID, short wCount, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_AddQuestItem(pUser, nItemID, wCount, nQuestID);
}

int api_quest_DelQuestItem(UINT nUserObjectID, int nItemID, short wCount, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_DelQuestItem(pUser, nItemID, wCount, nQuestID);
}

int api_quest_AllDelQuestItem(UINT nUserObjectID, int nItemID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_AllDelQuestItem(pUser, nItemID);
}

int api_quest_HasQuestItem(UINT nUserObjectID, int nItemIndex, int nItemCnt)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_quest_HasQuestItem(pUser, nItemIndex, nItemCnt);
}

int api_ui_OpenGuildCreate(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenGuildCreate(pUser);
}

int api_ui_OpenQuestReward(UINT nUserObjectID, int nRewardTableIndex, bool bActivate)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenQuestReward(pUser, nRewardTableIndex, bActivate);
}

int api_quest_RewardQuestUser(UINT nUserObjectID, int nRewardTableIndext, int nQuestID, int nRewardCheck)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_quest_RewardQuestUser(pUser, nRewardTableIndext, nQuestID, nRewardCheck);
}

/*
desc   : À¯Àú¸¦ ä³ÎÀ̵¿½ÃŲ´Ù.
param  : À¯ÀúÀ妽º, ä³ÎŸÀÔ
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, -2 ¾ø´Â ä³ÎŸÀÔ -3 ¾ø´Â ä³Î
*/

int api_user_ChangeChannel(UINT nUserObjectID, int ChannelType )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if( !pUser ) 
		return -1;

	int iAttr = 0;
	switch( ChannelType )
	{
		// PvP·Îºñ
		case 1:
		{
			iAttr = GlobalEnum::CHANNEL_ATT_PVPLOBBY;
			break;
		}
		default:
		{
			return -2;
		}
	}
	const sChannelInfo* pChannelInfo = g_pMasterConnection->GetChannelInfoFromAttr( iAttr );
	if( pChannelInfo == NULL )
		return -3;
	pUser->CmdSelectChannel( pChannelInfo->nChannelID, true );

	return 0;
}

int api_user_ChangeMap(UINT nUserObjectID, int nMapIndex, int nGateNo)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;
#if defined(_CH)
	if (pUser->GetFCMState() != FCMSTATE_NONE){
		pUser->SendQuestResult(ERROR_QUEST_FCM);
		return -1;
	}
#endif

	if (pUser->GetPartyID() > 0)
	{
		CDNParty * pParty = g_pPartyManager->GetParty(pUser->GetPartyID());
		if (pParty)
		{
			int nPermitCnt = g_pDataManager->GetMapPermitPartyCount(nMapIndex);
			if (nPermitCnt > 0 && pParty->GetMemberCount() > nPermitCnt)
				return -1;
		}
	}

	if( pUser->IsWindowState( WINDOW_BLIND ) == false )
	{
		if (!pUser->IsNoneWindowState()) 
			return -1;
	}

	int nMapType = g_pDataManager->GetMapType( nMapIndex );
	switch( nMapType ) {
		case GlobalEnum::MAP_UNKNOWN:
			return -2;
		case GlobalEnum::MAP_VILLAGE:
			if( pUser->GetPartyID() > 0 ) {
				CDNParty *pParty = g_pPartyManager->GetParty(pUser->GetPartyID());
				if (!pParty) return -1;
				if (g_pMasterConnection && g_pMasterConnection->GetActive())
					g_pMasterConnection->SendVillageToVillage(REQINFO_TYPE_PARTY, pParty->GetPartyID(), nMapIndex, -1, -1, pParty);	//pUser->GetLevel()
				else
					return -1;
			}
			else
			{
				if (g_pMasterConnection && g_pMasterConnection->GetActive())
					g_pMasterConnection->SendVillageToVillage(REQINFO_TYPE_SINGLE, pUser->GetAccountDBID(), nMapIndex, -1, -1);
				else
					return -1;
			}
			break;
		case GlobalEnum::MAP_WORLDMAP:
		case GlobalEnum::MAP_DUNGEON:
			{
				// ÆÄƼÀÏ °æ¿ì °ú¿¬ ½ºÅ©¸³Æ®¿¡¼­ °­Á¦ À̵¿½Ã¿¡ ´Ù¸¥³ðµéÀÌ µþ·Á°¡µÇ µÇ°Ú´À³Ä.. ÀÇ ¹®Á¦°¡ ÀÖ½À´Ï´Ù.
				// ÀÏ´ÜÀº À̵¿µÇ°Ô Çسõ°ÙÁö¸¸ ºÐ¸í ²¿ÀÌ´Â °æ¿ì°¡ »ý±æµí ÇÏ¿À´Ï ÃßÈÄ ³íÀÇ ÈÄ Ã³¸®ÇÏÁö¸»ÀÔ´Ï´Ù.
				if( pUser->GetPartyID() > 0 ) {
					CDNParty *pParty = g_pPartyManager->GetParty(pUser->GetPartyID());
					if (!pParty) return -1;
					pParty->SetRandomSeed( timeGetTime() );
					if (g_pMasterConnection && g_pMasterConnection->GetActive())
					{
						g_pMasterConnection->SendReqGameID( GameTaskType::Normal, REQINFO_TYPE_PARTY, pParty->GetPartyID(), pUser->GetChannelID(), pParty->GetRandomSeed(), nMapIndex, nGateNo, CONVERT_TO_DUNGEONDIFFICULTY(0), true, pParty );		// GameID¸¦ ¿äû
					}
					else
						return -1;
				}
				else {
					pUser->m_cGateNo = nGateNo;
					pUser->m_nSingleRandomSeed = timeGetTime();
					if (g_pMasterConnection && g_pMasterConnection->GetActive())
						g_pMasterConnection->SendReqGameID( GameTaskType::Normal, REQINFO_TYPE_SINGLE, pUser->GetAccountDBID(), pUser->GetChannelID(), pUser->m_nSingleRandomSeed, nMapIndex, 1, CONVERT_TO_DUNGEONDIFFICULTY(0), true );	// GameID¸¦ ¿äû
					else
						return -1;
				}
			}
			break;
	}
	return 0;
}

/*
desc   : ÇØ´ç À¯ÀúÀÇ ÆÄƼ¿ø¼ö¸¦ ¸®ÅÏÇÑ´Ù.
param  : À¯ÀúÀ妽º
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, ±×¿Ü´Â ÆÄƼ¿ø¼ö (ÁÖÀÇ !!!> ÆÄƼ¿¡ °¡ÀÔµÇÁö ¾ÊÀº »ç¿ëÀÚµµ 1 À» ¹Ýȯ)
*/
int api_user_GetPartymemberCount(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;
	if (pUser->GetPartyID() > 0)
	{
		//ÆÄƼ¶ó¸é ¸â¹öÄ«¿îÆ®
		CDNParty* pParty = g_pPartyManager->GetParty(pUser->GetPartyID());
		if (!pParty) return -1;

		return pParty->GetMemberCount();
	}
	
	// ÆÄƼ°¡ ¾øÀ¸¸é È¥ÀÚ¶ó´Â ¶æÀ̹ǷΠ1
	return 1;
}

/*
desc   : ÇØ´ç À¯Àú°¡ ÆÄƼ¿¡ °¡ÀÔµÈ »óÅÂÀÎÁö üũÇÑ´Ù.
param  : À¯ÀúÀ妽º
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 0 => ÆÄƼ¿¡ °¡ÀÔ ¾ÊµÇ¾îÀÖÀ½, 1 => ÆÄƼ¿¡ °¡ÀÔ µÇ¾îÀÖÀ½
*/
int api_user_IsPartymember(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;
	if (pUser->GetPartyID() > 0)
	{
		//ÆÄƼ¶ó¸é ¸â¹öÄ«¿îÆ®
		CDNParty* pParty = g_pPartyManager->GetParty(pUser->GetPartyID());
		if (!pParty) return -1;

		return 1;
	}

	// ÆÄƼ¿¡ °¡ÀÔÇÏÁö ¾ÊÀº »óÅÂÀ̸é 0 À» ¹Ýȯ
	return 0;
}

//blondy
/*
desc   : ÇØ´çÀ¯Àú¸¦ PVP·Îºñ¿À ¾È³».
param  : À¯ÀúÀ妽º
return : 1 ¼º°ø -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½
*/
int api_user_RequestEnterPVP( UINT nUserObjectID )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	pUser->SendPvPVillageToLobby();
	return 1;

}
//blondy end

/*
desc   : ÇØ´ç À¯ÀúÀÇ ½ºÅ×ÀÌÁö ³­À̵µ¸¦ ±¸ÇÔ (P.S.> VillageServer ¿¡¼­´Â Ç×»ó ½ÇÆÐÇÔ)
param  : À¯ÀúÀ妽º
return : 0 ~ 4 => ´øÀü ³­À̵µ (0:½¬¿ò / 1:º¸Åë / 2:¾î·Á¿ò / 3:¸¶½ºÅÍ : 4:¾îºñ½º), ±× ¿Ü´Â ½ÇÆÐ (±âº» -1)
*/
int api_user_GetStageConstructionLevel(UINT nUserObjectID)
{
//	DN_ASSERT(0,	"Can't be Called!");

	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return -1;
}

int api_user_GetMapIndex(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_GetMapIndex(pUser);
}

int api_user_GetLastStageClearRank(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_GetLastStageClearRank(pUser);
}

int api_user_EnoughCoin(UINT nUserObjectID, int nCoin )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_EnoughCoin(pUser, nCoin);
}

/*
desc   : À¯ÀúÀÇ ÇöÀç ¼ÒÁö±ÝÀ» È®ÀÎÇÑ´Ù.
param  : À¯ÀúÀ妽º
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 0 ÀÌ»ó => ÇöÀç ¼ÒÁö±Ý
*/
int api_user_GetCoin(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

#if defined(_CH)
	if (pUser->GetFCMState() != FCMSTATE_NONE){
		pUser->SendQuestResult(ERROR_QUEST_FCM);
		return -1;
	}
#endif

	return (int)(pUser->GetCoin());
}

/*
desc   : À¯Àú¿¡°Ô µ·À» °¨¼ÒÇÑ´Ù.
param  : À¯ÀúÀ妽º, µ· (0 ÃÊ°ú)
return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 1 => ¼º°ø
*/
int api_user_DelCoin(UINT nUserObjectID, int nDelCoin)
{
	DN_ASSERT(0 < nDelCoin,	"Invalid!");

	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

#if defined(_CH)
	if (pUser->GetFCMState() != FCMSTATE_NONE){
		pUser->SendQuestResult(ERROR_QUEST_FCM);
		return -1;
	}
#endif

	pUser->DelCoin(nDelCoin, DBDNWorldDef::CoinChangeCode::Use, 0);

	INT64 nCoin = pUser->GetCoin();

#ifndef _FINAL_BUILD
	std::wstring wszMsg;
	wszMsg = FormatW( L"ÄÚÀΰ¨¼Ò : %d ÃÖÁ¾ : %lld" , nDelCoin, nCoin);
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszMsg.size()*sizeof(WCHAR), L"", (WCHAR*)wszMsg.c_str());
#endif

	return 1;
}

int api_user_IsMissionGained(UINT nUserObjectID, int nMissionIndex)
{
	DN_ASSERT(CHECK_LIMIT(nMissionIndex, MISSIONMAX),	"Invalid!");

	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_IsMissionGained(pUser, nMissionIndex);
}

int api_user_IsMissionAchieved(UINT nUserObjectID, int nMissionIndex)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_IsMissionAchieved(pUser, nMissionIndex);
}

int api_user_HasItemWarehouse(UINT nUserObjectID, int nItemIndex, int nItemCnt)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_HasItemWarehouse(pUser, nItemIndex, nItemCnt);
}

int api_user_HasItemEquip(UINT nUserObjectID, int nItemIndex)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_HasItemEquip(pUser, nItemIndex);
}

int api_guild_GetGuildMemberRole(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_guild_GetGuildMemberRole(pUser);
}

/*
desc   : À¯ÀúÀÇ ÇöÀç ±æµåÀÇ Ã¢°í¼ÒÀ¯ ¿©ºÎ¸¦ ¾Ë·ÁÁØ´Ù.
param  : À¯ÀúÀ妽º
return : -1 : À¯Àú¸¦ ãÀ»¼ö ¾øÀ½ / 0 : ±æµåâ°í ¾øÀ½ / 1 : ±æµåâ°í ÀÖÀ½
*/
int api_guild_HasGuildWare(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	const TGuildUID GuildUID = pUser->GetGuildUID ();
	if (!GuildUID.IsSet())
		return -1;

	CDNGuildBase* pGuild = g_pGuildManager->At (GuildUID);
	if (!pGuild)
		return 0;


#if !defined( PRE_ADD_NODELETEGUILD )
	// ±æµå°¡Á¸ÀçÇÑ´Ù.
	CDetachAutoEx<CDNGuildBase>	AutoDetach (pGuild);
	if (FALSE == pGuild->IsEnable()) return 0;
#endif

	if (pGuild->GetWareSize() > 0)
		return 1;

	return 0;
}

int api_quest_IncQuestMemo(UINT nUserObjectID, int nQuestID, char nMemoIndex)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) {
		return LONG_MIN;
	}

	return DNScriptAPI::api_quest_IncQuestMemo(pUser, nQuestID, nMemoIndex);
}

int api_quest_DecQuestMemo(UINT nUserObjectID, int nQuestID, char nMemoIndex)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) {
		return LONG_MAX;
	}

	return DNScriptAPI::api_quest_DecQuestMemo(pUser, nQuestID, nMemoIndex);
}

int api_user_SetUserJobID(UINT nUserObjectID, int nJobID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) {
		return -1;
	}

	return DNScriptAPI::api_user_SetUserJobID(pUser, nJobID);
}

int api_user_IsJobInSameLine(UINT nUserObjectID, int nBaseJobID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) {
		return -1;
	}

	return DNScriptAPI::api_user_IsJobInSameLine(pUser, nBaseJobID);
}

int api_user_HasCashItem(UINT nUserObjectID, int nItemIndex, int nItemCnt)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_user_HasCashItem(pUser, nItemIndex, nItemCnt);
}

int api_user_HasCashItemEquip(UINT nUserObjectID, int nItemIndex)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_user_HasCashItemEquip(pUser, nItemIndex);
}

int api_quest_IncCounting(UINT nUserObjectID, int nCountingType, int nCountingIndex)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_quest_IncCounting(pUser, nCountingType, nCountingIndex);
}

int api_quest_IsPlayingQuestMaximum(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_quest_IsPlayingQuestMaximum(pUser);
}

int api_quest_ForceCompleteQuest(UINT nUserObjectID, int nQuestID, int nQuestCode, int bDoMark, int bDoDelete, int bDoRepeat)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	return DNScriptAPI::api_quest_ForceCompleteQuest(pUser, nQuestID, nQuestCode, bDoMark, bDoDelete, bDoRepeat);
}

int api_quest_ResetSkill(UINT nUserObjectID, int nQuestID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	CDNUserQuest* pQuest = pUser->GetQuest();
	if (!pQuest) {
		return -2;
	}

	bool bResult = pQuest->IsClearQuest(nQuestID);

	if ( bResult )
		return -3;

#if defined(_VILLAGESERVER)
	pUser->GetSkill()->ResetSkill( pUser->GetSkillPage() );
#elif defined(_GAMESERVER)
	return -1;
#endif // #if defined(_VILLAGESERVER)

	return 1;
}

int api_quest_GetWorldEventStep(UINT nUserObjectID, int nScheduleID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if (!g_pPeriodQuestSystem)
		return -1;

	return g_pPeriodQuestSystem->GetWorldEventStep(pUser->GetWorldSetID(), nScheduleID);
}

int api_quest_GetWorldEventCount (UINT nUserObjectID, int nScheduleID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if (!g_pPeriodQuestSystem)
		return -1;

	return g_pPeriodQuestSystem->GetWorldEventCount(pUser->GetWorldSetID(), nScheduleID);
}

int api_quest_ReturnItemToNpc (UINT nUserObjectID, int nScheduleID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	int nCount = pUser->GetItem()->ReturnItemToNpc(nScheduleID);
	if (nCount <= 0)
		return -1;

	return nCount;
}

void api_quest_OpenScoreWorldEvent (UINT nUserObjectID, int nScheduleID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return;

	TGlobalEventData* pEvent = g_pDataManager->GetGlobalEventData(nScheduleID);
	if (!pEvent) 
		return;

	int nMaxCount = pEvent->nCollectTotalCount;
	int nCurrentCount = g_pPeriodQuestSystem->GetWorldEventCount(pUser->GetWorldSetID(), nScheduleID);
	
	if (nCurrentCount >= nMaxCount)
		nCurrentCount = nMaxCount;
	
	pUser->SendScorePeriodQuest(nCurrentCount, nMaxCount);
}

/*
desc   : ƯÁ¤ »ç¿ëÀÚ¿¡°Ô ³óÀ屸¿ª ¸®½ºÆ®¸¦ º¸¿©ÁØ´Ù
param  : À¯ÀúÀ妽º
return : -1 : À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 1 ¼º°ø
*/
int api_quest_OpenFarmAreaList (UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	pUser->SendFarmOpenList();

	pUser->ReqFarmInfo(false);

	return 1;
}

/*
desc   : ƯÁ¤ »ç¿ëÀÚÀÇ À§Ä¡¸¦ À̵¿ ½ÃŲ´Ù.
param  : À¯ÀúÀ妽º, X ÁÂÇ¥, Y ÁÂÇ¥, Z ÁÂÇ¥
return : -1 : À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 1 ¼º°ø
*/
int api_user_ChangePos(UINT nUserObjectID, int nX, int nY, int nZ, int nLookX, int nLookY )
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}
#if defined(_CH)
	if (pUser->GetFCMState() != FCMSTATE_NONE){
		pUser->SendQuestResult(ERROR_QUEST_FCM);
		return -1;
	}
#endif

	pUser->ChangePos(nX, nY, nZ, float(nLookX), float(nLookY));

	return 1;
}


int api_npc_GetFavorPoint( UINT uiUserObjectID, int iNpcID )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if (!pUser)
		return -1;

	return DNScriptAPI::api_npc_GetFavorPoint(pUser, iNpcID);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_npc_GetMalicePoint( UINT uiUserObjectID, int iNpcID )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if( !pUser )
		return -1;

	return DNScriptAPI::api_npc_GetMalicePoint(pUser, iNpcID);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_npc_GetFavorPercent( UINT uiUserObjectID, int iNpcID )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if( !pUser )
		return -1;

	return DNScriptAPI::api_npc_GetFavorPercent(pUser, iNpcID);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_npc_GetMalicePercent( UINT uiUserObjectID, int iNpcID )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if( !pUser )
		return -1;

	return DNScriptAPI::api_npc_GetMalicePercent(pUser, iNpcID);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_npc_AddFavorPoint( UINT uiUserObjectID, int iNpcID, int val )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if( !pUser )
		return -1;

	return DNScriptAPI::api_npc_AddFavorPoint(pUser, iNpcID, val);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_npc_AddMalicePoint( UINT uiUserObjectID, int iNpcID, int val )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if( !pUser )
		return -1;

	return DNScriptAPI::api_npc_AddMalicePoint(pUser, iNpcID, val);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_npc_SendSelectedPresent( UINT uiUserObjectID, int iNpcID )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if( !pUser )
		return -1;

	return DNScriptAPI::api_npc_SendSelectedPresent(pUser, iNpcID);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_npc_Rage( UINT uiUserObjectID, int iNpcID )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if( !pUser )
		return -1;

	return DNScriptAPI::api_npc_Rage(pUser, iNpcID);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_npc_Disappoint( UINT uiUserObjectID, int iNpcID )
{
#if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if( !pUser )
		return -1;

	return DNScriptAPI::api_npc_Disappoint(pUser, iNpcID);
#else
	return -1;
#endif // #if defined( PRE_ADD_NPC_REPUTATION_SYSTEM )
}

int api_user_ResetSkill(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser) {
		return -1;
	}

	pUser->GetItem()->ResetSkillFromQuestScript();

	return 1;
}

int api_npc_CreateSecondarySkill( UINT uiUserObjectID, int iSkillID )
{
#if defined( PRE_ADD_SECONDARY_SKILL )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if (!pUser) 
		return -1;

	CSecondarySkillRepository* pRepository = pUser->GetSecondarySkillRepository();
	if( pRepository == NULL )
		return 0;

	if( pRepository->Create( iSkillID ) == false )
		return 0;

	return 1;
#else
	return -1;
#endif // #if defined( PRE_ADD_SECONDARY_SKILL )
}

int api_npc_CheckSecondarySkill( UINT uiUserObjectID, int iSkillID )
{
#if defined( PRE_ADD_SECONDARY_SKILL )
	CDNUserSession* pUser = __GetUserObj(uiUserObjectID);
	if (!pUser) 
		return -1;

	CSecondarySkillRepository* pRepository = pUser->GetSecondarySkillRepository();
	if( pRepository == NULL )
		return 0;

	if( pRepository->Get( iSkillID ) == NULL )
		return 0;

	return 1;
#else
	return -1;
#endif // #if defined( PRE_ADD_SECONDARY_SKILL )
}

/*
desc	: À¯Àú¿¡°Ô ±æµåâ°í¸¦ ¿­¶ó°í ¾Ë¸°´Ù.
param	: À¯ÀúÀ妽º
return  : -1 => À¯Àú¸¦ ãÀ» ¼ö ¾øÀ½, -2=>±æµå¿øÀÌ ¾Æ´Ô, 1=>¼º°ø
*/
int api_ui_OpenGuildWareHouse (UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);

	if ( !pUser ) 
		return -1;

	if (g_pGuildManager->OnRecvApiOpenGuildWare (pUser))
		pUser->SetCalledNpcResponse(true, false);	
	else
		return -2;

	return 1;
}


int api_ui_OpenMovieBrowser(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"¹«ºñŬ¸³ ºê¶ó¿ìÀú ¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	pUser->SendOpenMovieBrowser();

	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ

	return 1;
}

int api_ui_OpenBrowser(UINT nUserObjectID, const char* szUrl, int nX, int nY, int nWidth, int nHeight)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"npc ºê¶ó¿ìÀú ¿­±â (%s)", szUrl);
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	pUser->SendOpenBrowser(szUrl, nX, nY, nWidth, nHeight);

	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ

	return 1;
}

/*
desc   : ±æµåÀü ½Åû ¿©ºÎ¸¦ ¾Ë·ÁÁØ´Ù. (½Åû±â°£¸¸ Çã¿ë)
param  : À¯ÀúÀ妽º
return : -1 : À¯Àú¸¦ ãÀ»¼ö ¾øÀ½ / 0 : ±æµåÀü ½ÅûºÒ°¡´É / 1 : ±æµåÀü ½Åû°¡´É
*/
int api_guildwar_IsPreparation(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if (g_pGuildWarManager)
	{
		if (g_pGuildWarManager->GetStepIndex() == GUILDWAR_STEP_PREPARATION && pUser->GetGuildSelfView().IsSet())
		{
			if (pUser->GetGuildSelfView().btGuildRole == GUILDROLE_TYPE_MASTER && 
				pUser->GetGuildSelfView().wWarSchduleID != g_pGuildWarManager->GetScheduleID())
				return 1;
		}
	}
	return 0;
}
/*
desc   : ±æµåÀü ±â°£ üũ.
param  : À¯ÀúÀ妽º
return : -1 : À¯Àú¸¦ ãÀ»¼ö ¾øÀ½ / eGuildWarStepType / 0 : ±æµåÀü ±â°£ ¾Æ´Ô / 1 : ±æµåÀü ½Åû ±â°£ / 2 : ±æµåÀü ¿¹¼± ±â°£ / 3 : º»¼± ¹× º¸»ó±â°£
*/
int api_guildwar_GetStep(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if (g_pGuildWarManager)
		return g_pGuildWarManager->GetStepIndex();	
	return 0;
}
/*
desc   : ±æµåÀü ¿¹¼± ÁøÇà ÇöȲ º¸±â
param  : À¯ÀúÀ妽º
return : return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, -2 => ¿¹¼±Àü ±â°£ÀÌ ¾Æ´Ô, 0 : ¼º°ø
*/
int api_guildwar_GetTrialCurrentState(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if( g_pGuildWarManager->GetStepIndex() != GUILDWAR_STEP_TRIAL)
		return -2;	

	int nGuildWarPoint = 0;
	CDNGuildBase* pGuild = g_pGuildManager->At(pUser->GetGuildUID());

	if (pGuild)
	{
#if !defined( PRE_ADD_NODELETEGUILD )
		CDetachAutoEx<CDNGuildBase>	AutoDetach (pGuild);
		if (FALSE == pGuild->IsEnable()) return -1;
#endif

		if( pGuild->IsEnrollGuildWar() )
		{
			CDNGuildVillage* pGuildVillage = static_cast<CDNGuildVillage *>(pGuild);
			if( pGuildVillage->GetGuildWarScheduleID() != g_pGuildWarManager->GetScheduleID() )
			{
				pGuildVillage->GuildWarReset();
				pGuildVillage->SetGuildWarScheduleID(g_pGuildWarManager->GetScheduleID());
			}
			nGuildWarPoint = pGuildVillage->GetGuildWarPoint();
		}
	}
	// ¿­¾î¶ó¸¦ ¸ÕÀú º¸³½´Ù..(¿¹¼± °á°úâÇÏ°í UI¸¦ °°À̽Ἥ ÀÌ°É·Î º¸³»¾ßÇÔ)
	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ
	pUser->SendGuildWarTrialResultUIOpen();
	pUser->SendGuildWarStatusOpen( g_pGuildWarManager->GetBlueTeamPoint(), g_pGuildWarManager->GetRedTeamPoint(), pUser->GetGuildWarPoint(), nGuildWarPoint);
	return 0;
}
/*
desc   : ±æµåÀü ¿¹¼± °á°ú
param  : À¯ÀúÀ妽º
return : return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, -2 => º»¼± ¹× º¸»ó±â°£ÀÌ ¾Æ´Ô, -3 => ¾ÆÁ÷ ¿¹¼±°á°ú Áý°è°¡ ¿Ï·áµÇÁö ¾ÊÀ½, 0 : ¼º°ø
*/
int api_guildWar_GetTrialStats(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if( g_pGuildWarManager->GetStepIndex() != GUILDWAR_STEP_REWARD)
		return -2;
	if( !g_pGuildWarManager->GetGuildWarStats() )
		return -3;
	// ¿©±â¼­ ºÎÅÍ ¹®Á¦..±æµåÀü¿¡ Âü¿©ÇÏÁö ¾ÊÀº ³ÑÀº ¹Ù·Î º¸³»°í..Âü¿©ÇÑ ³ÑÀº ±æµå, ³»Á¤º¸ °Ë»öÇؾßÇÔ.

	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ
	pUser->SendGuildWarTrialResultUIOpen();

	CDNGuildBase* pGuild = g_pGuildManager->At(pUser->GetGuildUID());
	if (pGuild)
	{
#if !defined( PRE_ADD_NODELETEGUILD )
		CDetachAutoEx<CDNGuildBase>	AutoDetach (pGuild);
		if (FALSE == pGuild->IsEnable()) return -1;
#endif

		if( pGuild->IsEnrollGuildWar() )
		{
			CDNGuildVillage* pGuildVillage = static_cast<CDNGuildVillage *>(pGuild);
			if (!pGuildVillage->GetGuildWarStats() )
			{
				// ³» ±æµå Áý°èÁ¤º¸ °¡Á®¿À±â				
				CDNDBConnection* pDBCon = pGuild->GetDBCon();
				if (pDBCon)				
					pDBCon->QueryGetGuildWarPointGuildPartTotal(pGuild->GetDBThreadID(), pUser->GetWorldSetID(), pUser->GetAccountDBID(), 'G', pUser->GetGuildUID().nDBID);				
				return 0;
			}
			else if( !pUser->GetGuildWarStats() )
			{
				CDNDBConnection* pDBCon = pUser->GetDBConnection();
				if( pDBCon )				
					pDBCon->QueryGetGuildWarPointPartTotal(pUser->GetDBThreadID(), pUser->GetWorldSetID(), pUser->GetAccountDBID(), 'C', pUser->GetCharacterDBID());
				return 0;
			}			
		}
	}
	// ±æµå¿¡µµ °¡ÀԵǾî ÀÖÁö ¾Ê°í ±æµåÀü¿¡µµ Âü¿©ÇÏÁö ¾Ê¾ÒÀ¸¸é ¹Ù·Î º¸³»ÀÚ.
	pUser->SendGuildWarTrialResultOpen();	
	return 0;
}
/*
desc   : ±æµåÀü °á½Â ´ëÁøÇ¥ º¸±â
param  : À¯ÀúÀ妽º
return : return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, -2 => º»¼± ¹× º¸»ó±â°£ÀÌ ¾Æ´Ô, -3 => ´ëÁøÇ¥°¡ ¼ÂÆõÇÁö ¾Ê¾ÒÀ½, 0: ¼º°ø
*/
int api_guildWar_GetMatchList(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if( g_pGuildWarManager->GetStepIndex() != GUILDWAR_STEP_REWARD)
		return -2;
	if( !g_pGuildWarManager->GetGuildWarStats() )
		return -3;

	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ
	pUser->SendGuildWarTournamentInfoUIOpen();

	bool bPopularityVote = false;
	CDNGuildBase* pGuild = g_pGuildManager->At(pUser->GetGuildUID());
	if (pGuild)
	{
#if !defined( PRE_ADD_NODELETEGUILD )
		CDetachAutoEx<CDNGuildBase>	AutoDetach (pGuild);
		if (FALSE == pGuild->IsEnable()) return -1;
#endif

		// ±æµåÀü¿¡ Âü¿©Çß°í °á½Â ÁøÃâÆÀÀÌ ¾Æ´Ï°í ³»°¡ ¿¹¼±¿¡ Âü°¡ÇÑ Ä³¸¯ÅÍ À̸é.
		if( pGuild->IsEnrollGuildWar() && !g_pGuildWarManager->IsGuildWarFinal(pUser->GetGuildUID()) && pUser->GetGuildWarPoint() )
		{
			// ÅõÇ¥ÇÑÀû ¾ø°í DB¿¡¼­ ²¨³»¿ÂÀû ¾øÀ¸¸é
			if( !pUser->GetGuildWarVote() && !pUser->GetGuildWarVoteLoading() )
			{					
				CDNDBConnection* pDBCon = pUser->GetDBConnection();
				if (pDBCon)			
					pDBCon->QueryGetGuildWarPopularityVote(pUser->GetDBThreadID(), pUser->GetWorldSetID(), pUser->GetAccountDBID(), 'C', pUser->GetCharacterDBID());								
				return 0;
			}
			// DB¿¡¼­ ²¨³»¿Â°Ô ÀÖÀ¸¸é..
			else if( pUser->GetGuildWarVoteLoading() )
			{
				bPopularityVote = !pUser->GetGuildWarVote();
			}
		}
	}
	pUser->SendGuildWarTournamentInfoOpen(bPopularityVote);	
	return 0;
}
/*
desc   : ±æµåÀü Àαâ ÅõÇ¥ °á°ú
param  : À¯ÀúÀ妽º
return : return : -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, -2 => Áö³­ Àαâ ÅõÇ¥ °á°ú ¾øÀ½, -3 => ±æµåÀüÀÌ ÁøÇàÁßÀÓ, 0: ¼º°ø
*/
int api_guildWar_GetPopularityVote(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if( g_pGuildWarManager->GetStepIndex() == GUILDWAR_STEP_REWARD)
		return -3;

	if( g_pGuildWarManager->GetGuildWarVote() && g_pGuildWarManager->GetGuildWarVoteCount() == 0)
		return -2;

	// DB¿¡¼­ ²¨³»¿ÂÀûÀÌ ¾øÀ¸¸é
	if( !g_pGuildWarManager->GetGuildWarVote() )
	{	
		CDNDBConnection* pDBCon = pUser->GetDBConnection();
		if (pDBCon)			
			pDBCon->QueryGetGuildWarPopularityVote(pUser->GetDBThreadID(), pUser->GetWorldSetID(), pUser->GetAccountDBID(), 'G', 0);					
		return 0;		
	}
	pUser->SendGuildWarVoteTop(g_pGuildWarManager->GetGuildWarVoteCount(), g_pGuildWarManager->GetGuildWarVoteGuildName());
	return 0;	
}

/*
desc   : ±æµåÀü º»¼± À¯¹« üũ.
param  : À¯ÀúÀ妽º
return : -1 : À¯Àú¸¦ ãÀ»¼ö ¾øÀ½ / 0 : º»¼± ÁøÇà ¾ÈÇÔ / 1 : º»¼± ÁøÇàÇÔ
*/
int api_guildWar_GetFinalProgress(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	if (g_pGuildWarManager)
		return (int)g_pGuildWarManager->GetFinalProgress();	
	return 0;
}

#if defined (PRE_ADD_DONATION)
int api_ui_OpenDonation(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);

	return DNScriptAPI::api_ui_OpenDonation(pUser);
}
#endif // #if defined (PRE_ADD_DONATION)

int api_ui_OpenInventory(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);

	return DNScriptAPI::api_ui_OpenInventory(pUser);
}

/*
desc	: À¯ÀúÀÇ PC Cafeµî±Þ
param	:
return	: -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 0 => PC¹æÀÌ ¾Æ´Ô. ³ª¸ÓÁö PC¹æ µî±Þ.
*/
int api_user_GetPCCafe(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if( !pUser)
		return -1;	
	return pUser->GetPCBangGrade();
}

/*
desc	: PC¹æ À¯Àú¿¡°Ô ¹«±â, Å»°Í°ú °°Àº ´ë¿©¾ÆÀÌÅÛÀ» ¸¸µé¾î¼­ ³Ö¾îÁØ´Ù.
param	:
return	: -1 => À¯Àú¸¦ ãÀ»¼ö ¾øÀ½, 0 => ¼º°ø, 1 => PC¹æ À¯Àú°¡ ¾Æ´Ô, 2 => Áö±ÞÇÒ ¾ÆÀÌÅÛÀÌ ¾øÀ½, 3 => Àκ¥ÀÌ ¸ðÀÚ¸§, 4 => ÀÌ¹Ì ´ë¿©¾ÆÀÌÅÛÀ» °¡Áö°í ÀÖÀ½, 5 => ¾ÆÀÌÅÛ ¿¡·¯.
*/
int api_user_SetPCCafeItem(UINT nUserObjectID)
{
#if defined( PRE_ADD_PCBANG_RENTAL_ITEM )
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if( !pUser )
		return -1;
	if( pUser->GetPCBangGrade() == 0)
		return 1;

	// ¿©±â¼­ ÀÌ¹Ì ´ë¿© ¾ÆÀÌÅÛÀ» °¡Áö°í ÀÖ´ÂÁö üũ
	if( pUser->GetItem()->IsHavePcCafeRentItem())
		return 4;

	std::map<int,int> mapItemIDList;
	int nRequireInven = g_pDataManager->GetPcCafeRentItemID(pUser->GetLevel(), pUser->GetClassID(), pUser->GetUserJob(), pUser->GetPCBangGrade(),mapItemIDList);
	if( mapItemIDList.empty())
		return 2;

	// Àκ¥ üũ..
	if( nRequireInven > pUser->GetItem()->FindBlankInventorySlotCount() ) 
	{	
		pUser->SendPcCafeRentItem(ERROR_ITEM_INVENTORY_NOTENOUGH, nRequireInven);
		return 3;
	}

	std::map<int,int>::iterator itor;
	for( itor=mapItemIDList.begin(); itor !=mapItemIDList.end(); ++itor )
	{
		if( !pUser->GetItem()->CreatePCRentalItem(itor->first, itor->second) )
			return 5;
	}
	pUser->SendPcCafeRentItem(ERROR_NONE, 0);	
	return 0;
#else
	return -1;
#endif		
}

/*
desc   : À¯Àú°¡ °¡Áø Àåºñ ¾ÆÀÌÅÛÀ» ¼ö¸®ÇÏ°í, ¼ö¸®ºñ¿ëÀ» Â÷°¨ÇÕ´Ï´Ù.
param  : À¯Àú, Àüü¼ö¸® À¯¹«(1-Àüü¼ö¸®, 0-ÀåÂøÇѾÆÀÌÅÛ)
return : -1 : À¯Àú¸¦ ãÀ»¼ö ¾øÀ½ / 0 : ¼ö¸®ÇÒ ¾ÆÀÌÅÛ ¾øÀ½ / 1 : ¼ÒÁö±Ý ºÎÁ· / 2 : ¾ÆÀÌÅÛ ¼ö¸® ¿Ï·á
*/
int api_user_RepairItem(UINT nUserObjectID, int iAllRepair)
{
#if defined(PRE_ADD_REPAIR_NPC)
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) return -1;

	return DNScriptAPI::api_user_RepairItem(pUser, iAllRepair);
#else
	return -1;
#endif
}


int api_ui_OpenExchangeEnchant(UINT nUserObjectID)
{
#ifdef PRE_ADD_EXCHANGE_ENCHANT
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

	return DNScriptAPI::api_ui_OpenExchangeEnchant(pUser);
#else
	return -1;
#endif
}

int api_env_CheckCloseGateByTime(int iMapIndex)
{
#if defined(PRE_ADD_CHALLENGE_DARKLAIR)
	return DNScriptAPI::api_env_CheckCloseGateByTime(iMapIndex);
#else
	return 0;
#endif
}

int api_ui_OpenCostumeRandomMix(UINT nUserObjectID)
{
#ifdef PRE_ADD_COSRANDMIX_ACCESSORY
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"npc ·£´ýÇÕ¼º ¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	pUser->StartCostumeRandomMix(CostumeMix::RandomMix::OpenByNpc, 0, 0);
	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ

	return 1;
#else
	return -1;
#endif
}

int api_quest_WorldBuffCheck(int nItemID)
{
#if defined(PRE_DRAGONBUFF)
	return DNScriptAPI::api_quest_WorldBuffCheck(nItemID);
#else
	return -1;
#endif
}

int api_quest_ApplyWorldBuff(UINT nUserObjectID, int nItemID, int nMapIdx)
{
#if defined(PRE_DRAGONBUFF)
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return -1;
	return DNScriptAPI::api_quest_ApplyWorldBuff(pUser, nItemID, nMapIdx);
#else
	return -1;
#endif
}

#ifdef PRE_ADD_DWC
void api_ui_OpenCreateDwcTeamDlg(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if ( !pUser ) 
		return;

#ifndef _FINAL_BUILD
	std::wstring wszLog;
	wszLog = FormatW( L"DWC ÆÀ »ý¼º ´ëÈ­»óÀÚ ¿­±â");
	pUser->SendChat(CHATTYPE_NORMAL, (int)wszLog.size()*sizeof(WCHAR), L"", (WCHAR*)wszLog.c_str());
#endif

	pUser->SendOpenDwcTeamDialog();
	pUser->SetCalledNpcResponse(true, false);	// º¸Åë Ŭ¶óÀ̾ðÆ®¿¡ º¸³»´Â UI °³¼³ ¿äû ÀÌÈÄ ´ëÈ­·Î À̾îÁöÁö ¾Ê±â ¶§¹®¿¡ ¿¡·¯°¡ ¾Æ´Ñµ¥µµ º»ÀÇ¾Æ´Ï°Ô NPC ÀÀ´ä¿©ºÎ üũ¿¡ °É¸®°Ô µÇ¹Ç·Î ´ëÈ­ÇÑ °ÍÀ¸·Î ó¸®ÇØ ÁÜ
}
#endif // PRE_ADD_DWC

int api_ui_OpenJobChange(UINT nUserObjectID)
{
	CDNUserSession* pUser = __GetUserObj(nUserObjectID);
	if (!pUser)
		return -1;

	return DNScriptAPI::api_Open_ChangeJobDialog(pUser); 
}