antiblock
Elveron

  • Chatbox

    Did you check out our Discord? https://discord.gg/FFdvMjk9xA
    You don't have permission to chat.
    Load More
  • 0
Sign in to follow this  
Followers 0
Batman64

Tabela Bonus Ajuda Aquie

Asked by Batman64,

Question

Batman64    3

Batman64
Posted

a galera to com essa tabela bonus no cliente >>  http://i.imgur.com/McWn2CY.png queria tirar ela fora,  ou por nos stattus  alguem sabe quias pasta ta essa tabela. 

Share this post

Link to post
Share on other sites

4 answers to this question

  • 0

Batman64    3

Batman64
Posted

Alguém?-

Share this post

Link to post
Share on other sites
antiblock
diamwall
  • 0

Batman64    3

Batman64
Posted

Uiinventory vê se está lá algo

import ui
import player
import mouseModule
import net
import app
import snd
import item
import player
import chat
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommon
import uiPrivateShopBuilder # °³ÀλóÁ¡ ¿­µ¿¾È ItemMove ¹æÁö
import locale
import constInfo
import ime
 
 
ITEM_MALL_BUTTON_ENABLE = TRUE
 
 
 
ITEM_FLAG_APPLICABLE = 1 << 14
 
class CostumeWindow(ui.ScriptWindow):
 
def __init__(self, wndInventory):
import exception
 
if not app.ENABLE_COSTUME_SYSTEM:
exception.Abort("O que você faz?")
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)
 
self.wndEquip.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")
 
def __init__(self):
ui.ScriptWindow.__init__(self)
self.questionDialog = None
self.tooltipItem = None
self.sellingSlotNumber = -1
self.isLoaded = 0
self.isOpenedCostumeWindowWhenClosingInventory = 0 # Àκ¥Å丮 ´ÝÀ» ¶§ ÄÚ½ºÃõÀÌ ¿­·ÁÀÖ¾ú´ÂÁö ¿©ºÎ-_-; ³×ÀÌ¹Ö ¤¸¤µ
 
self.__LoadWindow()
 
def __del__(self):
ui.ScriptWindow.__del__(self)
 
def Show(self):
self.__LoadWindow()
 
ui.ScriptWindow.Show(self)
 
# Àκ¥Å丮¸¦ ´ÝÀ» ¶§ ÄÚ½ºÃõÀÌ ¿­·ÁÀÖ¾ú´Ù¸é Àκ¥Å丮¸¦ ¿­ ¶§ ÄÚ½ºÃõµµ °°ÀÌ ¿­µµ·Ï ÇÔ.
if self.isOpenedCostumeWindowWhenClosingInventory and self.wndCostume:
self.wndCostume.Show() 
 
def __LoadWindow(self):
if self.isLoaded == 1:
return
 
self.isLoaded = 1
 
try:
pyScrLoader = ui.PythonScriptLoader()
 
if ITEM_MALL_BUTTON_ENABLE:
pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "InventoryWindow.py")
else:
pyScrLoader.LoadScriptFile(self, "UIScript/InventoryWindow.py")
except:
import exception
exception.Abort("InventoryWindow.LoadWindow.LoadObject")
 
