Client schließt sich nach laden.

[Big Mike]

Guten Miitag,

Mein Problem

PHP Code:

0622 12:10:00851 :: invalid idx 0
0622 12:10:34440 :: GRANNY: r:/granny/rt/granny_file_info.cpp(145): File has run-time type tag of 0x8000000f, which doesn't match this version of Granny (0x80000010).  Automatic conversion will be attempted.
0622 12:11:45987 :: 
uiInventory.py(line:154) __LoadWindow
ui.py(line:2640) GetChild

InventoryWindow.LoadWindow.BindObject - exceptions.KeyError:Schwert_vert_Value

0622 12:11:45987 :: ============================================================================================================
0622 12:11:45987 :: Abort!!!! 


Hatt jemand eine Lösung ?

PHP Code:

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 disabled when private shop opened
import locale
import constInfo
import ime
import background
import uiToolTip

ITEM_MALL_BUTTON_ENABLE = TRUE
WARP_SCROLLS = [22011, 22000, 22010]
ITEM_FLAG_APPLICABLE = 1 << 14

COSTUME_START_INDEX = 109
COSTUME_SLOT_COUNT = 3

class CostumeWindow(ui.ScriptWindow):

    def __init__(self, wndInventory):
        import exception
        
        #if not app.ENABLE_COSTUME_SYSTEM:            
        #    exception.Abort("What do you do?")
        #    return

        if not wndInventory:
            exception.Abort("wndInventory parameter must be set to InventoryWindow")
            return                        
                  
        ui.ScriptWindow.__init__(self)

        self.isLoaded = 0
        self.wndInventory = wndInventory;

        self.__LoadWindow()

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

    def Show(self):
        self.__LoadWindow()

        ui.ScriptWindow.Show(self)

    def Close(self):
        self.Hide()

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

        self.isLoaded = 1

        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "UIScript/CostumeWindow.py")
        except:
            import exception
            exception.Abort("CostumeWindow.LoadWindow.LoadObject")

        try:
            wndEquip = self.GetChild("CostumeSlot")
            self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
            
        except:
            import exception
            exception.Abort("CostumeWindow.LoadWindow.BindObject")

        ## Equipment
        wndEquip.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))
        wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))
        wndEquip.SAFE_SetButtonEvent("RIGHT", "EXIST", self.CostumeClick)

        self.wndEquip = wndEquip
        
    def CostumeClick(self, slotNumber):
        import costumes
        self.Costumes = costumes.Costumes()
        self.Costumes.UnWear(slotNumber)
        
    def OnUpdate(self):
        for i in xrange(COSTUME_SLOT_COUNT):
            slotNumber = COSTUME_START_INDEX + i
            if slotNumber == COSTUME_START_INDEX + 0:
                self.wndEquip.SetItemSlot(slotNumber, int(constInfo.COSTUME_ARMOR), 0)
            elif slotNumber == COSTUME_START_INDEX + 1:
                self.wndEquip.SetItemSlot(slotNumber, int(constInfo.COSTUME_HAIR), 0)

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.itemVNum = 0
        self.sellingSlotNumber = -1
        self.isLoaded = 0
        self.isOpenedCostumeWindowWhenClosingInventory = 0

        self.__LoadWindow()

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

    def Show(self):
        self.__LoadWindow()

        ui.ScriptWindow.Show(self)
        
        if self.isOpenedCostumeWindowWhenClosingInventory and self.wndCostume:
            self.wndCostume.Show() 

    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.costumeButton = self.GetChild2("CostumeButton")
