Skocz do zawartości
Masz już aplikację Sharegon?

Odkryj wszystkie możliwości. Dowiedz się więcej
Sharegon.pl

Zainstaluj aplikację Sharegon i korzystaj z powiadomień push oraz licznika nowych aktywności bezpośrednio z ekranu głównego.

Aby zainstalować tę aplikację na iOS i iPadOS.
  1. Tap the Share icon in Safari
  2. Przewiń menu i stuknij Dodaj do ekranu początkowego.
  3. Stuknij Dodaj w prawym górnym rogu.
Zainstaluj aplikację Sharegon na Androidzie
  1. Otwórz Sklep Google Play na swoim smarfonie.
  2. Wyszukaj „Sharegon” w pasku wyszukiwania.
  3. Stuknij „Zainstaluj”, aby pobrać aplikację.
Promocja getcloud

Jak naprawić ekwipunek w kliencie PandoraMT2 i o co chodzi z entry core?

Uśpiony
Przez MilA
w Metin2 - Wsparcie

Featured Replies

Opublikowano

Cześć wszystkim. :)

Jako że chciałbym wrócić do metina 2 jako gracz i trochę się pobawić i czegoś chciałbym się nauczyć to przychodzę z pytaniem laika.
Posiadam pliki serwerowe PandoraMT2 z 07.12.2024. Maszynka i pliki pięknie działają, powoli sobie edytuję, uczę się pisać questy itd.
Ale mam jeden problem z którym chciałbym sobie poradzić i poprosiłbym o naprowadzenie i pomoc.
W kliencie jest wbudowany panel boczny przy ekwipunku.
Aktualnie on wygląda tak jak na grafice nr 1 z 0 yang na koncie - niestety to jest sam wygląd i żaden przycisk w panelu bocznym nie działa.
Chciałbym usunąć ten panel boczny lub go naprawić.
Jeżeli chciałbym go zmienić na taki jak jest aktualnie na pandorze - dwa następne screeny to co musiałbym zrobić dokładnie?
Albo jeżeli chciałbym naprawić ten co aktualnie jest w tym kliencie to od czego zacząć?
Pliki od tego znajdują się w packu root czy gdzieś indziej?
Jakie pliki wypakować i gdzie w środku szukać tego panelu?

Na sam koniec chciałbym też zapytać o dział Metin2 - Entry-core - o co z tym chodzi i jak uzyskać do tego dostęp?

Pozdro :)

sharegon_1770940629509.png

sharegon_1770940765416.png

sharegon_1770940779190.png

Opublikowano

root/uiinventory

uiscript/inventorywindow

Zacząłbym poszukiwania od tych plików c:
A jakbyś chciał upodobnić do tego niżej to takie przyciski widziałem na serwerze iveya, gdzieś pliki chyba latają c:

Opublikowano
  • Autor
6 godzin temu, mrvns napisał(a):

root/uiinventory

uiscript/inventorywindow

zacząłbym poszukiwania od tych plików c:
A jakbyś chciał upodobnić do tego niżej to takie przyciski widziałem na serwerze iveya, gdzieś pliki chyba latają c:

No to mam te pliczki.

uiinventory.py

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

import localeInfo

import constInfo

import ime

import wndMgr

import exchange

import uiToolTip

import config

import event

if config.ENABLE_SASH_SYSTEM:

import sash

ITEM_MALL_BUTTON_ENABLE = True

ITEM_FLAG_APPLICABLE = 1 << 14

class CostumeWindow(ui.ScriptWindow):

def init(self, wndInventory):

import exception

if not app.ENABLE_COSTUME_SYSTEM:

exception.Abort("What do you do?")

return

if not wndInventory:

exception.Abort("wndInventory parameter must be set to InventoryWindow")

return

ui.ScriptWindow.__init__(self)

self.isLoaded = 0

self.wndInventory = wndInventory;

self.__LoadWindow()

def del(self):

ui.ScriptWindow.__del__(self)

def Show(self):

self.__LoadWindow()

self.RefreshCostumeSlot()

ui.ScriptWindow.Show(self)

def Close(self):

self.Hide()

def __LoadWindow(self):

if self.isLoaded == 1:

return

self.isLoaded = 1

try:

pyScrLoader = ui.PythonScriptLoader()

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

except:

import exception

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

try:

wndEquip = self.GetChild("CostumeSlot")

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

except:

import exception

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

## Equipment

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

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

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

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

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

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

self.wndEquip = wndEquip

def RefreshCostumeSlot(self):

getItemVNum=player.GetItemIndex



for i in xrange(item.COSTUME_SLOT_COUNT):

slotNumber = item.COSTUME_SLOT_START + i

self.wndEquip.SetItemSlot(slotNumber, getItemVNum(slotNumber), 0)

self.wndEquip.RefreshSlot()



class BeltInventoryWindow(ui.ScriptWindow):

def init(self, wndInventory):

import exception

if not app.ENABLE_NEW_EQUIPMENT_SYSTEM:

exception.Abort("What do you do?")

return

if not wndInventory:

exception.Abort("wndInventory parameter must be set to InventoryWindow")

return



ui.ScriptWindow.__init__(self)

self.isLoaded = 0

self.wndInventory = wndInventory;



self.wndBeltInventoryLayer = None

self.wndBeltInventorySlot = None

self.expandBtn = None

self.minBtn = None

self.__LoadWindow()

def del(self):

ui.ScriptWindow.__del__(self)

def Show(self, openBeltSlot = FALSE):

self.__LoadWindow()

self.RefreshSlot()

ui.ScriptWindow.Show(self)



if openBeltSlot:

self.OpenInventory()

else:

self.CloseInventory()

def Close(self):

self.Hide()

def IsOpeningInventory(self):

return self.wndBeltInventoryLayer.IsShow()



def OpenInventory(self):

self.wndBeltInventoryLayer.Show()

self.expandBtn.Hide()

self.AdjustPositionAndSize()

def CloseInventory(self):

self.wndBeltInventoryLayer.Hide()

self.expandBtn.Show()

self.AdjustPositionAndSize()

def GetBasePosition(self):

x, y = self.wndInventory.GetGlobalPosition()

return x - 148, y + 241



def AdjustPositionAndSize(self):