try:
wndItem = self.GetChild("ItemSlot")
wndEquip = self.GetChild("EquipmentSlot")
self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
self.wndMoney = self.GetChild("Money")
self.wndMoneySlot = self.GetChild("Money_Slot")
self.mallButton = self.GetChild2("MallButton")
self.GetChild("Kard_def_Value").SetText(str(player.GetStatus(69)))
self.GetChild("Ketkezes_def_Value").SetText(str(player.GetStatus(70)))
self.GetChild("Tor_def_Value").SetText(str(player.GetStatus(71)))
self.GetChild("Nyil_def_Value").SetText(str(player.GetStatus(74)))
self.GetChild("Harang_def_Value").SetText(str(player.GetStatus(72)))
self.GetChild("Legyezo_def_Value").SetText(str(player.GetStatus(73)))
self.GetChild("Magia_def_Value").SetText(str(player.GetStatus(77)))
self.GetChild("Mereg_def_Value").SetText(str(player.GetStatus(81)))
self.GetChild("Harcos_def_Value").SetText(str(player.GetStatus(59)))
self.GetChild("Nindzsa_def_Value").SetText(str(player.GetStatus(60)))
self.GetChild("Sura_def_Value").SetText(str(player.GetStatus(61)))
self.GetChild("Saman_def_Value").SetText(str(player.GetStatus(62)))
self.GetChild("Krit_Value").SetText(str(player.GetStatus(40)))
self.GetChild("Athato_Value").SetText(str(player.GetStatus(41)))
self.GetChild("Atlagkar_Value").SetText(str(player.GetStatus(122)))
self.GetChild("Keszsegkar_Value").SetText(str(player.GetStatus(121)))
self.GetChild("Felember_Value").SetText(str(player.GetStatus(43)))
self.GetChild("Nemhalott_Value").SetText(str(player.GetStatus(47)))
self.GetChild("Ordog_Value").SetText(str(player.GetStatus(48)))
self.GetChild("Szorny_str_Value").SetText(str(player.GetStatus(53)))
self.GetChild("Harcos_str_Value").SetText(str(player.GetStatus(54)))
self.GetChild("Nindzsa_str_Value").SetText(str(player.GetStatus(55)))
self.GetChild("Sura_str_Value").SetText(str(player.GetStatus(56)))
self.GetChild("Saman_str_Value").SetText(str(player.GetStatus(57)))
self.costumeButton = self.GetChild2("CostumeButton")
 
self.inventoryTab = []
self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))
self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))
 
self.equipmentTab = []
self.equipmentTab.append(self.GetChild("Equipment_Tab_01"))
self.equipmentTab.append(self.GetChild("Equipment_Tab_02"))
 
if self.costumeButton and not app.ENABLE_COSTUME_SYSTEM:
self.costumeButton.Hide()
self.costumeButton.Destroy()
self.costumeButton = 0
 
except:
import exception
exception.Abort("InventoryWindow.LoadWindow.BindObject")
 
## Item
wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
 
## Equipment
wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
 
## PickMoneyDialog
dlgPickMoney = uiPickMoney.PickMoneyDialog()
dlgPickMoney.LoadDialog()
dlgPickMoney.Hide()
 
## RefineDialog
self.refineDialog = uiRefine.RefineDialog()
self.refineDialog.Hide()
 
## AttachMetinDialog
self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()
self.attachMetinDialog.Hide()
 
## MoneySlot
self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))
 
self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))
self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))
self.inventoryTab[0].Down()
 
self.equipmentTab[0].SetEvent(lambda arg=0: self.SetEquipmentPage(arg))
self.equipmentTab[1].SetEvent(lambda arg=1: self.SetEquipmentPage(arg))
self.equipmentTab[0].Down()
self.equipmentTab[0].Hide()
self.equipmentTab[1].Hide()
 
self.wndItem = wndItem
self.wndEquip = wndEquip
self.dlgPickMoney = dlgPickMoney
 
# MallButton
if self.mallButton:
self.mallButton.SetEvent(ui.__mem_func__(self.ClickMallButton))
        
# Costume Button
if self.costumeButton:
self.costumeButton.SetEvent(ui.__mem_func__(self.ClickCostumeButton))
 
self.wndCostume = None
 
  #####
 
## Refresh
self.SetInventoryPage(0)
self.SetEquipmentPage(0)
self.RefreshItemSlot()
self.RefreshStatus()
self.RefreshBonus()
 
def Destroy(self):
self.ClearDictionary()
 
self.dlgPickMoney.Destroy()
self.dlgPickMoney = 0
 
self.refineDialog.Destroy()
self.refineDialog = 0
 
self.attachMetinDialog.Destroy()
self.attachMetinDialog = 0
 
