Inventorywindow.py

[guii59 1]

Bonjour, j'ai un problème ....

 

Version des files : 2012

Domaine (Base de données, Core, etc.) : Client

Votre niveau (débutant, intermédiaire, avancé) : Intermédiaire

 

Description du problème :J'ai mis un design qu'a partager un membre ici https://fr.metin2.dev/topic/13117-python-interface-inventaire/ et ce design c'est l'inventaire, de ce fait je ne peut plus me connecter a mon serveur cela m'indique " Erreur de connection au serveur" on n'avais pas préciser qu'il fallais garder l'ancien locale en sauvegarde et je l'ai plus ...

 

Recherches et tests effectué : Remettre un autre inventorywindow.py

Résultat des recherches et tests : Pareil...

 

Je n'ai vraiment pas envie de recommencer mon client pour ça car j'ai implanter beaucoup de stuff... Si quelqu'un sait comment résoudre mon problème s'il vous plaît

 

Message d'erreur, capture d'écran :

 

En postant ma demande d'aide, j'affirme avoir lu et accepté le règlement des demandes d'aides.

[Kijaru 1451]

En tant que technicien, tu devrais pourtant savoir qu'il faut toujours faire des sauvegardes avant de faire chaque manipulation!

 

Le problème, c'est: as-tu gardé ton item_proto client? Ton mob_proto client?

Tant que tu peux récupérer ces deux fichiers là, on est bon, sinon, là oui, faudra tout recommencer

[guii59 1]

Oui bien-sûr j'ai encore mon Item-Proto, mais juste a cause de ce fichier je dois tout remettre dans un autre client?

[Kijaru 1451]

Si tu arrives à refaire à l'identique ton ancien uiinventory, non, sinon je crains que tu n'ais pas le choix...

[guii59 1]

J'ai juste modifier le inventorywindow pas uiiventory

 

PS: Et pour les Icon et tout ça ? Je prend pas ?

[herostar34 72]

Bonsoir,

 

A mon avis, avant que mettiez ce design d'inventaire, vous deviez avoir les bonus dans l'inventaire , est ce exact ?

[guii59 1]

Oui c'est exact, mais ceci était un echec et je ne l'ai pas enlever Herostar ... Si tu me parle de ceci c'est que l'erreur proviens de la non? Merci

[herostar34 72]

Oui c'est exact, ouvrez votre fichier uiinventory.py et remplacez le contenu par ceci :

 

import ui
import player
import mouseModule
import net
import app
import snd
import item
import player
import chat
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommon
import uiPrivateShopBuilder # °³ÀλóÁ¡ ¿­µ¿¾È ItemMove ¹æÁö
import locale
import constInfo
import ime

if locale.IsEUROPE()and app.GetLocalePath() != "locale/sg"  or locale.IsYMIR() or locale.IsJAPAN():
ITEM_MALL_BUTTON_ENABLE = TRUE
else:
ITEM_MALL_BUTTON_ENABLE = FALSE

ITEM_FLAG_APPLICABLE = 1 << 14

class InventoryWindow(ui.ScriptWindow):

USE_TYPE_TUPLE = ("USE_CLEAN_SOCKET", "USE_CHANGE_ATTRIBUTE", "USE_ADD_ATTRIBUTE", "USE_ADD_ATTRIBUTE2", "USE_ADD_ACCESSORY_SOCKET", "USE_PUT_INTO_ACCESSORY_SOCKET")

def __init__(self):
	ui.ScriptWindow.__init__(self)
	self.questionDialog = None
	self.tooltipItem = None
	self.sellingSlotNumber = -1
	self.isLoaded = 0

	self.__LoadWindow()

def __del__(self):
	ui.ScriptWindow.__del__(self)

def Show(self):
	self.__LoadWindow()

	ui.ScriptWindow.Show(self)


