[Problem]Yangi

[Szamaneczk@]

Witam!

Mój kolega posiada serwer hamachi i ma pewien problem : Gdy ktoś ma 100kk i np. do dodaje sobie jako gm 100kk to powinnam mieć 200kk a pisze ze mam 100kk. Co mam zrobić żeby było widać jak dodac sobie yangi zeby normalnie dzialało ?

[Virqoal]

Najlepiej zedytuj pierścien pod ten quest

MakinWasLubi.pltopic/31629-tut-jak-dodac-perscien-teleportacji/

i wtedy bedzie mógł sam sobie dać kase.

Pozdrawiam

[Szamaneczk@]

Najlepiej zedytuj pierścien pod ten quest

MakinWasLubi.pltopic/31629-tut-jak-dodac-perscien-teleportacji/

i wtedy bedzie mógł sam sobie dać kase.

Pozdrawiam

 

Mi chodzi o to że jak się expi i jak dropią yangi to widać że otrzymało się 1kk ale tego nie widać eq, dopiero po rlg. widać. I co trzeba zrobić żeby jak się otrzyma yang żeby liczba yang w eq się zmieniła bez relogu ...

[xDeStRuCtx]

Prawdopodobnie wina klienta - root - uiinventory.py. Wklej nam go tu.

[HeniekLopata]

jak się bawiłem zmianą game i db to jak było inne db to pokazywało właśnie że zabrało/dodało yang ale w eq tyle samo cały czas było ;p

[Szamaneczk@]

reef

[TheKamilPolska]

2x Up

Trzymaj :

 

 

import ui

import player

import mouseModule

import net

import app

import snd

import item

import player

import chat

import grp

import uiScriptLocale

import uiRefine

import uiAttachMetin

import uiPickMoney

import uiCommon

import uiPrivateShopBuilder # °łŔÎ?óÁˇ ż­?żľČ ItemMove ąćÁö

import locale

import constInfo

import ime

 

if locale.IsEUROPE()or locale.IsYMIR():

ITEM_MALL_BUTTON_ENABLE = TRUE

else:

ITEM_MALL_BUTTON_ENABLE = FALSE

 

ITEM_FLAG_APPLICABLE = 1 << 14

 

class InventoryWindow(ui.ScriptWindow):

 

USE_TYPE_TUPLE = ("USE_CLEAN_SOCKET", "USE_CHANGE_ATTRIBUTE", "USE_ADD_ATTRIBUTE", "USE_ADD_ATTRIBUTE2", "USE_ADD_ACCESSORY_SOCKET", "USE_PUT_INTO_ACCESSORY_SOCKET")

 

def __init__(self):

ui.ScriptWindow.__init__(self)

self.questionDialog = None

self.tooltipItem = None

self.sellingSlotNumber = -1

self.isLoaded = 0

 

self.__LoadWindow()

 

def __del__(self):

ui.ScriptWindow.__del__(self)

 

def Show(self):

self.__LoadWindow()

 

ui.ScriptWindow.Show(self)

 

 

def __LoadWindow(self):

if self.isLoaded == 1:

return

 

self.isLoaded = 1

 

try:

pyScrLoader = ui.PythonScriptLoader()

 

if ITEM_MALL_BUTTON_ENABLE:

pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "InventoryWindow.py")

else:

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

except:

import exception

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

 

try:

wndItem = self.GetChild("ItemSlot")

wndEquip = self.GetChild("EquipmentSlot")

self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))

self.wndMoney = self.GetChild("Money")

self.wndMoneySlot = self.GetChild("Money_Slot")

self.mallButton = self.GetChild2("MallButton")

 

self.inventoryTab = []

self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))

self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))

 

self.equipmentTab = []

self.equipmentTab.append(self.GetChild("Equipment_Tab_01"))

self.equipmentTab.append(self.GetChild("Equipment_Tab_02"))

 

except:

import exception

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

 

## Item

wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))

wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))

wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))

wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))

wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))

wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

 

## Equipment

wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))

wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))

wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))

wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))

wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))

wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

 

## PickMoneyDialog

dlgPickMoney = uiPickMoney.PickMoneyDialog()

