Beiträge von Passwort

Passwort · 31. Juli 2023

Zitat von .Shirolein

Es reichen bereits direkte Download Links.
Ich kann euch nur empfehlen, geht auf die Discord Homepage. Schaut euch den Antrag für Claims und co mal an. Und auch die Verweise, wann Discord eure Daten weiter gibt.

Es reicht leider auch schon ein Verdacht aus, dass sie euch bannen. Dann müsst ihr euch mit real Daten melden usw. Das Risiko würd ich nicht eingehen.
Von daher speichert euch eure Discord Server als Servervorlage immer ab. Nutzt Back Up Bots und
ganz wichtig, agiert wie der TE bereits beschrieben hat, mehr mit eurer HP.
Zur Not stellt auf Oldschool Forum zusätzlich um.
Dazu braucht ihr nur wen, der da aufräumt regelmäßig.

Das passiert in anderen Games seit Jahren. Das muss nicht zwangsläufig die GF sein, sondern kann die Konkurrenz bzw. eig jeder Hans und Ahmed beantragen.

Ihr könnt auf Foren verlinken, auf denen ihr eure Inhalte teilt. Zb. Elitepvpers in eurer Serverpräsentation. Da könnt ihr eure Previews posten und ihr setzt bei euch lediglich die Verlinkung zu der Seite hin.

Es ist etwas umständlich, aber damit geht ihr einen sicheren Weg.

Alles anzeigen

könnte man die Bilder auch auf einer image Seite wie imgur hochladen und den link im dc channel posten?

Passwort · 31. Juli 2023

Zitat von Aer0xx

aso ja des hab ich ja schon nur ich möchte zb das wenn ich eine rüssi in den bot ziehe er mir nur die Bonis anzeigt was ich in die rüssi machen kann und das halt für schwert schild schuhe usw.

Dann würde ich dir saniis switchbot empfehlen. Der ist deutlich schneller und nimmt soweit ich weiß automatisch die Bonis für dein eq was du in deinem Server eingestellt hast

Passwort · 31. Juli 2023

meinst du mit previews Ingame Bilder von mt2?

Passwort · 30. Juli 2023

Zitat von Psych0SociaL

PetSystem.h:76:17: error: 'unordered_map' in namespace 'boost' does not name a template type
76 | typedef boost::unordered_map<DWORD, CPetActor *> TPetActorMap;
| ^~~~~~~~~~~~~
In file included from cmd_general.cpp:9:
PetSystem.h:104:2: error: 'TPetActorMap' does not name a type; did you mean 'CPetActor'?
104 | TPetActorMap m_petActorMap;
| ^~~~~~~~~~~~
| CPetActor
cc1plus: warning: unrecognized command line option '-Wno-volatile'

Build Error help !

Alles anzeigen

update your gcc/g++

Passwort · 30. Juli 2023

Zitat von Aer0xx

Vielen dank erstmal für deine Antwort wie Passe ich denn das an?

In dem du die Zahl der jeweiligen Boni schreibst, die du auf deinem Server hast. Oder was ich empfehlen würde direkt den Namen schreiben etwa so hier

item.APPLY_STR

die findest du in uitooltip.py in der Klasse ItemToolTip

Passwort · 30. Juli 2023

Zitat von Aer0xx

Moin also entweder ich bin dumm oder einfach nur blöd
wenn ich möchte das nicht alle bonis angezeigt werden sondern nur die was ich eintrage für z.b Rüssi kommt des soch hier rein oder nich ?

Code

proposals = {

1: { # 1 = Weapon

"PVP (Koerper)":[

[9,10],

[15,10],

[17,10],

[16,10],

[5,8],

[3,8],

],

"PVP (Mental)":[

[9,10],

[15,10],

[17,10],

[6,8],

[5,10],

[16,10],

],

"PVM": [

[5,10],

[19,20],

],

},

2: [ # Armor

[ #BODY,#########HIER ? oder nicht )

[1, 9,] ##--> Beispiel

],

[ #HEAD,

],

[ #SHIELD,

],

[ #WRIST,

],

[ #FOOTS,

],

[ #NECK,

],

[ #EAR,

],

],

}

Alles anzeigen

Das ist nur die Liste für die vorgefertige Bonus. Du musst es in BONI_AVAIL anpassen

Passwort · 29. Juli 2023

Zitat von Onyxia

mit VS debuggen und den Crashpunkt finden

Hab ich schon. Der crash punkt gibt aber keine richtige Aussage

Bitte melden Sie sich an, um diesen Link zu sehen.

Passwort · 29. Juli 2023

Zitat von Sogma

Zitat von Passwort

Python part ist nicht drinne, egal ob mit oder ohne es stürzt mit dem selben Fehler ab

Zitat von Passwort

Hab das render target system von dracarys eingebaut. Problem ist jetzt, dass nach dem char Auswahl der client abstürzt ohne eine Fehlermeldung. Auch in debug gibt es keine Fehlermeldung. Dracarys meinte es liegt an dem python Part. Also hab ich python Part raus gemacht und es stürzt immer noch ab. Files sind von Sura Head

Also gibt es jetzt eine Fehlermeldung oder nicht?

Nein gibt keine. Das Ergebnis ob ich Python Part mache oder nicht ist der selbe---> beide geben keine Fehlermeldung. Heißt es liegt am Client source

Passwort · 28. Juli 2023

Hättest in dem release ein paar Kommentare weiter unten lesen müssen. Da stand die Lösung