def __LoadWindow(self):
	if self.isLoaded == 1:
		return

	self.isLoaded = 1

	try:
		pyScrLoader = ui.PythonScriptLoader()

		if ITEM_MALL_BUTTON_ENABLE:
			pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "InventoryWindow.py")
		else:
			pyScrLoader.LoadScriptFile(self, "UIScript/InventoryWindow.py")
	except:
		import exception
		exception.Abort("InventoryWindow.LoadWindow.LoadObject")

	try:
		wndItem = self.GetChild("ItemSlot")
		wndEquip = self.GetChild("EquipmentSlot")
		self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
		self.wndMoney = self.GetChild("Money")
		self.wndMoneySlot = self.GetChild("Money_Slot")
		self.mallButton = self.GetChild2("MallButton")

		self.inventoryTab = []
		self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))
		self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))

		self.equipmentTab = []
		self.equipmentTab.append(self.GetChild("Equipment_Tab_01"))
		self.equipmentTab.append(self.GetChild("Equipment_Tab_02"))

	except:
		import exception
		exception.Abort("InventoryWindow.LoadWindow.BindObject")

	## Item
	wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
	wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
	wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
	wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
	wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
	wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

	## Equipment
	wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
	wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
	wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
	wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
	wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
	wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

	## PickMoneyDialog
	dlgPickMoney = uiPickMoney.PickMoneyDialog()
	dlgPickMoney.LoadDialog()
	dlgPickMoney.Hide()

	## RefineDialog
	self.refineDialog = uiRefine.RefineDialog()
	self.refineDialog.Hide()

	## AttachMetinDialog
	self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()
	self.attachMetinDialog.Hide()

	## MoneySlot
	self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

	self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))
	self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))
	self.inventoryTab[0].Down()

	self.equipmentTab[0].SetEvent(lambda arg=0: self.SetEquipmentPage(arg))
	self.equipmentTab[1].SetEvent(lambda arg=1: self.SetEquipmentPage(arg))
	self.equipmentTab[0].Down()
	self.equipmentTab[0].Hide()
	self.equipmentTab[1].Hide()

	self.wndItem = wndItem
	self.wndEquip = wndEquip
	self.dlgPickMoney = dlgPickMoney

	# MallButton
	if self.mallButton:
		self.mallButton.SetEvent(ui.__mem_func__(self.ClickMallButton))

	#####

	## Refresh
	self.SetInventoryPage(0)
	self.SetEquipmentPage(0)
	self.RefreshItemSlot()
	self.RefreshStatus()

def Destroy(self):
	self.ClearDictionary()

	self.dlgPickMoney.Destroy()
	self.dlgPickMoney = 0

	self.refineDialog.Destroy()
	self.refineDialog = 0

	self.attachMetinDialog.Destroy()
	self.attachMetinDialog = 0

	self.tooltipItem = None
	self.wndItem = 0
	self.wndEquip = 0
	self.dlgPickMoney = 0
	self.wndMoney = 0
	self.wndMoneySlot = 0
	self.questionDialog = None
	self.mallButton = None

	self.inventoryTab = []
	self.equipmentTab = []

def Close(self):
	if None != self.tooltipItem:
		self.tooltipItem.HideToolTip()

	self.OnCloseQuestionDialog()
	self.dlgPickMoney.Close()
	self.Hide()

def SetInventoryPage(self, page):
	self.inventoryPageIndex = page
	self.inventoryTab[1-page].SetUp()
	self.RefreshBagSlotWindow()

def SetEquipmentPage(self, page):
	self.equipmentPageIndex = page
	self.equipmentTab[1-page].SetUp()
	self.RefreshEquipSlotWindow()

def ClickMallButton(self):
	print "click_mall_button"
	net.SendChatPacket("/click_mall")

def OpenPickMoneyDialog(self):

	if mouseModule.mouseController.isAttached():

		attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
		if player.SLOT_TYPE_SAFEBOX == mouseModule.mouseController.GetAttachedType():

			if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
				net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
				snd.PlaySound("sound/ui/money.wav")

		mouseModule.mouseController.DeattachObject()

	else:
		curMoney = player.GetElk()

		if curMoney <= 0:
			return

		self.dlgPickMoney.SetTitleName(locale.PICK_MONEY_TITLE)
		self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
		self.dlgPickMoney.Open(curMoney)
		self.dlgPickMoney.SetMax(7) # Àκ¥Å丮 990000 Á¦ÇÑ ¹ö±× ¼öÁ¤

