Jump to content

Item Stacking Broken Logic 😭

shadowofthelove
 Share

Recommended Posts

shadowofthelove Enthusiast

shadowofthelove 6

Posted
Posted

So I tried to implement transmutation, at first glance everything seemed perfect but things didn't work out correctly, I couldn't understand how or where did I screw it up this badly ?

Before transmutation my inventory stacking was good , refine scrolls were stackable , magic metals, blessing marbles

Now I have the following bugs with my file :
- If I do Shift+Click on a stack and put 20 pieces for example then try to throw it on the floor, the whole stack throws itself (unsure if it was there before but I just saw it)
- If I try to unstack a stack of blessing marbles, the client sends a USE packet instead of MOVE even on empty inventory slots and I end up with only 1 piece , if I unstack 199 pieces from a stack and I put them in a new inventory cell 198 of them vanish into thin air and I end up crying 
- I cannot stack and unstack any use item attributes like enchant bonus, switch bonus, magic metals , ANYTHING  
Not even Blessing Scrolls are not stackable anymore tho I have the same logic as in this topic \/

Can anyone please compare their uiinventory functions logic with mine ? 
  

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 localeInfo
import constInfo
import ime
import wndMgr

ITEM_MALL_BUTTON_ENABLE = True


ITEM_FLAG_APPLICABLE = 1 << 14

# ********************************************************************** #
# Add this import:
if app.ENABLE_CHEQUE_SYSTEM:
    import uiToolTip
    import uiPickETC
# ********************************************************************** #


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()
        self.RefreshCostumeSlot()

        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.SetUnselectItemSlotEvent(
            ui.__mem_func__(self.wndInventory.UseItemSlot)
        )
        wndEquip.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
        wndEquip.SetSelectEmptySlotEvent(
            ui.__mem_func__(self.wndInventory.SelectEmptySlot)
        )
        wndEquip.SetSelectItemSlotEvent(
            ui.__mem_func__(self.wndInventory.SelectItemSlot)
        )

        self.wndEquip = wndEquip

    def RefreshCostumeSlot(self):
        getItemVNum = player.GetItemIndex

        for i in xrange(item.COSTUME_SLOT_COUNT):
            slotNumber = item.COSTUME_SLOT_START + i
            self.wndEquip.SetItemSlot(slotNumber, getItemVNum(slotNumber), 0)

            if app.BL_TRANSMUTATION_SYSTEM:
                if not player.GetChangeLookVnum(player.EQUIPMENT, slotNumber) == 0:
                    self.wndEquip.SetSlotCoverImage(slotNumber,"icon/item/ingame_convert_Mark.tga")
                else:
                    self.wndEquip.EnableSlotCoverImage(slotNumber,False)

        self.wndEquip.RefreshSlot()


class BeltInventoryWindow(ui.ScriptWindow):

    def __init__(self, wndInventory):
        import exception

        if not app.ENABLE_NEW_EQUIPMENT_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.wndBeltInventoryLayer = None
        self.wndBeltInventorySlot = None
        self.expandBtn = None
        self.minBtn = None

        self.__LoadWindow()

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

    def Show(self, openBeltSlot=FALSE):
        self.__LoadWindow()
        self.RefreshSlot()

        ui.ScriptWindow.Show(self)

        if openBeltSlot:
            self.OpenInventory()
        else:
            self.CloseInventory()

    def Close(self):
        self.Hide()

    def IsOpeningInventory(self):
        return self.wndBeltInventoryLayer.IsShow()

    def OpenInventory(self):
        self.wndBeltInventoryLayer.Show()
        self.expandBtn.Hide()

        if localeInfo.IsARABIC() == 0:
            self.AdjustPositionAndSize()

    def CloseInventory(self):
        self.wndBeltInventoryLayer.Hide()
        self.expandBtn.Show()

        if localeInfo.IsARABIC() == 0:
            self.AdjustPositionAndSize()

    ## ÇöŔç ŔÎşĄĹ丮 Ŕ§Äˇ¸¦ ±âÁŘŔ¸·Î BASE Ŕ§Äˇ¸¦ °č»ę, ¸®ĹĎ.. ĽýŔÚ ÇϵĺÄÚµůÇϱâ Á¤¸» ˝ČÁö¸¸ ąćąýŔĚ ľř´Ů..
    def GetBasePosition(self):
        x, y = self.wndInventory.GetGlobalPosition()
        return x - 148, y + 241

    def AdjustPositionAndSize(self):
        bx, by = self.GetBasePosition()

        if self.IsOpeningInventory():
            self.SetPosition(bx, by)
            self.SetSize(self.ORIGINAL_WIDTH, self.GetHeight())

        else:
            self.SetPosition(bx + 138, by)
            self.SetSize(10, self.GetHeight())

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

        self.isLoaded = 1

        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "UIScript/BeltInventoryWindow.py")
        except:
            import exception

            exception.Abort("CostumeWindow.LoadWindow.LoadObject")

        try:
            self.ORIGINAL_WIDTH = self.GetWidth()
            wndBeltInventorySlot = self.GetChild("BeltInventorySlot")
            self.wndBeltInventoryLayer = self.GetChild("BeltInventoryLayer")
            self.expandBtn = self.GetChild("ExpandBtn")
            self.minBtn = self.GetChild("MinimizeBtn")

            self.expandBtn.SetEvent(ui.__mem_func__(self.OpenInventory))
            self.minBtn.SetEvent(ui.__mem_func__(self.CloseInventory))

            if localeInfo.IsARABIC():
                self.expandBtn.SetPosition(self.expandBtn.GetWidth() - 2, 15)
                self.wndBeltInventoryLayer.SetPosition(
                    self.wndBeltInventoryLayer.GetWidth() - 5, 0
                )
                self.minBtn.SetPosition(self.minBtn.GetWidth() + 3, 15)

            for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):
                slotNumber = item.BELT_INVENTORY_SLOT_START + i
                wndBeltInventorySlot.SetCoverButton(
                    slotNumber,
                    "d:/ymir work/ui/game/quest/slot_button_01.sub",
                    "d:/ymir work/ui/game/quest/slot_button_01.sub",
                    "d:/ymir work/ui/game/quest/slot_button_01.sub",
                    "d:/ymir work/ui/game/belt_inventory/slot_disabled.tga",
                    FALSE,
                    FALSE,
                )

        except:
            import exception

            exception.Abort("CostumeWindow.LoadWindow.BindObject")

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

        self.wndBeltInventorySlot = wndBeltInventorySlot

    def RefreshSlot(self):
        getItemVNum = player.GetItemIndex

        for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):
            slotNumber = item.BELT_INVENTORY_SLOT_START + i
            self.wndBeltInventorySlot.SetItemSlot(
                slotNumber, getItemVNum(slotNumber), player.GetItemCount(slotNumber)
            )
            self.wndBeltInventorySlot.SetAlwaysRenderCoverButton(slotNumber, TRUE)

            avail = "0"

            if player.IsAvailableBeltInventoryCell(slotNumber):
                self.wndBeltInventorySlot.EnableCoverButton(slotNumber)
            else:
                self.wndBeltInventorySlot.DisableCoverButton(slotNumber)

        self.wndBeltInventorySlot.RefreshSlot()


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",
        "USE_PUT_INTO_BELT_SOCKET",
        "USE_PUT_INTO_RING_SOCKET",
    )

    questionDialog = None
    tooltipItem = None
    wndCostume = None
    wndBelt = None
    dlgPickMoney = None