bx, by = self.GetBasePosition()



if self.IsOpeningInventory():

self.SetPosition(bx, by)

self.SetSize(self.ORIGINAL_WIDTH, self.GetHeight())



else:

self.SetPosition(bx + 138, by);

self.SetSize(10, self.GetHeight())

def __LoadWindow(self):

if self.isLoaded == 1:

return

self.isLoaded = 1

try:

pyScrLoader = ui.PythonScriptLoader()

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

except:

import exception

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

try:

self.ORIGINAL_WIDTH = self.GetWidth()

wndBeltInventorySlot = self.GetChild("BeltInventorySlot")

self.wndBeltInventoryLayer = self.GetChild("BeltInventoryLayer")

self.expandBtn = self.GetChild("ExpandBtn")

self.minBtn = self.GetChild("MinimizeBtn")



self.expandBtn.SetEvent(ui.__mem_func__(self.OpenInventory))

self.minBtn.SetEvent(ui.__mem_func__(self.CloseInventory))

for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):

slotNumber = item.BELT_INVENTORY_SLOT_START + i

wndBeltInventorySlot.SetCoverButton(slotNumber, "d:/ymir work/ui/game/quest/slot_button_01.sub",\

"d:/ymir work/ui/game/quest/slot_button_01.sub",\

"d:/ymir work/ui/game/quest/slot_button_01.sub",\

"d:/ymir work/ui/game/belt_inventory/slot_disabled.tga", FALSE, FALSE)



except:

import exception

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

## Equipment

wndBeltInventorySlot.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))

wndBeltInventorySlot.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))

wndBeltInventorySlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))

wndBeltInventorySlot.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))

wndBeltInventorySlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))

wndBeltInventorySlot.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))

self.wndBeltInventorySlot = wndBeltInventorySlot

def RefreshSlot(self):

getItemVNum=player.GetItemIndex



for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):

slotNumber = item.BELT_INVENTORY_SLOT_START + i

self.wndBeltInventorySlot.SetItemSlot(slotNumber, getItemVNum(slotNumber), player.GetItemCount(slotNumber))

self.wndBeltInventorySlot.SetAlwaysRenderCoverButton(slotNumber, TRUE)



avail = "0"



if player.IsAvailableBeltInventoryCell(slotNumber):

self.wndBeltInventorySlot.EnableCoverButton(slotNumber)

else:

self.wndBeltInventorySlot.DisableCoverButton(slotNumber)

self.wndBeltInventorySlot.RefreshSlot()



class InventoryWindow(ui.ScriptWindow):

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

wndPanel = None

dlgPickMoney = None



sellingSlotNumber = -1

isLoaded = 0

isOpenedCostumeWindowWhenClosingInventory = 0

isOpenedBeltWindowWhenClosingInventory = 0

def init(self):

if config.ENABLE_EXPANDED_MONEY_TASKBAR:

self.wndExpandedMoneyBar = None

self.wndGem = None

ui.ScriptWindow.__init__(self)

self.isOpenedBeltWindowWhenClosingInventory = 0

self.__LoadWindow()

def del(self):

ui.ScriptWindow.__del__(self)

if config.ENABLE_EXPANDED_MONEY_TASKBAR:

self.wndExpandedMoneyBar = None

self.wndGem = None

def Show(self):

self.__LoadWindow()

ui.ScriptWindow.Show(self)

if self.isOpenedCostumeWindowWhenClosingInventory and self.wndCostume:

self.wndCostume.Show()

if self.wndBelt:

self.wndBelt.Show(self.isOpenedBeltWindowWhenClosingInventory)

if self.wndPanel:

self.wndPanel.Show()

if config.ENABLE_EXPANDED_MONEY_TASKBAR:

if self.wndExpandedMoneyBar:

self.wndExpandedMoneyBar.Show()

def BindInterfaceClass(self, interface):

self.interface = interface



def __LoadWindow(self):

if self.isLoaded == 1:

return

self.isLoaded = 1

try:

pyScrLoader = ui.PythonScriptLoader()

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")

self.toolTip = uiToolTip.ToolTip()

self.toolTip.ClearToolTip()

if config.ENABLE_CHEQUE_SYSTEM:

self.wndCheque = self.GetChild("Cheque")

self.wndChequeSlot = self.GetChild("Cheque_Slot")

if config.ENABLE_GEM_SYSTEM:

self.wndMoneyIcon = self.GetChild("Money_Icon")

self.wndChequeIcon = self.GetChild("Cheque_Icon")

self.wndMoneyIcon.Hide()

self.wndMoneySlot.Hide()

self.wndChequeIcon.Hide()

self.wndChequeSlot.Hide()

## ?? ??

height = self.GetHeight()

width = self.GetWidth()

self.SetSize(width, height - 22)

self.GetChild("board").SetSize(width, height - 22)

else:

self.wndMoneyIcon = self.GetChild("Money_Icon")

self.wndChequeIcon = self.GetChild("Cheque_Icon")



self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 0)

self.wndChequeIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 1)



self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 0)

self.wndChequeIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 1)



self.toolTip = uiToolTip.ToolTip()

self.toolTip.ClearToolTip()

else:

if config.ENABLE_EXPANDED_MONEY_TASKBAR:

self.wndMoneyIcon = self.GetChild("Money_Icon")

self.wndMoneyIcon.Hide()

self.wndMoneySlot.Hide()

## lôRE Á¶Rý

height = self.GetHeight()

width = self.GetWidth()

self.SetSize(width, height - 22)

self.GetChild("board").SetSize(width, height - 22)

else:

self.wndMoneyIcon = self.GetChild("Money_Icon")

#self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 0)

#self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 0)

self.toolTip = uiToolTip.ToolTip()

self.toolTip.ClearToolTip()



self.inventoryTab = []

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

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

if config.ENABLE_BIGGER_INVENTORY:

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

# Belt Inventory Window

self.wndBelt = None

# Panel Inventory Window

self.wndPanel = None

if app.ENABLE_NEW_EQUIPMENT_SYSTEM:

self.wndBelt = BeltInventoryWindow(self)

self.wndPanel = PanelInventoryWindow(self)



except:

import exception

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

## Item

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

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

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

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

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

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