def OnPickMoney(self, money):
	mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)

def OnPickItem(self, count):
	itemSlotIndex = self.dlgPickMoney.itemGlobalSlotIndex
	selectedItemVNum = player.GetItemIndex(itemSlotIndex)
	mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, count)

def __InventoryLocalSlotPosToGlobalSlotPos(self, local):

	if player.IsEquipmentSlot(local):
		return local

	return self.inventoryPageIndex*player.INVENTORY_PAGE_SIZE + local

def RefreshBagSlotWindow(self):
	getItemVNum=player.GetItemIndex
	getItemCount=player.GetItemCount
	setItemVNum=self.wndItem.SetItemSlot
	for i in xrange(player.INVENTORY_PAGE_SIZE):
		slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
		itemCount = getItemCount(slotNumber)
		if itemCount <= 1:
			itemCount = 0

		itemVnum = getItemVNum(slotNumber)
		setItemVNum(i, itemVnum, itemCount)

		## ÀÚµ¿¹°¾à (#72723, #72724) Ư¼öó¸® - ¾ÆÀÌÅÛÀε¥µµ ½½·Ô¿¡ È°¼ºÈ­/ºñÈ°¼ºÈ­ Ç¥½Ã¸¦ À§ÇÑ ÀÛ¾÷ÀÓ - [hyo]
		if 72723 == itemVnum or 72724 == itemVnum or 72725 == itemVnum or 72727 == itemVnum or 72728 == itemVnum or 72729 == itemVnum:
			# metinSocket - [0] : È°¼ºÈ­ ¿©ºÎ, [1] : »ç¿ëÇÑ ¾ç, [2] : ÃÖ´ë ¿ë·®
			metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]	

			if 0 != int(metinSocket[0]):
				self.wndItem.ActivateSlot(slotNumber)
			else:
				self.wndItem.DeactivateSlot(slotNumber)			

	self.wndItem.RefreshSlot()

def RefreshEquipSlotWindow(self):
	getItemVNum=player.GetItemIndex
	getItemCount=player.GetItemCount
	setItemVNum=self.wndEquip.SetItemSlot
	for i in xrange(player.EQUIPMENT_PAGE_COUNT):
		slotNumber = player.EQUIPMENT_SLOT_START + i
		itemCount = getItemCount(slotNumber)
		if itemCount <= 1:
			itemCount = 0
		setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

	self.wndEquip.RefreshSlot()

def RefreshItemSlot(self):
	self.RefreshBagSlotWindow()
	self.RefreshEquipSlotWindow()

def RefreshStatus(self):
	money = player.GetElk()
	self.wndMoney.SetText(locale.NumberToMoneyString(money))

def SetItemToolTip(self, tooltipItem):
	self.tooltipItem = tooltipItem

def SellItem(self):

	net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count)
	snd.PlaySound("sound/ui/money.wav")
	self.OnCloseQuestionDialog()

def OnDetachMetinFromItem(self):
	if None == self.questionDialog:
		return

	#net.SendItemUseToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)		
	self.__SendUseItemToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)
	self.OnCloseQuestionDialog()

def OnCloseQuestionDialog(self):
	if self.questionDialog:
		self.questionDialog.Close()

	self.questionDialog = None

## Slot Event
def SelectEmptySlot(self, selectedSlotPos):
	if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:
		return

	selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)

	if mouseModule.mouseController.isAttached():

		attachedSlotType = mouseModule.mouseController.GetAttachedType()
		attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
		attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
		attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

		if player.SLOT_TYPE_INVENTORY == attachedSlotType:
			itemCount = player.GetItemCount(attachedSlotPos)
			attachedCount = mouseModule.mouseController.GetAttachedItemCount()
			self.__SendMoveItemPacket(attachedSlotPos, selectedSlotPos, attachedCount)

			if item.IsRefineScroll(attachedItemIndex):
				self.wndItem.SetUseMode(FALSE)

		elif player.SLOT_TYPE_PRIVATE_SHOP == attachedSlotType:
			mouseModule.mouseController.RunCallBack("INVENTORY")

		elif player.SLOT_TYPE_SHOP == attachedSlotType:
			net.SendShopBuyPacket(attachedSlotPos)

		elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:

			if player.ITEM_MONEY == attachedItemIndex:
				net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
				snd.PlaySound("sound/ui/money.wav")

			else:
				net.SendSafeboxCheckoutPacket(attachedSlotPos, selectedSlotPos)

		elif player.SLOT_TYPE_MALL == attachedSlotType:
			net.SendMallCheckoutPacket(attachedSlotPos, selectedSlotPos)

		mouseModule.mouseController.DeattachObject()

