Files

1643 lines
62 KiB
Python

import ui
import player
import mouseModule
import net
import app
import snd
import item
import player
import safebox
import chat
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommon
#import uiPrivateShopBuilder # 개인상점 열동안 ItemMove 방지
import localeInfo
import constInfo
import ime
import dbg
import wndMgr
import uiToolTip
import game
from uiUtils import Edit2 as Edit2
if app.BL_67_ATTR:
import uiAttr67Add
ITEM_MALL_BUTTON_ENABLE = True
import exception
ITEM_FLAG_APPLICABLE = 1 << 14
if app.ENABLE_SASH_SYSTEM:
import sash
class InventoryWindowNew(ui.ScriptWindow):
liHighlightedItems = []
USE_TYPE_TUPLE = ("USE_SPECIAL", "USE_CLEAN_SOCKET", "USE_CHANGE_ATTRIBUTE", "USE_CHANGE_ATTRIBUTE2", "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", "USE_CHANGE_COSTUME_ATTR", "USE_RESET_COSTUME_ATTR")
UPGRADE_TYPE = 1
BOOK_TYPE = 2
STONE_TYPE = 3
CHANGE_TYPE = 4
COSTUME_TYPE = 5
SAFEBOX_TYPE = 6
MALL_TYPE = 7
SLOT_WINDOW_TYPE = {
UPGRADE_TYPE : {"name": uiScriptLocale.STORAGE_1, "window" : player.UPGRADE_INVENTORY, "slot" : player.SLOT_TYPE_UPGRADE_INVENTORY},
BOOK_TYPE : {"name": uiScriptLocale.STORAGE_2, "window" : player.BOOK_INVENTORY, "slot" : player.SLOT_TYPE_BOOK_INVENTORY},
STONE_TYPE : {"name": uiScriptLocale.STORAGE_3, "window" : player.STONE_INVENTORY, "slot" : player.SLOT_TYPE_STONE_INVENTORY},
CHANGE_TYPE : {"name": uiScriptLocale.STORAGE_4, "window" : player.CHANGE_INVENTORY, "slot" : player.SLOT_TYPE_CHANGE_INVENTORY},
COSTUME_TYPE : {"name": uiScriptLocale.STORAGE_5, "window" : player.COSTUME_INVENTORY, "slot" : player.SLOT_TYPE_COSTUME_INVENTORY},
SAFEBOX_TYPE : {"name": uiScriptLocale.STORAGE_6, "window" : player.RESERVED_WINDOW, "slot" : player.SLOT_TYPE_SAFEBOX},
MALL_TYPE : {"name": uiScriptLocale.STORAGE_7, "window" : player.RESERVED_WINDOW, "slot" : player.SLOT_TYPE_MALL},
}
questionDialog = None
tooltipItem = None
dlgPickMoney = None
sellingSlotNumber = -1
isLoaded = 0
interface = None
#if app.WJ_ENABLE_TRADABLE_ICON:
# bindWnds = []
def __init__(self):
ui.ScriptWindow.__init__(self)
self.categoryPageIndex = 1
self.inventoryPageIndex = 0
self.ChangeEquipIndex = 0
self.rotationImage = 0
self.grid = ui.Grid(width = 5, height = (9*4))
if app.ENABLE_SASH_SYSTEM:
self.listAttachedSashs = []
if app.ENABLE_HIDE_COSTUME_SYSTEM:
self.elemets_hide = []
self.__LoadWindow()
def __del__(self):
ui.ScriptWindow.__del__(self)
def BindInterfaceClass(self, interface):
self.interface = interface
#if app.WJ_ENABLE_TRADABLE_ICON:
# def BindWindow(self, wnd):
# self.bindWnds.append(wnd)
def __LoadWindow(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/InventoryWindowNew.py")
except:
import exception
exception.Abort("InventoryWindow.LoadWindow.LoadObject")
try:
self.wndItem = self.GetChild("ItemSlot")
self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
self.wndBoard = self.GetChild("board")
self.inventory_special = []
for key, data in self.SLOT_WINDOW_TYPE.items():
pointer = self.GetChild("Inventory_Special_%d"%key)
pointer.SetEvent(lambda arg=key: self.SetCategoryPage(arg))
pointer.SetToolTipText(self.SLOT_WINDOW_TYPE[key]["name"])
self.inventory_special.append(pointer)
self.inventory_special[len(self.inventory_special)-1].Hide()#CLOSE MALL BTN
self.GetChild("SeparateButton").SetEvent(self.__CustomeEvent)
self.inventoryTab = []
for i in xrange(player.INVENTORY_PAGE_COUNT):
self.inventoryTab.append(self.GetChild("Inventory_Tab_%02d" % (i+1)))
self.inventoryTab[i].SetEvent(lambda arg=i: self.SetInventoryPage(arg))
self.dlgPickMoney = uiPickMoney.PickMoneyDialog()
self.dlgPickMoney.LoadDialog()
self.dlgPickMoney.Hide()
except:
import exception
exception.Abort("InventoryWindow.LoadWindow.BindObject")
self.wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
self.wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
self.wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
self.wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
self.wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
self.wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
self.lock, self.lock2, u, e = {}, {}, 0, 0
for i in xrange(18):
self.lock[i] = ui.Button()
self.lock[i].SetParent(self.wndItem)
if i >= 9:
self.lock[i].SetPosition(0,0+e)
e+=32
else:
self.lock[i].SetPosition(0,0+u)
self.lock[i].SetUpVisual("d:/ymir work/drakon2/inventory/0.tga")
self.lock[i].SetOverVisual("d:/ymir work/drakon2/inventory/0.tga")
self.lock[i].SetDownVisual("d:/ymir work/drakon2/inventory/0.tga")
self.lock[i].SetEvent(lambda x=i: self.ClickUnlockInventory(x))
self.lock[i].Hide()
u+=32
self.SetInventoryPage(0)
self.SetCategoryPage(1)
self.RefreshStatus()
def GetPageSizeCategory(self):
if self.GetIsCategorySpecial():
return player.SPECIAL_PAGE_SIZE
return player.INVENTORY_PAGE_SIZE
def GetPageCountCategory(self):
if self.GetIsCategorySpecial():
return 4
return player.INVENTORY_PAGE_COUNT
def GetIsCategorySpecial(self):
if self.categoryPageIndex <= 0:
return False
return True
def __CustomeEvent(self):
self.question = uiCommon.QuestionDialog()
self.question.SetCenterPosition()
self.question.SetText(uiScriptLocale.SORT_QUESTION)
self.question.SetAcceptEvent(ui.__mem_func__(self.ClickSort))
self.question.SetCancelEvent(ui.__mem_func__(self.NoOpenInventory))
self.question.SetAcceptText(uiScriptLocale.YES)
self.question.SetCancelText(uiScriptLocale.NO)
self.question.Open()
def ClickSort(self):
category = self.GetCategoryIndex()
if category == 0:
net.SendChatPacket("/click_sort_items")
else:
net.SendChatPacket("/click_sort_special_storage %d"%(category))
self.question.Close()
def ClickUnlockInventory(self, index):
if index > constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())]:
pass
else:
if constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())] <= 18:
self.question = uiCommon.QuestionDialog()
self.question.SetCenterPosition()
self.question.SetText(uiScriptLocale.INVENTORY_UNLOCK % int((constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())]*2)+2))
self.question.SetAcceptEvent(ui.__mem_func__(self.OpenInventory))
self.question.SetCancelEvent(ui.__mem_func__(self.NoOpenInventory))
self.question.SetAcceptText(uiScriptLocale.YES)
self.question.SetCancelText(uiScriptLocale.NO)
self.question.Open()
def OpenInventory(self):
if constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())] <= 18:
net.SendChatPacket("/unlock_inventory %d"%(self.GetCategoryIndex()))
self.question.Close()
def NoOpenInventory(self):
self.question.Close()
def Destroy(self):
self.ClearDictionary()
self.grid.reset()
self.grid = None
self.dlgPickMoney.Destroy()
self.dlgPickMoney = 0
self.tooltipItem = None
self.wndItem = 0
self.questionDialog = None
self.dlgQuestion = None
self.interface = None
#if app.WJ_ENABLE_TRADABLE_ICON:
# self.bindWnds = []
self.inventoryTab = []
self.Hide()
def Hide(self):
if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
self.OnCloseQuestionDialog()
return
if None != self.tooltipItem:
self.tooltipItem.HideToolTip()
if self.dlgPickMoney:
self.dlgPickMoney.Close()
wndMgr.Hide(self.hWnd)
def Close(self):
self.Hide()
if self.categoryPageIndex >= 6:
self.SetCategoryPage(1)#auto move to book inv.
def __InventoryLocalSlotPosToGlobalSlotPos(self, local):
if self.GetIsCategorySpecial():
return self.inventoryPageIndex * player.SPECIAL_PAGE_SIZE + 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 __InventoryLocalSlotPosToGlobalSlotPosWithPage(self, page, local):
if self.GetIsCategorySpecial():
return page * player.SPECIAL_PAGE_SIZE + local
if player.IsEquipmentSlot(local) or player.IsCostumeSlot(local) or (app.ENABLE_NEW_EQUIPMENT_SYSTEM and player.IsBeltInventorySlot(local)):
return local
return page*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
# if not self.wndItem:
# 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)
#
# elif app.BL_67_ATTR and onTopWnd == player.ON_TOP_WND_ATTR_67:
# mark = (not self.interface.IsAttr67RegistItem() and not uiAttr67Add.Attr67AddWindow.CantAttachToAttrSlot(slotNumber, True)) or \
# (self.interface.IsAttr67RegistItem() and not self.interface.IsAttr67SupportItem() and not uiAttr67Add.Attr67AddWindow.IsSupportItem(slotNumber))
#
# if mark:
# 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)
#
# elif app.BL_67_ATTR and onTopWnd == player.ON_TOP_WND_ATTR_67:
# mark = (not self.interface.IsAttr67RegistItem() and not uiAttr67Add.Attr67AddWindow.CantAttachToAttrSlot(slotNumber, True)) or \
# (self.interface.IsAttr67RegistItem() and not self.interface.IsAttr67SupportItem() and not uiAttr67Add.Attr67AddWindow.IsSupportItem(slotNumber))
#
# if mark:
# self.wndItem.SetUnusableSlotOnTopWnd(i)
# else:
# self.wndItem.SetUsableSlotOnTopWnd(i)
def GetCategoryIndex(self):
return self.categoryPageIndex
def SetCategoryPage(self,index):
# old category close!
if self.categoryPageIndex == 6:
net.SendChatPacket("/safebox_close")
elif self.categoryPageIndex == 7:
net.SendChatPacket("/mall_close")
self.categoryPageIndex = index
for i in xrange(len(self.inventory_special)):
self.inventory_special[i].SetUp()
self.inventory_special[index-1].Down()
if index >= 6:
self.SetInventoryPage(0)
for x in xrange(18):
self.lock[x].Hide()
self.ClearSlot()
self.GetChild("loadingImage").Show()
if index == 6:#safebox
net.SendChatPacket("/safebox_password 000000")
elif index == 7:#mall
net.SendChatPacket("/mall_password 000000")
else:
self.wndItem.Show()
self.GetChild("loadingImage").Hide()
for i in xrange(len(self.inventoryTab)):
self.inventoryTab[i].Show()
for x in xrange(18):
self.lock[x].SetUpVisual("d:/ymir work/drakon2/inventory/0.tga")
self.lock[x].SetOverVisual("d:/ymir work/drakon2/inventory/0.tga")
self.lock[x].SetDownVisual("d:/ymir work/drakon2/inventory/0.tga")
self.lock[x].Show()
self.RefreshItemSlot()
def SetInventoryPage(self, page):
self.inventoryPageIndex = page
for i in xrange(len(self.inventoryTab)):
self.inventoryTab[i].SetUp()
self.inventoryTab[page].Down()
if self.categoryPageIndex <= 5:
self.RefreshBagSlotWindow()
elif self.categoryPageIndex == 6:#safebox.
self.RefreshSafebox()
elif self.categoryPageIndex == 7:#mall.
self.RefreshMall()
def ShowWindow(self, size):
if self.categoryPageIndex >= 6:
pageCount = max(1, size / safebox.SAFEBOX_SLOT_Y_COUNT)
pageCount = min(4, pageCount)
self.pagecount = pageCount
for i in xrange(len(self.inventoryTab)):
self.inventoryTab[i].Hide()
if pageCount > len(self.inventoryTab):
pageCount = len(self.inventoryTab)
self.pagecount = pageCount
for j in xrange(pageCount):
self.inventoryTab[j].Show()
self.wndItem.Show()
self.GetChild("loadingImage").Hide()
self.RefreshStatus()
def __LocalPosToGlobalPos(self, local):
return self.inventoryPageIndex*safebox.SAFEBOX_PAGE_SIZE+local
def __LocalPosToGlobalPosWithPage(self, index, local):
return index*safebox.SAFEBOX_PAGE_SIZE+local
def RefreshSafebox(self):
# LoadGrid
self.grid.reset()
for j in xrange(4):
for i in xrange(safebox.SAFEBOX_PAGE_SIZE):
slotIndex = self.__LocalPosToGlobalPosWithPage(j,i)
itemCount = safebox.GetItemCount(slotIndex)
if itemCount == 0:
continue
itemVnum = safebox.GetItemID(slotIndex)
if itemVnum == 0:
continue
item.SelectItem(itemVnum)
(w, h) = item.GetItemSize()
self.grid.put(slotIndex,w, h)
for i in xrange(safebox.SAFEBOX_PAGE_SIZE):
slotIndex = self.__LocalPosToGlobalPos(i)
itemCount = safebox.GetItemCount(slotIndex)
if itemCount <= 1:
itemCount = 0
self.wndItem.SetItemSlot(i, safebox.GetItemID(slotIndex), itemCount)
self.wndItem.DeactivateSlot(i)
self.wndItem.RefreshSlot()
def CommandCloseSafebox(self):
#if need something after close safebox!..
pass
def RefreshMall(self):
for i in xrange(safebox.GetMallSize()):
itemID = safebox.GetMallItemID(i)
itemCount = safebox.GetMallItemCount(i)
if itemCount <= 1:
itemCount = 0
self.wndItem.SetItemSlot(i, itemID, itemCount)
self.wndItem.DeactivateSlot(i)
self.wndItem.RefreshSlot()
def CommandCloseMall(self):
#if need something after close mall!..
pass
def ClearSlot(self):
for i in xrange(self.GetPageSizeCategory()):
self.wndItem.ClearSlot(i)
self.wndItem.Hide()
def RefreshBagSlotWindow(self):
inven_type = self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"]
self.grid.reset()
for j in xrange(4):
for i in xrange(self.GetPageSizeCategory()):
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPosWithPage(j,i)
itemCount = player.GetItemCount(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], slotNumber)
if itemCount == 0:
continue
itemVnum = player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], slotNumber)
if itemVnum == 0:
continue
item.SelectItem(itemVnum)
(w, h) = item.GetItemSize()
self.grid.put(slotNumber,w, h)
for i in xrange(self.GetPageSizeCategory()):
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
itemCount = player.GetItemCount(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], slotNumber)
if 0 == itemCount:
self.wndItem.ClearSlot(i)
continue
elif 1 == itemCount:
itemCount = 0
itemVnum = player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], slotNumber)
self.wndItem.SetItemSlot(i, itemVnum, itemCount)
if itemVnum == 0 and [inven_type,i] in self.liHighlightedItems:
self.liHighlightedItems.remove(slotNumber)
if app.ENABLE_SASH_SYSTEM:
slotNumberChecked = 0
if not constInfo.IS_AUTO_POTION(itemVnum):
self.wndItem.DeactivateSlot(i)
for j in xrange(sash.WINDOW_MAX_MATERIALS):
(isHere, iCell) = sash.GetAttachedItem(j)
if isHere:
if iCell == slotNumber:
self.wndItem.ActivateSlot(i, (36.00 / 255.0), (222.00 / 255.0), (3.00 / 255.0), 1.0)
if not slotNumber in self.listAttachedSashs:
self.listAttachedSashs.append(slotNumber)
slotNumberChecked = 1
else:
if slotNumber in self.listAttachedSashs and not slotNumberChecked:
self.wndItem.DeactivateSlot(i)
self.listAttachedSashs.remove(slotNumber)
#if app.WJ_ENABLE_TRADABLE_ICON:
# self.RefreshMarkSlots(i)
self.__RefreshHighlights()
self.wndItem.RefreshSlot()
#if app.WJ_ENABLE_TRADABLE_ICON:
# map(lambda wnd:wnd.RefreshLockedSlot(), self.bindWnds)
def HighlightSlot(self, inven_type, slot):
if not [inven_type,slot] in self.liHighlightedItems:
self.liHighlightedItems.append([inven_type,slot])
def __RefreshHighlights(self):
inven_type = self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"]
for i in xrange(player.INVENTORY_PAGE_SIZE):
#slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
if [inven_type,i] in self.liHighlightedItems:
self.wndItem.ActivateSlot(i)
def RefreshItemSlot(self):
if self.categoryPageIndex <= 5:
self.RefreshBagSlotWindow()
elif self.categoryPageIndex == 6:#safebox.
self.RefreshSafebox()
elif self.categoryPageIndex == 7:#mall.
self.RefreshMall()
def RefreshStatus(self):
if self.categoryPageIndex <= 5:
self.RefreshBagSlotWindow()
elif self.categoryPageIndex == 6:#safebox.
self.RefreshSafebox()
elif self.categoryPageIndex == 7:#mall.
self.RefreshMall()
def OnUpdate(self):
if self.GetCategoryIndex() >= 6:
image = self.GetChild("loadingImage")
if image.IsShow():
self.rotationImage += 5
image.SetRotation(self.rotationImage)
else:
if constInfo.Inventory_Locked["Active"]:
if constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())] >= 18:
for i in xrange(18):
self.lock[i].Hide()
else:
if self.inventoryPageIndex >= 2:
self.lock[constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())]].SetUpVisual("d:/ymir work/drakon2/inventory/1.tga")
self.lock[constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())]].SetOverVisual("d:/ymir work/drakon2/inventory/1.tga")
self.lock[constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())]].SetDownVisual("d:/ymir work/drakon2/inventory/1.tga")
for i in xrange(9):
self.lock[i].Show()
if constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())] > i:
self.lock[i].Hide()
else:
for i in xrange(9):
self.lock[i].Hide()
if self.inventoryPageIndex == 3:
self.lock[constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())]].SetUpVisual("d:/ymir work/drakon2/inventory/1.tga")
self.lock[constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())]].SetOverVisual("d:/ymir work/drakon2/inventory/1.tga")
self.lock[constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())]].SetDownVisual("d:/ymir work/drakon2/inventory/1.tga")
for i in xrange(9,18):
self.lock[i].Show()
if constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(self.GetCategoryIndex())] > i:
self.lock[i].Hide()
else:
for i in xrange(9,18):
self.lock[i].Hide()
def SetItemToolTip(self, tooltipItem):
self.tooltipItem = tooltipItem
def SellItem(self):
if self.sellingSlotitemIndex == player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],self.sellingSlotNumber):
if self.sellingSlotitemCount == player.GetItemCount(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],self.sellingSlotNumber):
net.SendShopSellPacketNew(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], self.sellingSlotNumber, self.questionDialog.count)
#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 __OpenQuestionDialog(self, srcItemPos, dstItemPos):
self.dlgQuestion = uiCommon.QuestionDialog2()
self.dlgQuestion.SetAcceptEvent(lambda arg=srcItemPos, arg1=dstItemPos : self.__Accept(arg,arg1))
self.dlgQuestion.SetCancelEvent(ui.__mem_func__(self.__Cancel))
self.dlgQuestion.SetText1(localeInfo.DRAGON_SOUL_UNEQUIP_WARNING1)
self.dlgQuestion.SetText2(localeInfo.DRAGON_SOUL_UNEQUIP_WARNING2)
self.dlgQuestion.Open()
def __Accept(self,srcItemPos,dstItemSlotPos):
(attachedInvenType,attachedSlotPos) = srcItemPos
(attachedInvenType1, selectedSlotPos, attachedCount) = dstItemSlotPos
self.__SendMoveItemPacket(attachedInvenType, attachedSlotPos, attachedInvenType1, selectedSlotPos, attachedCount)
self.dlgQuestion.Close()
def __Cancel(self):
self.dlgQuestion.Close()
def SelectEmptySlot(self, selectedSlotPos):
if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
return
if mouseModule.mouseController.isAttached():
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
if self.categoryPageIndex == 6:#safebox.
selectedSlotPos = self.__LocalPosToGlobalPos(selectedSlotPos)
if player.SLOT_TYPE_SAFEBOX == attachedSlotType:
net.SendSafeboxItemMovePacket(attachedSlotPos, selectedSlotPos, 0)
#snd.PlaySound("sound/ui/drop.wav")
else:
attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
if player.RESERVED_WINDOW == attachedInvenType:
return
if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
net.SendSafeboxSaveMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
#snd.PlaySound("sound/ui/money.wav")
else:
net.SendSafeboxCheckinPacket(attachedInvenType, attachedSlotPos, selectedSlotPos)
#snd.PlaySound("sound/ui/drop.wav")
elif self.categoryPageIndex == 7:#mall.
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MALL_CANNOT_INSERT)
else:
selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)
if self.interface:
if self.interface.GetPosChangeItemManual() != -1:
if self.interface.GetPosChangeItemManual() == attachedSlotPos:
mouseModule.mouseController.DeattachObject()
return
slot_type_list = [player.SLOT_TYPE_INVENTORY,player.SLOT_TYPE_UPGRADE_INVENTORY,player.SLOT_TYPE_BOOK_INVENTORY,player.SLOT_TYPE_STONE_INVENTORY,player.SLOT_TYPE_CHANGE_INVENTORY,player.SLOT_TYPE_COSTUME_INVENTORY]
if attachedSlotType in slot_type_list:
attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
itemCount = player.GetItemCount(attachedInvenType,attachedSlotPos)
attachedCount = mouseModule.mouseController.GetAttachedItemCount()
if player.IsDSEquipmentSlot(attachedInvenType, attachedSlotPos):
srcItemPos = (attachedInvenType, attachedSlotPos)
dstItemPos = (self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], selectedSlotPos, attachedCount)
self.__OpenQuestionDialog(srcItemPos, dstItemPos)
else:
self.__SendMoveItemPacket(attachedInvenType, attachedSlotPos, self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], selectedSlotPos, attachedCount)
if item.IsRefineScroll(attachedItemIndex):
self.wndItem.SetUseMode(False)
if player.SLOT_TYPE_CHANGE_EQUIP == attachedSlotType:
attachedCount = mouseModule.mouseController.GetAttachedItemCount()
net.SendItemMovePacket(player.CHANGE_EQUIP, attachedSlotPos, player.INVENTORY, selectedSlotPos, attachedCount)
elif app.ENABLE_SWITCHBOT and player.SLOT_TYPE_SWITCHBOT == attachedSlotType:
attachedCount = mouseModule.mouseController.GetAttachedItemCount()
net.SendItemMovePacket(player.SWITCHBOT, attachedSlotPos, player.INVENTORY, selectedSlotPos, attachedCount)
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, self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], selectedSlotPos)
elif player.SLOT_TYPE_MALL == attachedSlotType:
net.SendMallCheckoutPacket(attachedSlotPos, selectedSlotPos)
mouseModule.mouseController.DeattachObject()
def AttachItemFromInventoryToSpecial(self, slotWindow, slotIndex):
attachedItemID = player.GetItemIndex(slotWindow, slotIndex)
item.SelectItem(attachedItemID)
if item.IsAntiFlag(item.ITEM_ANTIFLAG_SAFEBOX):
return False
(w, h) = item.GetItemSize()
pos = self.grid.find_blank(w, h)
if pos == -1:
return False
self.__SendMoveItemPacket(slotWindow, slotIndex, self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], pos, player.GetItemCount(slotWindow, slotIndex))
return True
def AttachItemFromInventoryToSafebox(self, slotWindow, slotIndex):
attachedItemID = player.GetItemIndex(slotWindow, slotIndex)
item.SelectItem(attachedItemID)
if item.IsAntiFlag(item.ITEM_ANTIFLAG_SAFEBOX):
return False
(w, h) = item.GetItemSize()
pos = self.grid.find_blank(w, h)
if pos == -1:
return False
net.SendSafeboxCheckinPacket(slotWindow, slotIndex, pos)
return True
def SelectItemSlot(self, itemSlotIndex):
if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
return
if self.categoryPageIndex == 6:#safebox.
selectedSlotPos = self.__LocalPosToGlobalPos(itemSlotIndex)
selectedItemID = safebox.GetItemID(selectedSlotPos)
if app.IsPressed(app.DIK_LCONTROL):
if self.interface:
if self.interface.AttachItemFromSafebox(selectedSlotPos, player.INVENTORY, selectedItemID):
return
if mouseModule.mouseController.isAttached():
attachedSlotType = mouseModule.mouseController.GetAttachedType()
if player.SLOT_TYPE_INVENTORY == attachedSlotType:
if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
net.SendSafeboxSaveMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
#snd.PlaySound("sound/ui/money.wav")
else:
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
#net.SendSafeboxCheckinPacket(attachedSlotPos, selectedSlotPos)
#snd.PlaySound("sound/ui/drop.wav")
mouseModule.mouseController.DeattachObject()
else:
curCursorNum = app.GetCursor()
if app.SELL == curCursorNum:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SAFEBOX_SELL_DISABLE_SAFEITEM)
elif app.BUY == curCursorNum:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)
else:
selectedItemID = safebox.GetItemID(selectedSlotPos)
mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_SAFEBOX, selectedSlotPos, selectedItemID)
#snd.PlaySound("sound/ui/pick.wav")
elif self.categoryPageIndex == 7:#mall
if mouseModule.mouseController.isAttached():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MALL_CANNOT_INSERT)
mouseModule.mouseController.DeattachObject()
else:
curCursorNum = app.GetCursor()
selectedItemID = safebox.GetMallItemID(itemSlotIndex)
mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_MALL, itemSlotIndex, selectedItemID)
#snd.PlaySound("sound/ui/pick.wav")
else:
itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)
# import dbg
# dbg.TraceError("Heelo ")
if self.interface:
if self.interface.GetPosChangeItemManual() != -1:
if self.interface.GetPosChangeItemManual() == itemSlotIndex:
return
if app.IsPressed(app.DIK_LCONTROL):
if self.interface and self.interface.AttachSpecialToInv(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], itemSlotIndex):
return
if app.IsPressed(app.DIK_LALT) and app.ENABLE_RENDER_TARGET:
self.interface.OpenRenderTargetWindow(0, player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], itemSlotIndex))
return
if mouseModule.mouseController.isAttached():
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()
if app.ENABLE_SPECIAL_STORAGE:
if player.SLOT_TYPE_INVENTORY == attachedSlotType or player.SLOT_TYPE_STONE_INVENTORY == attachedSlotType or player.SLOT_TYPE_CHANGE_INVENTORY == attachedSlotType or player.SLOT_TYPE_UPGRADE_INVENTORY == attachedSlotType or player.SLOT_TYPE_BOOK_INVENTORY == attachedSlotType or player.SLOT_TYPE_COSTUME_INVENTORY == attachedSlotType:
self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex, attachedSlotType)
else:
if player.SLOT_TYPE_INVENTORY == attachedSlotType:
self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex, attachedSlotType)
mouseModule.mouseController.DeattachObject()
else:
if self.interface:
if self.interface.GetPosChangeItemManual() != -1:
if self.interface.GetPosChangeItemManual() == itemSlotIndex:
return
curCursorNum = app.GetCursor()
if app.SELL == curCursorNum:
self.__SellItem(itemSlotIndex)
elif app.IsPressed(app.DIK_LSHIFT) and app.ENABLE_RENDER_TARGET and self.categoryPageIndex == 5:
self.interface.OpenRenderTargetWindow(0, player.GetItemIndex(itemSlotIndex))
elif app.BUY == curCursorNum:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)
elif app.IsPressed(app.DIK_LALT):
link = player.GetItemLink(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], itemSlotIndex)
ime.PasteString(link)
elif app.IsPressed(app.DIK_LSHIFT):
itemCount = player.GetItemCount(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],itemSlotIndex)
if itemCount > 1:
self.dlgPickMoney.SetTitleName(localeInfo.PICK_ITEM_TITLE)
self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))
self.dlgPickMoney.Open(itemCount)
self.dlgPickMoney.itemGlobalSlotIndex = itemSlotIndex
elif app.IsPressed(app.DIK_LCONTROL):
itemIndex = player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],itemSlotIndex)
if not self.GetIsCategorySpecial():
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(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],itemSlotIndex)
itemCount = player.GetItemCount(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],itemSlotIndex)
mouseModule.mouseController.AttachObject(self, self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["slot"], itemSlotIndex, selectedItemVNum, itemCount)
if self.__IsUsableItemToItem(selectedItemVNum, self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], itemSlotIndex):
self.wndItem.SetUseMode(True)
else:
self.wndItem.SetUseMode(False)
#snd.PlaySound("sound/ui/pick.wav")
def OnPickItem(self, count):
itemSlotIndex = self.dlgPickMoney.itemGlobalSlotIndex
selectedItemVNum = player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],itemSlotIndex)
mouseModule.mouseController.AttachObject(self, self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["slot"], itemSlotIndex, selectedItemVNum, count)
def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos,attachedSlotType):
destItemVnum = player.GetItemIndex(dstItemSlotPos)
item.SelectItem(destItemVnum)
destItemType = item.GetItemType()
destItemSubType = item.GetItemSubType()
if app.ENABLE_SPECIAL_STORAGE:
if srcItemSlotPos == dstItemSlotPos and (attachedSlotType != player.SLOT_TYPE_STONE_INVENTORY and attachedSlotType != player.SLOT_TYPE_CHANGE_INVENTORY):
return
if srcItemSlotPos == dstItemSlotPos and item.IsMetin(srcItemVID) and self.GetIsCategorySpecial() and attachedSlotType == player.SLOT_TYPE_STONE_INVENTORY:
return
if srcItemSlotPos == dstItemSlotPos and (item.GetUseType(srcItemVID) == "USE_CHANGE_ATTRIBUTE" or item.GetUseType(srcItemVID) == "USE_CHANGE_ATTRIBUTE2") and self.GetIsCategorySpecial() and attachedSlotType == player.SLOT_TYPE_CHANGE_INVENTORY:
return
else:
if srcItemSlotPos == dstItemSlotPos:
return
if srcItemVID == 71051 or srcItemVID == 71052 or srcItemVID == 90000:
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
if srcItemVID == 39022 or srcItemVID == 71032 or srcItemVID == 76009:
constInfo.ADDPERCENT = 10
if app.ENABLE_SOULBIND_SYSTEM and item.IsSealScroll(srcItemVID):
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
elif item.IsRefineScroll(srcItemVID):
return
self.RefineItem(srcItemSlotPos, dstItemSlotPos)
self.wndItem.SetUseMode(False)
elif item.IsMetin(srcItemVID):
self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)
elif destItemType == item.ITEM_TYPE_PET and destItemSubType == item.PET_LEVELABLE:
if srcItemVID == 55008:
self.interface.OpenChangeNameWindow(srcItemSlotPos,dstItemSlotPos,destItemVnum, 1)
elif srcItemVID == 72325:
self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)
elif (srcItemVID == 55001 or srcItemVID == 55033 or (srcItemVID >= 55010 and srcItemVID <= 55031)):
self.questionDialog = uiCommon.QuestionDialog()
if 55001 == srcItemVID:
self.questionDialog.SetText(localeInfo.PET_PROTEIN_QUESTION_TEXT)
elif 55033 == srcItemVID:
self.questionDialog.SetText(localeInfo.PET_REMOVE_QUESTION_TEXT)
else:
self.questionDialog.SetText(localeInfo.INVENTORY_REALLY_USE_ITEM % item.GetItemName())
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnAccept))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnCancel))
self.questionDialog.Open()
self.questionDialog.srcItemSlotPos = srcItemSlotPos
self.questionDialog.dstItemSlotPos = dstItemSlotPos
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
elif item.IsDetachScroll(srcItemVID):
self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)
elif app.ELEMENT_SPELL_WORLDARD and item.IsElement(srcItemVID):
self.ElementItem(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, srcItemVID, attachedSlotType)
else:
if player.IsEquipmentSlot(dstItemSlotPos):
if item.IsEquipmentVID(srcItemVID):
self.__UseItem(srcItemSlotPos)
else:
net.SendItemMovePacket(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], srcItemSlotPos, self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], dstItemSlotPos, 0)
def __SellItem(self, itemSlotPos):
if not player.IsEquipmentSlot(itemSlotPos):
self.sellingSlotNumber = itemSlotPos
itemIndex = player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],itemSlotPos)
itemCount = player.GetItemCount(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],itemSlotPos)
self.sellingSlotitemIndex = itemIndex
self.sellingSlotitemCount = itemCount
item.SelectItem(itemIndex)
## 안티 플레그 검사 빠져서 추가
## 20140220
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
itemPrice = itemCount / itemPrice
else:
#itemPrice = itemPrice * itemCount / 5
itemPrice = itemPrice * itemCount
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
if app.ELEMENT_SPELL_WORLDARD:
def ElementItem(self, srcItemSlotPos,dstItemSlotPos):
itemElement = player.GetItemIndex(srcItemSlotPos)
if player.ELEMENT_UPGRADE_CANT_ADD == player.GetElements(itemElement,dstItemSlotPos) or\
player.ELEMENT_DOWNGRADE_CANT_ADD == player.GetElements(itemElement,dstItemSlotPos) or\
player.ELEMENT_CANT_WORLDARD == player.GetElements(itemElement,dstItemSlotPos) or\
player.ELEMENT_CHANGE_CANT_ADD == player.GetElements(itemElement,dstItemSlotPos):
chat.AppendChat(chat.CHAT_TYPE_INFO, "No se puede realizar esta funcion.")
return
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
def RefineItem(self, scrollSlotPos, targetSlotPos):
scrollIndex = player.GetItemIndex(scrollSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)
if app.ENABLE_MULTI_REFINE_WORLDARD:
if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos) and self.CheckVnumMultiRefine(targetIndex) == False:
return
else:
if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos):
return
if app.ENABLE_REFINE_RENEWAL:
constInfo.AUTO_REFINE_TYPE = 1
constInfo.AUTO_REFINE_DATA["ITEM"][0] = scrollSlotPos
constInfo.AUTO_REFINE_DATA["ITEM"][1] = targetSlotPos
###########################################################
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, localeInfo.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, localeInfo.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, localeInfo.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, 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 app.ENABLE_SASH_SYSTEM:
if not player.CanDetach(scrollIndex, targetSlotPos):
item.SelectItem(scrollIndex)
if item.GetValue(0) == sash.CLEAN_ATTR_VALUE0:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SASH_FAILURE_CLEAN)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)
return
else:
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)
if app.ENABLE_SASH_SYSTEM:
item.SelectItem(targetIndex)
if item.GetItemType() == item.ITEM_TYPE_COSTUME and item.GetItemSubType() == item.COSTUME_TYPE_SASH:
item.SelectItem(scrollIndex)
if item.GetValue(0) == sash.CLEAN_ATTR_VALUE0:
self.questionDialog.SetText(localeInfo.SASH_DO_YOU_CLEAN)
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):
return#special-inv bug
if app.ENABLE_SPECIAL_STORAGE:
metinIndex = player.GetItemIndex(player.STONE_INVENTORY, metinSlotPos)
else:
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):
if self.categoryPageIndex == 6:#safebox.
self.wndItem.SetUsableItem(False)
slotIndex = self.__LocalPosToGlobalPos(overSlotPos)
if self.tooltipItem:
self.tooltipItem.SetSafeBoxItem(slotIndex)
elif self.categoryPageIndex == 7:#mall.
if self.tooltipItem:
self.tooltipItem.SetMallItem(overSlotPos)
else:
overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
self.wndItem.SetUsableItem(False)
inven_type = self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"]
if [inven_type, overSlotPosGlobal] in self.liHighlightedItems:
self.liHighlightedItems.remove([inven_type, overSlotPosGlobal])
self.wndItem.DeactivateSlot(overSlotPosGlobal)
if mouseModule.mouseController.isAttached():
attachedItemType = mouseModule.mouseController.GetAttachedType()
if app.ENABLE_SPECIAL_STORAGE:
if player.SLOT_TYPE_INVENTORY == attachedItemType or player.SLOT_TYPE_STONE_INVENTORY == attachedItemType or player.SLOT_TYPE_CHANGE_INVENTORY == attachedItemType or player.SLOT_TYPE_COSTUME_INVENTORY == attachedItemType:
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()
if self.__CanUseSrcItemToDstItem(attachedItemVNum, player.SlotTypeToInvenType(attachedSlotType), attachedSlotPos, overSlotPos):
self.wndItem.SetUsableItem(True)
self.wndItem.SetUseMode(True)
self.ShowToolTip(overSlotPos)
return
else:
if player.SLOT_TYPE_INVENTORY == attachedItemType:
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()
if self.__CanUseSrcItemToDstItem(attachedItemVNum, player.SlotTypeToInvenType(attachedSlotType), attachedSlotPos, overSlotPos):
self.wndItem.SetUsableItem(True)
self.ShowToolTip(overSlotPos)
return
self.ShowToolTip(overSlotPosGlobal)
def __IsUsableItemToItem(self, srcItemVNum, srcSlotType, srcSlotPos):
"다른 아이템에 사용할 수 있는 아이템인가?"
if item.IsRefineScroll(srcItemVNum):
return False
elif app.ENABLE_SOULBIND_SYSTEM and (item.IsSealScroll(srcItemVNum) or item.IsUnSealScroll(srcItemVNum)):
return True
elif item.IsMetin(srcItemVNum):
return True
elif item.IsDetachScroll(srcItemVNum):
return True
if srcItemVNum >= 55701 and srcItemVNum <= 55704:
return True
if srcItemVNum == 71051 or srcItemVNum == 71052 or srcItemVNum == 90000:
return True
if srcItemVNum == 55001:
return True
elif item.IsKey(srcItemVNum):
return True
elif srcItemVNum >= 55701 and srcItemVNum <= 55715:
return TRUE
elif srcItemVNum == 55008:
return TRUE
elif srcItemVNum == 55001:
return TRUE
elif srcItemVNum == 55033:
return TRUE
elif srcItemVNum >= 55101 and srcItemVNum <= 55121:
return TRUE
elif srcItemVNum >= 55010 and srcItemVNum <= 55031:
return TRUE
elif app.ELEMENT_SPELL_WORLDARD and item.IsElement(srcItemVNum):
return True
elif (player.GetItemFlags(srcSlotType, 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, srcSlotType, srcSlotPos, dstSlotPos):
item.SelectItem(player.GetItemIndex(dstSlotPos))
destItemType = item.GetItemType()
destItemSubType = item.GetItemSubType()
if app.ENABLE_SPECIAL_STORAGE:
#if srcSlotPos == dstSlotPos and not item.IsMetin(srcItemVNum):
if srcSlotPos == dstSlotPos and (not item.IsMetin(srcItemVNum) and (item.GetUseType(srcItemVNum) != "USE_CHANGE_ATTRIBUTE" or item.GetUseType(srcItemVNum) != "USE_CHANGE_ATTRIBUTE2")):
return False
if item.IsMetin(srcItemVNum):
return True
else:
if srcSlotPos == dstSlotPos:
return False
if srcItemVNum >= 55701 and srcItemVNum <= 55704 and player.GetItemIndex(dstSlotPos) == 55002:
return True
if srcItemVNum == 55001 and player.GetItemIndex(dstSlotPos) >= 55701 and player.GetItemIndex(dstSlotPos) <= 55704:
return True
if srcItemVNum == 71051 or srcItemVNum == 71052 or srcItemVNum == 90000:
return True
dstItemVNum = player.GetItemIndex(dstSlotPos)
if item.IsRefineScroll(srcItemVNum):
if app.ENABLE_MULTI_REFINE_WORLDARD:
if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos) or self.CheckVnumMultiRefine(dstItemVNum) == True:
return True
else:
if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):
return True
elif destItemType == item.ITEM_TYPE_PET and destItemSubType == item.PET_LEVELABLE:
if srcItemVNum == 55008:
return TRUE
elif srcItemVNum == 55001:
return TRUE
elif srcItemVNum == 55033:
return TRUE
elif srcItemVNum >= 55101 and srcItemVNum <= 55121:
return TRUE
elif srcItemVNum >= 55010 and srcItemVNum <= 55031:
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 app.ENABLE_SOULBIND_SYSTEM and item.IsSealScroll(srcItemVNum):
if (item.IsSealScroll(srcItemVNum) and player.CanSealItem(dstSlotPos)) or (item.IsUnSealScroll(srcItemVNum) and player.CanUnSealItem(dstSlotPos)):
return True
elif app.ELEMENT_SPELL_WORLDARD and item.IsElement(srcItemVNum):
if player.ELEMENT_UPGRADE_ADD == player.GetElements(srcItemVNum, dstSlotPos) or\
player.ELEMENT_DOWNGRADE_ADD == player.GetElements(srcItemVNum, dstSlotPos) or\
player.ELEMENT_CHANGE_ADD == player.GetElements(srcItemVNum, dstSlotPos):
return True
elif (player.GetItemFlags(srcSlotType, 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,srcItemVNum):
return True
elif app.BL_67_ATTR and "USE_CHANGE_ATTRIBUTE2" == useType:
if self.__CanChangeItemAttrList2(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;
elif "USE_PUT_INTO_BELT_SOCKET" == useType:
dstItemVNum = player.GetItemIndex(dstSlotPos)
print "USE_PUT_INTO_BELT_SOCKET", srcItemVNum, dstItemVNum
item.SelectItem(dstItemVNum)
if item.ITEM_TYPE_BELT == item.GetItemType():
return True
elif "USE_CHANGE_COSTUME_ATTR" == useType:
if self.__CanChangeCostumeAttrList(dstSlotPos):
return True
elif "USE_RESET_COSTUME_ATTR" == useType:
if self.__CanResetCostumeAttr(dstSlotPos):
return True
return False
if app.ENABLE_MULTI_REFINE_WORLDARD:
def CheckVnumMultiRefine(self,vnum):
if len(constInfo.multi_refine_dates) != 0:
for i in constInfo.multi_refine_dates:
if i == vnum:
return True
return False
def __CanCleanBrokenMetinStone(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], 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
if app.BL_67_ATTR:
def __CanChangeItemAttrList2(self, dstSlotPos):
return uiAttr67Add.Attr67AddWindow.CantAttachToAttrSlot(dstSlotPos, False)
def __CanChangeItemAttrList(self, dstSlotPos, srcItemVNum):
dstItemVNum = player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],dstSlotPos)
if dstItemVNum == 0:
return False
item.SelectItem(dstItemVNum)
if item.GetItemType() == item.ITEM_TYPE_DS and srcItemVNum != 71097:
return False
elif srcItemVNum == 71097 and item.GetItemType() != item.ITEM_TYPE_DS:
return False
elif not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR, item.ITEM_TYPE_RINGS) and srcItemVNum != 71097:
return False
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemAttribute(dstSlotPos, i) != 0:
return True
return False
def __CanChangeCostumeAttrList(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False
item.SelectItem(dstItemVNum)
if item.GetItemType() != item.ITEM_TYPE_COSTUME:
return False
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemAttribute(dstSlotPos, i) != 0:
return True
return False
def __CanResetCostumeAttr(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False
item.SelectItem(dstItemVNum)
if item.GetItemType() != item.ITEM_TYPE_COSTUME:
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 and item.GetItemType() != item.ITEM_TYPE_RINGS:
return False
if item.GetItemType() == item.ITEM_TYPE_ARMOR:
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)
type = item.GetItemSubType()
if item.GetItemType() == item.ITEM_TYPE_RINGS:
type = item.GetItemType()
if mtrlVnum != constInfo.GET_ACCESSORY_MATERIAL_VNUM(dstItemVNum, type):
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 and item.GetItemType() != item.ITEM_TYPE_RINGS:
return False
if item.GetItemType() == item.ITEM_TYPE_ARMOR:
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(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],dstSlotPos)
if dstItemVNum == 0:
return False
item.SelectItem(dstItemVNum)
if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR, item.ITEM_TYPE_RINGS):
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, self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"])
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 self.interface:
if self.interface.GetPosChangeItemManual() != -1:
if self.interface.GetPosChangeItemManual() == slotIndex:
return
if app.ENABLE_SASH_SYSTEM:
if self.isShowSashWindow():
sash.Add(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], slotIndex, 255)
return
self.__UseItem(slotIndex)
mouseModule.mouseController.DeattachObject()
self.OverOutItem()
def __GetCurrentItemGrid(self):
itemGrid = [[False for slot in xrange(self.GetPageSizeCategory())] for page in xrange(self.GetPageCountCategory())]
for page in xrange(self.GetPageCountCategory()):
for slot in xrange(self.GetPageSizeCategory()):
itemVnum = player.GetItemIndex(slot + page * self.GetPageSizeCategory())
if itemVnum <> 0:
(w, h) = item.GetItemSize(item.SelectItem(itemVnum))
for i in xrange(h):
itemGrid[page][slot + i * 5] = True
return itemGrid
def __FindEmptyCellForSize(self, itemGrid, size):
for page in xrange(self.GetPageCountCategory()):
for slot in xrange(self.GetPageSizeCategory()):
if itemGrid[page][slot] == False:
possible = True
for i in xrange(size):
p = slot + (i * 5)
try:
if itemGrid[page][p] == True:
possible = False
break
except IndexError:
possible = False
break
if possible:
return slot + page * self.GetPageSizeCategory()
return -1
def AttachItemFromSafebox(self, slotIndex, item_type, itemIndex):
itemGrid = self.__GetCurrentItemGrid()
if item.GetItemType(item.SelectItem(itemIndex)) == item.ITEM_TYPE_DS:
return
emptySlotIndex = self.__FindEmptyCellForSize(itemGrid, item.GetItemSize()[1])
if emptySlotIndex <> -1:
net.SendSafeboxCheckoutPacket(slotIndex, item_type, emptySlotIndex)
return True
def __UseItem(self, slotIndex):
ItemVNum = player.GetItemIndex(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],slotIndex)
item.SelectItem(ItemVNum)
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)
elif app.ENABLE_SHOW_CHEST_DROP and item.GetItemType() == item.ITEM_TYPE_GIFTBOX and app.IsPressed(app.DIK_LCONTROL):
if app.IsPressed(app.DIK_Z):
net.SendChatPacket("/chest_drop %d %d %d"%(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], slotIndex,player.GetItemCount(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"], slotIndex)))
else:
if self.interface:
self.interface.OpenChestDropWindow(ItemVNum,self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],slotIndex)
return
else:
if app.ENABLE_NEW_PET_SYSTEM and item.GetItemType() == item.ITEM_TYPE_PET and item.GetItemSubType() == item.PET_EGG:
self.interface.OpenChangeNameWindow(slotIndex,slotIndex,ItemVNum, 2)
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, srcItemVID = -1, srcInvType = -1):
#if srcItemVID != -1:
# if item.GetUseType(srcItemVID) == "USE_CHANGE_ATTRIBUTE" or item.GetUseType(srcItemVID) == "USE_CHANGE_ATTRIBUTE2":
# net.SendItemUseToItemPacket(player.CHANGE_INVENTORY, srcSlotPos, player.INVENTORY, dstSlotPos)
# return
if srcInvType != -1:
net.SendItemUseToItemPacket(player.SlotTypeToInvenType(srcInvType),srcSlotPos,self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],dstSlotPos)
else:
net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)
def __SendUseItemPacket(self, slotPos):
net.SendItemUsePacket(self.SLOT_WINDOW_TYPE[self.categoryPageIndex]["window"],slotPos)
def __SendMoveItemPacket(self, srcSlotWindow, srcSlotPos, dstSlotWindow, dstSlotPos, srcItemCount):
net.SendItemMovePacket(srcSlotWindow , srcSlotPos, dstSlotWindow, dstSlotPos, srcItemCount)
if app.ENABLE_SASH_SYSTEM:
def SetSashWindow(self, wndSashCombine, wndSashAbsorption):
self.wndSashCombine = wndSashCombine
self.wndSashAbsorption = wndSashAbsorption
def isShowSashWindow(self):
if self.wndSashCombine:
if self.wndSashCombine.IsShow():
return 1
if self.wndSashAbsorption:
if self.wndSashAbsorption.IsShow():
return 1
return 0