Yardım K Envanter sorunsalı

import ui_image as ui
import player5 as player
import mouseModule
import net5 as net
import os
import app5 as app
import snd
import item
import player5 as player
import chat5 as chat
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommons

import localeInfo
import constInfo
import ime
import time
import wndMgr5 as wndMgr
import uisaplingsw
import uisiralama
import uidepocu

import interfacemodule
import translate
import background
import event
import exchange
import shop
import safebox
import chr5 as chr
import uiPrivateShopBuilder
import dbg
import systemSetting
import uiToolTip
import game
import miniMap
import uievent

ITEM_MALL_BUTTON_ENABLE = TRUE

SYSTEMS_WINDOW=1

if app.ENABLE_SASH_SYSTEM:
import sash

if app.ENABLE_CHANGELOOK_SYSTEM:
import changelook

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()
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_CHANGELOOK_SYSTEM:
itemTransmutedVnum = player.GetItemTransmutation(slotNumber)
if itemTransmutedVnum:
self.wndEquip.DisableCoverButton(slotNumber)
else:
self.wndEquip.EnableCoverButton(slotNumber)

for i in xrange(2):
slotNumber = player.NEW_EQUIPMENT_SLOT_START + i
self.wndEquip.SetItemSlot(slotNumber, getItemVNum(slotNumber), 0)

self.wndEquip.RefreshSlot()

class InventoryWindow(ui.ScriptWindow):

if app.ENABLE_SOULBIND_SYSTEM:
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", "USE_BIND", "USE_UNBIND")
else:
USE_TYPE_TUPLE = ("USE_CLEAN_SOCKET", "USE_CHANGE_ATTRIBUTE", "USE_ADD_ATTRIBUTE", "USE_ADD_ATTRIBUTE2", "USE_ADD_ACCESSORY_SOCKET", "USE_PUT_INTO_ACCESSORY_SOCKET", "USE_PUT_INTO_BELT_SOCKET", "USE_PUT_INTO_RING_SOCKET")

questionDialog = None
tooltipItem = None
wndCostume = None
wndBelt = None
dlgPickMoney = None
interface = None
UiDepocum = None

if app.ENABLE_TRADABLE_ICON:
bindWnds = []

sellingSlotNumber = -1
isLoaded = 0
isOpenedCostumeWindowWhenClosingInventory = 0
isOpenedBeltWindowWhenClosingInventory = 0
sonbasma = 0

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

self.isOpenedBeltWindowWhenClosingInventory = 1

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

def BindInterfaceClass(self, interface):
self.interface = interface

if app.ENABLE_TRADABLE_ICON:
def BindWindow(self, wnd):
self.bindWnds.append(wnd)

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

self.isLoaded = 1

try:
pyScrLoader = ui.PythonScriptLoader()

if ITEM_MALL_BUTTON_ENABLE:
pyScrLoader.LoadScriptFile(self, "UIScript/InventoryWindow.py")

except:
import exception
exception.Abort("InventoryWindow.LoadWindow.LoadObject")

try:
wndItem = self.GetChild("ItemSlot")
wndEquip = self.GetChild("EquipmentSlot")
self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
self.wndMoney = self.GetChild("Money")
self.wndMoneySlot = self.GetChild("Money_Slot")
self.mallButton = self.GetChild2("MallButton")
self.DSSButton = self.GetChild2("DSSButton")
self.costumeButton = self.GetChild2("CostumeButton")
#if app.ENABLE_SPECIAL_STORAGE:
# self.SpecialStorageButton = self.GetChild2("SpecialStorageButton")
self.CombiningButton = self.GetChild("CombiningButton")

self.inventoryTab = []
self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))
self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))
self.inventoryTab.append(self.GetChild("Inventory_Tab_03"))
self.inventoryTab.append(self.GetChild("Inventory_Tab_04"))

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

if self.costumeButton and not app.ENABLE_COSTUME_SYSTEM:
self.costumeButton.Hide()
self.costumeButton.Destroy()
self.costumeButton = 0

#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
if app.ENABLE_TRADABLE_ICON:
self.attachMetinDialog = uiAttachMetin.AttachMetinDialog(self)
self.BindWindow(self.attachMetinDialog)
else:
self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()
self.attachMetinDialog.Hide()

## MoneySlot
self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))
self.CombiningButton.SetEvent(ui.__mem_func__(self.ClickCombiningButton))

self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))
self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))
self.inventoryTab[2].SetEvent(lambda arg=2: self.SetInventoryPage(arg))
self.inventoryTab[3].SetEvent(lambda arg=3: self.SetInventoryPage(arg))
self.inventoryTab[0].Down()
self.inventoryPageIndex = 0

self.equipmentTab[0].SetEvent(lambda arg=0: self.SetEquipmentPage(arg))
self.equipmentTab[1].SetEvent(lambda arg=1: self.SetEquipmentPage(arg))
self.equipmentTab[0].Down()
self.equipmentTab[0].Hide()
self.equipmentTab[1].Hide()

self.wndItem = wndItem
self.wndEquip = wndEquip
self.dlgPickMoney = dlgPickMoney

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

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

#if app.ENABLE_SPECIAL_STORAGE:
#if self.SpecialStorageButton:
#self.SpecialStorageButton.SetEvent(ui.__mem_func__(self.ClickSpecialStorage))

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

self.wndCostume = None

## Refresh
if app.ENABLE_SASH_SYSTEM:
self.listAttachedSashs = []

if app.ENABLE_CHANGELOOK_SYSTEM:
self.listAttachedCl = []

if app.ENABLE_HIGHLIGHT_SYSTEM:
self.listHighlightedSlot = []

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

def ClickCombiningButton(self):
if app.GetTime() > self.sonbasma:
self.sonbasma = app.GetTime() + 10
net.SendChatPacket('/dream_baba_yapti2')
snd.StopAllSound()
snd.PlaySound("BGM/" + "envanter_duzenlendi.mp3")
else:
v = self.sonbasma - app.GetTime()
chat.AppendChat(chat.CHAT_TYPE_INFO,"Bu işlemi bu kadar hızlı yapamazsın.")

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
self.DSSButton = None
self.interface = None
#if app.ENABLE_SPECIAL_STORAGE:
# self.SpecialStorageButton = None