self.tooltipItem = None
self.wndItem = 0
self.wndEquip = 0
self.dlgPickMoney = 0
self.wndMoney = 0
self.wndMoneySlot = 0
self.questionDialog = None
self.mallButton = None
 
if self.wndCostume:
self.wndCostume.Destroy()
self.wndCostume = 0
 
self.inventoryTab = []
self.equipmentTab = []
 
def Close(self):
if None != self.tooltipItem:
self.tooltipItem.HideToolTip()
 
if self.wndCostume:
self.isOpenedCostumeWindowWhenClosingInventory = self.wndCostume.IsShow() # Àκ¥Å丮 âÀÌ ´ÝÈú ¶§ ÄÚ½ºÃõÀÌ ¿­·Á ÀÖ¾ú´Â°¡?
self.wndCostume.Close()
 
self.OnCloseQuestionDialog()
self.dlgPickMoney.Close()
self.Hide()
 
def SetInventoryPage(self, page):
self.inventoryPageIndex = page
self.inventoryTab[1-page].SetUp()
self.RefreshBagSlotWindow()
 
def SetEquipmentPage(self, page):
self.equipmentPageIndex = page
self.equipmentTab[1-page].SetUp()
self.RefreshEquipSlotWindow()
 
def ClickMallButton(self):
print "click_mall_button"
net.SendChatPacket("/click_mall")
 
def ClickCostumeButton(self):
print "Click Costume Button"
if self.wndCostume:
if self.wndCostume.IsShow(): 
self.wndCostume.Hide()
else:
self.wndCostume.Show()
else:
self.wndCostume = CostumeWindow(self)
self.wndCostume.Show()
 
def OpenPickMoneyDialog(self):
 
if mouseModule.mouseController.isAttached():
 
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
if player.SLOT_TYPE_SAFEBOX == mouseModule.mouseController.GetAttachedType():
 
if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")
 
mouseModule.mouseController.DeattachObject()
 
else:
curMoney = player.GetElk()
 
if curMoney <= 0:
return
 
self.dlgPickMoney.SetTitleName(locale.PICK_MONEY_TITLE)
self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
self.dlgPickMoney.Open(curMoney)
self.dlgPickMoney.SetMax(7) # Àκ¥Å丮 990000 Á¦ÇÑ ¹ö±× ¼öÁ¤
 
def OnPickMoney(self, money):
mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)
 
def OnPickItem(self, count):
itemSlotIndex = self.dlgPickMoney.itemGlobalSlotIndex
selectedItemVNum = player.GetItemIndex(itemSlotIndex)
mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, count)
 
def __InventoryLocalSlotPosToGlobalSlotPos(self, local):
 
if player.IsEquipmentSlot(local) or player.IsCostumeSlot(local):
return local
 
return self.inventoryPageIndex*player.INVENTORY_PAGE_SIZE + local
 
def __LoadRefreshBonus(self):
self.RefreshBonus()
 