Bitte melden Sie sich an, um diesen Link zu sehen.

Passwort · 28. Juli 2023

Zitat von California

Zitat von Passwort

Hab das render target system von dracarys eingebaut. Problem ist jetzt, dass nach dem char Auswahl der client abstürzt ohne eine Fehlermeldung. Auch in debug gibt es keine Fehlermeldung. Dracarys meinte es liegt an dem python Part. Also hab ich python Part raus gemacht und es stürzt immer noch ab. Files sind von Sura Head

Python Parts werfen für gewöhnlich nen Syserr raus. Was ich des öfteren mal hatte wenn ich absolut keine Syserr erhielt, aber sich der Client geclosed hat, das der Fehler an den Bilddatein (tga etc) in ymir work/ui lag.

Ich weiß nicht wieso, aber diese haben oft einfach den Client zum crashen gebracht. Teilweise hat es gereicht die Datein in einem Programm wie z.b. Gimp zu öffnen und erneut abzuspeichern. Fehler behoben.

Muss nicht auf dein Problem drauf zu treffen, aber könnte ich mir gut vorstellen.

Lg.

Alles anzeigen

Python part ist nicht drinne, egal ob mit oder ohne es stürzt mit dem selben Fehler ab

Passwort · 28. Juli 2023

Hab das render target system von dracarys eingebaut. Problem ist jetzt, dass nach dem char Auswahl der client abstürzt ohne eine Fehlermeldung. Auch in debug gibt es keine Fehlermeldung. Dracarys meinte es liegt an dem python Part. Also hab ich python Part raus gemacht und es stürzt immer noch ab. Files sind von Sura Head

Passwort · 28. Juli 2023

Zitat von Steap

Es wundert mich nicht, dass kaum jemand Interesse an einem Fly-System hat, wenn man es so schlapp umsetzt und das praktisch als das Vorzeigebeispiel gilt.

Weil die maps in metin relativ klein sind, kaum einer will so ein System, weil er mit dem normalen mount bzw teleport schnell überall hinkommt.

Passwort · 26. Juli 2023

Handelscenter bzw Auktionshaus

Passwort · 24. Juli 2023

Zitat von California

Zitat von Legend65

# such die Methode __CanUpgradeBuff und ersetzen:

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

item.SelectItem(dstItemVNum)
if item.GetUseType(dstItemVNum) != "USE_BUFF":
return False

# Hier wird der Code hinzugefügt, um die Upgrade-Stufe des Buffs zu aktualisieren
# für alle Inventarseiten.
for i in xrange(player.INVENTORY_PAGE_SIZE * player.INVENTORY_MAX_NUM):
if self.interface.GetWindowItemSlot(i) == dstSlotPos:
self.interface.RefreshSlot(i)

return True

Alles anzeigen
Danke dir, allerdings klappt es nicht so ganz. Würde mich freuen wenn mich jemand verbessert.

So sieht das ganze nun bei mir aus:

Code

# BUFF SYSTEM START

def __CanUpgradeBuff(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return False

item.SelectItem(dstItemVNum)

if item.GetUseType(dstItemVNum) != "USE_BUFF":

return False

for i in xrange(player.INVENTORY_PAGE_SIZE * player.INVENTORY_MAX_NUM):

if self.interface.GetWindowItemSlot(i) == dstSlotPos:

self.interface.RefreshSlot(i)

return True

# BUFF SYSTEM END

Alles anzeigen

So sieht mein Syserr nun aus:

Code

0724 14:34:05065 ::

networkModule.py(line:208) SetSelectCharacterPhase

system.py(line:130) __pack_import

system.py(line:110) _process_result

introSelect.py(line:30) <module>

system.py(line:130) __pack_import

system.py(line:110) _process_result

interfaceModule.py(line:12) <module>

system.py(line:130) __pack_import

networkModule.SetSelectCharacterPhase - <type 'exceptions.IndentationError'>:expected an indented block (uiInventory.py, line 1444)

0724 14:34:05065 :: ============================================================================================================

0724 14:34:05065 :: Abort!!!!

Alles anzeigen

Line 1444 ist diese Stelle:

Code

self.interface.RefreshSlot(i)

Für weitere Informationen habe ich meine gesamte uiInventory.py mal angehängt.

Falls sich jemand die uiInventory.py nicht extra runter laden möchte, füge ich sie nochmal als Code ein:

Code

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 localeInfo

import constInfo

import ime

import wndMgr

import shop

import exchange

if app.__ENABLE_NEW_OFFLINESHOP__:

import offlineshop

import uiofflineshop

ITEM_MALL_BUTTON_ENABLE = TRUE

ITEM_FLAG_APPLICABLE = 1 << 14

class CostumeWindow(ui.ScriptWindow):

TITLE_HOVER_LIST = [uiScriptLocale.COSTUME_WINDOW_TITLE, uiScriptLocale.SHINING_WINDOW_TITLE, uiScriptLocale.CHANGE_COSTUME, uiScriptLocale.CHANGE_SHINING ]

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.page = False

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

wndShining = self.GetChild("ShiningSlot")

changeButton = self.GetChild("ChangeButton")

costumePage = self.GetChild("Costume_Page")

shiningPage = self.GetChild("Shining_Page")

board = self.GetChild("board")

except:

import exception

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

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

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

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

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

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

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

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

self.board = board

self.board.SetCloseEvent(ui.__mem_func__(self.Close))

self.changeButton = changeButton

self.changeButton.SetEvent(ui.__mem_func__(self.ClickChangeButton))

self.wndEquip = wndEquip

self.wndShining = wndShining

self.costumePage = costumePage

self.costumePage.Show()

self.shiningPage = shiningPage

self.shiningPage.Hide()

def ClickChangeButton(self):

if(self.page):

self.shiningPage.Hide()

self.costumePage.Show()

else:

self.costumePage.Hide()

self.shiningPage.Show()

self.changeButton.SetToolTipText(self.TITLE_HOVER_LIST[self.page+2])

self.page ^= True

self.board.SetTitleName(self.TITLE_HOVER_LIST[self.page])

self.RefreshCostumeSlot()

def RefreshCostumeSlot(self):

getItemVNum=player.GetItemIndex

getItemCount=player.GetItemCount

setItemVNum=self.wndEquip.SetItemSlot

for i in xrange(item.COSTUME_SLOT_COUNT):

slotNumber = item.COSTUME_SLOT_START + i

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

for i in xrange(item.SHINING_SLOT_COUNT):

slotNumber = item.SHINING_SLOT_START + i

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

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)