## Equipment

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

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

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

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

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

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

## PickMoneyDialog

dlgPickMoney = uiPickMoney.PickMoneyDialog()

dlgPickMoney.LoadDialog()

dlgPickMoney.Hide()

## RefineDialog

self.refineDialog = uiRefine.RefineDialog()

self.refineDialog.Hide()

## AttachMetinDialog

self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()

self.attachMetinDialog.Hide()

## MoneySlot

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

if config.ENABLE_BIGGER_INVENTORY:

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

else:

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))

if self.DSSButton:

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



# Costume Button

if self.costumeButton:

self.costumeButton.SetEvent(ui.__mem_func__(self.ClickCostumeButton))

self.wndCostume = None



#####

## Refresh

if config.ENABLE_HIGHLIGHT_SYSTEM:

self.listHighlightedSlot = []

if config.ENABLE_SASH_SYSTEM:

self.listAttachedSashs = []

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.DSSButton = None

self.interface = None

if self.wndCostume:

self.wndCostume.Destroy()

self.wndCostume = 0



if self.wndBelt:

self.wndBelt.Destroy()

self.wndBelt = None

if self.wndPanel:

self.wndPanel.Destroy()

self.wndPanel = None

self.inventoryTab = []

self.equipmentTab = []

if config.ENABLE_EXPANDED_MONEY_TASKBAR:

self.wndExpandedMoneyBar = None

def Hide(self):

if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():

self.OnCloseQuestionDialog()

return

if None != self.tooltipItem:

self.tooltipItem.HideToolTip()

if self.wndCostume:

self.isOpenedCostumeWindowWhenClosingInventory = self.wndCostume.IsShow()

self.wndCostume.Close()

if self.wndBelt:

self.isOpenedBeltWindowWhenClosingInventory = self.wndBelt.IsOpeningInventory()

print "Is Opening Belt Inven?? ", self.isOpenedBeltWindowWhenClosingInventory

self.wndBelt.Close()

if self.wndPanel:

self.isOpenedPanelWindowWhenClosingInventory = self.wndPanel.IsOpeningInventory()

print "Is Opening Panel Inven?? ", self.isOpenedPanelWindowWhenClosingInventory

self.wndPanel.Close()

if self.dlgPickMoney:

self.dlgPickMoney.Close()

if config.ENABLE_EXPANDED_MONEY_TASKBAR:

if self.wndExpandedMoneyBar:

self.wndExpandedMoneyBar.Close()

wndMgr.Hide(self.hWnd)

if config.ENABLE_EXPANDED_MONEY_TASKBAR:

def SetExpandedMoneyBar(self, wndBar):

self.wndExpandedMoneyBar = wndBar

if self.wndExpandedMoneyBar:

self.wndMoneySlot = self.wndExpandedMoneyBar.GetMoneySlot()

self.wndMoney = self.wndExpandedMoneyBar.GetMoney()

if config.ENABLE_CHEQUE_SYSTEM:

## Money

self.wndMoneyIcon = self.wndExpandedMoneyBar.GetMoneyIcon()

if self.wndMoneyIcon:

self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 0)

self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 0)

if self.wndMoneySlot:

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

## Won

self.wndChequeIcon = self.wndExpandedMoneyBar.GetChequeIcon()

if self.wndChequeIcon:

self.wndChequeIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 1)

self.wndChequeIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 1)

self.wndChequeSlot = self.wndExpandedMoneyBar.GetChequeSlot()

if self.wndChequeSlot:

self.wndChequeSlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog), 1)

self.wndCheque = self.wndExpandedMoneyBar.GetCheque()

## Gaya

self.wndGemIcon = self.wndExpandedMoneyBar.GetGemIcon()

if self.wndGemIcon:

self.wndGemIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 2)

self.wndGemIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 2)

self.wndGem = self.wndExpandedMoneyBar.GetGaya()

self.toolTip = uiToolTip.ToolTip()

self.toolTip.ClearToolTip()

else:

if self.wndMoneySlot:

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

self.wndMoneyIcon = self.wndExpandedMoneyBar.GetMoneyIcon()

if self.wndMoneyIcon:

self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_in", 0)

self.wndMoneyIcon.SetEvent(ui.__mem_func__(self.EventProgress), "mouse_over_out", 0)

if self.wndMoneySlot:

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

def OverInToolTip(self, arg):

arglen = len(str(arg))

pos_x, pos_y = wndMgr.GetMousePosition()



self.toolTip.ClearToolTip()

self.toolTip.SetThinBoardSize(11 * arglen)

self.toolTip.SetToolTipPosition(pos_x + 5, pos_y - 5)

self.toolTip.AppendTextLine(arg, 0xffffff00)

self.toolTip.Show()



def OverOutToolTip(self):

self.toolTip.Hide()



def EventProgress(self, event_type, idx):

if "mouse_over_in" == str(event_type):

if idx == 0:

self.OverInToolTip("Yang")

elif idx == 1:

self.OverInToolTip("Won")

elif idx == 2:

self.OverInToolTip("Gaya")

else:

return

elif "mouse_over_out" == str(event_type):

self.OverOutToolTip()

else:

return

def Close(self):

self.Hide()

if config.ENABLE_HIGHLIGHT_SYSTEM:

def HighlightSlot(self, slot):

if not slot in self.listHighlightedSlot:

self.listHighlightedSlot.append(slot)

if config.ENABLE_BIGGER_INVENTORY:

def SetInventoryPage(self, page):

self.inventoryTab[self.inventoryPageIndex].SetUp()

self.inventoryPageIndex = page

self.inventoryTab[self.inventoryPageIndex].Down()

self.RefreshBagSlotWindow()

else:

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")

# DSSButton

def ClickDSSButton(self):

print "click_dss_button"

self.interface.ToggleDragonSoulWindow()

def ClickCostumeButton(self):

print "Click Costume Button"

if self.wndCostume:

if self.wndCostume.IsShow():

self.wndCostume.Hide()

else:

self.wndCostume.Show()

else:

self.wndCostume = CostumeWindow(self)

self.wndCostume.Show()

def OpenPickMoneyDialog(self):

if mouseModule.mouseController.isAttached():

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

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

if 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 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 0 == itemCount:

self.wndItem.ClearSlot(i)