if app.ENABLE_TRADABLE_ICON:
self.bindWnds = []

if self.wndCostume:
self.wndCostume.Destroy()
self.wndCostume = 0

if self.wndBelt:
self.wndBelt.Kapat()
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 Inventory ", self.isOpenedBeltWindowWhenClosingInventory
# self.wndBelt.Close()

if self.wndBelt:
self.wndBelt.Kapat()

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

wndMgr.Hide(self.hWnd)

def Close(self):
self.Hide()

if app.ENABLE_HIGHLIGHT_SYSTEM:
def HighlightSlot(self, slot):
if not slot in self.listHighlightedSlot:
self.listHighlightedSlot.append(slot)

def SetInventoryPage(self, page):
self.inventoryTab[self.inventoryPageIndex].SetUp()
self.inventoryPageIndex = page
self.inventoryTab[self.inventoryPageIndex].Down()
self.RefreshBagSlotWindow()

def SetEquipmentPage(self, page):
self.equipmentPageIndex = page
self.equipmentTab[1-page].SetUp()
self.RefreshEquipSlotWindow()

def DepoMapEngel(self):
mapkontrolet = [
"metin2_map_n_snow_dungeon_01",
"metin2_map_skipia_dungeon_boss",
"metin2_map_wedding_01",
"metin2_map_t1",
"metin2_map_t2",
"metin2_map_t3",
"metin2_map_t4",
"metin2_map_oxevent",
"metin2_map_empirewar02",
"metin2_map_deviltower1",
"metin2_map_battlefied",
"metin2_map_spiderdungeon_03",
"metin2_map_devilscatacomb"
]
if str(background.GetCurrentMapName()) in mapkontrolet:
return TRUE

return FALSE

Time30 = {"LAST30":0}

def ClickMallButton(self):
if app.GetGlobalTimeStamp()>=self.Time30["LAST30"]:
self.Time30["LAST30"] = app.GetGlobalTimeStamp()+2
# Burada kodumuz başlıyor #
if self.DepoMapEngel():
chat.AppendChat(chat.CHAT_TYPE_INFO,"<Sistem> Bu bölgede depo menüsünü açamazsın. ")
return
net.SendChatPacket("/click_boxsafe")
#if not constInfo.depomenu:
# if not self.UiDepocum:
# self.UiDepocum = uidepocu.OptionDialog()
# self.UiDepocum.Show()
# constInfo.depomenu = 1
#else:
# chat.AppendChat(1, "<Sistem> Depo menüsünü zaten açık")
# Burada kodumuz bitiyor #
else:
chat.AppendChat(chat.CHAT_TYPE_INFO,"<Sistem> Bu işlemi bu kadar hızlı yapamazsın.")

# DSSButton
def ClickDSSButton(self):
print "click_dss_button"
self.interface.ToggleDragonSoulWindow()

#if app.ENABLE_SPECIAL_STORAGE:
#def ClickSpecialStorage(self):
#self.interface.ToggleSpecialStorageWindow()

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(localeInfo.PICK_MONEY_TITLE)
#self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
#self.dlgPickMoney.Open(curMoney)
#self.dlgPickMoney.SetMax(7)

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 __InventoryGlobalSlotPosToLocalSlotPos(self, globalPos):
return globalPos - self.inventoryPageIndex*player.INVENTORY_PAGE_SIZE

def GetInventoryPageIndex(self):
return self.inventoryPageIndex

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

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

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

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

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

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

return

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

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

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

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

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

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

def RefreshBagSlotWindow(self):
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 == 0ÀÌ¸é ¼ÒÄÏÀ» ºñ¿î´Ù.
if 0 == itemCount:
self.wndItem.ClearSlot(i)
continue
elif 1 == itemCount:
itemCount = 0

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

if app.ENABLE_CHANGELOOK_SYSTEM:
itemTransmutedVnum = player.GetItemTransmutation(slotNumber)
if itemTransmutedVnum:
self.wndItem.DisableCoverButton(i)
else:
self.wndItem.EnableCoverButton(i)

## ÀÚµ¿¹°¾à (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 * self.inventoryPageIndex:
slotNumber -= player.INVENTORY_PAGE_SIZE * self.inventoryPageIndex

isActivated = 0 != metinSocket[0]

if isActivated:
self.wndItem.ActivateSlot(slotNumber)
potionType = 0;
if constInfo.IS_AUTO_POTION_HP(itemVnum):
potionType = player.AUTO_POTION_TYPE_HP
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)

if app.ENABLE_TRADABLE_ICON:
self.RefreshMarkSlots(i)

if app.ENABLE_HIGHLIGHT_SYSTEM:
if slotNumber in self.listHighlightedSlot:
self.wndItem.ActivateSlot(i)

if app.ENABLE_SASH_SYSTEM and app.ENABLE_CHANGELOOK_SYSTEM:
slotNumberChecked = 0
if not constInfo.IS_AUTO_POTION(itemVnum):

if app.ENABLE_HIGHLIGHT_SYSTEM:
if not slotNumber in self.listHighlightedSlot:
self.wndItem.DeactivateSlot(i)
else:
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
for q in xrange(changelook.WINDOW_MAX_MATERIALS):
(isHere, iCell) = changelook.GetAttachedItem(q)
if isHere:
if iCell == slotNumber:
self.wndItem.ActivateSlot(i, (238.00 / 255.0), (11.00 / 255.0), (11.00 / 255.0), 1.0)
if not slotNumber in self.listAttachedCl:
self.listAttachedCl.append(slotNumber)

slotClNumberChecked = 1
else:
if slotNumber in self.listAttachedSashs and not slotNumberChecked:
self.wndItem.DeactivateSlot(i)
self.listAttachedSashs.remove(slotNumber)

self.wndItem.RefreshSlot()

if self.wndBelt:
self.wndBelt.RefreshSlot()

if app.ENABLE_TRADABLE_ICON:
map(lambda wnd:wnd.RefreshLockedSlot(), self.bindWnds)