self.wndEquip.RefreshSlot()

self.wndShining.RefreshSlot()

class BeltInventoryWindow(ui.ScriptWindow):

def __init__(self, wndInventory):

import exception

if not app.ENABLE_NEW_EQUIPMENT_SYSTEM:

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

return

if not wndInventory:

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

return

ui.ScriptWindow.__init__(self)

self.isLoaded = 0

self.wndInventory = wndInventory;

self.wndBeltInventoryLayer = None

self.wndBeltInventorySlot = None

self.expandBtn = None

self.minBtn = None

self.__LoadWindow()

def __del__(self):

ui.ScriptWindow.__del__(self)

def Show(self, openBeltSlot = FALSE):

self.__LoadWindow()

self.RefreshSlot()

ui.ScriptWindow.Show(self)

if openBeltSlot:

self.OpenInventory()

else:

self.CloseInventory()

def Close(self):

self.Hide()

def IsOpeningInventory(self):

return self.wndBeltInventoryLayer.IsShow()

def OpenInventory(self):

self.wndBeltInventoryLayer.Show()

self.expandBtn.Hide()

if localeInfo.IsARABIC() == 0:

self.AdjustPositionAndSize()

def CloseInventory(self):

self.wndBeltInventoryLayer.Hide()

self.expandBtn.Show()

if localeInfo.IsARABIC() == 0:

self.AdjustPositionAndSize()

## 현재 인벤토리 위치를 기준으로 BASE 위치를 계산, 리턴.. 숫자 하드코딩하기 정말 싫지만 방법이 없다..

def GetBasePosition(self):

x, y = self.wndInventory.GetGlobalPosition()

if app.ENABLE_SPECIAL_INVENTORY:

return x - 148, y + 380

else:

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

if localeInfo.IsARABIC() :

self.expandBtn.SetPosition(self.expandBtn.GetWidth() - 2, 15)

self.wndBeltInventoryLayer.SetPosition(self.wndBeltInventoryLayer.GetWidth() - 5, 0)

self.minBtn.SetPosition(self.minBtn.GetWidth() + 3, 15)

for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):

slotNumber = item.BELT_INVENTORY_SLOT_START + i

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

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

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

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

except:

import exception

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

## Equipment

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

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

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

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

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

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

self.wndBeltInventorySlot = wndBeltInventorySlot

def RefreshSlot(self):

getItemVNum=player.GetItemIndex

for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):

slotNumber = item.BELT_INVENTORY_SLOT_START + i

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

self.wndBeltInventorySlot.SetAlwaysRenderCoverButton(slotNumber, TRUE)

avail = "0"

if player.IsAvailableBeltInventoryCell(slotNumber):

self.wndBeltInventorySlot.EnableCoverButton(slotNumber)

else:

self.wndBeltInventorySlot.DisableCoverButton(slotNumber)

self.wndBeltInventorySlot.RefreshSlot()

if app.ENABLE_SPECIAL_INVENTORY:

class InventoryTypeTabWindow(ui.ScriptWindow):

IMG_PATH = "d:/ymir work/ui/special_inventory/"

IMG_WIDTH = 23

IMG_HEIGHT = 23

Y_SPACE = 3

TAB_INVENTORY = 0

TAB_SKILLBOOK = 1

TAB_STONE = 2

TAB_MATERIAL = 3

def __init__(self, wndInventory):

if not wndInventory:

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

return

ui.ScriptWindow.__init__(self)

self.wndInventory = wndInventory

self.buttonTab = []

self.isLoaded = False

self.__LoadWindow()

self.AdjustPosition()

def __del__(self):

ui.ScriptWindow.__del__(self)

def Destroy(self):

self.ClearDictionary()

def __LoadWindow(self):

if self.isLoaded:

return