# ********************************************************************** #
# Add after:
    if app.ENABLE_CHEQUE_SYSTEM:
        dlgPickETC = None
# ********************************************************************** #
    interface = None
    if app.WJ_ENABLE_TRADABLE_ICON:
        bindWnds = []
    sellingSlotNumber = -1
    isLoaded = 0
    isOpenedCostumeWindowWhenClosingInventory = 0
    isOpenedBeltWindowWhenClosingInventory = 0

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

        self.isOpenedBeltWindowWhenClosingInventory = 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()

        if self.wndBelt:
            self.wndBelt.Show(self.isOpenedBeltWindowWhenClosingInventory)

    def BindInterfaceClass(self, interface):
        self.interface = interface
        
    if app.WJ_ENABLE_TRADABLE_ICON:
        def BindWindow(self, wnd):
            self.bindWnds.append(wnd)
            
    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.DSSButton = self.GetChild2("DSSButton")
            self.costumeButton = self.GetChild2("CostumeButton")

# ********************************************************************** #
# Add after:
            if app.ENABLE_CHEQUE_SYSTEM:
                self.wndCheque = self.GetChild("Cheque")
                self.wndChequeSlot = self.GetChild("Cheque_Slot")

                if app.ENABLE_GEM_SYSTEM:
                    self.wndMoneyIcon = self.GetChild("Money_Icon")
                    self.wndChequeIcon = self.GetChild("Cheque_Icon")
                    self.wndMoneyIcon.Hide()
                    self.wndMoneySlot.Hide()
                    self.wndChequeIcon.Hide()
                    self.wndChequeSlot.Hide()

                    ## 높이 조절
                    height = self.GetHeight()
                    width = self.GetWidth()
                    self.SetSize(width, height - 22)
                    self.GetChild("board").SetSize(width, height - 22)

                else:
                    self.wndMoneyIcon = self.GetChild("Money_Icon")
                    self.wndChequeIcon = self.GetChild("Cheque_Icon")
                
                    self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 0)
                    self.wndChequeIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 1)
                
                    self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 0)
                    self.wndChequeIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 1)
                
                    self.toolTip = uiToolTip.ToolTip()
                    self.toolTip.ClearToolTip()
# ********************************************************************** #

            self.inventoryTab = []
            self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))
            self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))
            if app.ENABLE_4TH_INVENTORY:
                self.inventoryTab.append(self.GetChild("Inventory_Tab_03"))
                self.inventoryTab.append(self.GetChild("Inventory_Tab_04"))

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

# ********************************************************************** #
# Add after:
            if app.BL_TRANSMUTATION_SYSTEM:
                self.dlgQuestion = uiCommon.QuestionDialog2()
                self.dlgQuestion.Close()
                self.listHighlightedChangeLookSlot = []