def RefreshBonus(self):
try:
##BonusPageDialog
self.GetChild("Kard_def_Value").SetText(str(player.GetStatus(69)))
self.GetChild("Ketkezes_def_Value").SetText(str(player.GetStatus(70)))
self.GetChild("Tor_def_Value").SetText(str(player.GetStatus(71)))
self.GetChild("Nyil_def_Value").SetText(str(player.GetStatus(74)))
self.GetChild("Harang_def_Value").SetText(str(player.GetStatus(72)))
self.GetChild("Legyezo_def_Value").SetText(str(player.GetStatus(73)))
self.GetChild("Magia_def_Value").SetText(str(player.GetStatus(77)))
self.GetChild("Mereg_def_Value").SetText(str(player.GetStatus(81)))
self.GetChild("Harcos_def_Value").SetText(str(player.GetStatus(59)))
self.GetChild("Nindzsa_def_Value").SetText(str(player.GetStatus(60)))
self.GetChild("Sura_def_Value").SetText(str(player.GetStatus(61)))
self.GetChild("Saman_def_Value").SetText(str(player.GetStatus(62)))
self.GetChild("Krit_Value").SetText(str(player.GetStatus(40)))
self.GetChild("Athato_Value").SetText(str(player.GetStatus(41)))
self.GetChild("Atlagkar_Value").SetText(str(player.GetStatus(122)))
self.GetChild("Keszsegkar_Value").SetText(str(player.GetStatus(121)))
self.GetChild("Felember_Value").SetText(str(player.GetStatus(43)))
self.GetChild("Nemhalott_Value").SetText(str(player.GetStatus(47)))
self.GetChild("Ordog_Value").SetText(str(player.GetStatus(48)))
self.GetChild("Szorny_str_Value").SetText(str(player.GetStatus(53)))
self.GetChild("Harcos_str_Value").SetText(str(player.GetStatus(54)))
self.GetChild("Nindzsa_str_Value").SetText(str(player.GetStatus(55)))
self.GetChild("Sura_str_Value").SetText(str(player.GetStatus(56)))
self.GetChild("Saman_str_Value").SetText(str(player.GetStatus(57)))
except:
import exception
exception.Abort("InventoryWindow.RefreshBonus.BindObject")
 
def RefreshBagSlotWindow(self):
getItemVNum=player.GetItemIndex
getItemCount=player.GetItemCount
setItemVNum=self.wndItem.SetItemSlot
 
for i in xrange(player.INVENTORY_PAGE_SIZE):
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
itemCount = getItemCount(slotNumber)
if itemCount <= 1:
itemCount = 0
 
itemVnum = getItemVNum(slotNumber)
setItemVNum(i, itemVnum, itemCount)
 
## ÀÚµ¿¹°¾à (HP: #72723 ~ #72726, SP: #72727 ~ #72730) Ư¼öó¸® - ¾ÆÀÌÅÛÀε¥µµ ½½·Ô¿¡ È°¼ºÈ­/ºñÈ°¼ºÈ­ Ç¥½Ã¸¦ À§ÇÑ ÀÛ¾÷ÀÓ - [hyo]
if constInfo.IS_AUTO_POTION(itemVnum):
# metinSocket - [0] : È°¼ºÈ­ ¿©ºÎ, [1] : »ç¿ëÇÑ ¾ç, [2] : ÃÖ´ë ¿ë·®
metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]
 
if slotNumber >= player.INVENTORY_PAGE_SIZE:
slotNumber -= player.INVENTORY_PAGE_SIZE
 
isActivated = 0 != metinSocket[0]
 
if isActivated:
self.wndItem.ActivateSlot(slotNumber)
potionType = 0;
if constInfo.IS_AUTO_POTION_HP(itemVnum):
potionType = player.AUTO_POTION_TYPE_HP
elif constInfo.IS_AUTO_POTION_SP(itemVnum):
potionType = player.AUTO_POTION_TYPE_SP
 
usedAmount = int(metinSocket[1])
totalAmount = int(metinSocket[2])
player.SetAutoPotionInfo(potionType, isActivated, (totalAmount - usedAmount), totalAmount, self.__InventoryLocalSlotPosToGlobalSlotPos(i))
 
else:
self.wndItem.DeactivateSlot(slotNumber)
 
self.wndItem.RefreshSlot()
 
def RefreshEquipSlotWindow(self):
getItemVNum=player.GetItemIndex
getItemCount=player.GetItemCount
setItemVNum=self.wndEquip.SetItemSlot
for i in xrange(player.EQUIPMENT_PAGE_COUNT):
slotNumber = player.EQUIPMENT_SLOT_START + i
itemCount = getItemCount(slotNumber)
if itemCount <= 1:
itemCount = 0
setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)
 
self.wndEquip.RefreshSlot()
 
if self.wndCostume:
self.wndCostume.RefreshCostumeSlot()
 
def RefreshItemSlot(self):
self.RefreshBagSlotWindow()
self.RefreshEquipSlotWindow()
 
def RefreshStatus(self):
money = player.GetElk()
self.wndMoney.SetText(locale.NumberToMoneyString(money))
 