continue

elif 1 == itemCount:

itemCount = 0



itemVnum = getItemVNum(slotNumber)

setItemVNum(i, itemVnum, itemCount)



if constInfo.IS_AUTO_POTION(itemVnum):

metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]

if config.ENABLE_BIGGER_INVENTORY:

if slotNumber >= player.INVENTORY_PAGE_SIZE*self.inventoryPageIndex:

slotNumber -= player.INVENTORY_PAGE_SIZE*self.inventoryPageIndex

else:

if slotNumber >= player.INVENTORY_PAGE_SIZE:

slotNumber -= player.INVENTORY_PAGE_SIZE



isActivated = 0 != metinSocket[0]



if isActivated:

self.wndItem.ActivateSlot(slotNumber)

potionType = 0;

if constInfo.IS_AUTO_POTION_HP(itemVnum):

potionType = player.AUTO_POTION_TYPE_HP

elif constInfo.IS_AUTO_POTION_SP(itemVnum):

potionType = player.AUTO_POTION_TYPE_SP



usedAmount = int(metinSocket[1])

totalAmount = int(metinSocket[2])

player.SetAutoPotionInfo(potionType, isActivated, (totalAmount - usedAmount), totalAmount, self.__InventoryLocalSlotPosToGlobalSlotPos(i))



else:

self.wndItem.DeactivateSlot(slotNumber)

if config.ENABLE_HIGHLIGHT_SYSTEM:

if slotNumber in self.listHighlightedSlot:

self.wndItem.ActivateSlot(i)

if config.ENABLE_SASH_SYSTEM:

slotNumberChecked = 0

if not constInfo.IS_AUTO_POTION(itemVnum):

self.wndItem.DeactivateSlot(i)



for j in xrange(sash.WINDOW_MAX_MATERIALS):

(isHere, iCell) = sash.GetAttachedItem(j)

if isHere:

if iCell == slotNumber:

self.wndItem.ActivateSlot(i, (36.00 / 255.0), (222.00 / 255.0), (3.00 / 255.0), 1.0)

if not slotNumber in self.listAttachedSashs:

self.listAttachedSashs.append(slotNumber)



slotNumberChecked = 1

else:

if slotNumber in self.listAttachedSashs and not slotNumberChecked:

self.wndItem.DeactivateSlot(i)

self.listAttachedSashs.remove(slotNumber)

self.wndItem.RefreshSlot()

if self.wndBelt:

self.wndBelt.RefreshSlot()

def RefreshEquipSlotWindow(self):

getItemVNum=player.GetItemIndex

getItemCount=player.GetItemCount

setItemVNum=self.wndEquip.SetItemSlot

for i in xrange(player.EQUIPMENT_PAGE_COUNT):

slotNumber = player.EQUIPMENT_SLOT_START + i

itemCount = getItemCount(slotNumber)

if itemCount <= 1:

itemCount = 0

setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

if app.ENABLE_NEW_EQUIPMENT_SYSTEM:

for i in xrange(player.NEW_EQUIPMENT_SLOT_COUNT):

slotNumber = player.NEW_EQUIPMENT_SLOT_START + i

itemCount = getItemCount(slotNumber)

if itemCount <= 1:

itemCount = 0

setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

print "ENABLE_NEW_EQUIPMENT_SYSTEM", slotNumber, itemCount, getItemVNum(slotNumber)



self.wndEquip.RefreshSlot()



if self.wndCostume:

self.wndCostume.RefreshCostumeSlot()

def RefreshItemSlot(self):

self.RefreshBagSlotWindow()

self.RefreshEquipSlotWindow()

def RefreshStatus(self):

money = player.GetElk()

if config.ENABLE_EXPANDED_MONEY_TASKBAR:

self.wndMoney.SetText(localeInfo.NumberToMoneyString(money, ""))

else:

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



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 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")

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

if srcItemSlotPos == dstItemSlotPos:

return



if player.GetItemIndex(srcItemSlotPos) == player.GetItemIndex(dstItemSlotPos) and not player.IsEquipmentSlot(dstItemSlotPos):

self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)

return

elif item.IsRefineScroll(srcItemVID):

self.RefineItem(srcItemSlotPos, dstItemSlotPos)

self.wndItem.SetUseMode(False)

elif item.IsMetin(srcItemVID):

self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)

elif item.IsDetachScroll(srcItemVID):

self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)

elif item.IsKey(srcItemVID):

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

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

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

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

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

else:

if player.IsEquipmentSlot(dstItemSlotPos):

if item.IsEquipmentVID(srcItemVID):

self.__UseItem(srcItemSlotPos)

else:

self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)

def __SellItem(self, itemSlotPos):

if not player.IsEquipmentSlot(itemSlotPos):

self.sellingSlotNumber = itemSlotPos

itemIndex = player.GetItemIndex(itemSlotPos)

itemCount = player.GetItemCount(itemSlotPos)





self.sellingSlotitemIndex = itemIndex

self.sellingSlotitemCount = itemCount

item.SelectItem(itemIndex)

if item.IsAntiFlag(item.ANTIFLAG_SELL):

popup = uiCommon.PopupDialog()

popup.SetText(localeInfo.SHOP_CANNOT_SELL_ITEM)

popup.SetAcceptEvent(self.__OnClosePopupDialog)

popup.Open()

self.popup = popup

return

itemPrice = item.GetISellItemPrice()

if item.Is1GoldItem():

itemPrice = itemCount / itemPrice / 5

else:

itemPrice = itemPrice * itemCount / 5

item.GetItemName(itemIndex)

itemName = item.GetItemName()

self.questionDialog = uiCommon.QuestionDialog()

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

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

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

self.questionDialog.Open()

self.questionDialog.count = itemCount



constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

def __OnClosePopupDialog(self):

self.pop = None

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)

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 config.ENABLE_SASH_SYSTEM:

if not player.CanDetach(scrollIndex, targetSlotPos):

item.SelectItem(scrollIndex)

if item.GetValue(0) == sash.CLEAN_ATTR_VALUE0:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SASH_FAILURE_CLEAN)

else:

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



return

else:

if not player.CanDetach(scrollIndex, targetSlotPos):

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

return