dlgPickMoney.LoadDialog()

dlgPickMoney.Hide()

 

## RefineDialog

self.refineDialog = uiRefine.RefineDialog()

self.refineDialog.Hide()

 

## AttachMetinDialog

self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()

self.attachMetinDialog.Hide()

 

## MoneySlot

self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

 

self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))

self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))

self.inventoryTab[0].Down()

 

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

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

self.equipmentTab[0].Down()

self.equipmentTab[0].Hide()

self.equipmentTab[1].Hide()

 

self.wndItem = wndItem

self.wndEquip = wndEquip

self.dlgPickMoney = dlgPickMoney

 

# MallButton

if self.mallButton:

self.mallButton.SetEvent(ui.__mem_func__(self.ClickMallButton))

 

#####

 

## Refresh

self.SetInventoryPage(0)

self.SetEquipmentPage(0)

self.RefreshItemSlot()

self.RefreshStatus()

 

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.inventoryTab = []

self.equipmentTab = []

 

def Close(self):

if None != self.tooltipItem:

self.tooltipItem.HideToolTip()

 

self.OnCloseQuestionDialog()

self.dlgPickMoney.Close()

self.Hide()

 

def SetInventoryPage(self, page):

self.inventoryPageIndex = page

self.inventoryTab[1-page].SetUp()

self.RefreshBagSlotWindow()

 

def SetEquipmentPage(self, page):

self.equipmentPageIndex = page

self.equipmentTab[1-page].SetUp()

self.RefreshEquipSlotWindow()

 

def ClickMallButton(self):

print "click_mall_button"

net.SendChatPacket("/click_mall")

 

def OpenPickMoneyDialog(self):

 

if mouseModule.mouseController.isAttached():

 

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

if player.SLOT_TYPE_SAFEBOX == mouseModule.mouseController.GetAttachedType():

 

if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():

net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())

snd.PlaySound("sound/ui/money.wav")

 

mouseModule.mouseController.DeattachObject()

 

else:

curMoney = player.GetElk()

 

if curMoney <= 0:

return

 

self.dlgPickMoney.SetTitleName(locale.PICK_MONEY_TITLE)

self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))

self.dlgPickMoney.Open(curMoney)

self.dlgPickMoney.SetMax(7) # ŔÎşĄĹä¸? 990000 Á?ÇŃ ąö?× ĽöÁ¤

 

def OnPickMoney(self, money):

mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)

 

def OnPickItem(self, count):

itemSlotIndex = self.dlgPickMoney.itemGlobalSlotIndex

selectedItemVNum = player.GetItemIndex(itemSlotIndex)

mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, count)

 

def __InventoryLocalSlotPosToGlobalSlotPos(self, local):

 

if player.IsEquipmentSlot(local):

return local

 

return self.inventoryPageIndex*player.INVENTORY_PAGE_SIZE + local

 

def RefreshBagSlotWindow(self):

getItemVNum=player.GetItemIndex

getItemCount=player.GetItemCount

setItemVNum=self.wndItem.SetItemSlot

for i in xrange(player.INVENTORY_PAGE_SIZE):

slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)

itemCount = getItemCount(slotNumber)

if itemCount <= 1:

itemCount = 0

setItemVNum(i, getItemVNum(slotNumber), itemCount)

 

self.wndItem.RefreshSlot()

 

def RefreshEquipSlotWindow(self):

getItemVNum=player.GetItemIndex

getItemCount=player.GetItemCount

setItemVNum=self.wndEquip.SetItemSlot

for i in xrange(player.EQUIPMENT_PAGE_COUNT):

slotNumber = player.EQUIPMENT_SLOT_START + i

itemCount = getItemCount(slotNumber)

if itemCount <= 1:

itemCount = 0

setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

 

self.wndEquip.RefreshSlot()

 

def RefreshItemSlot(self):

self.RefreshBagSlotWindow()

self.RefreshEquipSlotWindow()

 

def RefreshStatus(self):

money = player.GetElk()

self.wndMoney.SetText(locale.NumberToMoneyString(money))

 

def SetItemToolTip(self, tooltipItem):