def SelectItemSlot(self, itemSlotIndex):
	if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:
		return

	itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

	if mouseModule.mouseController.isAttached():
		attachedSlotType = mouseModule.mouseController.GetAttachedType()
		attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
		attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()

		if player.SLOT_TYPE_INVENTORY == attachedSlotType:
			self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex)

		mouseModule.mouseController.DeattachObject()

	else:

		curCursorNum = app.GetCursor()
		if app.SELL == curCursorNum:
			self.__SellItem(itemSlotIndex)

		elif app.BUY == curCursorNum:
			chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SHOP_BUY_INFO)

		elif app.IsPressed(app.DIK_LALT):
			link = player.GetItemLink(itemSlotIndex)
			ime.PasteString(link)

		elif app.IsPressed(app.DIK_LSHIFT):
			itemCount = player.GetItemCount(itemSlotIndex)

			if itemCount > 1:
				self.dlgPickMoney.SetTitleName(locale.PICK_ITEM_TITLE)
				self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))
				self.dlgPickMoney.Open(itemCount)
				self.dlgPickMoney.itemGlobalSlotIndex = itemSlotIndex
			#else:
				#selectedItemVNum = player.GetItemIndex(itemSlotIndex)
				#mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum)

		elif app.IsPressed(app.DIK_LCONTROL):
			itemIndex = player.GetItemIndex(itemSlotIndex)

			if TRUE == item.CanAddToQuickSlotItem(itemIndex):
				player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_INVENTORY, itemSlotIndex)
			else:
				chat.AppendChat(chat.CHAT_TYPE_INFO, locale.QUICKSLOT_REGISTER_DISABLE_ITEM)

		else:
			selectedItemVNum = player.GetItemIndex(itemSlotIndex)
			itemCount = player.GetItemCount(itemSlotIndex)
			mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)

			if self.__IsUsableItemToItem(selectedItemVNum, itemSlotIndex):				
				self.wndItem.SetUseMode(TRUE)
			else:					
				self.wndItem.SetUseMode(FALSE)

			snd.PlaySound("sound/ui/pick.wav")

def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos):
	if srcItemSlotPos == dstItemSlotPos:
		return

	if item.IsRefineScroll(srcItemVID):
		self.RefineItem(srcItemSlotPos, dstItemSlotPos)
		self.wndItem.SetUseMode(FALSE)

	elif item.IsMetin(srcItemVID):
		self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)

	elif item.IsDetachScroll(srcItemVID):
		self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)

	elif item.IsKey(srcItemVID):
		self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)			

	elif (player.GetItemFlags(srcItemSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
		self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

	elif item.GetUseType(srcItemVID) in self.USE_TYPE_TUPLE:
		self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)			

	else:
		#snd.PlaySound("sound/ui/drop.wav")

		## À̵¿½ÃŲ °÷ÀÌ ÀåÂø ½½·ÔÀÏ °æ¿ì ¾ÆÀÌÅÛÀ» »ç¿ëÇؼ­ ÀåÂø ½ÃŲ´Ù - [levites]
		if player.IsEquipmentSlot(dstItemSlotPos):

			## µé°í ÀÖ´Â ¾ÆÀÌÅÛÀÌ ÀåºñÀ϶§¸¸
			if item.IsEquipmentVID(srcItemVID):
				self.__UseItem(srcItemSlotPos)

		else:
			self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
			#net.SendItemMovePacket(srcItemSlotPos, dstItemSlotPos, 0)

def __SellItem(self, itemSlotPos):
	if not player.IsEquipmentSlot(itemSlotPos):
		self.sellingSlotNumber = itemSlotPos
		itemIndex = player.GetItemIndex(itemSlotPos)
		itemCount = player.GetItemCount(itemSlotPos)

		item.SelectItem(itemIndex)
		itemPrice = item.GetISellItemPrice()

		if item.Is1GoldItem():
			itemPrice = itemCount / itemPrice / 5
		else:
			itemPrice = itemPrice * itemCount / 5

		item.GetItemName(itemIndex)
		itemName = item.GetItemName()

		self.questionDialog = uiCommon.QuestionDialog()
		self.questionDialog.SetText(locale.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))
		self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))
		self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
		self.questionDialog.Open()
		self.questionDialog.count = itemCount