self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.REFINE_DO_YOU_SEPARATE_METIN)

if config.ENABLE_SASH_SYSTEM:

item.SelectItem(targetIndex)

if item.GetItemType() item.ITEM_TYPE_COSTUME and item.GetItemSubType() item.COSTUME_TYPE_SASH:

item.SelectItem(scrollIndex)

if item.GetValue(0) == sash.CLEAN_ATTR_VALUE0:

self.questionDialog.SetText(localeInfo.SASH_DO_YOU_CLEAN)



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

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

self.questionDialog.Open()

self.questionDialog.sourcePos = scrollSlotPos

self.questionDialog.targetPos = targetSlotPos

def AttachMetinToItem(self, metinSlotPos, targetSlotPos):

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 config.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:

slotNumber -= player.INVENTORY_PAGE_SIZE



isActivated = 0 != metinSocket[0]

if isActivated:

stat = 1

elif constInfo.IS_ACCE_ITEM(itemVnum, 1) == TRUE:

metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]

isActivated = metinSocket[0]

if isActivated == 1:

stat = 1



if not stat:

self.wndItem.DeactivateSlot(overSlotPos)

try:

self.listHighlightedSlot.remove(slotNumber)

except:

pass

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 player.GetItemIndex(srcSlotPos) == player.GetItemIndex(dstSlotPos) and not player.IsEquipmentSlot(dstSlotPos):

return True

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;

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

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):

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 config.ENABLE_SASH_SYSTEM:

if self.isShowSashWindow():

sash.Add(player.INVENTORY, slotIndex, 255)

return

if config.ENABLE_MOVE_ITEM:

if self.interface.dlgExchange.IsShow() and (app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL)):

item.SelectItem(player.GetItemIndex(slotIndex))

emptyExchangeSlots = self.GetExchangeEmptyItemPos(item.GetItemSize()[1])

if emptyExchangeSlots == -1:

return

if item.IsAntiFlag(item.ANTIFLAG_GIVE):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE)

return

net.SendExchangeItemAddPacket(player.SLOT_TYPE_INVENTORY, slotIndex, emptyExchangeSlots[0])

else:

self.__UseItem(slotIndex)

mouseModule.mouseController.DeattachObject()

self.OverOutItem()

else:

self.__UseItem(slotIndex)

mouseModule.mouseController.DeattachObject()

self.OverOutItem()

if config.ENABLE_MOVE_ITEM:

def GetExchangeEmptyItemPos(self, itemHeight):

inventorySize = exchange.EXCHANGE_ITEM_MAX_NUM

inventoryWidth = 4

GetBlockedSlots = lambda slot, size: [slot+(round*inventoryWidth) for round in xrange(size)]

blockedSlots = [element for sublist in [GetBlockedSlots(slot, item.GetItemSize(item.SelectItem(exchange.GetItemVnumFromSelf(slot)))[1]) for slot in xrange(inventorySize) if exchange.GetItemVnumFromSelf(slot) != 0] for element in sublist]

freeSlots = [slot for slot in xrange(inventorySize) if not slot in blockedSlots and not True in [e in blockedSlots for e in [slot+(round*inventoryWidth) for round in xrange(itemHeight)]]]

return [freeSlots, -1][len(freeSlots) == 0]

def __UseItem(self, slotIndex):

ItemVNum = player.GetItemIndex(slotIndex)

item.SelectItem(ItemVNum)

if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.INVENTORY_REALLY_USE_ITEM)

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

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

self.questionDialog.Open()

self.questionDialog.slotIndex = slotIndex



constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

else:

self.__SendUseItemPacket(slotIndex)

def __UseItemQuestionDialog_OnCancel(self):

self.OnCloseQuestionDialog()

def __UseItemQuestionDialog_OnAccept(self):

self.__SendUseItemPacket(self.questionDialog.slotIndex)

self.OnCloseQuestionDialog()

def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)

def __SendUseItemPacket(self, slotPos):

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemUsePacket(slotPos)



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

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)



def SetDragonSoulRefineWindow(self, wndDragonSoulRefine):

if app.ENABLE_DRAGON_SOUL_SYSTEM:

self.wndDragonSoulRefine = wndDragonSoulRefine

if config.ENABLE_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



def OnMoveWindow(self, x, y):

if self.wndBelt:

self.wndBelt.AdjustPositionAndSize()

if self.wndPanel:

self.wndPanel.AdjustPositionAndSize()

class PanelInventoryWindow(ui.ScriptWindow):

global TITLE_COLOR

global WHITE_COLOR

global GREEN_COLOR

TITLE_COLOR = 0xffffc700

WHITE_COLOR = 0xffFFFFFF

GREEN_COLOR = 0xff3AC95D

def init(self, wndInventory):

import exception



if not wndInventory:

exception.Abort("wndInventory parameter must be set InventoryWindow")

return



ui.ScriptWindow.__init__(self)



self.isLoaded = 0

self.wndInventory = wndInventory;

self.wndPanelInventoryLayer = None

# self.wndChange = None

# self.wndBonus = None

# self.wndSwitcher = None

self.toolTip = uiToolTip.ToolTip()

self.toolTip.Hide()

# wndBuffs = uiitems.ItemsWindow()

# wndBuffs.Hide()

#self.wndBuffs = wndBuffs

# self.wndMarbleShop = uimarbleshop.MarbleShopWindow()

# self.wndMarbleShop.Hide()

# self.ZmienEQ = uifastequip.changeequip()

# self.BonusWindow = uiBonusList.CharacterBonusWindow()

self.__LoadWindow()



def del(self):

ui.ScriptWindow.__del__(self)



def Show(self):

ui.ScriptWindow.Show(self)



self.__LoadWindow()

self.OpenInventory()



def Close(self):

self.Hide()



def IsOpeningInventory(self):

return self.wndPanelInventoryLayer.IsShow()

def SetMainGame(self, game):

self.game = game



def OpenInventory(self):

self.wndPanelInventoryLayer.Show()



self.AdjustPositionAndSize()



def GetBasePosition(self):

x, y = self.wndInventory.GetGlobalPosition()

return x - 45 + 4, y + 5



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 + 138, by);

self.SetSize(10, self.GetHeight())

def __LoadWindow(self):