# ********************************************************************** #

            if app.BL_ENABLE_PICKUP_ITEM_EFFECT:
                self.listHighlightedSlot = []
            if self.costumeButton and not app.ENABLE_COSTUME_SYSTEM:
                self.costumeButton.Hide()
                self.costumeButton.Destroy()
                self.costumeButton = 0

            # Belt Inventory Window
            self.wndBelt = None

            if app.ENABLE_NEW_EQUIPMENT_SYSTEM:
                self.wndBelt = BeltInventoryWindow(self)

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

# ********************************************************************** #
# Add BEFORE:
        ## PickETCDialog
        if app.ENABLE_CHEQUE_SYSTEM:
            dlgPickETC = uiPickETC.PickETCDialog()
            dlgPickETC.LoadDialog()
            dlgPickETC.Hide()
# ********************************************************************** #

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

        ## AttachMetinDialog
        if app.WJ_ENABLE_TRADABLE_ICON:
            self.attachMetinDialog = uiAttachMetin.AttachMetinDialog(self)
            self.BindWindow(self.attachMetinDialog)
        else:
            self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()
        self.attachMetinDialog.Hide()

        ## MoneySlot
# ********************************************************************** #
# Replace with:
        if app.ENABLE_CHEQUE_SYSTEM:
            self.wndChequeSlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog), 1)
            self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog), 0)
        else:
            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))
        if app.ENABLE_4TH_INVENTORY:
            self.inventoryTab[2].SetEvent(lambda arg=2: self.SetInventoryPage(arg))
            self.inventoryTab[3].SetEvent(lambda arg=3: self.SetInventoryPage(arg))
        self.inventoryTab[0].Down()
        self.inventoryPageIndex = 0

        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

# ********************************************************************** #
# Add after:
        if app.ENABLE_CHEQUE_SYSTEM:
            self.dlgPickETC = dlgPickETC
# ********************************************************************** #

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

        if self.DSSButton:
            self.DSSButton.SetEvent(ui.__mem_func__(self.ClickDSSButton))

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

    def Destroy(self):
        self.ClearDictionary()

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

# ********************************************************************** #
# Add after:
        if app.ENABLE_CHEQUE_SYSTEM:
            self.dlgPickETC.Destroy()
            self.dlgPickETC = 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
# ********************************************************************** #
# Add after:
        if app.ENABLE_CHEQUE_SYSTEM:
            self.wndCheque = 0
            self.wndChequeSlot = 0
            self.dlgPickETC = 0
# ********************************************************************** #
        self.questionDialog = None
        self.mallButton = None
        self.DSSButton = None
        self.interface = None
        if app.WJ_ENABLE_TRADABLE_ICON:
            self.bindWnds = []
        if self.wndCostume:
            self.wndCostume.Destroy()
            self.wndCostume = 0

        if self.wndBelt:
            self.wndBelt.Destroy()
            self.wndBelt = None

# ********************************************************************** #
# Add after:
        if app.BL_TRANSMUTATION_SYSTEM:
            self.dlgQuestion = None
# ********************************************************************** #

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

    def Hide(self):
        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
            self.OnCloseQuestionDialog()
            return
        if None != self.tooltipItem:
            self.tooltipItem.HideToolTip()

        if self.wndCostume:
            self.isOpenedCostumeWindowWhenClosingInventory = self.wndCostume.IsShow()
            self.wndCostume.Close()

        if self.wndBelt:
            self.isOpenedBeltWindowWhenClosingInventory = self.wndBelt.IsOpeningInventory()
            print("Is Opening Belt Inven?? ", self.isOpenedBeltWindowWhenClosingInventory)
            self.wndBelt.Close()

        if self.dlgPickMoney:
            self.dlgPickMoney.Close()

# ********************************************************************** #
# Add after:
        if app.ENABLE_CHEQUE_SYSTEM:
            if self.dlgPickETC:
                self.dlgPickETC.Close()
# ********************************************************************** #

        wndMgr.Hide(self.hWnd)

    def Close(self):
        self.Hide()

    def SetInventoryPage(self, page):
        self.inventoryTab[self.inventoryPageIndex].SetUp()
        self.inventoryPageIndex = page
        self.inventoryTab[self.inventoryPageIndex].Down()
        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 ClickDSSButton(self):
        print("click_dss_button")
        self.interface.ToggleDragonSoulWindow()

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

# ********************************************************************** #
# Replace with:
    if app.ENABLE_CHEQUE_SYSTEM:
        def OpenPickMoneyDialog(self, focus_idx = 0):
            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()
                curCheque = player.GetCheque()

                if curMoney <= 0 and curCheque <= 0:
                    return

                self.dlgPickMoney.SetTitleName(localeInfo.PICK_MONEY_TITLE)
                self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
                self.dlgPickMoney.Open(curMoney, curCheque)
                self.dlgPickMoney.SetMax(9) # 인벤토리 990000 제한 버그 수정
                self.dlgPickMoney.SetMaxCheque(3)
                self.dlgPickMoney.SetFocus(focus_idx)
    else:
        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(localeInfo.PICK_MONEY_TITLE)
                self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
                self.dlgPickMoney.Open(curMoney)
                self.dlgPickMoney.SetMax(7)