def RefineItem(self, scrollSlotPos, targetSlotPos):

	scrollIndex = player.GetItemIndex(scrollSlotPos)
	targetIndex = player.GetItemIndex(targetSlotPos)

	if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos):
		return

	###########################################################
	self.__SendUseItemToItemPacket(scrollSlotPos, targetSlotPos)
	#net.SendItemUseToItemPacket(scrollSlotPos, targetSlotPos)
	return
	###########################################################

	###########################################################
	#net.SendRequestRefineInfoPacket(targetSlotPos)
	#return
	###########################################################

	result = player.CanRefine(scrollIndex, targetSlotPos)

	if player.REFINE_ALREADY_MAX_SOCKET_COUNT == result:
		#snd.PlaySound("sound/ui/jaeryun_fail.wav")
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_MORE_SOCKET)

	elif player.REFINE_NEED_MORE_GOOD_SCROLL == result:
		#snd.PlaySound("sound/ui/jaeryun_fail.wav")
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NEED_BETTER_SCROLL)

	elif player.REFINE_CANT_MAKE_SOCKET_ITEM == result:
		#snd.PlaySound("sound/ui/jaeryun_fail.wav")
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_SOCKET_DISABLE_ITEM)

	elif player.REFINE_NOT_NEXT_GRADE_ITEM == result:
		#snd.PlaySound("sound/ui/jaeryun_fail.wav")
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_UPGRADE_DISABLE_ITEM)

	elif player.REFINE_CANT_REFINE_METIN_TO_EQUIPMENT == result:
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_EQUIP_ITEM)

	if player.REFINE_OK != result:
		return

	self.refineDialog.Open(scrollSlotPos, targetSlotPos)

def DetachMetinFromItem(self, scrollSlotPos, targetSlotPos):
	scrollIndex = player.GetItemIndex(scrollSlotPos)
	targetIndex = player.GetItemIndex(targetSlotPos)

	if not player.CanDetach(scrollIndex, targetSlotPos):
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)
		return

	self.questionDialog = uiCommon.QuestionDialog()
	self.questionDialog.SetText(locale.REFINE_DO_YOU_SEPARATE_METIN)
	self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnDetachMetinFromItem))
	self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
	self.questionDialog.Open()
	self.questionDialog.sourcePos = scrollSlotPos
	self.questionDialog.targetPos = targetSlotPos

def AttachMetinToItem(self, metinSlotPos, targetSlotPos):
	metinIndex = player.GetItemIndex(metinSlotPos)
	targetIndex = player.GetItemIndex(targetSlotPos)

	item.SelectItem(metinIndex)
	itemName = item.GetItemName()

	result = player.CanAttachMetin(metinIndex, targetSlotPos)

	if player.ATTACH_METIN_NOT_MATCHABLE_ITEM == result:
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_CAN_NOT_ATTACH(itemName))

	if player.ATTACH_METIN_NO_MATCHABLE_SOCKET == result:
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_SOCKET(itemName))

	elif player.ATTACH_METIN_NOT_EXIST_GOLD_SOCKET == result:
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_GOLD_SOCKET(itemName))

	elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_EQUIP_ITEM)

	if player.ATTACH_METIN_OK != result:
		return

	self.attachMetinDialog.Open(metinSlotPos, targetSlotPos)



def OverOutItem(self):
	self.wndItem.SetUsableItem(FALSE)
	if None != self.tooltipItem:
		self.tooltipItem.HideToolTip()

