Beiträge von Kenny1609

Kenny1609 · 12. April 2021

Zitat von xAmnezia

Zitat von Kenny1609

Hat jemand den vielleicht noch ohne updater weil der link da nicht geht.

Wenn du mich in 3-4h nochmal daran erinnerst, schicke ich ihn dir

Leider zu spät gelesen wenn du Zeit hast kannst ihn mir gerne schicken.

danke schonmal

Kenny1609 · 10. April 2021

Hat jemand den vielleicht noch ohne updater weil der link da nicht geht.

Kenny1609 · 21. April 2019

Hat keiner gesagt das ich damit einen Server betreiben will ich will Sie lediglich nur testen

Kenny1609 · 21. April 2019

nach dem Einloggen kick egal mit welchem Charakter

Kenny1609 · 4. März 2019

download nicht mehr verfügbar

Kenny1609 · 4. Februar 2019

Du musst auf Freebsd 11.2 Release upgraden dann gehts

Kenny1609 · 24. Januar 2019

Laufen einwandfrei

Kenny1609 · 10. November 2018

Ist der offline?

Kenny1609 · 15. Juli 2018

Hab nur den Client gepackt von den Dateien die dabei waren und die Exe compiled also nichts zusätzlich eingebaut

Kenny1609 · 15. Juli 2018

Code