# ********************************************************************** #

# ********************************************************************** #
# Replace with:
    if app.ENABLE_CHEQUE_SYSTEM:
        def OnPickMoney(self, money, cheque):
            if cheque > 0 and money > 0:
                chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHEQUE_ONLY_VALUE)
                return
            if cheque > 0:
                mouseModule.mouseController.AttacCheque(self, player.SLOT_TYPE_INVENTORY, cheque)
            else:
                mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)
    else:
        def OnPickMoney(self, money):
            mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)
# ********************************************************************** #

    def OnPickItem(self, count):
        if app.ENABLE_CHEQUE_SYSTEM:
            itemSlotIndex = self.dlgPickETC.itemGlobalSlotIndex
        else:
            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)
            or player.IsCostumeSlot(local)
            or (app.ENABLE_NEW_EQUIPMENT_SYSTEM and player.IsBeltInventorySlot(local))
        ):
            return local

        return self.inventoryPageIndex * player.INVENTORY_PAGE_SIZE + local

    def GetInventoryPageIndex(self):
        return self.inventoryPageIndex

    if app.WJ_ENABLE_TRADABLE_ICON:

        def RefreshMarkSlots(self, localIndex=None):
            if not self.interface:
                return

            onTopWnd = self.interface.GetOnTopWindow()
            if localIndex:
                slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(localIndex)
                if onTopWnd == player.ON_TOP_WND_NONE:
                    self.wndItem.SetUsableSlotOnTopWnd(localIndex)

                elif onTopWnd == player.ON_TOP_WND_SHOP:
                    if player.IsAntiFlagBySlot(slotNumber, item.ANTIFLAG_SELL):
                        self.wndItem.SetUnusableSlotOnTopWnd(localIndex)
                    else:
                        self.wndItem.SetUsableSlotOnTopWnd(localIndex)

                elif onTopWnd == player.ON_TOP_WND_EXCHANGE:
                    if player.IsAntiFlagBySlot(slotNumber, item.ANTIFLAG_GIVE):
                        self.wndItem.SetUnusableSlotOnTopWnd(localIndex)
                    else:
                        self.wndItem.SetUsableSlotOnTopWnd(localIndex)

                elif onTopWnd == player.ON_TOP_WND_PRIVATE_SHOP:
                    if player.IsAntiFlagBySlot(slotNumber, item.ITEM_ANTIFLAG_MYSHOP):
                        self.wndItem.SetUnusableSlotOnTopWnd(localIndex)
                    else:
                        self.wndItem.SetUsableSlotOnTopWnd(localIndex)

                elif onTopWnd == player.ON_TOP_WND_SAFEBOX:
                    if player.IsAntiFlagBySlot(slotNumber, item.ANTIFLAG_SAFEBOX):
                        self.wndItem.SetUnusableSlotOnTopWnd(localIndex)
                    else:
                        self.wndItem.SetUsableSlotOnTopWnd(localIndex)

                return

            for i in xrange(player.INVENTORY_PAGE_SIZE):
                slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)

                if onTopWnd == player.ON_TOP_WND_NONE:
                    self.wndItem.SetUsableSlotOnTopWnd(i)

                elif onTopWnd == player.ON_TOP_WND_SHOP:
                    if player.IsAntiFlagBySlot(slotNumber, item.ANTIFLAG_SELL):
                        self.wndItem.SetUnusableSlotOnTopWnd(i)
                    else:
                        self.wndItem.SetUsableSlotOnTopWnd(i)

                elif onTopWnd == player.ON_TOP_WND_EXCHANGE:
                    if player.IsAntiFlagBySlot(slotNumber, item.ANTIFLAG_GIVE):
                        self.wndItem.SetUnusableSlotOnTopWnd(i)
                    else:
                        self.wndItem.SetUsableSlotOnTopWnd(i)

                elif onTopWnd == player.ON_TOP_WND_PRIVATE_SHOP:
                    if player.IsAntiFlagBySlot(slotNumber, item.ITEM_ANTIFLAG_MYSHOP):
                        self.wndItem.SetUnusableSlotOnTopWnd(i)
                    else:
                        self.wndItem.SetUsableSlotOnTopWnd(i)

                elif onTopWnd == player.ON_TOP_WND_SAFEBOX:
                    if player.IsAntiFlagBySlot(slotNumber, item.ANTIFLAG_SAFEBOX):
                        self.wndItem.SetUnusableSlotOnTopWnd(i)
                    else:
                        self.wndItem.SetUsableSlotOnTopWnd(i)

    def RefreshBagSlotWindow(self):
        getItemVNum = player.GetItemIndex
        getItemCount = player.GetItemCount
        setItemVNum = self.wndItem.SetItemSlot
        if app.BL_ENABLE_PICKUP_ITEM_EFFECT:
            for i in xrange(self.wndItem.GetSlotCount()):
                self.wndItem.DeactivateSlot(i)
        for i in xrange(player.INVENTORY_PAGE_SIZE):
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)

            itemCount = getItemCount(slotNumber)
            if 0 == itemCount:
                self.wndItem.ClearSlot(i)
                if app.WJ_ENABLE_TRADABLE_ICON:
                    self.RefreshMarkSlots(i)  # ADD THIS LINE HERE
                continue
            elif 1 == itemCount:
                itemCount = 0

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