def RefreshEquipSlotWindow(self):
getItemVNum=player.GetItemIndex
getItemCount=player.GetItemCount
setItemVNum=self.wndEquip.SetItemSlot
for i in xrange(player.EQUIPMENT_PAGE_COUNT):
slotNumber = player.EQUIPMENT_SLOT_START + i
itemCount = getItemCount(slotNumber)
if itemCount <= 1:
itemCount = 0
setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)
if app.ENABLE_CHANGELOOK_SYSTEM:
itemTransmutedVnum = player.GetItemTransmutation(slotNumber)
if itemTransmutedVnum:
self.wndEquip.DisableCoverButton(slotNumber)
else:
self.wndEquip.EnableCoverButton(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)
if app.ENABLE_CHANGELOOK_SYSTEM:
itemTransmutedVnum = player.GetItemTransmutation(slotNumber)
if itemTransmutedVnum:
self.wndEquip.DisableCoverButton(slotNumber)
else:
self.wndEquip.EnableCoverButton(slotNumber)
print "ENABLE_NEW_EQUIPMENT_SYSTEM", slotNumber, itemCount, getItemVNum(slotNumber)



self.wndEquip.RefreshSlot()

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

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

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

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 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_PRIVATE_SHOP == attachedSlotType:
mouseModule.mouseController.RunCallBack("INVENTORY")

elif player.SLOT_TYPE_SHOP == attachedSlotType:
net.SendShopBuyPacket(attachedSlotPos)

elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:

if player.ITEM_MONEY == attachedItemIndex:
net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")

else:
net.SendSafeboxCheckoutPacket(attachedSlotPos, selectedSlotPos)

elif player.SLOT_TYPE_MALL == attachedSlotType:
net.SendMallCheckoutPacket(attachedSlotPos, selectedSlotPos)

mouseModule.mouseController.DeattachObject()

def SelectItemSlot(self, itemSlotIndex):
if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
return

itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

if mouseModule.mouseController.isAttached():
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()

if app.ENABLE_SPECIAL_STORAGE:
if player.SLOT_TYPE_INVENTORY == attachedSlotType or player.SLOT_TYPE_STONE_INVENTORY == attachedSlotType:
self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex)
else:
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")

#ifdef ENABLE_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()
#endif

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


self.sellingSlotitemIndex = itemIndex
self.sellingSlotitemCount = itemCount

item.SelectItem(itemIndex)

if item.IsAntiFlag(item.ANTIFLAG_SELL):
popup = uiCommons.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 = uiCommons.QuestionDialog()
self.questionDialog.SetText(localeInfo.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
self.questionDialog.count = itemCount

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

def __OnClosePopupDialog(self):
self.pop = None

def RefineItem(self, scrollSlotPos, targetSlotPos):

scrollIndex = player.GetItemIndex(scrollSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)

if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos):
return

self.__SendUseItemToItemPacket(scrollSlotPos, targetSlotPos)
#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 and app.ENABLE_CHANGELOOK_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)
if item.GetValue(0) == changelook.CLEAN_ATTR_VALUE0:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHANGE_LOOK_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 = uiCommons.QuestionDialog()
self.questionDialog.SetText(localeInfo.REFINE_DO_YOU_SEPARATE_METIN)
if app.ENABLE_SASH_SYSTEM and app.ENABLE_CHANGELOOK_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)
if item.GetValue(0) == changelook.CLEAN_ATTR_VALUE0:
self.questionDialog.SetText(localeInfo.CHANGE_LOOK_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):
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 app.ENABLE_HIGHLIGHT_SYSTEM:
stat = 0
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
itemVnum = player.GetItemIndex(slotNumber)
if constInfo.IS_AUTO_POTION(itemVnum):
metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]
if slotNumber >= player.INVENTORY_PAGE_SIZE*self.inventoryPageIndex:
slotNumber -= player.INVENTORY_PAGE_SIZE*self.inventoryPageIndex

isActivated = 0 != metinSocket[0]
if isActivated:
stat = 1

if not stat:
if slotNumber in self.listHighlightedSlot:
self.wndItem.DeactivateSlot(overSlotPos)
try:
if app.ENABLE_SASH_SYSTEM:
if not slotNumber in self.listAttachedSashs:
self.listHighlightedSlot.remove(slotNumber)
else:
self.listHighlightedSlot.remove(slotNumber)
except:
pass
overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
self.wndItem.SetUsableItem(False)


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:
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()

if self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPos):
self.wndItem.SetUsableItem(True)
self.wndItem.SetUseMode(True)
self.ShowToolTip(overSlotPos)
return
else:
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):
"´Ù¸¥ ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö ÀÖ´Â ¾ÆÀÌÅÛÀΰ¡?"

#ifdef ENABLE_NEW_PET_SYSTEM
if srcItemVNum >= 55701 and srcItemVNum <= 55704:
return True

if srcItemVNum == 55001:
return True
#endif

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):
"´ë»ó ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö Àִ°¡?"

#ifdef ENABLE_NEW_PET_SYSTEM
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
#endif

if app.ENABLE_SPECIAL_STORAGE:
if srcSlotPos == dstSlotPos and not item.IsMetin(srcItemVNum):
return False
else:
if srcSlotPos == dstSlotPos:
return False

if item.IsRefineScroll(srcItemVNum):
if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):
return True
elif srcItemVNum == player.GetItemIndex(dstSlotPos):
if player.GetItemCount(dstSlotPos) < 200:
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

return False

def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos):

if app.ENABLE_SPECIAL_STORAGE:
if srcItemSlotPos == dstItemSlotPos and not item.IsMetin(srcItemVID):
return
else:
if srcItemSlotPos == dstItemSlotPos:
return

if srcItemVID == player.GetItemIndex(dstItemSlotPos):
self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
return

if player.GetItemIndex(srcItemSlotPos) == 71051:
self.AttachBonusToItem(srcItemSlotPos, dstItemSlotPos)