self.tooltipItem = tooltipItem

 

def SellItem(self):

 

net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count)

snd.PlaySound("sound/ui/money.wav")

self.OnCloseQuestionDialog()

 

def OnDetachMetinFromItem(self):

if None == self.questionDialog:

return

 

#net.SendItemUseToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)

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

self.OnCloseQuestionDialog()

 

def OnCloseQuestionDialog(self):

if self.questionDialog:

self.questionDialog.Close()

 

self.questionDialog = None

 

## Slot Event

def SelectEmptySlot(self, selectedSlotPos):

if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:

return

 

selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)

 

if mouseModule.mouseController.isAttached():

 

attachedSlotType = mouseModule.mouseController.GetAttachedType()

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()

attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

 

if player.SLOT_TYPE_INVENTORY == attachedSlotType:

itemCount = player.GetItemCount(attachedSlotPos)

attachedCount = mouseModule.mouseController.GetAttachedItemCount()

self.__SendMoveItemPacket(attachedSlotPos, selectedSlotPos, attachedCount)

 

if item.IsRefineScroll(attachedItemIndex):

self.wndItem.SetUseMode(FALSE)

 

elif player.SLOT_TYPE_PRIVATE_SHOP == attachedSlotType:

mouseModule.mouseController.RunCallBack("INVENTORY")

 

elif player.SLOT_TYPE_SHOP == attachedSlotType:

net.SendShopBuyPacket(attachedSlotPos)

 

elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:

 

if player.ITEM_MONEY == attachedItemIndex:

net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())

snd.PlaySound("sound/ui/money.wav")

 

else:

net.SendSafeboxCheckoutPacket(attachedSlotPos, selectedSlotPos)

 

elif player.SLOT_TYPE_MALL == attachedSlotType:

net.SendMallCheckoutPacket(attachedSlotPos, selectedSlotPos)

 

mouseModule.mouseController.DeattachObject()

 

def SelectItemSlot(self, itemSlotIndex):

if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:

return

 

itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

 

if mouseModule.mouseController.isAttached():

attachedSlotType = mouseModule.mouseController.GetAttachedType()

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()

 

if player.SLOT_TYPE_INVENTORY == attachedSlotType:

self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex)

 

mouseModule.mouseController.DeattachObject()

 

else:

 

curCursorNum = app.GetCursor()

if app.SELL == curCursorNum:

self.__SellItem(itemSlotIndex)

 

elif app.BUY == curCursorNum:

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SHOP_BUY_INFO)

 

elif app.IsPressed(app.DIK_LALT):

link = player.GetItemLink(itemSlotIndex)

ime.PasteString(link)

 

elif app.IsPressed(app.DIK_LSHIFT):

itemCount = player.GetItemCount(itemSlotIndex)

 

if itemCount > 1:

self.dlgPickMoney.SetTitleName(locale.PICK_ITEM_TITLE)

self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))

self.dlgPickMoney.Open(itemCount)

self.dlgPickMoney.itemGlobalSlotIndex = itemSlotIndex

#else:

#selectedItemVNum = player.GetItemIndex(itemSlotIndex)

#mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum)

 

elif app.IsPressed(app.DIK_LCONTROL):

itemIndex = player.GetItemIndex(itemSlotIndex)

 

if TRUE == item.CanAddToQuickSlotItem(itemIndex):

player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_INVENTORY, itemSlotIndex)

else:

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.QUICKSLOT_REGISTER_DISABLE_ITEM)

 

else:

selectedItemVNum = player.GetItemIndex(itemSlotIndex)

itemCount = player.GetItemCount(itemSlotIndex)

mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)

 

if self.__IsUsableItemToItem(selectedItemVNum, itemSlotIndex):

self.wndItem.SetUseMode(TRUE)

else:

self.wndItem.SetUseMode(FALSE)

 

snd.PlaySound("sound/ui/pick.wav")

 

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

if srcItemSlotPos == dstItemSlotPos:

return

 

if item.IsRefineScroll(srcItemVID):

self.RefineItem(srcItemSlotPos, dstItemSlotPos)

self.wndItem.SetUseMode(FALSE)

 