##BonusPageDialog
            self.GetChild("Schwert_vert_Value").SetText(str(player.GetStatus(69)))
            self.GetChild("Zweihänder_vert_Value").SetText(str(player.GetStatus(70)))
            self.GetChild("Dolche_vert_Value").SetText(str(player.GetStatus(71)))
            self.GetChild("Bogen_vert_Value").SetText(str(player.GetStatus(74)))
            self.GetChild("Glocke_vert_Value").SetText(str(player.GetStatus(72)))
            self.GetChild("Fächer_vert_Value").SetText(str(player.GetStatus(73)))
            self.GetChild("Magie_vert_Value").SetText(str(player.GetStatus(77)))
            self.GetChild("Gift_vert_Value").SetText(str(player.GetStatus(81)))
            self.GetChild("Krieger_vert_Value").SetText(str(player.GetStatus(59)))
            self.GetChild("Ninja_vert_Value").SetText(str(player.GetStatus(60)))
            self.GetChild("Sura_vert_Value").SetText(str(player.GetStatus(61)))
            self.GetChild("Schamane_vert_Value").SetText(str(player.GetStatus(62)))
            self.GetChild("Krit_Value").SetText(str(player.GetStatus(40)))
            self.GetChild("DurchBohrenden_Value").SetText(str(player.GetStatus(41)))
            self.GetChild("DSS_Value").SetText(str(player.GetStatus(122)))
            self.GetChild("FKS_Value").SetText(str(player.GetStatus(121)))
            self.GetChild("Halbmenschen_Value").SetText(str(player.GetStatus(43)))
            self.GetChild("Untote_Value").SetText(str(player.GetStatus(47)))
            self.GetChild("Teufel_Value").SetText(str(player.GetStatus(48)))
            self.GetChild("Krieger_str_Value").SetText(str(player.GetStatus(54)))
            self.GetChild("Ninja_str_Value").SetText(str(player.GetStatus(55)))
            self.GetChild("Sura_str_Value").SetText(str(player.GetStatus(56)))
            self.GetChild("Schamane_str_Value").SetText(str(player.GetStatus(57)))
##BonusPageDialog

            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))

        # Costume Button
        if self.costumeButton:
            self.costumeButton.SetEvent(ui.__mem_func__(self.ClickCostumeButton))

        self.wndCostume = None
        
         #####

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

    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

        if self.wndCostume:
            self.wndCostume.Destroy()
            self.wndCostume = 0
        
        self.inventoryTab = []
        self.equipmentTab = []

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

        if self.wndCostume:
            self.isOpenedCostumeWindowWhenClosingInventory = self.wndCostume.IsShow()    # Àκ¥Å丮 Ã¢ÀÌ ´ÝÈú ¶§ ÄÚ½ºÃõÀÌ ¿*·Á ÀÖ¾ú´Â°¡?
            self.wndCostume.Close()
            
        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 ClickCostumeButton(self):
        print "Click Costume Button"
        if self.wndCostume:
            if self.wndCostume.IsShow(): 
                self.wndCostume.Hide()
            else:
                self.wndCostume.Show()
        else:
            self.wndCostume = CostumeWindow(self)
            self.wndCostume.Show()
        
    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