#ifdef ENABLE_NEW_PET_SYSTEM
if srcItemVID >= 55701 and srcItemVID <= 55704 and player.GetItemIndex(dstItemSlotPos) == 55002:
self.questionDialog = uiCommons.QuestionDialog()
self.questionDialog.SetText("Eşyayı nakliye kutusuna eklemek istiyor musun? ")
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) <= 55704:
self.questionDialog = uiCommons.QuestionDialog()
self.questionDialog.SetText("Beslemek istediğine emin misin?")
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
#endif

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)

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 = uiCommons.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 __CanCleanBrokenMetinStone(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False

item.SelectItem(dstItemVNum)

if item.ITEM_TYPE_WEAPON != item.GetItemType():
return False

for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemMetinSocket(dstSlotPos, i) == constInfo.ERROR_METIN_STONE:
return TRUE

return False

def __CanChangeItemAttrList(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False

item.SelectItem(dstItemVNum)

if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):
return False

for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemAttribute(dstSlotPos, i) != 0:
return TRUE

return False

def __CanPutAccessorySocket(self, dstSlotPos, mtrlVnum):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False

item.SelectItem(dstItemVNum)

if item.GetItemType() != item.ITEM_TYPE_ARMOR:
return False

if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
return False

curCount = player.GetItemMetinSocket(dstSlotPos, 0)
maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

if mtrlVnum != constInfo.GET_ACCESSORY_MATERIAL_VNUM(dstItemVNum, item.GetItemSubType()):
return False

if curCount>=maxCount:
return False

return TRUE

def __CanAddAccessorySocket(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False

item.SelectItem(dstItemVNum)

if item.GetItemType() != item.ITEM_TYPE_ARMOR:
return False

if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
return False

curCount = player.GetItemMetinSocket(dstSlotPos, 0)
maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

ACCESSORY_SOCKET_MAX_SIZE = 3
if maxCount >= ACCESSORY_SOCKET_MAX_SIZE:
return False

return TRUE

def __CanAddItemAttr(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False

item.SelectItem(dstItemVNum)

if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):
return False

attrCount = 0
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemAttribute(dstSlotPos, i) != 0:
attrCount += 1

if attrCount<4:
return TRUE

return False

def ShowToolTip(self, slotIndex):
if None != self.tooltipItem:
self.tooltipItem.SetInventoryItem(slotIndex)

def OnTop(self):
if None != self.tooltipItem:
self.tooltipItem.SetTop()

if app.ENABLE_TRADABLE_ICON:
map(lambda wnd:wnd.RefreshLockedSlot(), self.bindWnds)
self.RefreshMarkSlots()

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

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

if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
return

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

if app.ENABLE_SASH_SYSTEM:
if self.isShowSashWindow():
sash.Add(player.INVENTORY, slotIndex, 255)
return

if app.ENABLE_CHANGELOOK_SYSTEM:
if self.isShowChangeLookWindow():
changelook.Add(player.INVENTORY, slotIndex, 255)
return

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

################################
#ITEM GIYME SURE ENGELI BAŞLADI
#Time6 = {"LAST6":0}

# if app.GetGlobalTimeStamp()>=self.Time6["LAST6"]:
# self.Time6["LAST6"] = app.GetGlobalTimeStamp()+1
# Burada kodumuz başlıyor #

# Burada kodumuz bitiyor #
# else:
# chat.AppendChat(chat.CHAT_TYPE_INFO,"<Sistem> Lütfen 1 saniye bekleyin.")
#
#ITEM GIYME SURE ENGELI BITTI
################################

def __UseItem(self, slotIndex):
ItemVNum = player.GetItemIndex(slotIndex)
item.SelectItem(ItemVNum)
if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):
self.questionDialog = uiCommons.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 player.GetItemTypeBySlot(slotIndex) == item.ITEM_TYPE_GIFTBOX:
if app.ENABLE_SHOW_CHEST_DROP:
if self.interface:
if self.interface.dlgChestDrop:
if not self.interface.dlgChestDrop.IsShow():
self.interface.dlgChestDrop.Open(slotIndex)
net.SendChestDropInfo(slotIndex)
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

if srcSlotPos >= player.DRAGON_SOUL_EQUIPMENT_SLOT_START and srcSlotPos <= (player.DRAGON_SOUL_EQUIPMENT_SLOT_START + player.DRAGON_SOUL_EQUIPMENT_FIRST_SIZE - 1):
return

net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)

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

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

if app.ENABLE_CHANGELOOK_SYSTEM:
def SetChangeLookWindow(self, wndChangeLook):
self.wndChangeLook = wndChangeLook

def isShowChangeLookWindow(self):
if self.wndChangeLook:
if self.wndChangeLook.IsShow():
return 1
return 0

def OnMoveWindow(self, x, y):
# print "Inventory Global Pos : ", self.GetGlobalPosition()
if self.wndBelt:
print "Belt Global Pos : ", self.wndBelt.GetGlobalPosition()
self.wndBelt.AdjustPositionAndSize()

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
#SECENEKLER - START
self.UiSaplingSwitchbot = None
self.UiSiralamaList = None
self.NewShop = None
self.UiPlayerListe = None
toolTip = None
#SECENEKLER - END
self.__LoadWindow()

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

def Kapat(self):
self.wndBeltInventoryLayer.Hide()
self.Hide()
self.AdjustPositionAndSize()

def Ac(self):
ui.ScriptWindow.Show(self)
self.wndBeltInventoryLayer.Show()
self.AdjustPositionAndSize()

def Show(self, openBeltSlot = False):
self.__LoadWindow()
self.RefreshSlot()
ui.ScriptWindow.Show(self)
self.AdjustPositionAndSize()

def Close(self):
if self.toolTip:
self.toolTip.Hide()

self.wndBeltInventoryLayer.Hide()
self.Hide()
self.AdjustPositionAndSize()

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

def OpenInventory(self):
self.wndBeltInventoryLayer.Hide()
self.AdjustPositionAndSize()

def CloseInventory(self):
self.wndBeltInventoryLayer.Hide()
self.AdjustPositionAndSize()

def GetBasePosition(self):
x, y = self.wndInventory.GetGlobalPosition()
return x - 55, y

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 + 47, by);
self.SetSize(20, self.GetHeight())

#SECENEK SISTEMI - START
Time10 = {"LAST10":0}
Time11 = {"LAST11":0}
Time12 = {"LAST12":0}
Time13 = {"LAST13":0}