def SetItemToolTip(self, tooltipItem):
self.tooltipItem = tooltipItem
 
def SellItem(self):
 
net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count)
snd.PlaySound("sound/ui/money.wav")
self.OnCloseQuestionDialog()
 
def OnDetachMetinFromItem(self):
if None == self.questionDialog:
return
 
#net.SendItemUseToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)
self.__SendUseItemToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)
self.OnCloseQuestionDialog()
 
def OnCloseQuestionDialog(self):
if self.questionDialog:
self.questionDialog.Close()
 
self.questionDialog = None
 
## Slot Event
def SelectEmptySlot(self, selectedSlotPos):
if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:
return
 
selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)
 
if mouseModule.mouseController.isAttached():
 
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
 
if player.SLOT_TYPE_INVENTORY == attachedSlotType:
itemCount = player.GetItemCount(attachedSlotPos)
attachedCount = mouseModule.mouseController.GetAttachedItemCount()
self.__SendMoveItemPacket(attachedSlotPos, selectedSlotPos, attachedCount)
 
if item.IsRefineScroll(attachedItemIndex):
self.wndItem.SetUseMode(FALSE)
 
elif player.SLOT_TYPE_PRIVATE_SHOP == attachedSlotType:
mouseModule.mouseController.RunCallBack("INVENTORY")
 
elif player.SLOT_TYPE_SHOP == attachedSlotType:
net.SendShopBuyPacket(attachedSlotPos)
 
elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:
 
if player.ITEM_MONEY == attachedItemIndex:
net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")
 
else:
net.SendSafeboxCheckoutPacket(attachedSlotPos, selectedSlotPos)
 
elif player.SLOT_TYPE_MALL == attachedSlotType:
net.SendMallCheckoutPacket(attachedSlotPos, selectedSlotPos)
 
mouseModule.mouseController.DeattachObject()
 
def SelectItemSlot(self, itemSlotIndex):
if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:
return
 
itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)
 
if mouseModule.mouseController.isAttached():
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()
 
if player.SLOT_TYPE_INVENTORY == attachedSlotType:
self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex)
 
mouseModule.mouseController.DeattachObject()
 
else:
 
curCursorNum = app.GetCursor()
if app.SELL == curCursorNum:
self.__SellItem(itemSlotIndex)
 
elif app.BUY == curCursorNum:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SHOP_BUY_INFO)
 
elif app.IsPressed(app.DIK_LALT):
link = player.GetItemLink(itemSlotIndex)
ime.PasteString(link)
 
elif app.IsPressed(app.DIK_LSHIFT):
itemCount = player.GetItemCount(itemSlotIndex)
 
if itemCount > 1:
self.dlgPickMoney.SetTitleName(locale.PICK_ITEM_TITLE)
self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))
self.dlgPickMoney.Open(itemCount)
self.dlgPickMoney.itemGlobalSlotIndex = itemSlotIndex
#else:
#selectedItemVNum = player.GetItemIndex(itemSlotIndex)
#mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum)
 
elif app.IsPressed(app.DIK_LCONTROL):
itemIndex = player.GetItemIndex(itemSlotIndex)
 
if TRUE == item.CanAddToQuickSlotItem(itemIndex):
player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_INVENTORY, itemSlotIndex)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.QUICKSLOT_REGISTER_DISABLE_ITEM)
 
else:
selectedItemVNum = player.GetItemIndex(itemSlotIndex)
itemCount = player.GetItemCount(itemSlotIndex)
mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)
 
if self.__IsUsableItemToItem(selectedItemVNum, itemSlotIndex):
self.wndItem.SetUseMode(TRUE)
else:
self.wndItem.SetUseMode(FALSE)
 
snd.PlaySound("sound/ui/pick.wav")
 
def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos):
if srcItemSlotPos == dstItemSlotPos:
return
 