##BonusPageDialog
    def __LoadRefreshBonus(self):
        self.RefreshBonus()

    def RefreshBonus(self):
        try:
            self.GetChild("Schwert_vert_Value").SetText(str(player.GetStatus(69)))
            self.GetChild("Zweihänder_vert_Value").SetText(str(player.GetStatus(70)))
            self.GetChild("Dolche_vert_Value").SetText(str(player.GetStatus(71)))
            self.GetChild("Bogen_vert_Value").SetText(str(player.GetStatus(74)))
            self.GetChild("Glocke_vert_Value").SetText(str(player.GetStatus(72)))
            self.GetChild("Fächer_vert_Value").SetText(str(player.GetStatus(73)))
            self.GetChild("Magie_vert_Value").SetText(str(player.GetStatus(77)))
            self.GetChild("Gift_vert_Value").SetText(str(player.GetStatus(81)))
            self.GetChild("Krieger_vert_Value").SetText(str(player.GetStatus(59)))
            self.GetChild("Ninja_vert_Value").SetText(str(player.GetStatus(60)))
            self.GetChild("Sura_vert_Value").SetText(str(player.GetStatus(61)))
            self.GetChild("Schamane_vert_Value").SetText(str(player.GetStatus(62)))
            self.GetChild("Krit_Value").SetText(str(player.GetStatus(40)))
            self.GetChild("DurchBohrenden_Value").SetText(str(player.GetStatus(41)))
            self.GetChild("DSS_Value").SetText(str(player.GetStatus(122)))
            self.GetChild("FKS_Value").SetText(str(player.GetStatus(121)))
            self.GetChild("Halbmenschen_Value").SetText(str(player.GetStatus(43)))
            self.GetChild("Untote_Value").SetText(str(player.GetStatus(47)))
            self.GetChild("Teufel_Value").SetText(str(player.GetStatus(48)))
            self.GetChild("Krieger_str_Value").SetText(str(player.GetStatus(54)))
            self.GetChild("Ninja_str_Value").SetText(str(player.GetStatus(55)))
            self.GetChild("Sura_str_Value").SetText(str(player.GetStatus(56)))
            self.GetChild("Schamane_str_Value").SetText(str(player.GetStatus(57)))
        except:
            import exception
            exception.Abort("InventoryWindow.RefreshBonus.BindObject")
##BonusPageDialog

    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)
            
            ## ÀÚµ¿¹°¾à (HP: #72723 ~ #72726, SP: #72727 ~ #72730) Æ¯¼ö󸮠- ¾ÆÀÌÅÛÀε¥µµ ½½·Ô¿¡ È°¼ºÈ*/ºñÈ°¼ºÈ* Ç¥½Ã¸¦ À§ÇÑ ÀÛ¾÷ÀÓ - [hyo]
            if constInfo.IS_AUTO_POTION(itemVnum):
                # metinSocket - [0] : È°¼ºÈ* ¿©ºÎ, [1] : »ç¿ëÇÑ ¾ç, [2] : ÃÖ´ë ¿ë·®
                metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]    
                
                if slotNumber >= player.INVENTORY_PAGE_SIZE:
                    slotNumber -= player.INVENTORY_PAGE_SIZE
                    
                isActivated = 0 != metinSocket[0]
                
                if isActivated:
                    self.wndItem.ActivateSlot(slotNumber)
                    potionType = 0;
                    if constInfo.IS_AUTO_POTION_HP(itemVnum):
                        potionType = player.AUTO_POTION_TYPE_HP
                    elif constInfo.IS_AUTO_POTION_SP(itemVnum):
                        potionType = player.AUTO_POTION_TYPE_SP                        
                    
                    usedAmount = int(metinSocket[1])
                    totalAmount = int(metinSocket[2])                    
                    player.SetAutoPotionInfo(potionType, isActivated, (totalAmount - usedAmount), totalAmount, self.__InventoryLocalSlotPosToGlobalSlotPos(i))
                    
                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

        ## WARP_SCROLL_BLOCK
        # Atlasinfo.txt szerint kell megadni a map neveket!
        itemVNum = player.GetItemIndex(slotPos)
        if itemVNum in WARP_SCROLLS:
            MapName = str(background.GetCurrentMapName())
            if MapName == "season1/metin2_map_oxevent" or MapName =="metin2_map_deviltower1"  or MapName == "metin2_map_t1" or MapName == "metin2_map_t2" or MapName == "metin2_map_t3":
                chat.AppendChat(chat.CHAT_TYPE_INFO, "Ezen a területen nem használatod a Visszaszállító tekercset!")
                return TRUE
        ## END_OF_WARP_SCROLL_BLOCK

        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)

##BonusPageDialog
    def OnUpdate(self):
        if self.isLoaded == 1:
            self.__LoadRefreshBonus()
##BonusPageDialog 


[xGr33n]

Könntest du deine uiInventory.py posten? Was hast du an der uiInventory.py als letztes geändert?