if self.isLoaded == 1:

return

self.isLoaded = 1



try:

pyScrLoader = ui.PythonScriptLoader()

pyScrLoader.LoadScriptFile(self, "uiScript/PanelInventoryWindow.py")



except:

import exception

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



try:

self.ORIGINAL_WIDTH = self.GetWidth()

self.wndPanelInventoryLayer = self.GetChild("PanelInventoryLayer")



self.Dozorca = self.GetChild2("Dozorca")#.SetEvent(ui.__mem_func__(self.ClickDozorca), 1)

self.OknoBonus = self.GetChild2("OknoBonus")

#self.EqButton = self.GetChild2("EqButton")

self.Switchbot = self.GetChild2("Switchbot")

self.AntyExpik = self.GetChild2("AntyExpik")

self.AntyPoli = self.GetChild2("AntyPoli")

self.Kosz = self.GetChild2("Kosz")

self.Dopau = self.GetChild2("Dopau")

self.ZapisTP = self.GetChild2("ZapisPoz")

self.ZmianaEQ = self.GetChild2("ZmianaEQ")

self.Dozorca.SetEvent(ui.__mem_func__(self.ClickDozorca))

#self.Dozorca.OnMouseLeftButtonDown = lambda: self.FastButtonOption(1)

# self.OknoBonus.SetEvent(ui.__mem_func__(self.ClickBonusWindow))

#self.EqButton.SetEvent(ui.__mem_func__(self.ChujEqButton))

# self.Switchbot.SetEvent(ui.__mem_func__(self.ClickSwitchButton))

self.AntyExpik.SetEvent(ui.__mem_func__(self.ClickAntyEXP))

# self.AntyPoli.SetEvent(ui.__mem_func__(self.ClickAntyPoli))

# self.Kosz.SetEvent(ui.__mem_func__(self.ClickKoszButton))

# self.Dopau.SetEvent(ui.__mem_func__(self.ClickDopalacze))

# self.Dopau.OnMouseRightButtonDown = lambda: self.Dopauy()

# self.ZapisTP.SetEvent(ui.__mem_func__(self.ClickSaveTeleport))

# self.ZmianaEQ.SetEvent(ui.__mem_func__(self.ClickChangeEQ))

except:

import exception

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

self.Dozorca.ShowToolTip = lambda : self.__OverInDozorca()

self.Dozorca.HideToolTip = lambda : self.__OverOutPanelButton()

# self.OknoBonus.ShowToolTip = lambda : self.__OverInOknoBonus()

# self.OknoBonus.HideToolTip = lambda : self.__OverOutPanelButton()

# self.ZmianaEQ.ShowToolTip = lambda : self.__OverInEqButton()

# self.ZmianaEQ.HideToolTip = lambda : self.__OverOutPanelButton()



# self.Switchbot.ShowToolTip = lambda : self.__OverInSwitchbot()

# self.Switchbot.HideToolTip = lambda : self.__OverOutPanelButton()

self.AntyExpik.ShowToolTip = lambda : self.__OverInAntyExpik()

self.AntyExpik.HideToolTip = lambda : self.__OverOutPanelButton()



# self.AntyPoli.ShowToolTip = lambda : self.__OverInAntyPoli()

# self.AntyPoli.HideToolTip = lambda : self.__OverOutPanelButton()



# self.Kosz.ShowToolTip = lambda : self.__OverInKosz()

# self.Kosz.HideToolTip = lambda : self.__OverOutPanelButton()



# self.Dopau.ShowToolTip = lambda : self.__OverInDopau()

# self.Dopau.HideToolTip = lambda : self.__OverOutPanelButton()



# self.ZapisTP.ShowToolTip = lambda : self.__OverInZapisTP()

# self.ZapisTP.HideToolTip = lambda : self.__OverOutPanelButton()

def ClickAntyEXP(self):

activare_antiexp = constInfo.ANTIEXP_QUESTINDEX

event.QuestButtonClick(activare_antiexp)

def ClickAntyPoli(self):

#event.QuestButtonClick(constInfo.Polimorfia)

if self.wndMarbleShop.IsShow():

self.wndMarbleShop.Hide()

else:

self.wndMarbleShop.Show()

def ClickSaveTeleport(self):

#event.QuestButtonClick(constInfo.TePe)

self.wndInventory.SaveTeleport()

def ClickBonusWindow(self):

#import uiBonus

#print "Click Bonus Button"

#if self.wndBonus:

# if self.wndBonus.IsShow():

# self.wndBonus.Hide()

# else:

# self.wndBonus.Show()

#else:

# self.wndBonus = uiBonus.BonusWindow()

# self.wndBonus.Show()

self.BonusWindow.OpenWindow()

# def ClickKoszButton(self):

#constInfo.Kosz = 1

#self.wndInventory.game.OpenKosz()

# def Dopauy(self):

#self.wndBuffs.OpenWindow()

# def ClickDopalacze(self):

#for i in xrange(player.INVENTORY_PAGE_SIZE*5):

# Vnum = player.GetItemIndex(i)

# if Vnum 50821 or Vnum 50822 or Vnum 50823 or Vnum 50824 or Vnum 50825 or Vnum 50826 or Vnum 72033 or Vnum 72036 or Vnum 72038 or Vnum 72042 or Vnum 71044 or Vnum 71045:

# net.SendItemUsePacket(i)

#chat.AppendChat(chat.CHAT_TYPE_INFO, "|cFFFFC700|H|h[Informacja]: |h|r|cFFFFFFFF|H|hDopalacze aktywowane!|h|r")

#self.wndBuffs.OpenWindow()

#self.wndBuffs.OnUseItem()

# def ClickSwitchButton(self):

# import switchbot

# self.SwitchBonusDialog = switchbot.Bot()

# self.SwitchBonusDialog.Show()

# def ClickChangeEQ(self):

# if self.ZmienEQ.IsShow():

# self.ZmienEQ.Hide()

# else:

# self.ZmienEQ.Show()

def ClickDozorca(self):

net.SendChatPacket("/click_safebox")

# Panel Tooltip

def __OverOutPanelButton(self):

self.__HidePanelToolTip()



def __HidePanelToolTip(self):

self.toolTip.Hide()