# ********************************************************************** #
# Add above:
            if app.BL_TRANSMUTATION_SYSTEM:
                if not player.GetChangeLookVnum(player.INVENTORY, slotNumber) == 0:
                    self.wndItem.SetSlotCoverImage(i,"icon/item/ingame_convert_Mark.tga")
                else:
                    self.wndItem.EnableSlotCoverImage(i,False)
# ********************************************************************** #

            if constInfo.IS_AUTO_POTION(itemVnum):
                metinSocket = [
                    player.GetItemMetinSocket(slotNumber, j)
                    for j in xrange(player.METIN_SOCKET_MAX_NUM)
                ]

                if slotNumber >= player.INVENTORY_PAGE_SIZE * self.inventoryPageIndex:
                    slotNumber -= player.INVENTORY_PAGE_SIZE * self.inventoryPageIndex

                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
                        self.wndItem.SetSlotDiffuseColor(
                            slotNumber, wndMgr.COLOR_TYPE_RED
                        )
                    elif constInfo.IS_AUTO_POTION_SP(itemVnum):
                        potionType = player.AUTO_POTION_TYPE_SP
                        self.wndItem.SetSlotDiffuseColor(
                            slotNumber, wndMgr.COLOR_TYPE_SKY
                        )
                        
                    usedAmount = int(metinSocket[1])
                    totalAmount = int(metinSocket[2])
                    player.SetAutoPotionInfo(
                        potionType,
                        isActivated,
                        (totalAmount - usedAmount),
                        totalAmount,
                        self.__InventoryLocalSlotPosToGlobalSlotPos(i),
                    )

                else:
                    self.wndItem.DeactivateSlot(slotNumber)
            if app.WJ_ENABLE_TRADABLE_ICON:
                self.RefreshMarkSlots(i)
        if app.BL_ENABLE_PICKUP_ITEM_EFFECT:
            self.__HighlightSlot_Refresh()
        #if app.WJ_ENABLE_TRADABLE_ICON:
        #    self.RefreshMarkSlots(i)
        self.wndItem.RefreshSlot()

        if self.wndBelt:
            self.wndBelt.RefreshSlot()
        if app.WJ_ENABLE_TRADABLE_ICON:
            map(lambda wnd: wnd.RefreshLockedSlot(), self.bindWnds)

    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)

# ********************************************************************** #
            if app.BL_TRANSMUTATION_SYSTEM:
                if not player.GetChangeLookVnum(player.EQUIPMENT, slotNumber) == 0:
                    self.wndEquip.SetSlotCoverImage(slotNumber,"icon/item/ingame_convert_Mark.tga")
                else:
                    self.wndEquip.EnableSlotCoverImage(slotNumber,False)
# ********************************************************************** #

        if app.ENABLE_NEW_EQUIPMENT_SYSTEM:
            for i in xrange(player.NEW_EQUIPMENT_SLOT_COUNT):
                slotNumber = player.NEW_EQUIPMENT_SLOT_START + i
                itemCount = getItemCount(slotNumber)
                if itemCount <= 1:
                    itemCount = 0
                setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)
                print(
                    "ENABLE_NEW_EQUIPMENT_SYSTEM",
                    slotNumber,
                    itemCount,
                    getItemVNum(slotNumber),
                )

        self.wndEquip.RefreshSlot()

        if self.wndCostume:
            self.wndCostume.RefreshCostumeSlot()

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

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

# ********************************************************************** #
# Add after:
        if app.ENABLE_CHEQUE_SYSTEM:
            cheque = player.GetCheque()
            self.wndCheque.SetText(localeInfo.NumberToGoldNotText(cheque))
# ********************************************************************** #

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

    def SellItem(self):
        if self.sellingSlotitemIndex == player.GetItemIndex(self.sellingSlotNumber):
            if self.sellingSlotitemCount == player.GetItemCount(self.sellingSlotNumber):
                net.SendShopSellPacketNew(
                    self.sellingSlotNumber, self.questionDialog.count, player.INVENTORY
                )
                snd.PlaySound("sound/ui/money.wav")
        self.OnCloseQuestionDialog()

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

        self.__SendUseItemToItemPacket(
            self.questionDialog.sourcePos, self.questionDialog.targetPos
        )
        self.OnCloseQuestionDialog()

    def OnCloseQuestionDialog(self):
        if not self.questionDialog:
            return

        self.questionDialog.Close()
        self.questionDialog = None
        constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

    def SelectEmptySlot(self, selectedSlotPos):
        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
            return

# ********************************************************************** #
        if app.BL_TRANSMUTATION_SYSTEM:
            if player.GetChangeLookWindowOpen() == 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_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, localeInfo.SHOP_BUY_INFO)

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