buttons = [

{

"text" : uiScriptLocale.INVENTORY_TITLE,

"up_visual" : self.IMG_PATH + "tab_inventory_01_normal.png" ,

"over_visual" : self.IMG_PATH + "tab_inventory_01_normal.png",

"down_visual" : self.IMG_PATH + "tab_inventory_03_active.png",

},

{

"text" : uiScriptLocale.SPECIAL_INVENTORY_SKILLBOOK_TITLE,

"up_visual" : self.IMG_PATH + "tab_skillbook_01_normal.png" ,

"over_visual" : self.IMG_PATH + "tab_skillbook_01_normal.png",

"down_visual" : self.IMG_PATH + "tab_skillbook_03_active.png",

},

{

"text" : uiScriptLocale.SPECIAL_INVENTORY_STONE_TITLE,

"up_visual" : self.IMG_PATH + "tab_stone_01_normal.png" ,

"over_visual" : self.IMG_PATH + "tab_stone_01_normal.png",

"down_visual" : self.IMG_PATH + "tab_stone_03_active.png",

},

{

"text" : uiScriptLocale.SPECIAL_INVENTORY_MATERIAL_TITLE,

"up_visual" : self.IMG_PATH + "tab_material_01_normal.png" ,

"over_visual" : self.IMG_PATH + "tab_material_01_normal.png",

"down_visual" : self.IMG_PATH + "tab_material_03_active.png",

},

]

self.SetSize(self.IMG_WIDTH, (self.IMG_HEIGHT + self.Y_SPACE) * len(buttons) - self.Y_SPACE)

i = 0

for button in buttons:

tab = ui.RadioButton()

tab.SetParent(self)

tab.SetToolTipText(button["text"])

tab.SetUpVisual(button["up_visual"])

tab.SetOverVisual(button["over_visual"])

tab.SetDownVisual(button["down_visual"])

tab.SetPosition(0, (self.IMG_HEIGHT + self.Y_SPACE) * i)

tab.Show()

self.buttonTab.append(tab)

i += 1

self.isLoaded = True

def __TabExists(self, i):

if i > len(self.buttonTab)+1:

return False

return True

def SetTabEvent(self, i, event):

if not self.__TabExists(i):

return

self.buttonTab[i].SetEvent(event)

def SetUp(self, i):

if not self.__TabExists(i):

return

self.buttonTab[i].SetUp()

def Down(self, i):

if not self.__TabExists(i):

return

self.buttonTab[i].Down()

def AdjustPosition(self):

x, y = self.wndInventory.GetGlobalPosition()

self.SetPosition(x - self.IMG_WIDTH + 1, y + 270)

class InventoryWindow(ui.ScriptWindow):

liHighlightedItems = []

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

questionDialog = None

tooltipItem = None

wndCostume = None

wndBelt = None

if app.ENABLE_SPECIAL_INVENTORY:

wndInventoryTypeTab = None

inventoryTypeIndex = 0

dlgPickMoney = None

sellingSlotNumber = -1

isLoaded = 0

isOpenedCostumeWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 코스츔이 열려있었는지 여부-_-; 네이밍 ㅈㅅ

isOpenedBeltWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 벨트 인벤토리가 열려있었는지 여부-_-; 네이밍 ㅈㅅ

def __init__(self):

ui.ScriptWindow.__init__(self)

self.isOpenedBeltWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 벨트 인벤토리가 열려있었는지 여부-_-; 네이밍 ㅈㅅ

self.__LoadWindow()

def __del__(self):

ui.ScriptWindow.__del__(self)

def Show(self):

self.__LoadWindow()

ui.ScriptWindow.Show(self)

# 인벤토리를 닫을 때 코스츔이 열려있었다면 인벤토리를 열 때 코스츔도 같이 열도록 함.

if self.isOpenedCostumeWindowWhenClosingInventory and self.wndCostume:

self.wndCostume.Show()

# 인벤토리를 닫을 때 벨트 인벤토리가 열려있었다면 같이 열도록 함.

if self.wndBelt:

self.wndBelt.Show(self.isOpenedBeltWindowWhenClosingInventory)

if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:

self.wndInventoryTypeTab.Show()

def BindInterfaceClass(self, interface):

self.interface = interface

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.LagerButton = self.GetChild2("LagerButton")

self.DSSButton = self.GetChild2("DSSButton")

self.costumeButton = self.GetChild2("CostumeButton")

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

if app.ENABLE_INVENTORY_SORT:

self.sortButton = self.GetChild("SortButton")

self.sortButton.SetEvent(self.OnSortInventory)

if app.__ENABLE_NEW_OFFLINESHOP__:

self.OpenOfflineShopBoardButton = self.GetChild("OfflineShopButton")

self.OpenOfflineShopBoardButton.SAFE_SetEvent(self.__OnClickOpenOfflineShopBoardButton)

# Belt Inventory Window

self.wndBelt = None

if app.ENABLE_SPECIAL_INVENTORY:

self.wndInventoryTypeTab = InventoryTypeTabWindow(self)

# if app.ENABLE_NEW_EQUIPMENT_SYSTEM:

# self.wndBelt = BeltInventoryWindow(self)

except:

import exception

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

## Item

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

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

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

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

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

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

## Equipment

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

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

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

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

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

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

## PickMoneyDialog

dlgPickMoney = uiPickMoney.PickMoneyDialog()

dlgPickMoney.LoadDialog()

dlgPickMoney.Hide()

## RefineDialog

self.refineDialog = uiRefine.RefineDialog()

self.refineDialog.Hide()

## AttachMetinDialog

self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()

self.attachMetinDialog.Hide()

## 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[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

if app.ENABLE_SPECIAL_INVENTORY:

self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_INVENTORY, lambda arg = 0 : self.SetInventoryType(arg))

self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_SKILLBOOK, lambda arg = 1 : self.SetInventoryType(arg))

self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_STONE, lambda arg = 2 : self.SetInventoryType(arg))

self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_MATERIAL, lambda arg = 3 : self.SetInventoryType(arg))

self.wndInventoryTypeTab.Down(InventoryTypeTabWindow.TAB_INVENTORY)

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