import ui
import player
import mouseModule
import net
import app
import snd
import item
import player
import chat
import config
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommon
import uiPrivateShopBuilder
import localeInfo
import constInfo
import ime
import wndMgr
import playerSettingModule
if app.ENABLE_NON_TRADEABLE_ITEM_EFFEKT:
import exchange
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("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()
if app.ENABLE_ITEM_EFFECT_SYSTEM:
pyScrLoader.LoadScriptFile(self, "uiscript/costumewindow_effect_slot.py")
else:
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.ENABLE_WEAPON_COSTUME_SYSTEM:
self.wndEquip.SetItemSlot(item.COSTUME_SLOT_WEAPON, getItemVNum(item.COSTUME_SLOT_WEAPON), 0)
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()
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 + 140, 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):
if app.ENABLE_HIGHLIGHT_SYSTEM:
liHighlightedItems = []
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")
if app.ENABLE_SOULBIND_SYSTEM:
USE_TYPE_TUPLE = USE_TYPE_TUPLE + ("USE_BIND", "USE_UNBIND",)
if app.ENABLE_ENCHANT_BONUS_ADD:
USE_TYPE_TUPLE = USE_TYPE_TUPLE + ("USE_CHANGE_COSTUME_ATTR","USE_RESET_COSTUME_ATTR",)
if app.ENABLE_CHANGE_LOOK_SYSTEM:
USE_TYPE_TUPLE = USE_TYPE_TUPLE + ("USE_RESET_LOOK_VNUM",)
questionDialog = None
tooltipItem = None
wndCostume = None
wndBelt = None
dlgPickMoney = None
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
def __LoadWindow(self):
if self.isLoaded == 1:
return
self.isLoaded = 1
try:
pyScrLoader = ui.PythonScriptLoader()
if app.ENABLE_EXTEND_INVEN_SYSTEM:
pyScrLoader.LoadScriptFile(self, "UIScript/InventoryWindowEx.py")
else:
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")
if app.ENABLE_CHEQUE_SYSTEM:
# self.wndChequeIcon = self.GetChild("Cheque_Icon")
self.wndCheque = self.GetChild("Cheque")
self.wndChequeSlot = self.GetChild("Cheque_Slot")
self.mallButton = self.GetChild2("MallButton")
self.DSSButton = self.GetChild2("DSSButton")
self.costumeButton = self.GetChild2("CostumeButton")
if config.ENABLE['ENABLE_BONUS_BOARD_IN_INVENTORY'] == 1:
self.minimizeButton = self.GetChild2("ButtonMinimize")
self.minimizeButton.SetEvent(ui.__mem_func__(self.ClickBonusBoardButton))
self.BONUS_BOARD_SHOW = False
self.statArray = [["Schwert", 69], ["2Hand", 70], ["Dolch", 71], ["Pfeilwiderstand", 74], ["Glocke", 72], ["Faecher", 73], ["Magiewiederstand", 77], ["Giftwiederstand", 81], ["Krieger", 59], ["Ninja", 60], ["Sura", 61], ["Schamane", 62], ["Krit", 40], ["DB", 41], ["DSS", 122], ["FKS", 121], ["Halbmenschen", 43], ["Untote", 47], ["Teufel", 48], ["KriegerO", 54], ["NinjaO", 55], ["SuraO", 56], ["SchamaneO", 57]]
self.SetSize(176, 565)
self.GetChild("board").SetSize(176, 565)
self.GetChild("TitleBar").SetWidth(161)
self.GetChild("TitleName").SetPosition(77, 3)
self.GetChild("ButtonMinimize").SetPosition(131, 10)
self.SetPosition(wndMgr.GetScreenWidth() - 176, wndMgr.GetScreenHeight() - 37 - 565)
for i in xrange(len(self.statArray)):
self.GetChild("{}".format(self.statArray[i][0])).Hide()
self.GetChild("{}".format(self.statArray[i][0]+"_info")).Hide()
self.GetChild("HeadlineOffensive").Hide()
self.GetChild("HeadlineDefensive").Hide()
self.inventoryTab = []
for i in xrange(player.INVENTORY_PAGE_COUNT):
self.inventoryTab.append(self.GetChild("Inventory_Tab_%02d" % (i+1)))
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
# 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()
## RefineDialog
self.refineDialog = uiRefine.RefineDialog()
self.refineDialog.Hide()
## AttachMetinDialog
self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()
self.attachMetinDialog.Hide()
# self.wndMoneyIcon.SetText("Gold")
# self.wndChequeIcon.SetText("Won")
## MoneySlot
self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))
if app.ENABLE_CHEQUE_SYSTEM:
## WonSlot
self.wndChequeSlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))
for i in xrange(player.INVENTORY_PAGE_COUNT):
self.inventoryTab[i].SetEvent(lambda arg=i: 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))
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
if app.ENABLE_NON_TRADEABLE_ITEM_EFFEKT:
self.listUnusableSlot = []
## Refresh
self.SetInventoryPage(0)
self.SetEquipmentPage(0)
self.RefreshItemSlot()
self.RefreshStatus()
if config.ENABLE['ENABLE_BONUS_BOARD_IN_INVENTORY'] == 1:
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
if app.ENABLE_CHEQUE_SYSTEM:
self.wndCheque = 0
self.wndChequeSlot = 0
self.questionDialog = None
self.mallButton = None
self.DSSButton = None
self.interface = None
if self.wndCostume:
self.wndCostume.Destroy()
self.wndCostume = 0
if self.wndBelt:
self.wndBelt.Destroy()
self.wndBelt = 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()
wndMgr.Hide(self.hWnd)
def Close(self):
self.Hide()
def SetInventoryPage(self, page):
self.inventoryPageIndex = page
for i in xrange(player.INVENTORY_PAGE_COUNT):
if i!=page:
self.inventoryTab[i].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")
#BONUS BOARD
def ClickBonusBoardButton(self):
isActive = self.BONUS_BOARD_SHOW
if isActive:
self.SetSize(176, 565)
self.GetChild("board").SetSize(176, 565)
self.GetChild("TitleBar").SetWidth(161)
self.GetChild("TitleName").SetPosition(77, 3)
self.GetChild("ButtonMinimize").SetPosition(131, 10)
self.SetPosition(wndMgr.GetScreenWidth() - 176, wndMgr.GetScreenHeight() - 37 - 565)
self.BONUS_BOARD_SHOW = False
else:
self.SetSize(296, 565)
self.GetChild("board").SetSize(296, 565)
self.GetChild("TitleBar").SetWidth(281)
self.GetChild("TitleName").SetPosition(197, 3)
self.GetChild("ButtonMinimize").SetPosition(251, 10)
self.SetPosition(wndMgr.GetScreenWidth() - 176 - 121, wndMgr.GetScreenHeight() - 37 - 565)
self.BONUS_BOARD_SHOW = True
self.toggleStats(isActive)
if self.wndBelt:
self.wndBelt.AdjustPositionAndSize()
def toggleStats(self, var):
if var:
for i in xrange(len(self.statArray)):
self.GetChild("{}".format(self.statArray[i][0])).Hide()
self.GetChild("{}".format(self.statArray[i][0]+"_info")).Hide()
self.GetChild("HeadlineOffensive").Hide()
self.GetChild("HeadlineDefensive").Hide()
else:
for i in xrange(len(self.statArray)):
self.GetChild("{}".format(self.statArray[i][0])).Show()
self.GetChild("{}".format(self.statArray[i][0]+"_info")).Show()
self.GetChild("HeadlineOffensive").Show()
self.GetChild("HeadlineDefensive").Show()
# DSSButton
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()
def OpenPickMoneyDialog(self):
if mouseModule.mouseController.isAttached():
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
if player.SLOT_TYPE_SAFEBOX == mouseModule.mouseController.GetAttachedType():
if app.ENABLE_CHEQUE_SYSTEM:
if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")
elif player.ITEM_CHEQUE == mouseModule.mouseController.GetAttachedItemIndex():
# net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")
else:
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 app.ENABLE_CHEQUE_SYSTEM:
curCheque = player.GetWon()
if curMoney <= 0:
return
self.dlgPickMoney.SetTitleName(localeInfo.PICK_MONEY_TITLE)
self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
if app.ENABLE_CHEQUE_SYSTEM:
self.dlgPickMoney.Open(curMoney, curCheque)
else:
self.dlgPickMoney.Open(curMoney)
self.dlgPickMoney.SetMax(9)
if app.ENABLE_CHEQUE_SYSTEM:
def OnPickMoney(self, money, cheque):
if money > 0 and cheque <= 0:
mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)
elif cheque > 0 and money <= 0:
mouseModule.mouseController.AttachCheque(self, player.SLOT_TYPE_INVENTORY, cheque)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Info: N? ?permitido descartar duas moedas juntas.")
else:
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) or (app.ENABLE_NEW_EQUIPMENT_SYSTEM and player.IsBeltInventorySlot(local)):
return local
return self.inventoryPageIndex*player.INVENTORY_PAGE_SIZE + local
def RefreshBagSlotWindow(self):
is_activated = 0
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)
# itemCount == X
if 0 == itemCount:
self.wndItem.ClearSlot(i)
continue
elif 1 == itemCount:
itemCount = 0
itemVnum = getItemVNum(slotNumber)
setItemVNum(i, itemVnum, itemCount)
if app.ENABLE_NON_TRADEABLE_ITEM_EFFEKT:
if exchange.isTrading() and item.IsAntiFlag(item.ANTIFLAG_GIVE):
self.wndItem.SetUnusableSlot(i)
self.listUnusableSlot.append(i)
elif not exchange.isTrading() and item.IsAntiFlag(item.ANTIFLAG_GIVE) and slotNumber in self.listUnusableSlot:
self.wndItem.SetUsableSlot(i)
self.listUnusableSlot.remove(i)
if app.ENABLE_HIGHLIGHT_SYSTEM:
if itemVnum == 0 and slotNumber in self.liHighlightedItems:
self.liHightlightedItems.remove(slotNumber)
if app.ENABLE_ACCE_COSTUME_SYSTEM:
if constInfo.IS_ACCE_ITEM(itemVnum, 1) == TRUE:
metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]
isActivated = metinSocket[0]
if isActivated == 1:
player.SetAcceInfo(isActivated, i)
self.wndItem.ActivateAcceSlot(i)
else:
self.wndItem.DeactivateAcceSlot(i)
if constInfo.IS_AUTO_POTION(itemVnum):
metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]
isActivated = 0 != metinSocket[0]
if app.ENABLE_HIGHLIGHT_SYSTEM:
if isActivated:
self.wndItem.ActivateSlot(i)
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(i)
else:
self.wndItem.DeactivateSlot(i)
if not app.ENABLE_HIGHLIGHT_SYSTEM:
if isActivated:
self.wndItem.ActivateSlot(i)
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(i)
if app.ENABLE_HIGHLIGHT_SYSTEM:
self.__RefreshHighlights()
self.wndItem.RefreshSlot()
if self.wndBelt:
self.wndBelt.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)
if app.ENABLE_CHANGE_LOOK_SYSTEM:
if player.GetItemLook(slotNumber):
self.wndEquip.EnableSlotCoverImage(slotNumber)
else:
self.wndEquip.DisableSlotCoverImage(slotNumber)
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)
if app.ENABLE_CHANGE_LOOK_SYSTEM:
if player.GetItemLook(slotNumber):
self.wndEquip.EnableSlotCoverImage(slotNumber)
else:
self.wndEquip.DisableSlotCoverImage(slotNumber)
self.wndEquip.RefreshSlot()
if self.wndCostume:
self.wndCostume.RefreshCostumeSlot()
def RefreshItemSlot(self):
self.RefreshBagSlotWindow()
self.RefreshEquipSlotWindow()
def RefreshBonus(self):
for i in xrange(len(self.statArray)):
self.GetChild("bonus_{}".format(i+1)).SetText(str(player.GetStatus(self.statArray[i][1])))
def RefreshStatus(self):
money = player.GetElk()
self.wndMoney.SetText(localeInfo.NumberToMoneyString(money))
if app.ENABLE_CHEQUE_SYSTEM:
cheque = player.GetWon()
self.wndCheque.SetText(str(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
#net.SendItemUseToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)
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)
## Slot Event
def SelectEmptySlot(self, selectedSlotPos):
if app.ENABLE_CHANGE_LOOK_SYSTEM:
if constInfo.BusySlots():
return
if constInfo.GET_ITEM_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_OFFLINE_SHOP == attachedSlotType:
#mouseModule.mouseController.RunCallBack("INVENTORY")
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 app.ENABLE_CHEQUE_SYSTEM:
if player.ITEM_MONEY == attachedItemIndex:
net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")
elif player.ITEM_CHEQUE == attachedItemIndex:
# net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")
else:
net.SendSafeboxCheckoutPacket(attachedSlotPos, selectedSlotPos)
else:
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)
elif app.IsPressed(app.DIK_LSHIFT):
itemCount = player.GetItemCount(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
#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, 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")
if app.NEW_PET_SYSTEM:
def UseTransportBox(self):
self.__SendUseItemToItemPacket(self.questionDialog.src, self.questionDialog.dst)
self.OnCloseQuestionDialog()
def UseProtein(self):
self.__SendUseItemToItemPacket(self.questionDialog.src, self.questionDialog.dst)
self.OnCloseQuestionDialog()
def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos):
if srcItemSlotPos == dstItemSlotPos:
return
elif srcItemVID == player.GetItemIndex(dstItemSlotPos):
self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
return
if app.NEW_PET_SYSTEM:
if srcItemVID >= 55701 and srcItemVID <= 55706 and player.GetItemIndex(dstItemSlotPos) == 55002:
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(localeInfo.INVENTORY_REALLY_USE_PET_BAG_ITEM)
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.UseTransportBox))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
self.questionDialog.src = srcItemSlotPos
self.questionDialog.dst = dstItemSlotPos
if srcItemVID == 55001 and player.GetItemIndex(dstItemSlotPos) >= 55701 and player.GetItemIndex(dstItemSlotPos) <= 55706:
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(localeInfo.INVENTORY_REALLY_USE_PET_FEEDSTUFF_ITEM)
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.UseProtein))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
self.questionDialog.src = srcItemSlotPos
self.questionDialog.dst = dstItemSlotPos
elif srcItemVID == player.GetItemIndex(dstItemSlotPos):
self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
return
if app.ENABLE_SOULBIND_SYSTEM:
SrcItemVNum = player.GetItemIndex(srcItemSlotPos)
DstItemVNum = player.GetItemIndex(dstItemSlotPos)
item.SelectItem(SrcItemVNum)
SrcSubType = item.GetItemSubType()
if SrcSubType == item.USE_BIND or SrcSubType == item.USE_UNBIND:
item.SelectItem(DstItemVNum)
if item.IsAntiFlag(item.ANTIFLAG_BIND):
return
else:
if SrcSubType == item.USE_BIND and player.GetItemBind(dstItemSlotPos) > 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SOULBIND_ALERT3)
elif SrcSubType == item.USE_BIND and player.GetItemBind(dstItemSlotPos) == 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SOULBIND_ALERT2)
elif SrcSubType == item.USE_UNBIND and player.GetItemBind(dstItemSlotPos) > 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SOULBIND_ALERT3)
elif SrcSubType == item.USE_UNBIND and player.GetItemBind(dstItemSlotPos) != 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SOULBIND_ALERT1)
else:
action = "bind"
if SrcSubType == item.USE_UNBIND:
action = "unbind"
self.__SoulBindItem(srcItemSlotPos, dstItemSlotPos, action)
return
else:
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:
if player.IsEquipmentSlot(dstItemSlotPos):
if item.IsEquipmentVID(srcItemVID):
self.__UseItem(srcItemSlotPos)
else:
self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
else:
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:
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)
## 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
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
if app.ENABLE_CHANGE_LOOK_SYSTEM:
def OnUpdate(self):
self.RefreshBagSlotWindow()
if config.ENABLE['ENABLE_BONUS_BOARD_IN_INVENTORY'] == 1:
self.RefreshBonus()
for i in xrange(player.INVENTORY_PAGE_SIZE):
GlobalSlot = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
if player.GetItemLook(GlobalSlot):
import chat
# chat.AppendChat(7, "Transmutation vnum: %d slot: %d" % (player.GetItemLook(GlobalSlot), GlobalSlot))
self.wndItem.EnableSlotCoverImage(i)
else:
self.wndItem.DisableSlotCoverImage(i)
if player.FindActivedChangeLookSlot(0) == GlobalSlot or player.FindActivedChangeLookSlot(1) == GlobalSlot:
self.wndItem.ActivateChangeLookSlot(i)
else:
self.wndItem.DeactivateChangeLookSlot(i)
else:
def OnUpdate(self):
if config.ENABLE['ENABLE_BONUS_BOARD_IN_INVENTORY'] == 1:
self.RefreshBonus()
pass
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, 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)
if app.ENABLE_ACCE_COSTUME_SYSTEM:
def DetachMetinFromItem(self, scrollSlotPos, targetSlotPos):
scrollIndex = player.GetItemIndex(scrollSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)
for i in xrange(player.INVENTORY_PAGE_SIZE*4):
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
getItemVNum=player.GetItemIndex
itemVnum = getItemVNum(slotNumber)
if 85009 == itemVnum:
item.SelectItem(targetIndex)
if item.GetItemSubType() == item.COSTUME_TYPE_ACCE:
if self.GetAcceAttribute(targetSlotPos) == 0:
return
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText("Would you like to reset your sash shoulder stats?")
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
else:
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)
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
if not app.ENABLE_ACCE_COSTUME_SYSTEM:
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):
overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
self.wndItem.SetUsableItem(False)
if app.ENABLE_HIGHLIGHT_SYSTEM:
if overSlotPosGlobal in self.liHighlightedItems:
self.liHighlightedItems.remove(overSlotPosGlobal)
self.wndItem.DeactivateSlot(overSlotPos)
if mouseModule.mouseController.isAttached():
attachedItemType = mouseModule.mouseController.GetAttachedType()
if player.SLOT_TYPE_INVENTORY == attachedItemType:
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()
if attachedItemVNum==player.ITEM_MONEY: # @fixme005
pass
elif self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPos):
self.wndItem.SetUsableItem(True)
self.ShowToolTip(overSlotPosGlobal)
return
self.ShowToolTip(overSlotPosGlobal)
def __IsUsableItemToItem(self, srcItemVNum, srcSlotPos):
"다른 아이템에 사용할 수 있는 아이템인가?"
if app.NEW_PET_SYSTEM:
if srcItemVNum >= 55701 and srcItemVNum <= 55706:
return True
if srcItemVNum == 55001:
return True
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 app.NEW_PET_SYSTEM:
if srcItemVNum >= 55701 and srcItemVNum <= 55706 and player.GetItemIndex(dstSlotPos) == 55002:
return True
if srcItemVNum == 55001 and player.GetItemIndex(dstSlotPos) >= 55701 and player.GetItemIndex(dstSlotPos) <= 55706:
return True
if srcSlotPos == dstSlotPos:
return False
if srcItemVNum == player.GetItemIndex(dstSlotPos):
if player.GetItemCount(dstSlotPos) < 250:
return True
elif 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;
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 useType == "USE_BIND" or useType == "USE_UNBIND":
if not app.ENABLE_SOULBIND_SYSTEM:
return FALSE
dstItemVNum = player.GetItemIndex(dstSlotPos)
item.SelectItem(dstItemVNum)
if item.IsAntiFlag(item.ANTIFLAG_BIND):
return FALSE
elif useType == "USE_BIND" and player.GetItemBind(dstSlotPos) == 1:
return FALSE
elif useType == "USE_BIND" and player.GetItemBind(dstSlotPos) > 1:
return FALSE
elif useType == "USE_UNBIND" and player.GetItemBind(dstSlotPos) != 1:
return FALSE
else:
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
elif "USE_RESET_LOOK_VNUM" == useType:
if not app.ENABLE_CHANGE_LOOK_SYSTEM:
return False
if self.__CanResetLookVnum(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
if app.ENABLE_SOULBIND_SYSTEM:
def __SoulBindItem(self, scrollSlotPos, targetSlotPos, action = "bind"):
DstItemVNum = player.GetItemIndex(targetSlotPos)
item.SelectItem(DstItemVNum)
item_name = item.GetItemName()
self.questionDialog = uiCommon.QuestionDialog()
if action == "bind":
self.questionDialog.SetText(localeInfo.SOULBIND_ITEM % (item_name))
else:
self.questionDialog.SetText(localeInfo.SOULUNBIND_ITEM % (item_name))
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnAcceptSoulBindItem))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
self.questionDialog.sourcePos = scrollSlotPos
self.questionDialog.targetPos = targetSlotPos
def OnAcceptSoulBindItem(self):
if self.questionDialog == None:
return
self.__SendUseItemToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)
self.OnCloseQuestionDialog()
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 __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:
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)
if app.ENABLE_CHANGE_LOOK_SYSTEM:
def __CanResetLookVnum(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False
if player.GetItemLook(dstSlotPos):
return True
return False
def OnTop(self):
if None != self.tooltipItem:
self.tooltipItem.SetTop()
def OnPressEscapeKey(self):
self.Close()
return True
def UseItemSlot(self, slotIndex):
if app.ENABLE_CHANGE_LOOK_SYSTEM:
if constInfo.BusySlots():
return
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 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)
#net.SendItemUsePacket(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
if config.ENABLE['ENABLE_BELTINVENTORY_MOVE_WITH_INVENTORY'] == 1:
def OnMoveWindow(self, x, y):
if self.wndBelt:
self.wndBelt.AdjustPositionAndSize()
if app.ENABLE_ACCE_COSTUME_SYSTEM:
def GetAcceAttribute(self, srcSlotPos):
result = 0
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(player.GetItemAttribute(srcSlotPos, i))
if 0 != attrSlot:
for c in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[c][0]
if type != 0:
result = result + 1
return result
if app.ENABLE_HIGHLIGHT_SYSTEM:
def HighlightSlot(self, slot):
if not slot in self.liHighlightedItems:
self.liHighlightedItems.append(slot)
def __RefreshHighlights(self):
for i in xrange(player.INVENTORY_PAGE_SIZE):
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
if slotNumber in self.liHighlightedItems:
self.wndItem.ActivateSlot(i)