# In the SelectItemSlot method, find the shift+click section and replace it with:
            elif app.IsPressed(app.DIK_LSHIFT):
                itemCount = player.GetItemCount(itemSlotIndex)

                if itemCount > 1:
                    # Use the appropriate dialog based on cheque system
                    if app.ENABLE_CHEQUE_SYSTEM:
                        self.dlgPickETC.SetTitleName(localeInfo.PICK_ITEM_TITLE)
                        self.dlgPickETC.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))
                        self.dlgPickETC.Open(itemCount)
                        self.dlgPickETC.itemGlobalSlotIndex = itemSlotIndex
                    else:
                        self.dlgPickMoney.SetTitleName(localeInfo.PICK_ITEM_TITLE)
                        self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))
                        self.dlgPickMoney.Open(itemCount)
                        self.dlgPickMoney.itemGlobalSlotIndex = itemSlotIndex
                else:
                    # If only 1 item, just attach it directly
                    selectedItemVNum = player.GetItemIndex(itemSlotIndex)
                    mouseModule.mouseController.AttachObject(
                        self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, 1
                    )

            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, localeInfo.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):
			if player.GetItemIndex(srcItemSlotPos) == player.GetItemIndex(dstItemSlotPos):
				self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos,0)
			else:
				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:
            if player.GetItemIndex(srcItemSlotPos) == player.GetItemIndex(dstItemSlotPos):
                self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
            else:
                self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

        elif item.GetUseType(srcItemVID) in self.USE_TYPE_TUPLE:
            # FIX: Always move when dragging to empty slots or same item type
            dstItemIndex = player.GetItemIndex(dstItemSlotPos)
            if dstItemIndex == 0 or dstItemIndex == srcItemVID:
                self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
            else:
                self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
        # ********************************************************************** #
        if app.BL_TRANSMUTATION_SYSTEM:
            if player.GetChangeLookWindowOpen() == 1:
                return
        # ********************************************************************** #
        else:
            # snd.PlaySound("sound/ui/drop.wav")
            # ********************************************************************** #
            if app.BL_TRANSMUTATION_SYSTEM:
                if item.IsChangeLookClearScroll(srcItemVID):
                    if player.CanChangeLookClearItem(srcItemVID, player.INVENTORY, dstItemSlotPos):
                        self.__OpenQuestionDialog(srcItemSlotPos, dstItemSlotPos)
                        return
            # ********************************************************************** #

            if player.IsEquipmentSlot(dstItemSlotPos):
                if item.IsEquipmentVID(srcItemVID):
                    self.__UseItem(srcItemSlotPos)
            else:
                self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)

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

            self.sellingSlotitemIndex = itemIndex
            self.sellingSlotitemCount = itemCount

            item.SelectItem(itemIndex)
            if item.IsAntiFlag(item.ANTIFLAG_SELL):
                popup = uiCommon.PopupDialog()
                popup.SetText(localeInfo.SHOP_CANNOT_SELL_ITEM)
                popup.SetAcceptEvent(self.__OnClosePopupDialog)
                popup.Open()
                self.popup = popup
                return

            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(
                localeInfo.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

            constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

    def __OnClosePopupDialog(self):
        self.pop = None

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

        result = player.CanRefine(scrollIndex, targetSlotPos)

        if player.REFINE_ALREADY_MAX_SOCKET_COUNT == result:
            chat.AppendChat(
                chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_MORE_SOCKET
            )

        elif player.REFINE_NEED_MORE_GOOD_SCROLL == result:
            chat.AppendChat(
                chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NEED_BETTER_SCROLL
            )

        elif player.REFINE_CANT_MAKE_SOCKET_ITEM == result:
            chat.AppendChat(
                chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_SOCKET_DISABLE_ITEM
            )

        elif player.REFINE_NOT_NEXT_GRADE_ITEM == result:
            chat.AppendChat(
                chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_UPGRADE_DISABLE_ITEM
            )

        elif player.REFINE_CANT_REFINE_METIN_TO_EQUIPMENT == result:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.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, localeInfo.REFINE_FAILURE_METIN_INSEPARABLE_ITEM
            )
            return

        self.questionDialog = uiCommon.QuestionDialog()
        self.questionDialog.SetText(localeInfo.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, localeInfo.REFINE_FAILURE_CAN_NOT_ATTACH(itemName)
            )

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

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

        elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.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 app.BL_ENABLE_PICKUP_ITEM_EFFECT:
            self.DelHighlightSlot(overSlotPos)
        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