self.LagerButton.SetEvent(ui.__mem_func__(self.ClickLagerButton))

if self.DSSButton:

#self.DSSButton.Hide()

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

self.SetInventoryPage(0)

self.SetEquipmentPage(0)

if app.ENABLE_SPECIAL_INVENTORY:

self.SetInventoryType(0)

self.RefreshItemSlot()

self.RefreshStatus()

if app.ENABLE_INVENTORY_SORT:

def OnSortInventory(self):

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.INVENTORY_SORT_QUESTION)

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

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

self.questionDialog.Open()

self.questionDialog.inventoryTypeIndex = self.inventoryTypeIndex

def CancelSortInventory(self):

self.OnCloseQuestionDialog()

def AcceptSortInventory(self):

if self.questionDialog:

if self.questionDialog.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

net.SendChatPacket("/sort_inventory")

else:

net.SendChatPacket("/sort_special_inventory %i" % (self.questionDialog.inventoryTypeIndex-1))

self.questionDialog.Close()

self.questionDialog = None

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 app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:

self.inventoryTypeIndex = 0

self.wndInventoryTypeTab.Destroy()

self.wndInventoryTypeTab = None

self.inventoryTab = []

self.equipmentTab = []

if app.__ENABLE_NEW_OFFLINESHOP__:

def __OnClickOpenOfflineShopBoardButton(self):

uiofflineshop.OpenOfflineShopBoard()

def Hide(self):

if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():

self.OnCloseQuestionDialog()

return

if None != self.tooltipItem:

self.tooltipItem.HideToolTip()

if self.wndCostume:

self.isOpenedCostumeWindowWhenClosingInventory = self.wndCostume.IsShow() # 인벤토리 창이 닫힐 때 코스츔이 열려 있었는가?

self.wndCostume.Close()

if self.wndBelt:

self.isOpenedBeltWindowWhenClosingInventory = self.wndBelt.IsOpeningInventory() # 인벤토리 창이 닫힐 때 벨트 인벤토리도 열려 있었는가?

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

self.wndBelt.Close()

if self.dlgPickMoney:

self.dlgPickMoney.Close()

if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:

self.wndInventoryTypeTab.Hide()

wndMgr.Hide(self.hWnd)

def Close(self):

self.Hide()

# def SetInventoryPage(self, page):

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

# self.inventoryPageIndex = page

# self.RefreshBagSlotWindow()

def SetInventoryPage(self, page):

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

self.inventoryPageIndex = page

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

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

self.RefreshBagSlotWindow()

else:

self.RefreshSpecialInventory()

else:

self.RefreshBagSlotWindow()

def SetEquipmentPage(self, page):

self.equipmentPageIndex = page

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

self.RefreshEquipSlotWindow()

if app.ENABLE_SPECIAL_INVENTORY:

def SetInventoryType(self, type):

self.wndInventoryTypeTab.SetUp(self.inventoryTypeIndex)

self.inventoryTypeIndex = int(type)

self.wndInventoryTypeTab.Down(self.inventoryTypeIndex)

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

self.RefreshBagSlotWindow()

else:

self.RefreshSpecialInventory()

def GetInventoryType(self):

return self.inventoryTypeIndex

def __SpecialInventoryLocalSlotPosToGlobalSlotPos(self, local):

if player.IsEquipmentSlot(local) or player.IsCostumeSlot(local):

return local

start = player.SPECIAL_INVENTORY_SLOT_START

slotCountPerType = (player.SPECIAL_INVENTORY_PAGE_SIZE * player.INVENTORY_PAGE_COUNT)

slotStartForType = start + slotCountPerType * (self.inventoryTypeIndex-1)

slotPageStart = slotStartForType + (player.SPECIAL_INVENTORY_PAGE_SIZE * self.inventoryPageIndex)

return slotPageStart + local

def RefreshSpecialInventory(self):

for i in xrange(player.SPECIAL_INVENTORY_PAGE_SIZE):

slotNumber = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(i)

itemCount = player.GetItemCount(slotNumber)

if 0 == itemCount:

self.wndItem.ClearSlot(i)

continue

elif 1 == itemCount:

itemCount = 0

itemVnum = player.GetItemIndex(slotNumber)

if itemVnum == 0 and slotNumber in self.liHighlightedItems:

self.liHighlightedItems.remove(slotNumber)

self.wndItem.DeactivateSlot(slotNumber)

self.wndItem.SetItemSlot(i, itemVnum, itemCount)

self.__RefreshHighlights()

self.wndItem.RefreshSlot()

def ClickMallButton(self):

print "click_mall_button"

net.SendChatPacket("/click_mall")

def ClickLagerButton(self):

import event

qid = constInfo.mallqin

event.QuestButtonClick(qid)

# 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) # 인벤토리 990000 제한 버그 수정

def OnPickMoney(self, money):

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

def OnPickItem(self, count):

itemSlotIndex = self.dlgPickMoney.itemGlobalSlotIndex

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, itemSlotIndex):

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

return

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)

# itemCount == 0이면 소켓을 비운다.

if 0 == itemCount:

self.wndItem.ClearSlot(i)

continue

elif 1 == itemCount:

itemCount = 0

itemVnum = getItemVNum(slotNumber)

setItemVNum(i, itemVnum, itemCount)

if itemVnum == 0 and slotNumber in self.liHighlightedItems:

self.liHightlightedItems.remove(slotNumber)

## 자동물약 (HP: #72723 ~ #72726, SP: #72727 ~ #72730) 특수처리 - 아이템인데도 슬롯에 활성화/비활성화 표시를 위한 작업임 - [hyo]