if item.IsRefineScroll(srcItemVID):
self.RefineItem(srcItemSlotPos, dstItemSlotPos)
self.wndItem.SetUseMode(FALSE)
 
elif item.IsMetin(srcItemVID):
self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)
 
elif item.IsDetachScroll(srcItemVID):
self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)
 
elif item.IsKey(srcItemVID):
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
 
elif (player.GetItemFlags(srcItemSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
 
elif item.GetUseType(srcItemVID) in self.USE_TYPE_TUPLE:
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
 
else:
#snd.PlaySound("sound/ui/drop.wav")
 
## À̵¿½ÃŲ °÷ÀÌ ÀåÂø ½½·ÔÀÏ °æ¿ì ¾ÆÀÌÅÛÀ» »ç¿ëÇؼ­ ÀåÂø ½ÃŲ´Ù - [levites]
if player.IsEquipmentSlot(dstItemSlotPos):
 
## µé°í ÀÖ´Â ¾ÆÀÌÅÛÀÌ ÀåºñÀ϶§¸¸
if item.IsEquipmentVID(srcItemVID):
self.__UseItem(srcItemSlotPos)
 
else:
self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
#net.SendItemMovePacket(srcItemSlotPos, dstItemSlotPos, 0)
 
def __SellItem(self, itemSlotPos):
if not player.IsEquipmentSlot(itemSlotPos):
self.sellingSlotNumber = itemSlotPos
itemIndex = player.GetItemIndex(itemSlotPos)
itemCount = player.GetItemCount(itemSlotPos)
 
item.SelectItem(itemIndex)
itemPrice = item.GetISellItemPrice()
 
if item.Is1GoldItem():
itemPrice = itemCount / itemPrice / 5
else:
itemPrice = itemPrice * itemCount / 5
 
item.GetItemName(itemIndex)
itemName = item.GetItemName()
 
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(locale.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
self.questionDialog.count = itemCount
 
def RefineItem(self, scrollSlotPos, targetSlotPos):
 
scrollIndex = player.GetItemIndex(scrollSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)
 
if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos):
return
 
###########################################################
self.__SendUseItemToItemPacket(scrollSlotPos, targetSlotPos)
#net.SendItemUseToItemPacket(scrollSlotPos, targetSlotPos)
return
###########################################################
 
###########################################################
#net.SendRequestRefineInfoPacket(targetSlotPos)
#return
###########################################################
 
result = player.CanRefine(scrollIndex, targetSlotPos)
 
if player.REFINE_ALREADY_MAX_SOCKET_COUNT == result:
#snd.PlaySound("sound/ui/jaeryun_fail.wav")
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_MORE_SOCKET)
 
elif player.REFINE_NEED_MORE_GOOD_SCROLL == result:
#snd.PlaySound("sound/ui/jaeryun_fail.wav")
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NEED_BETTER_SCROLL)
 
elif player.REFINE_CANT_MAKE_SOCKET_ITEM == result:
#snd.PlaySound("sound/ui/jaeryun_fail.wav")
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_SOCKET_DISABLE_ITEM)
 
elif player.REFINE_NOT_NEXT_GRADE_ITEM == result:
#snd.PlaySound("sound/ui/jaeryun_fail.wav")
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_UPGRADE_DISABLE_ITEM)
 
elif player.REFINE_CANT_REFINE_METIN_TO_EQUIPMENT == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_EQUIP_ITEM)
 
if player.REFINE_OK != result:
return
 
self.refineDialog.Open(scrollSlotPos, targetSlotPos)
 
def DetachMetinFromItem(self, scrollSlotPos, targetSlotPos):
scrollIndex = player.GetItemIndex(scrollSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)
 
if not player.CanDetach(scrollIndex, targetSlotPos):
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)
return
 
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(locale.REFINE_DO_YOU_SEPARATE_METIN)
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnDetachMetinFromItem))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
self.questionDialog.sourcePos = scrollSlotPos
self.questionDialog.targetPos = targetSlotPos
 