# ********************************************************************** #
            if app.BL_TRANSMUTATION_SYSTEM:
                if item.IsChangeLookClearScroll(srcItemVNum):
                    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) or player.GetItemIndex(dstSlotPos) == srcItemVNum:
                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) or player.GetItemIndex(dstSlotPos) == srcItemVNum:
                    return True
            elif "USE_CHANGE_ATTRIBUTE" == useType:
                if self.__CanChangeItemAttrList(dstSlotPos) or player.GetItemIndex(dstSlotPos) == srcItemVNum:
                    return True
            elif "USE_ADD_ATTRIBUTE" == useType:
                if self.__CanAddItemAttr(dstSlotPos) or player.GetItemIndex(dstSlotPos) == srcItemVNum:
                    return True
            elif "USE_ADD_ATTRIBUTE2" == useType:
                if self.__CanAddItemAttr(dstSlotPos) or player.GetItemIndex(dstSlotPos) == srcItemVNum:
                    return True
            elif "USE_ADD_ACCESSORY_SOCKET" == useType:
                if self.__CanAddAccessorySocket(dstSlotPos) or player.GetItemIndex(dstSlotPos) == srcItemVNum:
                    return True
            elif "USE_PUT_INTO_ACCESSORY_SOCKET" == useType:
                if self.__CanPutAccessorySocket(dstSlotPos, srcItemVNum) or player.GetItemIndex(dstSlotPos) == srcItemVNum:
                    return TRUE
            elif "USE_PUT_INTO_BELT_SOCKET" == useType:
                dstItemVNum = player.GetItemIndex(dstSlotPos)
                item.SelectItem(dstItemVNum)
    
                if item.ITEM_TYPE_BELT == item.GetItemType() or dstItemVNum == srcItemVNum:
                    return True

# ********************************************************************** #
            if app.BL_TRANSMUTATION_SYSTEM:
                if player.CanChangeLookClearItem(srcItemVNum, player.INVENTORY, dstSlotPos):
                    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()
        if app.WJ_ENABLE_TRADABLE_ICON:
            map(lambda wnd: wnd.RefreshLockedSlot(), self.bindWnds)
            self.RefreshMarkSlots()

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

    def UseItemSlot(self, slotIndex):
        curCursorNum = app.GetCursor()
        if app.SELL == curCursorNum:
            return

        if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
            return

        slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

        if app.ENABLE_DRAGON_SOUL_SYSTEM:
            if self.wndDragonSoulRefine.IsShow():
                self.wndDragonSoulRefine.AutoSetItem((player.INVENTORY, slotIndex), 1)
                return

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

    def __UseItem(self, slotIndex):
        ItemVNum = player.GetItemIndex(slotIndex)
        item.SelectItem(ItemVNum)

# ********************************************************************** #
        if app.BL_TRANSMUTATION_SYSTEM:
            if player.GetChangeLookWindowOpen() == 1:
                return
# ********************************************************************** #

        if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):
            self.questionDialog = uiCommon.QuestionDialog()
            self.questionDialog.SetText(localeInfo.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

            constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

        else:
            self.__SendUseItemPacket(slotIndex)

    def __UseItemQuestionDialog_OnCancel(self):
        self.OnCloseQuestionDialog()

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

    def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):
        if uiPrivateShopBuilder.IsBuildingPrivateShop():
            chat.AppendChat(
                chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP
            )
            return

        net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)

    def __SendUseItemPacket(self, slotPos):
        if uiPrivateShopBuilder.IsBuildingPrivateShop():
            chat.AppendChat(
                chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP
            )
            return

        net.SendItemUsePacket(slotPos)

    def __SendMoveItemPacket(self, srcSlotPos, dstSlotPos, srcItemCount):
        if uiPrivateShopBuilder.IsBuildingPrivateShop():
            chat.AppendChat(
                chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP
            )
            return

        net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)

    def SetDragonSoulRefineWindow(self, wndDragonSoulRefine):
        if app.ENABLE_DRAGON_SOUL_SYSTEM:
            self.wndDragonSoulRefine = wndDragonSoulRefine

    def OnMoveWindow(self, x, y):
        if self.wndBelt:
            self.wndBelt.AdjustPositionAndSize()

# ********************************************************************** #
# Add this in the end of the file:
    if app.ENABLE_CHEQUE_SYSTEM:
        def OverInToolTip(self, arg):
            arglen = len(str(arg))
            pos_x, pos_y = wndMgr.GetMousePosition()
            
            self.toolTip.ClearToolTip()
            self.toolTip.SetThinBoardSize(11 * arglen)
            self.toolTip.SetToolTipPosition(pos_x + 5, pos_y - 5)
            self.toolTip.AppendTextLine(arg, 0xffffff00)
            self.toolTip.Show()

        def OverOutToolTip(self):
            self.toolTip.Hide()

        def EventProgress(self, event_type, idx):
            if "mouse_over_in" == str(event_type):
                if idx == 0 :
                    self.OverInToolTip(localeInfo.CHEQUE_SYSTEM_UNIT_YANG)
                elif idx == 1 :
                    self.OverInToolTip(localeInfo.CHEQUE_SYSTEM_UNIT_WON)
                elif app.ENABLE_GEM_SYSTEM and idx == 2:
                    self.OverInToolTip(localeInfo.GEM_SYSTEM_NAME)
                else:
                    return 
            elif "mouse_over_out" == str(event_type) :
                self.OverOutToolTip()
            else:
                return

    if app.BL_TRANSMUTATION_SYSTEM:
        def IsDlgQuestionShow(self):
            if self.dlgQuestion.IsShow():
                return True
            else:
                return False
        
        def CancelDlgQuestion(self):
            self.__Cancel()
        
        def __OpenQuestionDialog(self, srcItemPos, dstItemPos):
            if self.interface.IsShowDlgQuestionWindow():
                self.interface.CloseDlgQuestionWindow()
                
            getItemVNum=player.GetItemIndex
            self.srcItemPos = srcItemPos
            self.dstItemPos = dstItemPos
            
            self.dlgQuestion.SetAcceptEvent(ui.__mem_func__(self.__Accept))
            self.dlgQuestion.SetCancelEvent(ui.__mem_func__(self.__Cancel))

            self.dlgQuestion.SetText1("%s" % item.GetItemName(getItemVNum(srcItemPos)) )
            self.dlgQuestion.SetText2(localeInfo.INVENTORY_REALLY_USE_ITEM)

            self.dlgQuestion.Open()
            
        def __Accept(self):
            self.dlgQuestion.Close()
            self.__SendUseItemToItemPacket(self.srcItemPos, self.dstItemPos)
            self.srcItemPos = (0, 0)
            self.dstItemPos = (0, 0)

        def __Cancel(self):
            self.srcItemPos = (0, 0)
            self.dstItemPos = (0, 0)
            self.dlgQuestion.Close()

        def __AddHighlightSlotChangeLook(self, slotIndex):
            if not slotIndex in self.listHighlightedChangeLookSlot:
                self.listHighlightedChangeLookSlot.append(slotIndex)

        def __DelHighlightSlotChangeLook(self, slotIndex):
            if slotIndex in self.listHighlightedChangeLookSlot:
                if slotIndex >= player.INVENTORY_PAGE_SIZE:
                    self.wndItem.DeactivateSlot(slotIndex - (self.inventoryPageIndex * player.INVENTORY_PAGE_SIZE) )
                else:
                    self.wndItem.DeactivateSlot(slotIndex)
                self.listHighlightedChangeLookSlot.remove(slotIndex)