elif item.IsMetin(srcItemVID):

self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)

 

elif item.IsDetachScroll(srcItemVID):

self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)

 

elif item.IsKey(srcItemVID):

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

 

elif (player.GetItemFlags(srcItemSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

 

elif item.GetUseType(srcItemVID) in self.USE_TYPE_TUPLE:

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

 

else:

#snd.PlaySound("sound/ui/drop.wav")

 

## ŔĚ?ż˝ĂŲ °÷ŔĚ ŔĺÂř ˝˝?ÔŔĎ °ćżě ľĆŔĚĹŰŔ? ?çżëÇŘĽ­ ŔĺÂř ˝ĂŲ´Ů - [levites]

if player.IsEquipmentSlot(dstItemSlotPos):

 

## ?é°í ŔÖ´Â ľĆŔĚĹŰŔĚ ŔĺşńŔĎ?§¸¸

if item.IsEquipmentVID(srcItemVID):

self.__UseItem(srcItemSlotPos)

 

else:

self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)

#net.SendItemMovePacket(srcItemSlotPos, dstItemSlotPos, 0)

 

def __SellItem(self, itemSlotPos):

if not player.IsEquipmentSlot(itemSlotPos):

self.sellingSlotNumber = itemSlotPos

itemIndex = player.GetItemIndex(itemSlotPos)

itemCount = player.GetItemCount(itemSlotPos)

 

item.SelectItem(itemIndex)

itemPrice = item.GetISellItemPrice()

 

if item.Is1GoldItem():

itemPrice = itemCount / itemPrice / 5

else:

itemPrice = itemPrice * itemCount / 5

 

item.GetItemName(itemIndex)

itemName = item.GetItemName()

 

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(locale.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))

self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))

self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))

self.questionDialog.Open()

self.questionDialog.count = itemCount

 

def RefineItem(self, scrollSlotPos, targetSlotPos):

 

scrollIndex = player.GetItemIndex(scrollSlotPos)

targetIndex = player.GetItemIndex(targetSlotPos)

 

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

return

 

###########################################################

self.__SendUseItemToItemPacket(scrollSlotPos, targetSlotPos)

#net.SendItemUseToItemPacket(scrollSlotPos, targetSlotPos)

return

###########################################################

 

###########################################################

#net.SendRequestRefineInfoPacket(targetSlotPos)

#return

###########################################################

 

result = player.CanRefine(scrollIndex, targetSlotPos)

 

if player.REFINE_ALREADY_MAX_SOCKET_COUNT == result:

#snd.PlaySound("sound/ui/jaeryun_fail.wav")

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_MORE_SOCKET)

 

elif player.REFINE_NEED_MORE_GOOD_SCROLL == result:

#snd.PlaySound("sound/ui/jaeryun_fail.wav")

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NEED_BETTER_SCROLL)

 

elif player.REFINE_CANT_MAKE_SOCKET_ITEM == result:

#snd.PlaySound("sound/ui/jaeryun_fail.wav")

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_SOCKET_DISABLE_ITEM)

 

elif player.REFINE_NOT_NEXT_GRADE_ITEM == result:

#snd.PlaySound("sound/ui/jaeryun_fail.wav")

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_UPGRADE_DISABLE_ITEM)

 

elif player.REFINE_CANT_REFINE_METIN_TO_EQUIPMENT == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_EQUIP_ITEM)

 

if player.REFINE_OK != result:

return

 

self.refineDialog.Open(scrollSlotPos, targetSlotPos)

 

def DetachMetinFromItem(self, scrollSlotPos, targetSlotPos):

scrollIndex = player.GetItemIndex(scrollSlotPos)

targetIndex = player.GetItemIndex(targetSlotPos)

 

if not player.CanDetach(scrollIndex, targetSlotPos):

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)

return

 

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(locale.REFINE_DO_YOU_SEPARATE_METIN)

self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnDetachMetinFromItem))

self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))

self.questionDialog.Open()

self.questionDialog.sourcePos = scrollSlotPos

self.questionDialog.targetPos = targetSlotPos

 

def AttachMetinToItem(self, metinSlotPos, targetSlotPos):