def AttachMetinToItem(self, metinSlotPos, targetSlotPos):
metinIndex = player.GetItemIndex(metinSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)
 
item.SelectItem(metinIndex)
itemName = item.GetItemName()
 
result = player.CanAttachMetin(metinIndex, targetSlotPos)
 
if player.ATTACH_METIN_NOT_MATCHABLE_ITEM == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_CAN_NOT_ATTACH(itemName))
 
if player.ATTACH_METIN_NO_MATCHABLE_SOCKET == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_SOCKET(itemName))
 
elif player.ATTACH_METIN_NOT_EXIST_GOLD_SOCKET == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_GOLD_SOCKET(itemName))
 
elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_EQUIP_ITEM)
 
if player.ATTACH_METIN_OK != result:
return
 
self.attachMetinDialog.Open(metinSlotPos, targetSlotPos)
 
 
 
def OverOutItem(self):
self.wndItem.SetUsableItem(FALSE)
if None != self.tooltipItem:
self.tooltipItem.HideToolTip()
 
def OverInItem(self, overSlotPos):
overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
self.wndItem.SetUsableItem(FALSE)
 
if mouseModule.mouseController.isAttached():
attachedItemType = mouseModule.mouseController.GetAttachedType()
if player.SLOT_TYPE_INVENTORY == attachedItemType:
 
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()
 
if self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPos):
self.wndItem.SetUsableItem(TRUE)
self.ShowToolTip(overSlotPos)
return
 
self.ShowToolTip(overSlotPos)
 
 
def __IsUsableItemToItem(self, srcItemVNum, srcSlotPos):
"´Ù¸¥ ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö ÀÖ´Â ¾ÆÀÌÅÛÀΰ¡?"
 
if item.IsRefineScroll(srcItemVNum):
return TRUE
elif item.IsMetin(srcItemVNum):
return TRUE
elif item.IsDetachScroll(srcItemVNum):
return TRUE
elif item.IsKey(srcItemVNum):
return TRUE
elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
return TRUE
else:
if item.GetUseType(srcItemVNum) in self.USE_TYPE_TUPLE:
return TRUE
 
return FALSE
 
def __CanUseSrcItemToDstItem(self, srcItemVNum, srcSlotPos, dstSlotPos):
"´ë»ó ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö Àִ°¡?"
 
if srcSlotPos == dstSlotPos:
return FALSE
 
if item.IsRefineScroll(srcItemVNum):
if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):
return TRUE
elif item.IsMetin(srcItemVNum):
if player.ATTACH_METIN_OK == player.CanAttachMetin(srcItemVNum, dstSlotPos):
return TRUE
elif item.IsDetachScroll(srcItemVNum):
if player.DETACH_METIN_OK == player.CanDetach(srcItemVNum, dstSlotPos):
return TRUE
elif item.IsKey(srcItemVNum):
if player.CanUnlock(srcItemVNum, dstSlotPos):
return TRUE
 
elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
return TRUE
 
else:
useType=item.GetUseType(srcItemVNum)
 
if "USE_CLEAN_SOCKET" == useType:
if self.__CanCleanBrokenMetinStone(dstSlotPos):
return TRUE
elif "USE_CHANGE_ATTRIBUTE" == useType:
if self.__CanChangeItemAttrList(dstSlotPos):
return TRUE
elif "USE_ADD_ATTRIBUTE" == useType:
if self.__CanAddItemAttr(dstSlotPos):
return TRUE
elif "USE_ADD_ATTRIBUTE2" == useType:
if self.__CanAddItemAttr(dstSlotPos):
return TRUE
elif "USE_ADD_ACCESSORY_SOCKET" == useType:
if self.__CanAddAccessorySocket(dstSlotPos):
return TRUE
elif "USE_PUT_INTO_ACCESSORY_SOCKET" == useType:
if self.__CanPutAccessorySocket(dstSlotPos, srcItemVNum):
return TRUE;
 
return FALSE
 