def efsun_quest(self): # Efsun botu
if not constInfo.efsunmenu:
if not self.UiSaplingSwitchbot:
self.UiSaplingSwitchbot = uisaplingsw.OptionDialog()
self.UiSaplingSwitchbot.Show()
constInfo.efsunmenu = 1
else:
chat.AppendChat(1, "<Sistem> Efsun botu menüsü zaten açık ")

def pazar_quest(self): # Pazar butonu
if str(player.GetName())[0] == "[":
chat.AppendChat(chat.CHAT_TYPE_INFO, "<Sistem> Oyun yetkilisi pazar kuramaz. ")
return
if app.GetGlobalTimeStamp()>=self.Time10["LAST10"]:
self.Time10["LAST10"] = app.GetGlobalTimeStamp()+5
# Burada kodumuz başlıyor #
quest = constInfo.PAZAR_QUEST_BUTTON
event.QuestButtonClick(quest)
# Burada kodumuz bitiyor #
else:
chat.AppendChat(chat.CHAT_TYPE_INFO,"<Sistem> Bu işlemi bu kadar hızlı yapamazsın.")

def ticaret_quest(self): # Ticaret aynasi
if app.GetGlobalTimeStamp()>=self.Time11["LAST11"]:
self.Time11["LAST11"] = app.GetGlobalTimeStamp()+5
# Burada kodumuz başlıyor #
if not constInfo.ticaretayna:
quest = constInfo.AYNA_QUEST_BUTTON
event.QuestButtonClick(quest)
constInfo.ticaretayna = 1
else:
chat.AppendChat(1, "<Sistem> Ticaret aynası zaten açık")
# Burada kodumuz bitiyor #
else:
chat.AppendChat(chat.CHAT_TYPE_INFO,"<Sistem> Bu işlemi bu kadar hızlı yapamazsın.")

def antiexp_quest(self):
if app.GetGlobalTimeStamp()>=self.Time12["LAST12"]:
self.Time12["LAST12"] = app.GetGlobalTimeStamp()+5
# Burada kodumuz başlıyor #
quest = constInfo.ANTIEXP_QUEST_BUTTON
event.QuestButtonClick(quest)
# Burada kodumuz bitiyor #
else:
chat.AppendChat(chat.CHAT_TYPE_INFO,"<Sistem> Bu işlemi bu kadar hızlı yapamazsın.")

def TurnuvaEngel(self):
mapkontrol2 = [
"metin2_map_skipia_dungeon_01",
"metin2_map_skipia_dungeon_02",
"metin2_map_skipia_dungeon_boss",
"metin2_map_wedding_01",
"metin2_map_t1",
"metin2_map_t2",
"metin2_map_t3",
"metin2_map_t4",
"metin2_map_oxevent",
"metin2_map_empirewar02",
"gm_guild_build",
"metin2_map_guild_inside01",
"metin2_map_deviltower1"
]
if str(background.GetCurrentMapName()) in mapkontrol2:
return TRUE

return FALSE

def turnuva_quest(self): # Turnuva Sistemi
if self.TurnuvaEngel():
chat.AppendChat(1, "")
chat.AppendChat(1, "|cffFFC125<Sistem> Bu bölgede turnuvaya giriş yapamazsın.")
return
if not constInfo.turnuvapenceresi:
#KOD BURAYA - START
constInfo.turnuvapenceresi = 1
self.OpenCombatZoneWindow()
#KOD BURAYA - END
else:
chat.AppendChat(1, "<Sistem> Turnuva penceresi zaten açık")

def hizli_ekipman(self):
import uiVectorsHzl
self.VectorsHzl = uiVectorsHzl.VectorsKSK()
self.VectorsHzl.Show()

def etkinlik_takvim(self):
if not constInfo.takvim:
self.comp = uievent.Dialog1()
self.comp.OpenWindow()
constInfo.takvim = 1
else:
chat.AppendChat(1, "<Sistem> Hızlı statü zaten açık ")

def boss_siralama(self):
if not constInfo.bossrank2:
import uiBossRanking
self.BossGui = uiBossRanking.BossGui()
self.BossGui.Show()
constInfo.bossrank2 = 1
else:
chat.AppendChat(1, "<Sistem> Sıralama zaten açık ")

def oto_mesaj(self):
if not constInfo.spambot:
import uiSpamBot
self.Spamdialog = uiSpamBot.Spamdialog()
self.Spamdialog.Show()
constInfo.spambot = 1
else:
chat.AppendChat(1, "<Sistem> Mesaj botu zaten açık ")

def hizli_statu(self):
if not constInfo.hizlistat:
import uiStatusUp
self.StatusUp = uiStatusUp.StatusUp()
self.StatusUp.Show()
constInfo.hizlistat = 1
else:
chat.AppendChat(1, "<Sistem> Hızlı statü zaten açık ")

def gunluk_hediye(self):
if player.GetStatus(player.LEVEL)<constInfo.HEDIYE_LEVEL:
chat.AppendChat(chat.CHAT_TYPE_INFO,"Günlük hediye alabilmen için 80.seviye olmalısın.")
return
if app.GetGlobalTimeStamp()>=self.Time13["LAST13"]:
self.Time13["LAST13"] = app.GetGlobalTimeStamp()+5
# Burada kodumuz başlıyor #
quest = constInfo.HEDIYE_QUEST_BUTTON
event.QuestButtonClick(quest)
# Burada kodumuz bitiyor #
else:
chat.AppendChat(chat.CHAT_TYPE_INFO,"<Sistem> Bu işlemi bu kadar hızlı yapamazsın.")

def Rank_Sistemi(self):
if not constInfo.siralamaboard:
if not self.UiSiralamaList:
self.UiSiralamaList = uisiralama.OptionDialog()
self.UiSiralamaList.Show()
constInfo.siralamaboard = 1
else:
chat.AppendChat(1, "<Sistem> Sıralama menüsü zaten açık ")

def _VectorsHzl(self):
import uiVectorsHzl
self.VectorsHzl = uiVectorsHzl.VectorsKSK()
self.VectorsHzl.Show()