def OverInItem(self, overSlotPos):
	overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
	self.wndItem.SetUsableItem(FALSE)

	if mouseModule.mouseController.isAttached():
		attachedItemType = mouseModule.mouseController.GetAttachedType()
		if player.SLOT_TYPE_INVENTORY == attachedItemType:

			attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
			attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()

			if self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPos):
				self.wndItem.SetUsableItem(TRUE)
				self.__ShowToolTip(overSlotPos)
				return

	self.__ShowToolTip(overSlotPos)


def __IsUsableItemToItem(self, srcItemVNum, srcSlotPos):
	"´Ù¸¥ ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö ÀÖ´Â ¾ÆÀÌÅÛÀΰ¡?"

	if item.IsRefineScroll(srcItemVNum):
		return TRUE
	elif item.IsMetin(srcItemVNum):
		return TRUE
	elif item.IsDetachScroll(srcItemVNum):
		return TRUE
	elif item.IsKey(srcItemVNum):
		return TRUE
	elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
		return TRUE
	else:
		if item.GetUseType(srcItemVNum) in self.USE_TYPE_TUPLE:
			return TRUE

	return FALSE

def __CanUseSrcItemToDstItem(self, srcItemVNum, srcSlotPos, dstSlotPos):
	"´ë»ó ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö Àִ°¡?"

	if srcSlotPos == dstSlotPos:
		return FALSE

	if item.IsRefineScroll(srcItemVNum):
		if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):
			return TRUE
	elif item.IsMetin(srcItemVNum):
		if player.ATTACH_METIN_OK == player.CanAttachMetin(srcItemVNum, dstSlotPos):
			return TRUE
	elif item.IsDetachScroll(srcItemVNum):
		if player.DETACH_METIN_OK == player.CanDetach(srcItemVNum, dstSlotPos):
			return TRUE
	elif item.IsKey(srcItemVNum):
		if player.CanUnlock(srcItemVNum, dstSlotPos):
			return TRUE

	elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
		return TRUE

	else:
		useType=item.GetUseType(srcItemVNum)

		if "USE_CLEAN_SOCKET" == useType:
			if self.__CanCleanBrokenMetinStone(dstSlotPos):
				return TRUE
		elif "USE_CHANGE_ATTRIBUTE" == useType:
			if self.__CanChangeItemAttrList(dstSlotPos):
				return TRUE
		elif "USE_ADD_ATTRIBUTE" == useType:
			if self.__CanAddItemAttr(dstSlotPos):
				return TRUE
		elif "USE_ADD_ATTRIBUTE2" == useType:
			if self.__CanAddItemAttr(dstSlotPos):
				return TRUE
		elif "USE_ADD_ACCESSORY_SOCKET" == useType:
			if self.__CanAddAccessorySocket(dstSlotPos):
				return TRUE
		elif "USE_PUT_INTO_ACCESSORY_SOCKET" == useType:								
			if self.__CanPutAccessorySocket(dstSlotPos, srcItemVNum):
				return TRUE;

	return FALSE

def __CanCleanBrokenMetinStone(self, dstSlotPos):
	dstItemVNum = player.GetItemIndex(dstSlotPos)
	if dstItemVNum == 0:
		return FALSE

	item.SelectItem(dstItemVNum)

	if item.ITEM_TYPE_WEAPON != item.GetItemType():
		return FALSE

	for i in xrange(player.METIN_SOCKET_MAX_NUM):
		if player.GetItemMetinSocket(dstSlotPos, i) == constInfo.ERROR_METIN_STONE:
			return TRUE

	return FALSE

def __CanChangeItemAttrList(self, dstSlotPos):
	dstItemVNum = player.GetItemIndex(dstSlotPos)
	if dstItemVNum == 0:
		return FALSE

	item.SelectItem(dstItemVNum)

	if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):	 
		return FALSE

	for i in xrange(player.METIN_SOCKET_MAX_NUM):
		if player.GetItemAttribute(dstSlotPos, i) != 0:
			return TRUE

	return FALSE