def __CanCleanBrokenMetinStone(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
 
item.SelectItem(dstItemVNum)
 
if item.ITEM_TYPE_WEAPON != item.GetItemType():
return FALSE
 
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemMetinSocket(dstSlotPos, i) == constInfo.ERROR_METIN_STONE:
return TRUE
 
return FALSE
 
def __CanChangeItemAttrList(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
 
item.SelectItem(dstItemVNum)
 
if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):
return FALSE
 
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemAttribute(dstSlotPos, i) != 0:
return TRUE
 
return FALSE
 
def __CanPutAccessorySocket(self, dstSlotPos, mtrlVnum):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
 
item.SelectItem(dstItemVNum)
 
if item.GetItemType() != item.ITEM_TYPE_ARMOR:
return FALSE
 
if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
return FALSE
 
curCount = player.GetItemMetinSocket(dstSlotPos, 0)
maxCount = player.GetItemMetinSocket(dstSlotPos, 1)
 
if mtrlVnum != constInfo.GET_ACCESSORY_MATERIAL_VNUM(dstItemVNum, item.GetItemSubType()):
return FALSE
 
if curCount>=maxCount:
return FALSE
 
return TRUE
 
def __CanAddAccessorySocket(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
 
item.SelectItem(dstItemVNum)
 
if item.GetItemType() != item.ITEM_TYPE_ARMOR:
return FALSE
 
if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
return FALSE
 
curCount = player.GetItemMetinSocket(dstSlotPos, 0)
maxCount = player.GetItemMetinSocket(dstSlotPos, 1)
 
ACCESSORY_SOCKET_MAX_SIZE = 3
if maxCount >= ACCESSORY_SOCKET_MAX_SIZE:
return FALSE
 
return TRUE
 
def __CanAddItemAttr(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
 
item.SelectItem(dstItemVNum)
 
if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):
return FALSE
 
attrCount = 0
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemAttribute(dstSlotPos, i) != 0:
attrCount += 1
 
if attrCount<4:
return TRUE
 
return FALSE
 
def ShowToolTip(self, slotIndex):
if None != self.tooltipItem:
self.tooltipItem.SetInventoryItem(slotIndex)
 
def OnTop(self):
if None != self.tooltipItem:
self.tooltipItem.SetTop()
 
def OnPressEscapeKey(self):
self.Close()
return TRUE
 
def UseItemSlot(self, slotIndex):
if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS():
return
 
slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)
 
self.__UseItem(slotIndex)
mouseModule.mouseController.DeattachObject()
self.OverOutItem()
 
def __UseItem(self, slotIndex):
ItemVNum = player.GetItemIndex(slotIndex)
item.SelectItem(ItemVNum)
if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(locale.INVENTORY_REALLY_USE_ITEM)
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnAccept))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnCancel))
self.questionDialog.Open()
self.questionDialog.slotIndex = slotIndex
 
else:
self.__SendUseItemPacket(slotIndex)
#net.SendItemUsePacket(slotIndex)
 
def __UseItemQuestionDialog_OnCancel(self):
self.OnCloseQuestionDialog()
 
def __UseItemQuestionDialog_OnAccept(self):
self.__SendUseItemPacket(self.questionDialog.slotIndex)
 
if self.questionDialog:
self.questionDialog.Close()
self.questionDialog = None
 
def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):
# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_ITEM_FAILURE_PRIVATE_SHOP)
return
 
net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)
 
def __SendUseItemPacket(self, slotPos):
# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_ITEM_FAILURE_PRIVATE_SHOP)
return
 
net.SendItemUsePacket(slotPos)
 
def __SendMoveItemPacket(self, srcSlotPos, dstSlotPos, srcItemCount):
# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
return
 
net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)
 
def OnUpdate(self):
if self.isLoaded == 1:
self.__LoadRefreshBonus()

Share this post

Link to post
Share on other sites
  • 0

Batman64    3

Batman64
Posted

AONDE DESATIVO

Share this post

Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Sign in to follow this  
Followers 0
Go To Question Listing Dúvidas & Pedidos