if constInfo.IS_AUTO_POTION(itemVnum):

# metinSocket - [0] : 활성화 여부, [1] : 사용한 양, [2] : 최대 용량

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

if slotNumber >= player.INVENTORY_PAGE_SIZE:

slotNumber -= player.INVENTORY_PAGE_SIZE

isActivated = 0 != metinSocket[0]

if isActivated:

self.wndItem.ActivateSlot(i)

potionType = 0;

if constInfo.IS_AUTO_POTION_HP(itemVnum):

potionType = player.AUTO_POTION_TYPE_HP

elif constInfo.IS_AUTO_POTION_SP(itemVnum):

potionType = player.AUTO_POTION_TYPE_SP

usedAmount = int(metinSocket[1])

totalAmount = int(metinSocket[2])

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

else:

self.wndItem.DeactivateSlot(i)

else:

self.wndItem.DeactivateSlot(i)

if itemVnum == 72501:

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

if slotNumber >= player.INVENTORY_PAGE_SIZE:

slotNumber -= player.INVENTORY_PAGE_SIZE

isActivated = 0 != metinSocket[0]

if isActivated:

self.wndItem.ActivateSlot(i)

else:

self.wndItem.DeactivateSlot(i)

self.__RefreshHighlights()

self.wndItem.RefreshSlot()

if self.wndBelt:

self.wndBelt.RefreshSlot()

def RefreshEquipSlotWindow(self):

getItemVNum=player.GetItemIndex

getItemCount=player.GetItemCount

setItemVNum=self.wndEquip.SetItemSlot

for i in xrange(player.EQUIPMENT_PAGE_COUNT):

slotNumber = player.EQUIPMENT_SLOT_START + i

itemCount = getItemCount(slotNumber)

if itemCount <= 1:

itemCount = 0

setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

if app.ENABLE_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.RefreshEquipSlotWindow()

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

self.RefreshBagSlotWindow()

else:

self.RefreshSpecialInventory()

else:

self.RefreshBagSlotWindow()

def RefreshStatus(self):

money = player.GetElk()

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

def SetItemToolTip(self, tooltipItem):

self.tooltipItem = tooltipItem

def SellItem(self):

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, self.sellingSlotNumber):

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

return

if self.sellingSlotitemIndex == player.GetItemIndex(self.sellingSlotNumber):

if self.sellingSlotitemCount == player.GetItemCount(self.sellingSlotNumber):

## 용혼석도 팔리게 하는 기능 추가하면서 인자 type 추가

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

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

self.OnCloseQuestionDialog()

if app.ENABLE_QUICK_SELL:

def QuickSellItem(self, itemSlotIndex):

itemIndex = player.GetItemIndex(itemSlotIndex)

itemCount = player.GetItemCount(itemSlotIndex)

if itemIndex == player.GetItemIndex(itemSlotIndex):

if itemCount == player.GetItemCount(itemSlotIndex):

net.SendShopSellPacketNew(itemSlotIndex, itemCount, player.INVENTORY)

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

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

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)

else:

selectedSlotPos = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)

else:

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 app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.SlotTypeToInvenType(attachedSlotType),attachedSlotPos):

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

return

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

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

else:

itemSlotIndex = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

else:

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 shop.IsOpen() == TRUE:

if not player.IsEquipmentSlot(itemSlotIndex):

self.sellingSlotNumber = itemSlotIndex

itemIndex = player.GetItemIndex(itemSlotIndex)

itemCount = player.GetItemCount(itemSlotIndex)

self.sellingSlotitemIndex = itemIndex

self.sellingSlotitemCount = itemCount

item.SelectItem(itemIndex)

net.SendShopSellPacketNew(self.sellingSlotNumber, self.sellingSlotitemCount, player.INVENTORY)

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

else:

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 app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and (uiofflineshop.IsSaleSlot(player.INVENTORY, srcItemSlotPos) or uiofflineshop.IsSaleSlot(player.INVENTORY , dstItemSlotPos)):

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

return

if srcItemSlotPos == dstItemSlotPos:

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:

#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 app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop():

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

return

if not player.IsEquipmentSlot(itemSlotPos):

self.sellingSlotNumber = itemSlotPos

itemIndex = player.GetItemIndex(itemSlotPos)

itemCount = player.GetItemCount(itemSlotPos)

self.sellingSlotitemIndex = itemIndex

self.sellingSlotitemCount = itemCount

item.SelectItem(itemIndex)

## 안티 플레그 검사 빠져서 추가

## 20140220

if item.IsAntiFlag(item.ANTIFLAG_SELL):

popup = uiCommon.PopupDialog()

popup.SetText(localeInfo.SHOP_CANNOT_SELL_ITEM)

popup.SetAcceptEvent(self.__OnClosePopupDialog)

popup.Open()

self.popup = popup

return

itemPrice = item.GetISellItemPrice()

if item.Is1GoldItem():

itemPrice = itemCount / itemPrice / 5

else:

itemPrice = itemPrice * itemCount / 5

item.GetItemName(itemIndex)

itemName = item.GetItemName()

self.questionDialog = uiCommon.QuestionDialog()

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

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

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

self.questionDialog.Open()

self.questionDialog.count = itemCount

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

def __OnClosePopupDialog(self):

self.pop = None

def RefineItem(self, scrollSlotPos, targetSlotPos):

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop():

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

return