Alles anzeigen

Kenny1609 · 15. Juli 2018

Genau die Stelle die ich zu Anfang gepostet habe wiederholt sich immer wieder aufs neue.

Kenny1609 · 14. Juli 2018

Und wie behebt man den Fehler?

Kenny1609 · 19. Juni 2018

Ich nutze die Servios Files die laufen bisher auch sehr gut nur wenn ich client schliese kommt folgender Syserr Eintrag und das mehrmals das die Syserr aus allen Nähten platzt
Vielleicht kann mir einer bei dem Fehler helfen hier mal die Syserr vom Client :

0618 17:45:32384 :: File "uiInventory.py", line 1061, in OnUpdate

0618 17:45:32384 :: File "uiInventory.py", line 633, in RefreshBagSlotWindow

0618 17:45:32384 :: AttributeError
0618 17:45:32384 :: :
0618 17:45:32384 :: 'int' object has no attribute 'SetItemSlot'
0618 17:45:32384 ::

0618 17:45:32385 :: Traceback (most recent call last):

Kenny1609 · 9. Juni 2018

Spoiler anzeigen

Kann mir einer sagen wie ich das beheben kann damit wird die syserr vom client vollgespamt

Kenny1609 · 4. Juni 2018

Ihr könnt auch mir eine pn schreiben oder in Skype adden unter [email protected]