def __OverInDozorca(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Dozorca", TITLE_COLOR)

self.toolTip.AppendTextLine("Otwiera twój magazyn.", WHITE_COLOR)

self.toolTip.AppendTextLine("Opcja dostępna w każdym miejscu.", WHITE_COLOR)

self.toolTip.Show()

def __OverInOknoBonus(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Bonusy", TITLE_COLOR)

self.toolTip.AppendTextLine("Otwiera oddzielne Okno z Bonusami.", WHITE_COLOR)

#self.toolTip.AppendTextLine("Opcja dostępna również w panelu postaci.", WHITE_COLOR)

self.toolTip.Show()

def __OverInEqButton(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Zmiana Ekwipunku", TITLE_COLOR)

self.toolTip.AppendTextLine("Otwiera specjalne okno w któym", WHITE_COLOR)

self.toolTip.AppendTextLine("szybko możez zmienić ekwipunek.", WHITE_COLOR)

self.toolTip.Show()

def __OverInSwitchbot(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Bonus Switcher", TITLE_COLOR)

self.toolTip.AppendTextLine("Otwiera specjalne okno w którym", WHITE_COLOR)

self.toolTip.AppendTextLine("możesz bonować swoje przedmioty.", WHITE_COLOR)

self.toolTip.Show()

def __OverInAntyExpik(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Anty Exp", TITLE_COLOR)

self.toolTip.AppendTextLine("Kliknij aby zablokować/odblokować", WHITE_COLOR)

self.toolTip.AppendTextLine("zdobywanie doświadczenia.", WHITE_COLOR)

self.toolTip.Show()

def __OverInAntyPoli(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Marmury", TITLE_COLOR)

self.toolTip.AppendTextLine("Kliknij aby otworzyć gui w którym", WHITE_COLOR)

self.toolTip.AppendTextLine("możesz zakupić marmury a także", WHITE_COLOR)

self.toolTip.AppendTextLine("usunąć polimorfie.", WHITE_COLOR)

#self.toolTip.AppendTextLine("zdobywanie doświadczenia.")

self.toolTip.Show()

def __OverInKosz(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Kosz na przedmioty", TITLE_COLOR)

self.toolTip.AppendTextLine("Otwiera specjalne okno w którym", WHITE_COLOR)

self.toolTip.AppendTextLine("możesz usunąć swoje przedmioty.", WHITE_COLOR)

self.toolTip.Show()

def __OverInDopau(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Dopalacze", TITLE_COLOR)

self.toolTip.AppendTextLine("Kliknij |cff3AC95D|H|hPPM|h|r aby skonfigurować", WHITE_COLOR)

self.toolTip.AppendTextLine("liste używanych przedmiotów", WHITE_COLOR)

self.toolTip.AppendTextLine("Kliknij |cff3AC95D|H|hLPM|h|r aby natychmiast", WHITE_COLOR)

self.toolTip.AppendTextLine("użyć przedmioty", WHITE_COLOR)

self.toolTip.AppendTextLine("")

self.toolTip.AppendTextLine("Opcja dostępna również pod", WHITE_COLOR)

self.toolTip.AppendTextLine("przyciskiem|h|r |cff3AC95D|H|hF6", WHITE_COLOR)

self.toolTip.Show()

def __OverInZapisTP(self):

self.toolTip.ClearToolTip()

self.toolTip.AppendTextLine("Zapis Pozycji", TITLE_COLOR)

self.toolTip.AppendTextLine("Otwiera specjalne okno w którym", WHITE_COLOR)

self.toolTip.AppendTextLine("możesz zapisać swoje pozycje.", WHITE_COLOR)

self.toolTip.Show()



# Panel ToolTip

Rozumiem że końcówka tego kodu z wczytaniem uiscript/panelinventorywindows.py odpowiada za ten panel boczny?
A panel nie działa ze względu na to że wszystko jest zakomentowane?

Tutaj jeszcze plik

uiscript/panelinventorywindows.py

import uiScriptLocale

### SETTINGS ###

ROOT_PATH = "panel/"

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

window = {

"name" : "PanelInventoryWindow",

"x" : SCREEN_WIDTH - 176 - 148,

#"y" : SCREEN_HEIGHT - 37 - 565 + 209 - 96,

"y" : SCREEN_HEIGHT - 37 - 565,

"width" : 50,

"height" : 155+40+50+175,

"type" : "image",

"image" : "d:/ymir work/ui/game/belt_inventory/bg.tga",

"children" :

(

{

"name" : "PanelInventoryLayer",

"type" : "board",

#"type" : "image",

#"image" : "testequip.png",

"x" : -15,

"y" : 0,

"width" : 50,

"height" : 155+35+50+175,

"children" :

(

{

"name" : "Switchbot",

"type" : "button",

"x" : 14,

"y" : 15,

#"tooltip_text" : "Bonus Switcher",

#"tooltip_x" : -18,

#"tooltip_y" : 0,

"default_image" : ROOT_PATH + "bon_01.png",

"over_image" : ROOT_PATH + "bony_02.png",

"down_image" : ROOT_PATH + "bon_03.png",

},

{

"name" : "OknoBonus",

"type" : "button",

"x" : 14,

"y" : 7+(32+3.5)*1+16,

#"tooltip_text" : "Bonusy",

"default_image" : ROOT_PATH + "zakladka_bonus_01.png",

"over_image" : ROOT_PATH + "zakladka_bonus_02.png",

"down_image" : ROOT_PATH + "zakladka_bonus_03.png",

},

{

"name" : "AntyExpik",

"type" : "button",

"x" : 14,

"y" : 7+(32+3.5)*2+24,

#"tooltip_text" : "AntyExp",

#"tooltip_x" : -26,

#"tooltip_y" : 0,

"default_image" : ROOT_PATH + "anty_exp_01.png",

"over_image" : ROOT_PATH + "anty_exp_02.png",

"down_image" : ROOT_PATH + "anty_exp_03.png",

},

{

"name" : "AntyPoli",

"type" : "button",

"x" : 14,

"y" : 7+(32+3.5)*3+32,

#"tooltip_text" : "Polimorfia",

#"tooltip_x" : -32,

#"tooltip_y" : 0,

"default_image" : ROOT_PATH + "polimorfia_01.png",

"over_image" : ROOT_PATH + "polimorfia_02.png",

"down_image" : ROOT_PATH + "polimorfia_03.png",

},

{

"name" : "Kosz",

"type" : "button",

"x" : 14,

"y" : 7+(32+3.5)*4+40,

#"tooltip_text" : "Kosz",

#"tooltip_x" : -32,

#"tooltip_y" : 0,

"default_image" : ROOT_PATH + "kosz_01.png",

"over_image" : ROOT_PATH + "kosz_02.png",

"down_image" : ROOT_PATH + "kosz_03.png",

},

{

"name" : "Dopau",

"type" : "button",

"x" : 14,

"y" : 7+(32+3.5)*5+48,

#"tooltip_text" : "Użyj Dopalacze",

#"tooltip_x" : -32,

#"tooltip_y" : 0,

"default_image" : ROOT_PATH + "dopy_01.png",

"over_image" : ROOT_PATH + "dopy_02.png",

"down_image" : ROOT_PATH + "dopy_03.png",

},

{

"name" : "ZapisPoz",

"type" : "button",



"x" : 14,

"y" : 7+(32+3.5)*6+56,

#"tooltip_text" : "Zapis Pozycji",

#"tooltip_x" : -26,

#"tooltip_y" : 0,

"default_image" : ROOT_PATH + "tp_01.png",

"over_image" : ROOT_PATH + "tp_02.png",

"down_image" : ROOT_PATH + "tp_03.png",

},

{

"name" : "Dozorca",

"type" : "button",

"x" : 14,

"y" : 7+(32+3.5)*7+64,

#"tooltip_text" : "Otwórz Magazyn",

#"tooltip_x" : -32,

#"tooltip_y" : 0,

"default_image" : ROOT_PATH + "magazyn_dozorca_01.png",

"over_image" : ROOT_PATH + "magazyn_dozorca_02.png",

"down_image" : ROOT_PATH + "magazyn_dozorca_03.png",

},

{

"name" : "ZmianaEQ",

"type" : "button",

"x" : 14,

"y" : 7+(32+3.5)*8+72,

#"tooltip_text" : "Zmiana Ekwipunku",

#"tooltip_x" : -20,

#"tooltip_y" : 0,

"default_image" : ROOT_PATH + "zmiana_eq_01.png",

"over_image" : ROOT_PATH + "zmiana_eq_02.png",

"down_image" : ROOT_PATH + "zmiana_eq_03.png",

},

),

},

),

}

Tutaj jest ROOT_PATH = "panel/", rozumiem że taki folder powinien się znajdować gdzieś tutaj w roocie czy może być też w innych plikach?

Jest ktoś w stanie trochę tutaj objaśnić?
Bo ja wiem jedynie tyle że w pierwszym pliku jest dużo zakomentowanego kodu i przez to nie działa, dobrze myślę?

Opublikowano
  • Autor
7 godzin temu, xedyn napisał(a):

Pliki EntryCore były/są robione przez @Sevence , ale obecnie już ich nie ma i nie wiem czy planuje wydać kolejną wersję tych plików.

Okej, dzięki za info :D

Próbowałem odkomentowywać zakomentowane części ale niestety wywala wtedy klienta.
Zakomentowałem cały fragment z tym panelem + funkcje która ją wywołuje i panel zniknął. Znalazłem też ten folder panel, zapakowany jest w innym pliku.
Jest może gdzieś jakieś gotowe rozwiązanie z tym panelem bocznym z jakimś wyjaśnieniem jak co działa? Chciałbym to tak dodawać żeby czegoś się nauczyć a nie że wkleję i będzie działać ale nie wiadomo dlaczego.

Opublikowano

bo musisz na nowo funkcje powgrywać i rzeczy które miałeś pod panelem xDDD

no w skrócie to mozesz se nowy panel cały zrobić. w sensie podpiąc odpowiednie funkcje bądz gui pod panel

Opublikowano
  • Autor

Jest może gdzieś jakiś gotowy taki panel lub jakiś tutorial jak to zrobić? Bo szukam w necie i nie mogę znaleźć albo już linki nieaktualne.

Opublikowano
53 minuty temu, MilA napisał(a):

Jest może gdzieś jakiś gotowy taki panel lub jakiś tutorial jak to zrobić? Bo szukam w necie i nie mogę znaleźć albo już linki nieaktualne.

Większość plików serwerowych na tym forum ma panel boczny, a co do tuta to chociażby na kanale Paszka masz nagrane krok po kroku jak dodać jakiś system do istniejącego panelu np. on tam pokazywał kosz, jedna kwestia jest panel boczny ( to co masz po stronie klienta czyli tylko ikonka), druga kwestia system który pod ten panel przypiszesz. Są proste rzeczy, na które wystarczy tylko wgrać odpowiedni quest, sa też bardziej skomplikowane systemy, które ludzie podpinają pod ten panel, gdzie musisz wgrać cały system ( do src ) i dodać do panelu bocznego aby np. druga ikonka od góry aktywowała właśnie ten system. Także pobierasz sobie klienta, i pliki i wyciągasz system, funkcję, questa konkretnego, który Cię interesuje i dodajesz na swój serwer, a kwestia tego w jaki sposób przypisać do panelu bocznego, na ten moment Cię nie interesuje najpierw znajdz sobie system wgraj przetestuj czy działa i wtedy podpinaj tam w kliencie w root w uiinventory dokładnie w ten sposób jak Paszka omawia to się nie pogubisz.https://www.youtube.com/watch?v=TNOBS_9bqzM tu masz link do filmiku skoro od wczoraj nie znalazłeś.

Jeśli chcesz dodać odpowiedź, zaloguj się lub zarejestruj nowe konto
Tematy

Konto

Nawigacja

Skonfiguruj powiadomienia push w przeglądarce.
Chrome (Android)
  1. Stuknij ikonę kłódki obok paska adresu.
  2. Wybierz Uprawnienia → Powiadomienia.
  3. Dostosuj swoje preferencje.
Chrome (Desktop)
  1. Kliknij ikonę kłódki na pasku adresu.
  2. Wybierz Ustawienia witryny.
  3. Znajdź Powiadomienia i dostosuj swoje preferencje.