if (app.ENABLE_COMBAT_ZONE):
def OnAskCombatZoneQuestionDialog(self):
import uiCommons
constInfo.turnuvapenceresi = 0
self.combatZoneLeaveQuestionDialog = uiCommons.QuestionDialog2()
self.combatZoneLeaveQuestionDialog.SetText1(uiScriptLocale.EXIT_BATTLE_FIELD_COLLECTED_POINTS % (player.GetCombatZonePoints()))
self.combatZoneLeaveQuestionDialog.SetText2(uiScriptLocale.EXIT_BATTLE_FIELD)
self.combatZoneLeaveQuestionDialog.SetWidth(320)
self.combatZoneLeaveQuestionDialog.SetAcceptEvent(lambda arg = TRUE: self.OnToggleCombatZoneQuestionDialog(arg))
self.combatZoneLeaveQuestionDialog.SetCancelEvent(lambda arg = FALSE: self.OnToggleCombatZoneQuestionDialog(arg))
self.combatZoneLeaveQuestionDialog.Open()

def OnToggleCombatZoneQuestionDialog(self, answer):
if not self.combatZoneLeaveQuestionDialog:
return

self.combatZoneLeaveQuestionDialog.Close()
self.combatZoneLeaveQuestionDialog = None

if not answer:
return

constInfo.turnuvapenceresi = 0
net.SendCombatZoneRequestActionPacket(net.COMBAT_ZONE_ACTION_LEAVE, net.COMBAT_ZONE_EMPTY_DATA)
return TRUE

def OpenCombatZoneWindow(self):
if player.IsCombatZoneMap():
self.OnAskCombatZoneQuestionDialog()
else:
net.SendCombatZoneRequestActionPacket(net.COMBAT_ZONE_ACTION_OPEN_RANKING, net.COMBAT_ZONE_EMPTY_DATA)
#SECENEK SISTEMI - END

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

self.isLoaded = 1
self.SkillTooltip = uiToolTip.ToolTip(180)

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

try:
self.ORIGINAL_WIDTH = self.GetWidth()
self.wndBeltInventoryLayer = self.GetChild("BeltInventoryLayer")
tooltip = uiToolTip.ToolTip()
self.toolTip = tooltip

self.efsunBtn = self.GetChild("Efsun_Botu") # Efsun botu 1
self.pazarBtn = self.GetChild("Pazar_Butonu") # Pazar butonu 2
self.ticaynaBtn = self.GetChild("Ticaret_Aynasi") # Ticaret aynasi 3
self.siralamaBtn = self.GetChild("Siralama_Sistemi") # Siralama sistemi 4
self.expBtn = self.GetChild("Anti_Exp") # Anti exp sistemi 5
self.hizliEkipman = self.GetChild("hizli_ekipman") # Hizli ekipman sistemi 6
self.etkinlikTakvim = self.GetChild("etkinlik_takvim") #Etkinlik takvim sistemi 7
self.bosSiralama = self.GetChild("boss_siralama") # Boss sıralama sistemi 8
self.otoMesaj = self.GetChild("oto_mesaj") # Oto spam bot sistemi 9
self.hizliStatu = self.GetChild("hizli_statu") # Hızlı statü sistemi 10
self.gunlukHediye = self.GetChild("gunluk_hediye") # Gunluk hediye sistemi 11
self.RankSistem = self.GetChild("Rank_Sistemi") # Oyun ici siralama sistemi 12
self.VectorsHzl = self.GetChild2("VectorsHzl")

self.efsunBtn.SetEvent(ui.__mem_func__(self.efsun_quest)) # Efsun botu 1
self.pazarBtn.SetEvent(ui.__mem_func__(self.pazar_quest)) # Pazar butonu 2
self.ticaynaBtn.SetEvent(ui.__mem_func__(self.ticaret_quest)) # Ticaret aynasi 3
self.siralamaBtn.SetEvent(ui.__mem_func__(self.turnuva_quest)) # Siralama sistemi 4
self.expBtn.SetEvent(ui.__mem_func__(self.antiexp_quest)) # Anti exp sistemi 5
self.hizliEkipman.SetEvent(ui.__mem_func__(self.hizli_ekipman)) # Hızlı ekipman sistemi 6
self.etkinlikTakvim.SetEvent(ui.__mem_func__(self.etkinlik_takvim)) # Etkinlik takvim sistemi 7
self.bosSiralama.SetEvent(ui.__mem_func__(self.boss_siralama)) # Boss sıralama sistemi 8
self.otoMesaj.SetEvent(ui.__mem_func__(self.oto_mesaj)) # Oto spam bot sistemi 9
self.hizliStatu.SetEvent(ui.__mem_func__(self.hizli_statu)) # Hızlı statü sistemi 10
self.gunlukHediye.SetEvent(ui.__mem_func__(self.gunluk_hediye)) # Gunluk hediye sistemi 11
self.RankSistem.SetEvent(ui.__mem_func__(self.Rank_Sistemi)) # Oyun ici siralama sistemi 12

self.efsunBtn.ShowToolTip = lambda arg=1: self.__OverInButtonMenu(arg)
self.efsunBtn.HideToolTip = lambda arg=1: self.__OverOutButtonMenu()
self.pazarBtn.ShowToolTip = lambda arg=2: self.__OverInButtonMenu(arg)
self.pazarBtn.HideToolTip = lambda arg=2: self.__OverOutButtonMenu()
self.ticaynaBtn.ShowToolTip = lambda arg=3: self.__OverInButtonMenu(arg)
self.ticaynaBtn.HideToolTip = lambda arg=3: self.__OverOutButtonMenu()
self.siralamaBtn.ShowToolTip = lambda arg=4: self.__OverInButtonMenu(arg)
self.siralamaBtn.HideToolTip = lambda arg=4: self.__OverOutButtonMenu()
self.expBtn.ShowToolTip = lambda arg=5: self.__OverInButtonMenu(arg)
self.expBtn.HideToolTip = lambda arg=5: self.__OverOutButtonMenu()

self.hizliEkipman.ShowToolTip = lambda arg=6: self.__OverInButtonMenu(arg)
self.hizliEkipman.HideToolTip = lambda arg=6: self.__OverOutButtonMenu()

self.etkinlikTakvim.ShowToolTip = lambda arg=7: self.__OverInButtonMenu(arg)
self.etkinlikTakvim.HideToolTip = lambda arg=7: self.__OverOutButtonMenu()