metinIndex = player.GetItemIndex(metinSlotPos)

targetIndex = player.GetItemIndex(targetSlotPos)

 

item.SelectItem(metinIndex)

itemName = item.GetItemName()

 

result = player.CanAttachMetin(metinIndex, targetSlotPos)

 

if player.ATTACH_METIN_NOT_MATCHABLE_ITEM == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_CAN_NOT_ATTACH(itemName))

 

if player.ATTACH_METIN_NO_MATCHABLE_SOCKET == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_SOCKET(itemName))

 

elif player.ATTACH_METIN_NOT_EXIST_GOLD_SOCKET == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_NO_GOLD_SOCKET(itemName))

 

elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.REFINE_FAILURE_EQUIP_ITEM)

 

if player.ATTACH_METIN_OK != result:

return

 

self.attachMetinDialog.Open(metinSlotPos, targetSlotPos)

 

 

 

def OverOutItem(self):

self.wndItem.SetUsableItem(FALSE)

if None != self.tooltipItem:

self.tooltipItem.HideToolTip()

 

def OverInItem(self, overSlotPos):

overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)

self.wndItem.SetUsableItem(FALSE)

 

if mouseModule.mouseController.isAttached():

attachedItemType = mouseModule.mouseController.GetAttachedType()

if player.SLOT_TYPE_INVENTORY == attachedItemType:

 

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()

 

if self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPos):

self.wndItem.SetUsableItem(TRUE)

self.__ShowToolTip(overSlotPos)

return

 

self.__ShowToolTip(overSlotPos)

 

 

def __IsUsableItemToItem(self, srcItemVNum, srcSlotPos):

"´Ů¸Ą ľĆŔĚĹŰżˇ ?çżëÇŇ Ľö ŔÖ´Â ľĆŔĚĹŰŔΰˇ?"

 

if item.IsRefineScroll(srcItemVNum):

return TRUE

elif item.IsMetin(srcItemVNum):

return TRUE

elif item.IsDetachScroll(srcItemVNum):

return TRUE

elif item.IsKey(srcItemVNum):

return TRUE

elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:

return TRUE

else:

if item.GetUseType(srcItemVNum) in self.USE_TYPE_TUPLE:

return TRUE

 

return FALSE

 

def __CanUseSrcItemToDstItem(self, srcItemVNum, srcSlotPos, dstSlotPos):

"´ë?ó ľĆŔĚĹŰżˇ ?çżëÇŇ Ľö Ŕִ°ˇ?"

 

if srcSlotPos == dstSlotPos:

return FALSE

 

if item.IsRefineScroll(srcItemVNum):

if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):

return TRUE

elif item.IsMetin(srcItemVNum):

if player.ATTACH_METIN_OK == player.CanAttachMetin(srcItemVNum, dstSlotPos):

return TRUE

elif item.IsDetachScroll(srcItemVNum):

if player.DETACH_METIN_OK == player.CanDetach(srcItemVNum, dstSlotPos):

return TRUE

elif item.IsKey(srcItemVNum):

if player.CanUnlock(srcItemVNum, dstSlotPos):

return TRUE

 

elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:

return TRUE

 

else:

useType=item.GetUseType(srcItemVNum)

 

if "USE_CLEAN_SOCKET" == useType:

if self.__CanCleanBrokenMetinStone(dstSlotPos):

return TRUE

elif "USE_CHANGE_ATTRIBUTE" == useType:

if self.__CanChangeItemAttrList(dstSlotPos):

return TRUE

elif "USE_ADD_ATTRIBUTE" == useType:

if self.__CanAddItemAttr(dstSlotPos):

return TRUE

elif "USE_ADD_ATTRIBUTE2" == useType:

if self.__CanAddItemAttr(dstSlotPos):

return TRUE

elif "USE_ADD_ACCESSORY_SOCKET" == useType:

if self.__CanAddAccessorySocket(dstSlotPos):

return TRUE

elif "USE_PUT_INTO_ACCESSORY_SOCKET" == useType:

if self.__CanPutAccessorySocket(dstSlotPos, srcItemVNum):

return TRUE;

 