scrollIndex = player.GetItemIndex(scrollSlotPos)

targetIndex = player.GetItemIndex(targetSlotPos)

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

return

if app.ENABLE_REFINE_RENEWAL:

constInfo.AUTO_REFINE_TYPE = 1

constInfo.AUTO_REFINE_DATA["ITEM"][0] = scrollSlotPos

constInfo.AUTO_REFINE_DATA["ITEM"][1] = targetSlotPos

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

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 not player.CanDetach(scrollIndex, targetSlotPos):

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

return

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.REFINE_DO_YOU_SEPARATE_METIN)

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

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

self.questionDialog.Open()

self.questionDialog.sourcePos = scrollSlotPos

self.questionDialog.targetPos = targetSlotPos

def AttachMetinToItem(self, metinSlotPos, targetSlotPos):

metinIndex = player.GetItemIndex(metinSlotPos)

targetIndex = player.GetItemIndex(targetSlotPos)

item.SelectItem(metinIndex)

itemName = item.GetItemName()

result = player.CanAttachMetin(metinIndex, targetSlotPos)

if player.ATTACH_METIN_NOT_MATCHABLE_ITEM == result:

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

if player.ATTACH_METIN_NO_MATCHABLE_SOCKET == result:

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

elif player.ATTACH_METIN_NOT_EXIST_GOLD_SOCKET == result:

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

elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:

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

if player.ATTACH_METIN_OK != result:

return

self.attachMetinDialog.Open(metinSlotPos, targetSlotPos)

def OverOutItem(self):

self.wndItem.SetUsableItem(FALSE)

if None != self.tooltipItem:

self.tooltipItem.HideToolTip()

def OverInItem(self, overSlotPos):

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)

else:

overSlotPosGlobal = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(overSlotPos)

else:

overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)

self.wndItem.SetUsableItem(False)

if overSlotPosGlobal in self.liHighlightedItems:

self.liHighlightedItems.remove(overSlotPosGlobal)

self.wndItem.DeactivateSlot(overSlotPos)

if mouseModule.mouseController.isAttached():

attachedItemType = mouseModule.mouseController.GetAttachedType()

if player.SLOT_TYPE_INVENTORY == attachedItemType:

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()

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

self.wndItem.SetUsableItem(True)

self.ShowToolTip(overSlotPosGlobal)

return

self.ShowToolTip(overSlotPosGlobal)

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;

# BUFF SYSTEM START

elif "USE_UPGRADE_BUFF" == useType:

if self.__CanUpgradeBuff(dstSlotPos):

return True

# BUFF SYSTEM END

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

# BUFF SYSTEM START

def __CanUpgradeBuff(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return False

item.SelectItem(dstItemVNum)

if item.GetUseType(dstItemVNum) != "USE_BUFF":

return False

for i in xrange(player.INVENTORY_PAGE_SIZE * player.INVENTORY_MAX_NUM):

if self.interface.GetWindowItemSlot(i) == dstSlotPos:

self.interface.RefreshSlot(i)

return True

# BUFF SYSTEM END

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)

if self.interface.dlgExchange.IsShow():

self.tooltipItem.AppendTradeableInformation()

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() or uiofflineshop.IsBuildingAuction():

self.__AddTooltipSaleMode(slotIndex)

if app.__ENABLE_NEW_OFFLINESHOP__:

def __AddTooltipSaleMode(self, slot):

if player.IsEquipmentSlot(slot):

return

itemIndex = player.GetItemIndex(slot)

if itemIndex !=0:

item.SelectItem(itemIndex)

if item.IsAntiFlag(item.ANTIFLAG_MYSHOP) or item.IsAntiFlag(item.ANTIFLAG_GIVE):

return

self.tooltipItem.AddRightClickForSale()

def OnTop(self):

if None != self.tooltipItem:

self.tooltipItem.SetTop()

def OnPressEscapeKey(self):

self.Close()

return TRUE

def UseItemSlot(self, slotIndex):

if app.__ENABLE_NEW_OFFLINESHOP__:

globalSlot = 0

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

globalSlot = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

else:

globalSlot = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(slotIndex)

else:

globalSlot = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

if uiofflineshop.IsBuildingShop():

itemIndex = player.GetItemIndex(globalSlot)

item.SelectItem(itemIndex)

if not item.IsAntiFlag(item.ANTIFLAG_GIVE) and not item.IsAntiFlag(item.ANTIFLAG_MYSHOP):

offlineshop.ShopBuilding_AddInventoryItem(globalSlot)

else:

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

return

elif uiofflineshop.IsBuildingAuction():

itemIndex = player.GetItemIndex(globalSlot)

item.SelectItem(itemIndex)

if not item.IsAntiFlag(item.ANTIFLAG_GIVE) and not item.IsAntiFlag(item.ANTIFLAG_MYSHOP):

offlineshop.AuctionBuilding_AddInventoryItem(globalSlot)

else:

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

return

curCursorNum = app.GetCursor()

if app.SELL == curCursorNum:

return

if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():

return

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

else:

slotIndex = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(slotIndex)

else:

slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

if app.ENABLE_QUICK_SELL:

import shop

if app.IsPressed(app.DIK_LSHIFT) or app.IsPressed(app.DIK_RSHIFT):

if shop.IsOpen():

if not shop.IsPrivateShop():

self.QuickSellItem(slotIndex)

return

if app.ENABLE_DRAGON_SOUL_SYSTEM:

if self.wndDragonSoulRefine.IsShow():