self.bosSiralama.ShowToolTip = lambda arg=8: self.__OverInButtonMenu(arg)
self.bosSiralama.HideToolTip = lambda arg=8: self.__OverOutButtonMenu()

self.otoMesaj.ShowToolTip = lambda arg=9: self.__OverInButtonMenu(arg)
self.otoMesaj.HideToolTip = lambda arg=9: self.__OverOutButtonMenu()

self.hizliStatu.ShowToolTip = lambda arg=10: self.__OverInButtonMenu(arg)
self.hizliStatu.HideToolTip = lambda arg=10: self.__OverOutButtonMenu()

self.gunlukHediye.ShowToolTip = lambda arg=11: self.__OverInButtonMenu(arg)
self.gunlukHediye.HideToolTip = lambda arg=11: self.__OverOutButtonMenu()

self.RankSistem.ShowToolTip = lambda arg=12: self.__OverInButtonMenu(arg)
self.RankSistem.HideToolTip = lambda arg=12: self.__OverOutButtonMenu()

safa = 5

except:
import exception
exception.Abort("CostumeWindow.LoadWindow.BindObject")

def __ShowMenuToolTip(self, statDesc):
self.toolTip.ClearToolTip()
self.toolTip.AppendTextLine(statDesc)
self.toolTip.Show()

def __OverInButtonMenu(self, num):
if num == 1:
self.__ShowMenuToolTip("Efsun Botu")
elif num == 2:
self.__ShowMenuToolTip("Market Aç")
elif num == 3:
self.__ShowMenuToolTip("Ticaret Aynası")
elif num == 4:
self.__ShowMenuToolTip("Hayomi Turnuvası")
elif num == 5:
self.__ShowMenuToolTip("Anti EXP")
elif num == 6:
self.__ShowMenuToolTip("Hızlı Ekipman")
elif num == 7:
self.__ShowMenuToolTip("Etkinlik Takvimi")
elif num == 8:
self.__ShowMenuToolTip("Boss Sıralaması")
elif num == 9:
self.__ShowMenuToolTip("Otomatik Mesaj")
elif num == 10:
self.__ShowMenuToolTip("Hızlı Statü")
elif num == 11:
self.__ShowMenuToolTip("Günlük Hediye")
elif num == 12:
self.__ShowMenuToolTip("Oyun Sıralaması")

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

def RefreshSlot(self):
getItemVNum=player.GetItemIndex

Hepsini görmek için tıklayın...

import uiScriptLocale
import app5 as app
import item

EQUIPMENT_START_INDEX = 180
ROOT = "d:/ymir work/ui/game/"