def __CanPutAccessorySocket(self, dstSlotPos, mtrlVnum):
	dstItemVNum = player.GetItemIndex(dstSlotPos)
	if dstItemVNum == 0:
		return FALSE

	item.SelectItem(dstItemVNum)

	if item.GetItemType() != item.ITEM_TYPE_ARMOR:
		return FALSE

	if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
		return FALSE

	curCount = player.GetItemMetinSocket(dstSlotPos, 0)
	maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

	if mtrlVnum != constInfo.GET_ACCESSORY_MATERIAL_VNUM(dstItemVNum, item.GetItemSubType()):
		return FALSE

	if curCount>=maxCount:
		return FALSE

	return TRUE

def __CanAddAccessorySocket(self, dstSlotPos):
	dstItemVNum = player.GetItemIndex(dstSlotPos)
	if dstItemVNum == 0:
		return FALSE

	item.SelectItem(dstItemVNum)

	if item.GetItemType() != item.ITEM_TYPE_ARMOR:
		return FALSE

	if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
		return FALSE

	curCount = player.GetItemMetinSocket(dstSlotPos, 0)
	maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

	ACCESSORY_SOCKET_MAX_SIZE = 3
	if maxCount >= ACCESSORY_SOCKET_MAX_SIZE:
		return FALSE

	return TRUE

def __CanAddItemAttr(self, dstSlotPos):
	dstItemVNum = player.GetItemIndex(dstSlotPos)
	if dstItemVNum == 0:
		return FALSE

	item.SelectItem(dstItemVNum)

	if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):	 
		return FALSE

	attrCount = 0
	for i in xrange(player.METIN_SOCKET_MAX_NUM):
		if player.GetItemAttribute(dstSlotPos, i) != 0:
			attrCount += 1

	if attrCount<4:
		return TRUE

	return FALSE

def __ShowToolTip(self, slotIndex):
	if None != self.tooltipItem:
		self.tooltipItem.SetInventoryItem(slotIndex)

def OnTop(self):
	if None != self.tooltipItem:
		self.tooltipItem.SetTop()

def OnPressEscapeKey(self):
	self.Close()
	return TRUE

def UseItemSlot(self, slotIndex):
	if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS():
		return

	slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

	self.__UseItem(slotIndex)
	mouseModule.mouseController.DeattachObject()
	self.OverOutItem()

def __UseItem(self, slotIndex):
	ItemVNum = player.GetItemIndex(slotIndex)
	item.SelectItem(ItemVNum)
	if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):
		self.questionDialog = uiCommon.QuestionDialog()
		self.questionDialog.SetText(locale.INVENTORY_REALLY_USE_ITEM)
		self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnAccept))
		self.questionDialog.SetCancelEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnCancel))
		self.questionDialog.Open()
		self.questionDialog.slotIndex = slotIndex

	else:
		self.__SendUseItemPacket(slotIndex)
		#net.SendItemUsePacket(slotIndex)	

def __UseItemQuestionDialog_OnCancel(self):
	self.OnCloseQuestionDialog()

def __UseItemQuestionDialog_OnAccept(self):
	self.__SendUseItemPacket(self.questionDialog.slotIndex)

	if self.questionDialog:
		self.questionDialog.Close()
	self.questionDialog = None

def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):
	# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
	if uiPrivateShopBuilder.IsBuildingPrivateShop():
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_ITEM_FAILURE_PRIVATE_SHOP)
		return

	net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)

def __SendUseItemPacket(self, slotPos):
	# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
	if uiPrivateShopBuilder.IsBuildingPrivateShop():
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_ITEM_FAILURE_PRIVATE_SHOP)
		return

	net.SendItemUsePacket(slotPos)

def __SendMoveItemPacket(self, srcSlotPos, dstSlotPos, srcItemCount):
	# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
	if uiPrivateShopBuilder.IsBuildingPrivateShop():
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
		return

	net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)

[guii59 1]

Ça ne marche toujours pas ...

[Kameyu 184]

Bonjour,

 

Le sujet contient la balise [glow=#800000][Résolu][/glow] ou reste sans réponse depuis deux semaines ou plus, de ce fait il a été déplacé dans la section "Résolu ou sans réponse".

 

Cordialement.