self.wndDragonSoulRefine.AutoSetItem((player.INVENTORY, slotIndex), 1)

return

if app.IsPressed(app.DIK_LSHIFT):

ItemVNum = player.GetItemIndex(slotIndex)

item.SelectItem(ItemVNum)

if item.GetItemType()==23 and item.GetItemSubType()==0:

itemCount = player.GetItemCount(slotIndex)

if itemCount > 1:

self.dlgPickMoney.SetTitleName(localeInfo.MULTI_CHEST_OPEN)

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

self.dlgPickMoney.Open(itemCount)

self.dlgPickMoney.itemGlobalSlotIndex = slotIndex

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

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

def OnUseTreasure(self,value):

if value:

for x in xrange(value):

net.SendItemUsePacket(self.dlgPickMoney.itemGlobalSlotIndex)

def GetExchangeEmptyItemPos(self, itemHeight):

inventorySize = exchange.EXCHANGE_ITEM_MAX_NUM

inventoryWidth = 6 # Change it to your Trade-Window with ( Metin2 default is 4, Trade Renewal is 6 )

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

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, slotIndex):

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

return

ItemVNum = player.GetItemIndex(slotIndex)

item.SelectItem(ItemVNum)

if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.INVENTORY_REALLY_USE_ITEM)

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

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

self.questionDialog.Open()

self.questionDialog.slotIndex = slotIndex

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

else:

self.__SendUseItemPacket(slotIndex)

#net.SendItemUsePacket(slotIndex)

def __UseItemQuestionDialog_OnCancel(self):

self.OnCloseQuestionDialog()

def __UseItemQuestionDialog_OnAccept(self):

self.__SendUseItemPacket(self.questionDialog.slotIndex)

self.OnCloseQuestionDialog()

def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):

# 개인상점 열고 있는 동안 아이템 사용 방지

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)

def __SendUseItemPacket(self, slotPos):

# 개인상점 열고 있는 동안 아이템 사용 방지

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemUsePacket(slotPos)

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

# 개인상점 열고 있는 동안 아이템 사용 방지

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)

def SetDragonSoulRefineWindow(self, wndDragonSoulRefine):

if app.ENABLE_DRAGON_SOUL_SYSTEM:

self.wndDragonSoulRefine = wndDragonSoulRefine

def OnMoveWindow(self, x, y):

# print "Inventory Global Pos : ", self.GetGlobalPosition()

if self.wndBelt:

# print "Belt Global Pos : ", self.wndBelt.GetGlobalPosition()

self.wndBelt.AdjustPositionAndSize()

if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:

self.wndInventoryTypeTab.AdjustPosition()

def HighlightSlot(self, slot):

if not slot in self.liHighlightedItems:

self.liHighlightedItems.append(slot)

def __RefreshHighlights(self):

for i in xrange(player.INVENTORY_PAGE_SIZE):

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)

else:

slotNumber = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(i)

else:

slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)

if slotNumber in self.liHighlightedItems:

self.wndItem.ActivateSlot(i)

Alles anzeigen

Vielleicht ist es hilfreich zu wissen das ich das Special Inventory von Sanii verbaut habe.

Würde mich freuen wenn mir da einer weiterhelfen kann.
Lg.

Alles anzeigen

In der zeile 1444 musst du zweimal Tab drücken

So sollte es aussehen:
Bitte melden Sie sich an, um diesen Link zu sehen.

Passwort · 22. Juli 2023

Zitat von Steap

Zitat von Ratatatatatata

nie

Zitat von Blacky (Mobile2)

wird nichts mehr kommen .

Quelle?

Das sind Troller. Die verbreiten überall lügen

Passwort · 20. Juli 2023

Zitat von Syntax

Zitat von Passwort

Syntax hat seine hilfe dir angeboten, add ihn auf discord

Er hat keine game und keine DB tgz deshalb sollte er einfach die von fliege v3 nehmen und die Struktur anpassen bzw die Dateien ersetzen. Ich glaube cyn3 kann einfach die tgz mit liefern und dann ist die Sache gegessen 😅

Die game und db muss er auch auf seinem freebsd kompilieren. Dazu braucht er nur eine Makefile, die soll er von fliege nehmen und anpassen

Passwort · 19. Juli 2023

Zitat von Sinan1034

Grüße zurück xDD
Problem besteht immer noch^^

Syntax hat seine hilfe dir angeboten, add ihn auf discord

Passwort · 19. Juli 2023

Bitte melden Sie sich an, um diesen Link zu sehen.

Passwort · 19. Juli 2023

Da steht file not found, sollte selbsterklärend sein

Passwort · 15. Juli 2023

Good products and good service ++++

Beiträge von Passwort

Discord Copyright problem wegen Previews

Ingame Switchbot by Mijago 2.3 einbauen

Discord Copyright problem wegen Previews

Pet slot system

Ingame Switchbot by Mijago 2.3 einbauen

Ingame Switchbot by Mijago 2.3 einbauen

[25€ Belohnung] Dracarys Render Target Client crash

[25€ Belohnung] Dracarys Render Target Client crash

Multifarmblock CHXelo release

[25€ Belohnung] Dracarys Render Target Client crash

[25€ Belohnung] Dracarys Render Target Client crash

Wünsche Systeme

Wünsche Systeme

Buff Items Stufe werden nur auf 1. Inventarseite angezeigt.

[Free] Itemshop by sura_head

Files Aufsetzten

Files Aufsetzten

Files Aufsetzten

Compile Error

dracaryS / Service - Systems