window = {
"name" : "InventoryWindow",
## 600 - (width + 오른쪽으로 부터 띄우기 24 px)
"x" : SCREEN_WIDTH - 176,
"y" : SCREEN_HEIGHT - 37 - 565,

"style" : ("movable", "float",),

"width" : 176,
"height" : 565,

"children" :
(
## Inventory, Equipment Slots
{
"name" : "board",
"type" : "board",
"style" : ("attach",),

"x" : 0,
"y" : 0,

"width" : 176,
"height" : 565,

"children" :
(
## Title
{
"name" : "TitleBar",
"type" : "titlebar",
"style" : ("attach",),

"x" : 38,
#"x" : 8,
"y" : 7,

"width" : 130,
"color" : "yellow",

"children" :
(
#{ "name":"TitleName", "type":"text", "x":77, "y":3, "text":uiScriptLocale.INVENTORY_TITLE, "text_horizontal_align":"center" },
{ "name":"TitleName", "type":"text", "x":91, "y":3, "text":uiScriptLocale.INVENTORY_TITLE, "text_horizontal_align":"right" },
),
},

{
"name" : "CombiningButton",
"type" : "button",

# "x" : 0,
# "y" : 0,

"x" : 5,
"y" : 3,

"tooltip_text" : uiScriptLocale.INVENTORY_COMBINING_TEXT,

"default_image" : "d:/ymir work/ui/NormalInventoryButton.tga",
"over_image" : "d:/ymir work/ui/RefInventoryButton.tga",
"down_image" : "d:/ymir work/ui/BasiliInventoryButton.tga",

},

## Equipment Slot
{
"name" : "Equipment_Base",
"type" : "image",

"x" : 10,
"y" : 33,

"image" : "equipment_bg_without_ring.tga",

"children" :
(

{
"name" : "EquipmentSlot",
"type" : "slot",

"x" : 3,
"y" : 3,

"width" : 150,
"height" : 182,

"slot" : (
{"index":EQUIPMENT_START_INDEX+0, "x":39, "y":37, "width":32, "height":64},
{"index":EQUIPMENT_START_INDEX+1, "x":39, "y":2, "width":32, "height":32},
{"index":EQUIPMENT_START_INDEX+2, "x":39, "y":145, "width":32, "height":32},
{"index":EQUIPMENT_START_INDEX+3, "x":75, "y":67, "width":32, "height":32},
{"index":EQUIPMENT_START_INDEX+4, "x":3, "y":3, "width":32, "height":96},
{"index":EQUIPMENT_START_INDEX+5, "x":114, "y":67, "width":32, "height":32},
{"index":EQUIPMENT_START_INDEX+6, "x":114, "y":35, "width":32, "height":32},
{"index":EQUIPMENT_START_INDEX+7, "x":2, "y":144, "width":32, "height":32}, # RING SLOT 1
{"index":EQUIPMENT_START_INDEX+8, "x":74, "y":144, "width":32, "height":32}, # RING SLOT 2
{"index":EQUIPMENT_START_INDEX+9, "x":114, "y":2, "width":32, "height":32},
{"index":EQUIPMENT_START_INDEX+10, "x":75, "y":35, "width":32, "height":32},
{"index":item.EQUIPMENT_BELT, "x":39, "y":106, "width":32, "height":32},
),
},
## Dragon Soul Button
{
"name" : "DSSButton",
"type" : "button",

"x" : 115,
"y" : 107,

"tooltip_text" : "Simya",

"default_image" : "d:/ymir work/ui/dragonsoul/dss_inventory_button_01.tga",
"over_image" : "d:/ymir work/ui/dragonsoul/dss_inventory_button_02.tga",
"down_image" : "d:/ymir work/ui/dragonsoul/dss_inventory_button_03.tga",
},
## MallButton
{
"name" : "MallButton",
"type" : "button",

"x" : 118,
"y" : 147,

"tooltip_text" : "Depo",

"default_image" : "d:/ymir work/ui/game/TaskBar/Mall_Button_01.tga",
"over_image" : "d:/ymir work/ui/game/TaskBar/Mall_Button_02.tga",
"down_image" : "d:/ymir work/ui/game/TaskBar/Mall_Button_03.tga",
},

#{
# "name" : "SpecialStorageButton",
# "type" : "button",

# "x" : 5,
# "y" : 108,

# "tooltip_text" : "Envanter [K]",

# "default_image" : ROOT + "TaskBar/Inventory_Button_01.sub",
# "over_image" : ROOT + "TaskBar/Inventory_Button_02.sub",
# "down_image" : ROOT + "TaskBar/Inventory_Button_03.sub",
#},

## CostumeButton
{
"name" : "CostumeButton",
"type" : "button",

"x" : 78,
"y" : 5,

"tooltip_text" : uiScriptLocale.COSTUME_TITLE,

"default_image" : "d:/ymir work/ui/game/taskbar/costume_Button_01.tga",
"over_image" : "d:/ymir work/ui/game/taskbar/costume_Button_02.tga",
"down_image" : "d:/ymir work/ui/game/taskbar/costume_Button_03.tga",
},
{
"name" : "Equipment_Tab_01",
"type" : "radio_button",

"x" : 86,
"y" : 161,

"default_image" : "d:/ymir work/ui/game/windows/tab_button_small_01.sub",
"over_image" : "d:/ymir work/ui/game/windows/tab_button_small_02.sub",
"down_image" : "d:/ymir work/ui/game/windows/tab_button_small_03.sub",

"children" :
(
{
"name" : "Equipment_Tab_01_Print",
"type" : "text",

"x" : 0,
"y" : 0,

"all_align" : "center",

"text" : "I",
},
),
},
{
"name" : "Equipment_Tab_02",
"type" : "radio_button",

"x" : 86 + 32,
"y" : 161,

"default_image" : "d:/ymir work/ui/game/windows/tab_button_small_01.sub",
"over_image" : "d:/ymir work/ui/game/windows/tab_button_small_02.sub",
"down_image" : "d:/ymir work/ui/game/windows/tab_button_small_03.sub",

"children" :
(
{
"name" : "Equipment_Tab_02_Print",
"type" : "text",

"x" : 0,
"y" : 0,

"all_align" : "center",

"text" : "II",
},
),
},

),
},

{
"name" : "Inventory_Tab_01",
"type" : "radio_button",

"x" : 10,
"y" : 33 + 191,

"default_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_01.sub",
"over_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_02.sub",
"down_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_03.sub",
"tooltip_text" : uiScriptLocale.INVENTORY_PAGE_BUTTON_TOOLTIP_1,

"children" :
(
{
"name" : "Inventory_Tab_01_Print",
"type" : "text",

"x" : 0,
"y" : 0,

"all_align" : "center",

"text" : "I",
},
),
},
{
"name" : "Inventory_Tab_02",
"type" : "radio_button",

#"x" : 10 + 78,
"x" : 10 + 39,
"y" : 33 + 191,

"default_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_01.sub",
"over_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_02.sub",
"down_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_03.sub",
"tooltip_text" : uiScriptLocale.INVENTORY_PAGE_BUTTON_TOOLTIP_2,

"children" :
(
{
"name" : "Inventory_Tab_02_Print",
"type" : "text",

"x" : 0,
"y" : 0,

"all_align" : "center",

"text" : "II",
},
),
},

{
"name" : "Inventory_Tab_03",
"type" : "radio_button",

"x" : 10 + 39 + 39,
"y" : 33 + 191,

"default_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_01.sub",
"over_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_02.sub",
"down_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_03.sub",
"tooltip_text" : uiScriptLocale.INVENTORY_PAGE_BUTTON_TOOLTIP_3,

"children" :
(
{
"name" : "Inventory_Tab_03_Print",
"type" : "text",

"x" : 0,
"y" : 0,

"all_align" : "center",

"text" : "III",
},
),
},

{
"name" : "Inventory_Tab_04",
"type" : "radio_button",

"x" : 10 + 39 + 39 + 39,
"y" : 33 + 191,

"default_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_01.sub",
"over_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_02.sub",
"down_image" : "d:/ymir work/ui/game/windows/tab_button_large_half_03.sub",
"tooltip_text" : uiScriptLocale.INVENTORY_PAGE_BUTTON_TOOLTIP_4,

"children" :
(
{
"name" : "Inventory_Tab_04_Print",
"type" : "text",

"x" : 0,
"y" : 0,

"all_align" : "center",

"text" : "IV",
},
),
},

## Item Slot
{
"name" : "ItemSlot",
"type" : "grid_table",

"x" : 8,
"y" : 246,

"start_index" : 0,
"x_count" : 5,
"y_count" : 9,
"x_step" : 32,
"y_step" : 32,

"image" : "d:/ymir work/ui/public/Slot_Base.sub"
},

## Print
{
"name":"Money_Slot",
"type":"button",

"x":10,
"y":28,

"horizontal_align":"center",
"vertical_align":"bottom",

"default_image" : "d:/ymir work/ui/public/parameter_slot_05.sub",
"over_image" : "d:/ymir work/ui/public/parameter_slot_05.sub",
"down_image" : "d:/ymir work/ui/public/parameter_slot_05.sub",

"children" :
(
{
"name":"Money_Icon",
"type":"image",

"x":-18,
"y":2,

"image":"d:/ymir work/ui/game/windows/money_icon.sub",
},

{
"name" : "Money",
"type" : "text",

"x" : 3,
"y" : 3,

"horizontal_align" : "right",
"text_horizontal_align" : "right",

"text" : "123456789",
},
),
},
),
},
),
}

Hepsini görmek için tıklayın...