Kenny1609 · 2. Juni 2018

Ganz am Anfang ist ein Video das hat mir sehr geholfen die files aufzusetzen.

Kenny1609 · 25. Mai 2018

Bei mir klappt auch alles Server startet und komme Ingame.
Nur meine Frage wäre noch da gibt's Tabellen die in mysql die eigenartige Buchstaben haben müssen die so bleiben oder kann man die löschen?

Kenny1609 · 24. Mai 2018

Ja bei mir ist auch kein Server src nur der Extern ist drin.

Kenny1609 · 25. März 2018

bei mir packt der Archiver die pack Dateien nicht. Kann mir einer helfen?

Kenny1609 · 10. März 2018

Kann bitte nochmal einer den Entpacker erklären wie der funktioniert?

Beiträge von Kenny1609

[Rls] Hanashi V2 mit und Ohne Updater

[Rls] Hanashi V2 mit und Ohne Updater

Moyoko2 Serverfiles

Moyoko2 Serverfiles

9.18GB Systeme /FREE/

root server

Mukari2 File+Source

[Newschool - Offizielle Vorstellung 18Uhr] Kiruma2 - Die Legende lebt!

Fehler in der UiInventory.py bitte um Hilfe

Fehler in der UiInventory.py bitte um Hilfe

Fehler in der UiInventory.py bitte um Hilfe

Fehler in der UiInventory.py bitte um Hilfe

Fehler in der UiInventory.py bitte um Hilfe

Servios Serverfiles/Source

Suche Beta Spieler

Servios Serverfiles/Source

Servios Serverfiles/Source

Servios Serverfiles/Source

Titania Stuff

Titania Stuff