return FALSE

 

def __CanCleanBrokenMetinStone(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

 

item.SelectItem(dstItemVNum)

 

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

return FALSE

 

for i in xrange(player.METIN_SOCKET_MAX_NUM):

if player.GetItemMetinSocket(dstSlotPos, i) == constInfo.ERROR_METIN_STONE:

return TRUE

 

return FALSE

 

def __CanChangeItemAttrList(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

 

item.SelectItem(dstItemVNum)

 

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

return FALSE

 

for i in xrange(player.METIN_SOCKET_MAX_NUM):

if player.GetItemAttribute(dstSlotPos, i) != 0:

return TRUE

 

return FALSE

 

def __CanPutAccessorySocket(self, dstSlotPos, mtrlVnum):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

 

item.SelectItem(dstItemVNum)

 

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

return FALSE

 

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

return FALSE

 

curCount = player.GetItemMetinSocket(dstSlotPos, 0)

maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

 

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

return FALSE

 

if curCount>=maxCount:

return FALSE

 

return TRUE

 

def __CanAddAccessorySocket(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

 

item.SelectItem(dstItemVNum)

 

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

return FALSE

 

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

return FALSE

 

curCount = player.GetItemMetinSocket(dstSlotPos, 0)

maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

 

ACCESSORY_SOCKET_MAX_SIZE = 3

if maxCount >= ACCESSORY_SOCKET_MAX_SIZE:

return FALSE

 

return TRUE

 

def __CanAddItemAttr(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

 

item.SelectItem(dstItemVNum)

 

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

return FALSE

 

attrCount = 0

for i in xrange(player.METIN_SOCKET_MAX_NUM):

if player.GetItemAttribute(dstSlotPos, i) != 0:

attrCount += 1

 

if attrCount<4:

return TRUE

 

return FALSE

 

def __ShowToolTip(self, slotIndex):

if None != self.tooltipItem:

self.tooltipItem.SetInventoryItem(slotIndex)

 

def OnTop(self):

if None != self.tooltipItem:

self.tooltipItem.SetTop()

 

def OnPressEscapeKey(self):

self.Close()

return TRUE

 

def UseItemSlot(self, slotIndex):

if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS():

return

 

slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

 

self.__UseItem(slotIndex)

mouseModule.mouseController.DeattachObject()

self.OverOutItem()

 

def __UseItem(self, slotIndex):

ItemVNum = player.GetItemIndex(slotIndex)

item.SelectItem(ItemVNum)

if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(locale.INVENTORY_REALLY_USE_ITEM)

self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnAccept))

self.questionDialog.SetCancelEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnCancel))

self.questionDialog.Open()

self.questionDialog.slotIndex = slotIndex

 

else:

self.__SendUseItemPacket(slotIndex)

#net.SendItemUsePacket(slotIndex)

 

def __UseItemQuestionDialog_OnCancel(self):

self.OnCloseQuestionDialog()

 

def __UseItemQuestionDialog_OnAccept(self):

self.__SendUseItemPacket(self.questionDialog.slotIndex)

 

if self.questionDialog:

self.questionDialog.Close()

self.questionDialog = None

 

def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):

# °łŔÎ?óÁˇ ż­°í ŔÖ´Â ?żľČ ľĆŔĚĹŰ ?çżë ąćÁö

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_ITEM_FAILURE_PRIVATE_SHOP)

return

 

net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)

 

def __SendUseItemPacket(self, slotPos):

# °łŔÎ?óÁˇ ż­°í ŔÖ´Â ?żľČ ľĆŔĚĹŰ ?çżë ąćÁö

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_ITEM_FAILURE_PRIVATE_SHOP)

return

 

net.SendItemUsePacket(slotPos)

 

def __SendMoveItemPacket(self, srcSlotPos, dstSlotPos, srcItemCount):

# °łŔÎ?óÁˇ ż­°í ŔÖ´Â ?żľČ ľĆŔĚĹŰ ?çżë ąćÁö

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.MOVE_ITEM_FAILURE_PRIVATE_SHOP)

return

 

net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)

 

 

 

[Glinka.]

reef

 

Refy co 24h!