# ********************************************************************** #

    if app.BL_ENABLE_PICKUP_ITEM_EFFECT:

        def ActivateSlot(self, slotindex, type):
            if type == wndMgr.HILIGHTSLOT_MAX:
                return

# ********************************************************************** #
            if app.BL_TRANSMUTATION_SYSTEM:
                if type == wndMgr.HILIGHTSLOT_CHANGE_LOOK:
                    self.__AddHighlightSlotChangeLook(slotindex)
# ********************************************************************** #

        def DeactivateSlot(self, slotindex, type):
            if type == wndMgr.HILIGHTSLOT_MAX:
                return

# ********************************************************************** #
            if app.BL_TRANSMUTATION_SYSTEM:
                if type == wndMgr.HILIGHTSLOT_CHANGE_LOOK:
                    self.__DelHighlightSlotChangeLook(slotindex)
# ********************************************************************** #

        def __HighlightSlot_Refresh(self):
            for i in xrange(self.wndItem.GetSlotCount()):
                slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
                if slotNumber in self.listHighlightedSlot:
                    self.wndItem.ActivateSlot(i)

# ********************************************************************** #
                if app.BL_TRANSMUTATION_SYSTEM:
                    if slotNumber in self.listHighlightedChangeLookSlot:
                        self.wndItem.ActivateSlot(i)
                        self.wndItem.SetSlotDiffuseColor(i, wndMgr.COLOR_TYPE_RED)
# ********************************************************************** #

        def __HighlightSlot_Clear(self):
            for i in xrange(self.wndItem.GetSlotCount()):
                slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
                if slotNumber in self.listHighlightedSlot:
                    self.wndItem.DeactivateSlot(i)
                    self.listHighlightedSlot.remove(slotNumber)

# ********************************************************************** #
                if app.BL_TRANSMUTATION_SYSTEM:
                    if slotNumber in self.listHighlightedChangeLookSlot:
                        self.wndItem.DeactivateSlot(i)
                        self.listHighlightedChangeLookSlot.remove(slotNumber)
# ********************************************************************** #

        def HighlightSlot(self, slot):
            if slot > player.INVENTORY_PAGE_SIZE * player.INVENTORY_PAGE_COUNT:
                return

            if not slot in self.listHighlightedSlot:
                self.listHighlightedSlot.append(slot)

        def DelHighlightSlot(self, inventorylocalslot):
            if inventorylocalslot in self.listHighlightedSlot:
                if inventorylocalslot >= player.INVENTORY_PAGE_SIZE:
                    self.wndItem.DeactivateSlot(
                        inventorylocalslot
                        - (self.inventoryPageIndex * player.INVENTORY_PAGE_SIZE)
                    )
                else:
                    self.wndItem.DeactivateSlot(inventorylocalslot)

                self.listHighlightedSlot.remove(inventorylocalslot)

Thank you very much in advance, best regards

Link to comment
https://metin2.dev/topic/34093-item-stacking-broken-logic-%F0%9F%98%AD/
Share on other sites
  • Replies 0
  • Created
  • Last Reply

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Don't use any images from : imgur, turkmmop, freakgamers, inforge, hizliresim... Or your content will be deleted without notice...
Use : https://metin2.download/media/add/

Please use https://metin2.download/ when uploading files smaller than 100MB, otherwise the approval will take longer due to manual upload.

Please sign in to comment

You will be able to leave a comment after signing in



Sign In Now
 Share
Go to topic listing
×
×
  • Create New...

Important Information

Terms of Use / Privacy Policy / Guidelines / We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.