[R]34083 Crafting Sistemi

[Pavor]

ROHAN2 WORLD 1-120 TR TİPİ OFFICIAL YOHARA, BALATHOR VE AMON! 80. GÜNÜNDE! +10.000 ONLİNE! HİLE VE BOT %100 ENGELLİ HEMEN TIKLA!

Öncelikle Merhaba Arkadaşlar Bu Gün Sizlere Crafting Sistemi Nasıl Eklenir Onu Göstereceğim .

Çoğu Yabancı Forum Gibi Sitelerde Bu Doğru Anlatılmamış Yapamayan Arkadaşlarımız Olmuş

Bu Sistem cube.txt İle Bağlantılıdır Ordaki İtemleri Düzenlemeniz Gerekecektir .


Başlamadan Önce Notlar ;

Tavsiye Edilen Client Sürümü ; 34083

Tavsiye Edilen GAME Sürümü ; 34083 , 40250

Düzenlemenizde Yardımcı Olacak Program ; Notepad ++

Başlayalım ...

Öncelikle Bize .epk Ve .eix Dosyaları Gerekiyor Bunları Metin2 Klasöründeki Packlardan Alacaksınız

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

Yukardaki Resimdeki Pack Dosyalarını Alalım .

Not ; " Bazı Fileslerde Locale_tr Yerine Locale_de'dir Dikkatli Seçiniz .


Bu 3 Dosyayı Eternexus İle Açıyoruz .

Karşınıza Klasörler Gelecek Root Klasörüne Giriyoruz .

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

Game.py Yi Açıyoruz . Ve En Aşağıya Bu Kodları Ekliyoruz ;

# CUBE     def BINARY_Cube_Open(self, npcVNUM): 
        self.currentCubeNPC = npcVNUM 
         
        self.interface.OpenCubeWindow() 

         
        if npcVNUM not in self.cubeInformation: 
            net.SendChatPacket("/cube r_info") 
        else: 
            cubeInfoList = self.cubeInformation[npcVNUM] 
             
            i = 0 
            for cubeInfo in cubeInfoList:                                 
                self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"]) 
                 
                j = 0                 
                for materialList in cubeInfo["materialList"]: 
                    for materialInfo in materialList: 
                        itemVnum, itemCount = materialInfo 
                        self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount) 
                    j = j + 1                         
                         
                i = i + 1 
                 
            self.interface.wndCube.Refresh() 

    def BINARY_Cube_Close(self): 
        self.interface.CloseCubeWindow() 

    # Á¦ÀÛ¿¡ ÇÊ¿äÇÑ °ñµå, ¿¹»óµÇ´Â ¿Ï¼ºÇ°ÀÇ VNUM°ú °³¼ö Á¤º¸ update 
    def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count): 
        self.interface.UpdateCubeInfo(gold, itemVnum, count) 
         
    def BINARY_Cube_Succeed(self, itemVnum, count): 
        print "Å¥ºê Á¦ÀÛ ¼º°ø" 
        self.interface.SucceedCubeWork(itemVnum, count) 
        pass 

    def BINARY_Cube_Failed(self): 
        print "Å¥ºê Á¦ÀÛ ½ÇÆĞ" 
        self.interface.FailedCubeWork() 
        pass 

    def BINARY_Cube_ResultList(self, npcVNUM, listText): 
        # ResultList Text Format : 72723,1/72725,1/72730.1/50001,5  ÀÌ·±½ÄÀ¸·Î "/" ¹®ÀÚ·Î ±¸ºĞµÈ ¸®½ºÆ®¸¦ ÁÜ 
        #print listText 
         
        if npcVNUM == 0: 
            npcVNUM = self.currentCubeNPC 
         
        self.cubeInformation[npcVNUM] = [] 
         
        try: 
            for eachInfoText in listText.split("/"): 
                eachInfo = eachInfoText.split(",") 
                itemVnum    = int(eachInfo[0]) 
                itemCount    = int(eachInfo[1]) 

                self.cubeInformation[npcVNUM].append({"vnum": itemVnum, "count": itemCount}) 
                self.interface.wndCube.AddCubeResultItem(itemVnum, itemCount) 
             
            resultCount = len(self.cubeInformation[npcVNUM]) 
            requestCount = 7 
            modCount = resultCount % requestCount 
            splitCount = resultCount / requestCount 
            for i in xrange(splitCount): 
                #print("/cube r_info %d %d" % (i * requestCount, requestCount)) 
                net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount)) 
                 
            if 0 < modCount: 
                #print("/cube r_info %d %d" % (splitCount * requestCount, modCount))                 
                net.SendChatPacket("/cube r_info %d %d" % (splitCount * requestCount, modCount)) 

        except RuntimeError, msg: 
            dbg.TraceError(msg) 
            return 0 
             
        pass 
         
    def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText): 
        # Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000 
        try: 
            #print listText 
             
            if 3 > len(listText): 
                dbg.TraceError("Wrong Cube Material Infomation") 
                return 0 

             
             
            eachResultList = listText.split("@") 

            cubeInfo = self.cubeInformation[self.currentCubeNPC]             
             
            itemIndex = 0 
            for eachResultText in eachResultList: 
                cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []] 
                materialList = cubeInfo[startIndex + itemIndex]["materialList"] 
                 
                gold = 0 
                splitResult = eachResultText.split("/") 
                if 1 < len(splitResult): 
                    gold = int(splitResult[1]) 
                     
                #print "splitResult : ", splitResult 
                eachMaterialList = splitResult[0].split("&") 
                 
                i = 0 
                for eachMaterialText in eachMaterialList: 
                    complicatedList = eachMaterialText.split("|") 
                     
                    if 0 < len(complicatedList): 
                        for complicatedText in complicatedList: 
                            (itemVnum, itemCount) = complicatedText.split(",") 
                            itemVnum = int(itemVnum) 
                            itemCount = int(itemCount) 
                            self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount) 
                             
                            materialList[i].append((itemVnum, itemCount)) 
                             
                    else: 
                        itemVnum, itemCount = eachMaterialText.split(",") 
                        itemVnum = int(itemVnum) 
                        itemCount = int(itemCount) 
                        self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount) 
                         
                        materialList[i].append((itemVnum, itemCount)) 
                         
                    i = i + 1 
                     
                     
                     
                itemIndex = itemIndex + 1 
                 
            self.interface.wndCube.Refresh() 
             
                 
        except RuntimeError, msg: 
            dbg.TraceError(msg) 
            return 0 
             
        pass 
     
    # END_OF_CUBE 
     
    # ¿ëÈ¥¼®     
    def BINARY_Highlight_Item(self, inven_type, inven_pos): 
        self.interface.Highligt_Item(inven_type, inven_pos) 
     
    def BINARY_DragonSoulGiveQuilification(self): 
        self.interface.DragonSoulGiveQuilification() 
         
    def BINARY_DragonSoulRefineWindow_Open(self): 
        self.interface.OpenDragonSoulRefineWindow() 

    def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos): 
        self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos) 

    def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos): 
        self.interface.SucceedDragonSoulRefine(inven_type, inven_pos) 
     
    # END of DRAGON SOUL REFINE WINDOW

Burayı Ekledikten Sonra Kaydediyoruz .

Ve Root İçerisinde Yeni Bir Metin Belgesi Oluşturuyoruz ;

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

İsmini ; dragon_soul_refine_settings Yapıyoruz .


Ardından İçine Bu Kodları Ekliyoruz ;

import item 
default_grade_need_count = [15, 10, 5, 3] 
default_grade_fee = [30000, 50000, 70000, 100000] 
default_step_need_count = [4, 3, 2, 1] 
default_step_fee = [20000, 30000, 40000, 50000] 

strength_fee = { 
    item.MATERIAL_DS_REFINE_NORMAL : 10000, 
    item.MATERIAL_DS_REFINE_BLESSED : 20000, 
    item.MATERIAL_DS_REFINE_HOLLY : 30000, 
} 

# °*È*°¡ ¾î´À ´Ü°è ±îÁö °¡´É ÇÑÁö 
# table(GRADE, STEP) = max strength. 
default_strength_max_table = [ 
    [2, 2, 3, 3, 4], 
    [3, 3, 3, 4, 4], 
    [4, 4, 4, 4, 4], 
    [4, 4, 4, 4, 5], 
    [4, 4, 4, 5, 6], 
] 

# ÀÏ´Ü ±âȹÀûÀ¸·Î´Â strength °*È*ÀÇ °æ¿ì, °*È*¼®¿¡ ÀÇÇØ fee°¡ ¼ÂÆõDZ⠶§¹®¿¡, 
# dragon_soul_refine_info¿¡ ³ÖÁö ¾Ê¾Ò´Ù. 
# (°*È*¼®¸¸ ³Ö¾îµµ ¾ó¸¶ ÇÊ¿äÇÑÁö º¸ÀÏ ¼ö ÀÖµµ·Ï Çϱâ À§ÇØ) 
# ´Ù¸¸ ¼*¹ö¿¡¼*´Â ¿ëÈ¥¼® ŸÀÔ º°·Î °*È*¼® fee¸¦ ¼ÂÆÃÇÒ ¼ö ÀÖµµ·Ï Çسù±â ¶§¹®¿¡, 
# ¸¸ÀÏ ¿ëÈ¥¼® º°·Î °*È*¼® fee¸¦ ´Ù¸£°Ô ÇÏ°í ½Í´Ù¸é, 
# Ŭ¶ó Äڵ带 ¼öÁ¤ÇؾßÇÒ °ÍÀÌ´Ù. 
default_refine_info = { 
    "grade_need_count" : default_grade_need_count, 
    "grade_fee" : default_grade_fee, 
    "step_need_count" : default_step_need_count, 
    "step_fee" : default_step_fee, 
    "strength_max_table" : default_strength_max_table, 
} 

dragon_soul_refine_info = { 
    11 : default_refine_info, 
    12 : default_refine_info, 
    13 : default_refine_info, 
    14 : default_refine_info, 
    15 : default_refine_info, 
    16 : default_refine_info, 
}

Bu Kodları Ekledikten Sonra Bu Metin Belgesini Kaydedeceğiz Ama Nasıl Kaydedeceğiz ?

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

İlk Önce Kaydetmeden Önce All Types (*.*) Bu Seçeneği Seçiyoruz

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

Ardından .txt Yi Silip Oraya .py Yazıyoruz

Şimdi Root İle İşimiz Şu Anda Bitti .

Locale_tr.epk Dosyamızı Açmıştık Bunun İçine Girip

Locale > Locale > Ui Klasörüne Giriyoruz .

Daha Sonra Size Atacağım Dosyayı İndirip Locale / Ui ' ye Atacaksınız

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

Bu Dosyayı İndireceksiniz .

Konu Sonunda VİRÜS TOTALLERİ Vereceğim .

Ardından Root Klasörüne Tekrar Girip .

Yukarıda Verdiğim Taktikle uidragonsoul.py

Adında Bir Metin Belgesi Oluşturup

import ui import player 
import mouseModule 
import net 
import app 
import snd 
import item 
import chat 
import grp 
import uiScriptLocale 
import uiRefine 
import uiAttachMetin 
import uiPickMoney 
import uiCommon 
import uiPrivateShopBuilder 
import locale 
import constInfo 
import ime 
import uiInventory 
import sys 
ITEM_FLAG_APPLICABLE = 1 << 14 

# ¿ëÈ¥¼® Vnum¿¡ ´ëÇÑ comment     
# ITEM VNUMÀ» 10¸¸ ÀÚ¸®ºÎÅÍ, FEDCBA¶ó°í ÇÑ´Ù¸é 
# FE : ¿ëÈ¥¼® Á¾·ù.    D : µî±Ş 
# C : ´Ü°è            B : °*È*         
# A : ¿©¹úÀÇ ¹øÈ£µé...      

class DragonSoulWindow(ui.ScriptWindow): 
    KIND_TAP_TITLES = [uiScriptLocale.DRAGONSOUL_TAP_TITLE_1, uiScriptLocale.DRAGONSOUL_TAP_TITLE_2, 
            uiScriptLocale.DRAGONSOUL_TAP_TITLE_3, uiScriptLocale.DRAGONSOUL_TAP_TITLE_4, uiScriptLocale.DRAGONSOUL_TAP_TITLE_5, uiScriptLocale.DRAGONSOUL_TAP_TITLE_6] 
    def __init__(self): 
        ui.ScriptWindow.__init__(self) 
        self.questionDialog = None 
        self.tooltipItem = None 
        self.sellingSlotNumber = -1 
        self.isLoaded = 0 
        self.isActivated = FALSE 
        self.DSKindIndex = 0 
        self.tabDict = None 
        self.tabButtonDict = None 
        self.deckPageIndex = 0 
        self.inventoryPageIndex = 0 
        self.SetWindowName("DragonSoulWindow") 
        self.__LoadWindow() 

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

        ui.ScriptWindow.Show(self) 
    def __LoadWindow(self): 
        if self.isLoaded == 1: 
            return 
        self.isLoaded = 1 
        try: 
            pyScrLoader = ui.PythonScriptLoader()             
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "dragonsoulwindow.py") 
         
        except: 
            import exception 
            exception.Abort("dragonsoulwindow.LoadWindow.LoadObject") 
        try: 
            if locale.IsARABIC(): 
                self.board = self.GetChild("Equipment_Base") 
                self.board.SetScale(-1.0, 1.0) 
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0) 
                self.board = self.GetChild("Tab_01") 
                self.board.SetScale(-1.0, 1.0) 
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0) 
                self.board = self.GetChild("Tab_02") 
                self.board.SetScale(-1.0, 1.0) 
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0) 
                self.board = self.GetChild("Tab_03") 
                self.board.SetScale(-1.0, 1.0) 
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0) 
                self.board = self.GetChild("Tab_04") 
                self.board.SetScale(-1.0, 1.0) 
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0) 
                self.board = self.GetChild("Tab_05") 
                self.board.SetScale(-1.0, 1.0) 
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0) 
                self.board = self.GetChild("Tab_06") 
                self.board.SetScale(-1.0, 1.0) 
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0) 
                 
            wndItem = self.GetChild("ItemSlot") 
            wndEquip = self.GetChild("EquipmentSlot") 
            self.activateButton = self.GetChild("activate") 
            self.deckTab = [] 
            self.deckTab.append(self.GetChild("deck1")) 
            self.deckTab.append(self.GetChild("deck2")) 
            self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))             
            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.inventoryTab.append(self.GetChild("Inventory_Tab_05")) 
            self.tabDict = { 
                0    : self.GetChild("Tab_01"), 
                1    : self.GetChild("Tab_02"), 
                2    : self.GetChild("Tab_03"), 
                3    : self.GetChild("Tab_04"), 
                4    : self.GetChild("Tab_05"), 
                5    : self.GetChild("Tab_06"), 
            } 
            self.tabButtonDict = { 
                0    : self.GetChild("Tab_Button_01"), 
                1    : self.GetChild("Tab_Button_02"), 
                2    : self.GetChild("Tab_Button_03"), 
                3    : self.GetChild("Tab_Button_04"), 
                4    : self.GetChild("Tab_Button_05"), 
                5    : self.GetChild("Tab_Button_06"), 
            } 
            self.tabText = self.GetChild("tab_text_area") 
        except: 
            import exception 
            exception.Abort("InventoryWindow.LoadWindow.BindObject") 
        ## DragonSoul Kind Tap 
        for (tabKey, tabButton) in self.tabButtonDict.items(): 
            tabButton.SetEvent(ui.__mem_func__(self.SetDSKindIndex), tabKey) 
        ## Item 
        wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem)) 
        wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem)) 
        wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot)) 
        wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot)) 
        wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot)) 
        wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot)) 
         
        ## Equipment 
        wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptyEquipSlot)) 
        wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectEquipItemSlot)) 
        wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseEquipItemSlot)) 
        wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseEquipItemSlot)) 
        wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInEquipItem)) 
        wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutEquipItem)) 
         
        ## Deck 
        self.deckTab[0].SetToggleDownEvent(lambda arg=0: self.SetDeckPage(arg)) 
        self.deckTab[1].SetToggleDownEvent(lambda arg=1: self.SetDeckPage(arg)) 
        self.deckTab[0].SetToggleUpEvent(lambda arg=0: self.__DeckButtonDown(arg)) 
        self.deckTab[1].SetToggleUpEvent(lambda arg=1: self.__DeckButtonDown(arg)) 
        self.deckTab[0].Down() 
        ## Grade button 
        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[4].SetEvent(lambda arg=4: self.SetInventoryPage(arg)) 
        self.inventoryTab[0].Down() 
        ## Etc 
        self.wndItem = wndItem 
        self.wndEquip = wndEquip 
         
        self.dlgQuestion = uiCommon.QuestionDialog2() 
        self.dlgQuestion.Close() 
         
        self.activateButton.SetToggleDownEvent(ui.__mem_func__(self.ActivateButtonClick)) 
        self.activateButton.SetToggleUpEvent(ui.__mem_func__(self.ActivateButtonClick)) 
        self.wndPopupDialog = uiCommon.PopupDialog() 
         
        ##  
        self.listHighlightedSlot = [] 
         
        ## Refresh 
        self.SetInventoryPage(0) 
        self.RefreshItemSlot() 
        self.RefreshEquipSlotWindow() 
        self.RefreshBagSlotWindow() 
        self.SetDSKindIndex(0) 
        self.activateButton.Enable() 
        self.deckTab[self.deckPageIndex].Down() 
        self.activateButton.SetUp() 

    def Destroy(self): 
        self.ClearDictionary() 
        self.tooltipItem = None 
        self.wndItem = 0 
        self.wndEquip = 0 
        self.activateButton = 0 
        self.questionDialog = None 
        self.mallButton = None 
        self.inventoryTab = [] 
        self.deckTab = [] 
        self.equipmentTab = [] 
        self.tabDict = None 
        self.tabButtonDict = None 
         
    def Close(self): 
        if None != self.tooltipItem: 
            self.tooltipItem.HideToolTip() 
         self.Hide() 
      
     def __DeckButtonDown(self, deck): 
         self.deckTab[deck].Down() 
      
    def SetInventoryPage(self, page): 
        if self.inventoryPageIndex != page: 
            self.__HighlightSlot_ClearCurrentPage() 
        self.inventoryPageIndex = page 
        self.inventoryTab[(page+1)%5].SetUp() 
        self.inventoryTab[(page+2)%5].SetUp() 
        self.inventoryTab[(page+3)%5].SetUp() 
        self.inventoryTab[(page+4)%5].SetUp() 
        self.RefreshBagSlotWindow() 
         
    def SetItemToolTip(self, tooltipItem): 
        self.tooltipItem = tooltipItem 
         
    def RefreshItemSlot(self): 
        self.RefreshBagSlotWindow() 
        self.RefreshEquipSlotWindow() 
         
    def RefreshEquipSlotWindow(self): 
        for i in xrange(6): 
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i) 
            itemVnum = player.GetItemIndex(slotNumber) 
            self.wndEquip.SetItemSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i, itemVnum, 0) 
            self.wndEquip.EnableSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i) 
             
            if itemVnum != 0: 
                item.SelectItem(itemVnum) 
                for j in xrange(item.LIMIT_MAX_NUM): 
                    (limitType, limitValue) = item.GetLimit(j) 
                     
                    # ¹Ø¿¡¼* remain_timeÀÌ 0ÀÌÇÏÀÎÁö üũ Çϱ⠶§¹®¿¡ ÀÓÀÇÀÇ ¾ç¼ö·Î ÃʱâÈ* 
                    remain_time = 999 
                    # ÀÏ´Ü ÇöÀç ŸÀ̸Ӵ ÀÌ ¼¼°³ »ÓÀÌ´Ù. 
                    if item.LIMIT_REAL_TIME == limitType: 
                        remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0) - app.GetGlobalTimeStamp() 
                    elif item.LIMIT_REAL_TIME_START_FIRST_USE == limitType: 
                        remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0) - app.GetGlobalTimeStamp() 
                    elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType: 
                        remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0) 
                         
                    if remain_time <= 0: 
                        self.wndEquip.DisableSlot(player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i) 
                        break 
                     
        self.wndEquip.RefreshSlot() 
         
    def RefreshStatus(self): 
        self.RefreshItemSlot() 
         
    def __InventoryLocalSlotPosToGlobalSlotPos(self, window_type, local_slot_pos): 
        if player.INVENTORY == window_type: 
            return self.deckPageIndex * player.DRAGON_SOUL_EQUIPMENT_FIRST_SIZE + local_slot_pos 
             
        return (self.DSKindIndex * 5 * player.DRAGON_SOUL_PAGE_SIZE) + self.inventoryPageIndex * player.DRAGON_SOUL_PAGE_SIZE + local_slot_pos 
         
    def RefreshBagSlotWindow(self): 
        getItemVNum=player.GetItemIndex 
        getItemCount=player.GetItemCount 
        setItemVnum=self.wndItem.SetItemSlot 
        for i in xrange(player.DRAGON_SOUL_PAGE_SIZE): 
            self.wndItem.EnableSlot(i) 
            #<- dragon soul kind 
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i) 

            itemCount = getItemCount(player.DRAGON_SOUL_INVENTORY, slotNumber) 
            if 0 == itemCount: 
                self.wndItem.ClearSlot(i) 
                continue 
            elif 1 == itemCount: 
                itemCount = 0 
            itemVnum = getItemVNum(player.DRAGON_SOUL_INVENTORY, slotNumber) 

            setItemVnum(i, itemVnum, itemCount) 

            if itemVnum != 0: 
                item.SelectItem(itemVnum) 
                for j in xrange(item.LIMIT_MAX_NUM): 
                    (limitType, limitValue) = item.GetLimit(j) 

                    # ¹Ø¿¡¼* remain_timeÀÌ À½¼öÀÎÁö üũ Çϱ⠶§¹®¿¡ ÀÓÀÇÀÇ ¾ç¼ö·Î ÃʱâÈ* 
                    remain_time = 999 
                    if item.LIMIT_REAL_TIME == limitType: 
                        remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0) 
                    elif item.LIMIT_REAL_TIME_START_FIRST_USE == limitType: 
                        remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0) 
                    elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType: 
                        remain_time = player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotNumber, 0) 
                 
                    if remain_time <= 0: 
                        self.wndItem.DisableSlot(i) 
                        break 

        self.__HighlightSlot_RefreshCurrentPage() 
        self.wndItem.RefreshSlot() 
         
    def ShowToolTip(self, window_type, slotIndex): 
        if None != self.tooltipItem: 
            if player.INVENTORY == window_type: 
                self.tooltipItem.SetInventoryItem(slotIndex) 
            else: 
                self.tooltipItem.SetInventoryItem(slotIndex, player.DRAGON_SOUL_INVENTORY) 

    def OnPressEscapeKey(self): 
        self.Close() 
        return TRUE 
             
    def OnTop(self): 
        if None != self.tooltipItem: 
            self.tooltipItem.SetTop() 
     
    # item slot °ü·Ã ÇÔ¼ö                 
    def OverOutItem(self): 
        self.wndItem.SetUsableItem(FALSE) 
        if None != self.tooltipItem: 
            self.tooltipItem.HideToolTip() 
             
    def OverInItem(self, overSlotPos): 
        self.wndItem.DeactivateSlot(overSlotPos) 
        overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, overSlotPos) 
        try: 
            self.listHighlightedSlot.remove(overSlotPos) 
        except: 
            pass 
         
        self.wndItem.SetUsableItem(FALSE) 
        self.ShowToolTip(player.DRAGON_SOUL_INVENTORY, overSlotPos) 
     
    def __UseItem(self, slotIndex): 
        ItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, slotIndex) 
        if 0 == player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, slotIndex, 0): 
            self.wndPopupDialog.SetText(locale.DRAGON_SOUL_EXPIRED) 
            self.wndPopupDialog.Open() 
            return 
  
        self.__EquipItem(slotIndex) 

    def __EquipItem(self, slotIndex):     
        ItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, slotIndex) 
        item.SelectItem(ItemVNum) 
        subType = item.GetItemSubType() 
        equipSlotPos = player.DRAGON_SOUL_EQUIPMENT_SLOT_START + self.deckPageIndex * player.DRAGON_SOUL_EQUIPMENT_FIRST_SIZE + subType 
        srcItemPos = (player.DRAGON_SOUL_INVENTORY, slotIndex) 
        dstItemPos = (player.INVENTORY, equipSlotPos) 
        self.__OpenQuestionDialog(TRUE, srcItemPos, dstItemPos) 
     
    def SelectItemSlot(self, itemSlotIndex): 
        if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1: 
            return 

        itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, itemSlotIndex) 

        if mouseModule.mouseController.isAttached(): 
            attachedSlotType = mouseModule.mouseController.GetAttachedType() 
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber() 
            attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex() 
                 
            attachedInvenType = player.SlotTypeToInvenType(attachedSlotType) 
            if player.RESERVED_WINDOW != attachedInvenType: 
                net.SendItemUseToItemPacket(attachedInvenType, attachedSlotPos, player.DRAGON_SOUL_INVENTORY, itemSlotIndex) 

            mouseModule.mouseController.DeattachObject() 

        else: 
            selectedItemVNum = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, itemSlotIndex) 
            itemCount = player.GetItemCount(player.DRAGON_SOUL_INVENTORY, itemSlotIndex) 
            mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_DRAGON_SOUL_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount) 
            self.wndItem.SetUseMode(FALSE) 
            snd.PlaySound("sound/ui/pick.wav") 

    def SelectEmptySlot(self, selectedSlotPos): 
        if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1: 
            return 

        selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, selectedSlotPos) 
        print "__debug", selectedSlotPos 
        if mouseModule.mouseController.isAttached(): 

            attachedSlotType = mouseModule.mouseController.GetAttachedType() 
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber() 
            attachedItemCount = mouseModule.mouseController.GetAttachedItemCount() 
            attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex() 

            attachedInvenType = player.SlotTypeToInvenType(attachedSlotType) 
            if 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, player.DRAGON_SOUL_INVENTORY, selectedSlotPos) 

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

            elif player.RESERVED_WINDOW != attachedInvenType: 
                if player.IsDSEquipmentSlot(attachedInvenType, attachedSlotPos): 
                    srcItemPos = (attachedInvenType, attachedSlotPos) 
                    dstItemPos = (player.DRAGON_SOUL_INVENTORY, selectedSlotPos) 
                    self.__OpenQuestionDialog(FALSE, srcItemPos, dstItemPos) 
                else: 
                    itemCount = player.GetItemCount(attachedInvenType, attachedSlotPos) 
                    attachedCount = mouseModule.mouseController.GetAttachedItemCount() 
  
                    self.__SendMoveItemPacket(attachedInvenType, attachedSlotPos, player.DRAGON_SOUL_INVENTORY, selectedSlotPos, attachedCount) 

            mouseModule.mouseController.DeattachObject() 

    def UseItemSlot(self, slotIndex): 
        if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS(): 
            return 
        slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, slotIndex) 
        try: 
            # ¿ëÈ¥¼® °*È*âÀÌ ¿*·ÁÀÖÀ¸¸é, ¾ÆÀÌÅÛ ¿ìŬ¸¯ ½Ã ÀÚµ¿À¸·Î °*È*âÀ¸·Î µé¾î°¨. 
            if self.wndDragonSoulRefine.IsShow(): 
                if uiPrivateShopBuilder.IsBuildingPrivateShop(): 
                    chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP) 
                    return 
                self.wndDragonSoulRefine.AutoSetItem((player.DRAGON_SOUL_INVENTORY, slotIndex), 1) 
                return 
        except: 
            pass 

        self.__UseItem(slotIndex) 
  
        mouseModule.mouseController.DeattachObject() 
        self.OverOutItem() 
         
    def __SendMoveItemPacket(self, srcSlotWindow, srcSlotPos, dstSlotWindow, dstSlotPos, srcItemCount): 
        if uiPrivateShopBuilder.IsBuildingPrivateShop(): 
            chat.AppendChat(chat.CHAT_TYPE_INFO, locale.MOVE_ITEM_FAILURE_PRIVATE_SHOP) 
            return 
         
        net.SendItemMovePacket(srcSlotWindow , srcSlotPos, dstSlotWindow, dstSlotPos, srcItemCount) 
     
    # equip ½½·Ô °ü·Ã ÇÔ¼öµé. 
    def OverOutEquipItem(self): 
        self.OverOutItem() 
             
    def OverInEquipItem(self, overSlotPos): 
        overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, overSlotPos) 
        self.wndItem.SetUsableItem(FALSE) 
        self.ShowToolTip(player.INVENTORY, overSlotPos) 
     
    def UseEquipItemSlot(self, slotIndex): 
        if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS(): 
            return 

        slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, slotIndex) 

        self.__UseEquipItem(slotIndex) 
        mouseModule.mouseController.DeattachObject() 
        self.OverOutEquipItem() 
     
    def __UseEquipItem(self, slotIndex): 
        if uiPrivateShopBuilder.IsBuildingPrivateShop(): 
            chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_ITEM_FAILURE_PRIVATE_SHOP) 
            return 

        self.__OpenQuestionDialog(FALSE, (player.INVENTORY, slotIndex), (1, 1)) 
                     
     
    def SelectEquipItemSlot(self, itemSlotIndex): 
        if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1: 
            return 

        itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, itemSlotIndex) 

        if mouseModule.mouseController.isAttached(): 
            attachedSlotType = mouseModule.mouseController.GetAttachedType() 
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber() 
            # ÀÚ±â ÀÚ½ÅÀ» ÀÚ±â Àڽſ¡°Ô µå·¡±×ÇÏ´Â °æ¿ì 
            if player.SLOT_TYPE_INVENTORY == attachedSlotType and itemSlotIndex == attachedSlotPos: 
                return 
  
            attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex() 
                 
            attachedInvenType = player.SlotTypeToInvenType(attachedSlotType) 
            if player.RESERVED_WINDOW != attachedInvenType: 
                net.SendItemUseToItemPacket(attachedInvenType, attachedSlotPos, player.INVENTORY, itemSlotIndex) 

            mouseModule.mouseController.DeattachObject() 
        else: 
            selectedItemVNum = player.GetItemIndex(player.INVENTORY, itemSlotIndex) 
            itemCount = player.GetItemCount(player.INVENTORY, itemSlotIndex) 
            mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount) 
            self.wndItem.SetUseMode(FALSE) 
            snd.PlaySound("sound/ui/pick.wav") 
             
    def SelectEmptyEquipSlot(self, selectedSlot): 
        if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1: 
            return 

        selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, selectedSlot) 

        if mouseModule.mouseController.isAttached(): 
            attachedSlotType = mouseModule.mouseController.GetAttachedType() 
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber() 
            attachedItemCount = mouseModule.mouseController.GetAttachedItemCount() 
            attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex() 

            if player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedSlotType: 
                if 0 == player.GetItemMetinSocket(player.DRAGON_SOUL_INVENTORY, attachedSlotPos, 0): 
                    self.wndPopupDialog.SetText(locale.DRAGON_SOUL_EXPIRED) 
                    self.wndPopupDialog.Open() 
                    return 
             
                item.SelectItem(attachedItemIndex) 
                subType = item.GetItemSubType() 
                if subType != (selectedSlot - player.DRAGON_SOUL_EQUIPMENT_SLOT_START): 
                    self.wndPopupDialog.SetText(locale.DRAGON_SOUL_UNMATCHED_SLOT) 
                    self.wndPopupDialog.Open() 
                else: 
                    srcItemPos = (player.DRAGON_SOUL_INVENTORY, attachedSlotPos) 
                    dstItemPos = (player.INVENTORY, selectedSlotPos) 
                    self.__OpenQuestionDialog(TRUE, srcItemPos, dstItemPos) 

            mouseModule.mouseController.DeattachObject() 
    # equip ½½·Ô °ü·Ã ÇÔ¼öµé ³¡. 
     
    # °æ°íâ °ü·Ã 
    def __OpenQuestionDialog(self, Equip, srcItemPos, dstItemPos): 
        self.srcItemPos = srcItemPos 
        self.dstItemPos = dstItemPos 
         
        self.dlgQuestion.SetAcceptEvent(ui.__mem_func__(self.__Accept)) 
        self.dlgQuestion.SetCancelEvent(ui.__mem_func__(self.__Cancel)) 

        if Equip: 
            self.dlgQuestion.SetText1(locale.DRAGON_SOUL_EQUIP_WARNING1) 
            self.dlgQuestion.SetText2(locale.DRAGON_SOUL_EQUIP_WARNING2) 
        else: 
            self.dlgQuestion.SetText1(locale.DRAGON_SOUL_UNEQUIP_WARNING1) 
            self.dlgQuestion.SetText2(locale.DRAGON_SOUL_UNEQUIP_WARNING2) 
  
        self.dlgQuestion.Open() 
         
    def __Accept(self): 
        if (-1, -1) == self.dstItemPos: 
            net.SendItemUsePacket(*srcItemPos) 
        else: 
            self.__SendMoveItemPacket(*(self.srcItemPos + self.dstItemPos + (0,))) 
        self.dlgQuestion.Close() 

    def __Cancel(self): 
        self.srcItemPos = (0, 0) 
        self.dstItemPos = (0, 0) 
        self.dlgQuestion.Close() 

    # °æ°íâ °ü·Ã ³¡ 
     
    def SetDSKindIndex(self, kindIndex): 
        if self.DSKindIndex != kindIndex: 
            self.__HighlightSlot_ClearCurrentPage() 
         
        self.DSKindIndex = kindIndex 

        for (tabKey, tabButton) in self.tabButtonDict.items(): 
            if kindIndex!=tabKey: 
                tabButton.SetUp() 

        for tabValue in self.tabDict.itervalues(): 
            tabValue.Hide() 

        self.tabDict[kindIndex].Show() 
        self.tabText.SetText(DragonSoulWindow.KIND_TAP_TITLES[kindIndex]) 
         
        self.RefreshBagSlotWindow() 
         
    def SetDeckPage(self, page): 
        if page == self.deckPageIndex: 
            return 
     
        if self.isActivated: 
            self.DeactivateDragonSoul() 
            net.SendChatPacket("/dragon_soul deactivate") 
        self.deckPageIndex = page 
        self.deckTab[page].Down() 
        self.deckTab[(page+1)%2].SetUp() 
         
        self.RefreshEquipSlotWindow() 
     
    # ¿ëÈ¥¼® È°¼ºÈ* °ü·Ã 
    def ActivateDragonSoulByExtern(self, deck): 
        self.isActivated = TRUE 
        self.activateButton.Down() 
        self.deckPageIndex = deck 
        self.deckTab[deck].Down() 
        self.deckTab[(deck+1)%2].SetUp() 
        self.RefreshEquipSlotWindow() 
         
    def DeactivateDragonSoul(self): 
        self.isActivated = FALSE 
        self.activateButton.SetUp() 

    def ActivateButtonClick(self): 
        self.isActivated = self.isActivated ^ TRUE 
        if self.isActivated: 
            if self.__CanActivateDeck(): 
                net.SendChatPacket("/dragon_soul activate " + str(self.deckPageIndex)) 
            else: 
                self.isActivated = FALSE 
                self.activateButton.SetUp() 
        else: 
            net.SendChatPacket("/dragon_soul deactivate") 

    def __CanActivateDeck(self): 
        canActiveNum = 0 
        for i in xrange(6): 
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.INVENTORY, player.DRAGON_SOUL_EQUIPMENT_SLOT_START + i) 
            itemVnum = player.GetItemIndex(slotNumber) 
             
            if itemVnum != 0: 
                item.SelectItem(itemVnum) 
                isNoLimit = TRUE 
                for i in xrange(item.LIMIT_MAX_NUM): 
                    (limitType, limitValue) = item.GetLimit(i) 
                     
                    # LIMIT_TIMER_BASED_ON_WEAR´Â ¼ÒÄÏ0¿¡ ³²Àº ½Ã°£À» ¹Ú´Â´Ù. 
                    # LIMIT_REAL_TIMEÀº ½Ã°£ ´Ù µÇ¸é ¾ÆÀÌÅÛÀÌ »ç¶óÁö¹Ç·Î ÇÒ ÇÊ¿ä°¡ ¾ø´Ù. 
                    # LIMIT_REAL_TIME_START_FIRST_USE´Â ¼*¹ö¿¡ Á¦´ë·Î Á¤ÀǵÇÁö ¾Ê¾Æ ÀÏ´Ü ³ÀµĞ´Ù. 
                    if item.LIMIT_TIMER_BASED_ON_WEAR == limitType: 
                        isNoLimit = FALSE 
                        remain_time = player.GetItemMetinSocket(player.INVENTORY, slotNumber, 0) 
                        if 0 != remain_time: 
                            canActiveNum += 1 
                            break 
                # ŸÀ̸Ӱ¡ ¾ø´Ù¸é ActivateÇÒ ¼ö ÀÖ´Â ¿ëÈ¥¼®. 
                if isNoLimit: 
                    canActiveNum += 1 
         
        return canActiveNum > 0 
     
    # È°¼ºÈ* °ü·Ã ³¡ 
     
    # ½½·Ô highlight °ü·Ã 
    def __HighlightSlot_ClearCurrentPage(self): 
        for i in xrange(self.wndItem.GetSlotCount()): 
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i) 
            if slotNumber in self.listHighlightedSlot: 
                self.wndItem.DeactivateSlot(i) 
                self.listHighlightedSlot.remove(slotNumber) 
     
    def __HighlightSlot_RefreshCurrentPage(self): 
        for i in xrange(self.wndItem.GetSlotCount()): 
            slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(player.DRAGON_SOUL_INVENTORY, i) 
            if slotNumber in self.listHighlightedSlot: 
                self.wndItem.ActivateSlot(i) 
     
    def HighlightSlot(self, slot): 
        if not slot in self.listHighlightedSlot: 
            self.listHighlightedSlot.append (slot) 
    # ½½·Ô highlight °ü·Ã ³¡ 
     
    def SetDragonSoulRefineWindow(self, wndDragonSoulRefine): 
        if app.ENABLE_DRAGON_SOUL_SYSTEM: 
            from _weakref import proxy 
            self.wndDragonSoulRefine = proxy(wndDragonSoulRefine) 

## °*È*ÇÒ ¼ö ¾ø´Â °æ¿ì ³¯¸®´Â ¿¹¿Ü 
#class DragonSoulRefineException(Exception): 
    #pass 

class DragonSoulRefineWindow(ui.ScriptWindow): 
    REFINE_TYPE_GRADE, REFINE_TYPE_STEP, REFINE_TYPE_STRENGTH = xrange(3) 
    DS_SUB_HEADER_DIC = { 
        REFINE_TYPE_GRADE : player.DS_SUB_HEADER_DO_UPGRADE, 
        REFINE_TYPE_STEP : player.DS_SUB_HEADER_DO_IMPROVEMENT, 
        REFINE_TYPE_STRENGTH : player.DS_SUB_HEADER_DO_REFINE  
    } 
    REFINE_STONE_SLOT, DRAGON_SOUL_SLOT = xrange(2) 

    INVALID_DRAGON_SOUL_INFO = -1 
     
    def __init__(self): 
        ui.ScriptWindow.__init__(self) 
        self.tooltipItem = None 
        self.sellingSlotNumber = -1 
        self.isLoaded = 0 
        self.refineChoiceButtonDict = None 
        self.doRefineButton = None 
        self.wndMoney = None 
        self.SetWindowName("DragonSoulRefineWindow") 
        self.__LoadWindow() 
         
    def __del__(self): 
        ui.ScriptWindow.__del__(self) 

    def Show(self): 
        self.__LoadWindow() 
        ui.ScriptWindow.Show(self) 

    def __LoadWindow(self): 
        if self.isLoaded == 1: 
            return 
        self.isLoaded = 1 
        try: 
            pyScrLoader = ui.PythonScriptLoader()             
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "dragonsoulrefinewindow.py") 

        except: 
            import exception 
            exception.Abort("dragonsoulrefinewindow.LoadWindow.LoadObject") 
        try: 
            if locale.IsARABIC(): 
                self.board = self.GetChild("DragonSoulRefineWindowBaseImage") 
                self.board.SetScale(-1.0, 1.0) 
                self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0) 
                 
            wndRefineSlot = self.GetChild("RefineSlot") 
            wndResultSlot = self.GetChild("ResultSlot") 
            self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))             
            self.refineChoiceButtonDict = { 
                self.REFINE_TYPE_GRADE    : self.GetChild("GradeButton"), 
                self.REFINE_TYPE_STEP: self.GetChild("StepButton"), 
                self.REFINE_TYPE_STRENGTH    : self.GetChild("StrengthButton"), 
            } 
            self.doRefineButton = self.GetChild("DoRefineButton") 
            self.wndMoney = self.GetChild("Money_Slot") 
         
        except: 
            import exception 
            exception.Abort("DragonSoulRefineWindow.LoadWindow.BindObject") 
         
     
        ## Item Slots 
        wndRefineSlot.SetOverInItemEvent(ui.__mem_func__(self.__OverInRefineItem)) 
        wndRefineSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutItem)) 
        wndRefineSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.__SelectRefineEmptySlot)) 
        wndRefineSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot)) 
        wndRefineSlot.SetUseSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot)) 
        wndRefineSlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.__SelectRefineItemSlot)) 
         
        wndResultSlot.SetOverInItemEvent(ui.__mem_func__(self.__OverInResultItem)) 
        wndResultSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutItem)) 
        self.wndRefineSlot = wndRefineSlot 
        self.wndResultSlot = wndResultSlot 
         
        ## Button 
        self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].SetToggleDownEvent(self.__ToggleDownGradeButton) 
        self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetToggleDownEvent(self.__ToggleDownStepButton) 
        self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetToggleDownEvent(self.__ToggleDownStrengthButton) 
        self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_GRADE)) 
        self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_STEP)) 
        self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetToggleUpEvent(lambda : self.__ToggleUpButton(self.REFINE_TYPE_STRENGTH)) 
        self.doRefineButton.SetEvent(self.__PressDoRefineButton) 
         
        ## Dialog 
        self.wndPopupDialog = uiCommon.PopupDialog() 
         
        self.currentRefineType = self.REFINE_TYPE_GRADE 
        self.refineItemInfo = {} 
        self.resultItemInfo = {} 
        self.currentRecipe = {} 
         
        self.wndMoney.SetText(locale.NumberToMoneyString(0)) 
        self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].Down() 
         
        self.__Initialize() 
         
    def Destroy(self): 
        self.ClearDictionary() 
        self.tooltipItem = None 
        self.wndItem = 0 
        self.wndEquip = 0 
        self.activateButton = 0 
        self.questionDialog = None 
        self.mallButton = None 
        self.inventoryTab = [] 
        self.deckTab = [] 
        self.equipmentTab = [] 
        self.tabDict = None 
        self.tabButtonDict = None 
         
    def Close(self): 
        if None != self.tooltipItem: 
            self.tooltipItem.HideToolTip() 
         
        self.__FlushRefineItemSlot() 
        player.SendDragonSoulRefine(player.DRAGON_SOUL_REFINE_CLOSE) 
         self.Hide() 

     def Show(self): 
         self.currentRefineType = self.REFINE_TYPE_GRADE 
        self.wndMoney.SetText(locale.NumberToMoneyString(0)) 
        self.refineChoiceButtonDict[self.REFINE_TYPE_GRADE].Down() 
        self.refineChoiceButtonDict[self.REFINE_TYPE_STEP].SetUp() 
        self.refineChoiceButtonDict[self.REFINE_TYPE_STRENGTH].SetUp() 
         
        self.Refresh() 
          
        ui.ScriptWindow.Show(self) 

    def SetItemToolTip(self, tooltipItem): 
        self.tooltipItem = tooltipItem 
     
    # ¹öÆ° ´*·Á ÀÖ´Â »óŸ¦ Á¦¿ÜÇÑ ¸ğµç °*È*â °ü·Ã º¯¼öµéÀ» ÃʱâÈ*. 
    def __Initialize(self): 
        self.currentRecipe = {} 
        self.refineItemInfo = {} 
        self.resultItemInfo = {} 
         
        if self.REFINE_TYPE_STRENGTH == self.currentRefineType: 
            self.refineSlotLockStartIndex = 2 
        else: 
            self.refineSlotLockStartIndex = 1 

        for i in xrange(self.refineSlotLockStartIndex): 
            self.wndRefineSlot.HideSlotBaseImage(i) 

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

    def __FlushRefineItemSlot(self): 
        ## Item slot settings 
        # ¿ø·¡ Àκ¥ÀÇ ¾ÆÀÌÅÛ Ä«¿îÆ® ȸº¹ 
        for invenType, invenPos, itemCount in self.refineItemInfo.values(): 
            remainCount = player.GetItemCount(invenType, invenPos) 
            player.SetItemCount(invenType, invenPos, remainCount + itemCount) 
        self.__Initialize() 
     
     def __ToggleUpButton(self, idx): 
         #if self.REFINE_TYPE_GRADE == self.currentRefineType: 
         self.refineChoiceButtonDict[idx].Down() 
  
     def __ToggleDownGradeButton(self): 
         if self.REFINE_TYPE_GRADE == self.currentRefineType: 
             return 
         self.refineChoiceButtonDict[self.currentRefineType].SetUp() 
         self.currentRefineType = self.REFINE_TYPE_GRADE 
         self.__FlushRefineItemSlot() 
        self.Refresh() 
          
     def __ToggleDownStepButton(self): 
         if self.REFINE_TYPE_STEP == self.currentRefineType: 
             return 
         self.refineChoiceButtonDict[self.currentRefineType].SetUp() 
         self.currentRefineType = self.REFINE_TYPE_STEP 
        self.__FlushRefineItemSlot() 
        self.Refresh() 

     def __ToggleDownStrengthButton(self): 
         if self.REFINE_TYPE_STRENGTH == self.currentRefineType: 
             return 
         self.refineChoiceButtonDict[self.currentRefineType].SetUp() 
         self.currentRefineType = self.REFINE_TYPE_STRENGTH 
         self.__FlushRefineItemSlot() 
         self.Refresh() 

     def __PopUp(self, message): 
        self.wndPopupDialog.SetText(message) 
        self.wndPopupDialog.Open() 
      
     def __SetItem(self, (invenType, invenPos), dstSlotIndex, itemCount): 
         
        if dstSlotIndex >= self.refineSlotLockStartIndex: 
            return FALSE 
             
        itemVnum = player.GetItemIndex(invenType, invenPos) 
        maxCount = player.GetItemCount(invenType, invenPos) 
         
        if itemCount > maxCount: 
            raise Exception, ("Invalid attachedItemCount(%d). (base pos (%d, %d), base itemCount(%d))" % (itemCount, invenType, invenPos, maxCount)) 
            #return FALSE 
         
        # strength °*È*ÀÏ °æ¿ì, 0¹ø¿£ °*È*¼®, 1¹ø¿£ ¿ëÈ¥¼®À» ³õµµ·Ï °*Á¦ÇÔ. 
        if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType: 
            if self.__IsDragonSoul(itemVnum): 
                dstSlotIndex = 1 
            else: 
                dstSlotIndex = 0 
         
        # ºó ½½·ÔÀ̾î¾ßÇÔ. 
        if dstSlotIndex in self.refineItemInfo: 
            return FALSE 
             
        # °*È*â¿¡ ¿Ã¸± ¼ö ÀÖ´Â ¾ÆÀÌÅÛÀÎÁö °Ë»ç. 
        if FALSE == self.__CheckCanRefine(itemVnum): 
            return FALSE 
         
        # ²ø¾î´Ù ³õÀº ¾ÆÀÌÅÛ Ä«¿îÆ®¸¸Å* ¿ø·¡ ÀÚ¸®ÀÇ ¾ÆÀÌÅÛ Ä«¿îÆ® °¨¼Ò 
        player.SetItemCount(invenType, invenPos, maxCount - itemCount) 
        self.refineItemInfo[dstSlotIndex] = (invenType, invenPos, itemCount) 
        self.Refresh() 

        return TRUE 
     
    # °*È* °¡´ÉÇÑ ¾ÆÀÌÅÛÀÎÁö üũ 
    # ¿ëÈ¥¼® °*È*´Â °*È* ·¹½ÃÇǸ¦ Á¤Çسõ°í ½ÃÀÛÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó, 
    # óÀ½¿¡ °*È*â¿¡ ¿Ã¸° ¿ëÈ¥¼®¿¡ ÀÇÇØ °*È* ·¹½ÃÇÇ°¡ °áÁ¤µÈ´Ù. 
    # ±×·¡¼* __CanRefineGrade, __CanRefineStep, __CanRefineStrength ÇÔ¼ö¿¡¼* 
    # °*È* ·¹½ÃÇÇ°¡ ¾ø´Ù¸é(óÀ½ ¿Ã¸®´Â ¾ÆÀÌÅÛÀ̶ó¸é), °*È* ·¹½ÃÇǸ¦ ¼³Á¤ÇØÁÖ´Â ¿ªÇÒµµ ÇÑ´Ù. 
    def __CheckCanRefine(self, vnum): 
        if self.REFINE_TYPE_GRADE == self.currentRefineType: 
            return self.__CanRefineGrade(vnum) 

        elif self.REFINE_TYPE_STEP == self.currentRefineType: 
            return self.__CanRefineStep(vnum) 
                 
        elif self.REFINE_TYPE_STRENGTH == self.currentRefineType: 
            return self.__CanRefineStrength(vnum) 
                 
        else: 
            return FALSE 
                 
        return TRUE 

    def __CanRefineGrade (self, vnum): 
        ds_info = self.__GetDragonSoulTypeInfo(vnum) 
         
        if DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO == ds_info: 
            self.__PopUp(locale.DRAGON_SOUL_IS_NOT_DRAGON_SOUL) 
            return FALSE 
             
        if self.currentRecipe: 
            ds_type, grade, step, strength = ds_info 
            cur_refine_ds_type, cur_refine_grade, cur_refine_step, cur_refine_strength = self.currentRecipe["ds_info"] 
            if not (cur_refine_ds_type == ds_type and cur_refine_grade == grade): 
                self.__PopUp(locale.DRAGON_SOUL_INVALID_DRAGON_SOUL) 
                return FALSE 
        # °*È* â¿¡ óÀ½ ¾ÆÀÌÅÛÀ» ¿Ã¸®´Â °æ¿ì, °*È* Àç·á¿¡ °üÇÑ Á¤º¸°¡ ¾ø´Ù. 
        # ¿ëÈ¥¼® °*È*°¡, ·¹½ÃÇǸ¦ °¡Áö°í ½ÃÀÛÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó, °*È*â¿¡ óÀ½ ¿Ã¸®´Â ¾ÆÀÌÅÛÀÌ ¹«¾ùÀ̳Ŀ¡ µû¶ó, 
        # ¹«¾ùÀ» °*È*ÇÏ°í, Àç·á°¡ ¹«¾ùÀÎÁö(ÀÌÇÏ ·¹½ÃÇÇ)°¡ Á¤ÇØÁø´Ù. 
        # ·¹½ÃÇÇ°¡ ¾ø´Ù¸é, óÀ½ ¿Ã¸° ¾ÆÀÌÅÛÀ̶ó »ı°¢ÇÏ°í, vnumÀ» ¹ÙÅÁÀ¸·Î ·¹½ÃÇǸ¦ ¼ÂÆÃ. 
        else: 
            self.currentRecipe = self.__GetRefineGradeRecipe(vnum) 

            if self.currentRecipe: 
                self.refineSlotLockStartIndex = self.currentRecipe["need_count"] 
                self.wndMoney.SetText(locale.NumberToMoneyString(self.currentRecipe["fee"]))                 
                return TRUE 
            else: 
            # °*È* Á¤º¸ ¼ÂÆÿ¡ ½ÇÆĞÇÏ¸é ¿Ã¸± ¼ö ¾ø´Â ¾ÆÀÌÅÛÀ¸·Î ÆÇ´Ü. 
                self.__PopUp(locale.DRAGON_SOUL_CANNOT_REFINE) 
                return FALSE 

    def __CanRefineStep (self, vnum): 
        ds_info = self.__GetDragonSoulTypeInfo(vnum) 
         
        if DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO == ds_info: 
            self.__PopUp(locale.DRAGON_SOUL_IS_NOT_DRAGON_SOUL) 
            return FALSE 
         
        if self.currentRecipe: 
            ds_type, grade, step, strength = ds_info 
            cur_refine_ds_type, cur_refine_grade, cur_refine_step, cur_refine_strength = self.currentRecipe["ds_info"] 
            if not (cur_refine_ds_type == ds_type and cur_refine_grade == grade and cur_refine_step == step): 
                self.__PopUp(locale.DRAGON_SOUL_INVALID_DRAGON_SOUL) 
                return FALSE 
        # °*È* â¿¡ óÀ½ ¾ÆÀÌÅÛÀ» ¿Ã¸®´Â °æ¿ì, Àç·á¿¡ °üÇÑ Á¤º¸°¡ ¾ø´Ù. 
        # ¿ëÈ¥¼® °*È*°¡, ·¹½ÃÇǸ¦ °¡Áö°í ½ÃÀÛÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó, °*È*â¿¡ óÀ½ ¿Ã¸®´Â ¾ÆÀÌÅÛÀÌ ¹«¾ùÀ̳Ŀ¡ µû¶ó, 
        # ¹«¾ùÀ» °*È*ÇÏ°í, Àç·á°¡ ¹«¾ùÀÎÁö(ÀÌÇÏ ·¹½ÃÇÇ)°¡ Á¤ÇØÁø´Ù. 
        # ·¹½ÃÇÇ°¡ ¾ø´Ù¸é, óÀ½ ¿Ã¸° ¾ÆÀÌÅÛÀ̶ó »ı°¢ÇÏ°í, vnumÀ» ¹ÙÅÁÀ¸·Î ·¹½ÃÇǸ¦ ¼ÂÆÃ. 
        else: 
            self.currentRecipe = self.__GetRefineStepRecipe(vnum) 

            if self.currentRecipe: 
                self.refineSlotLockStartIndex = self.currentRecipe["need_count"] 
                self.wndMoney.SetText(locale.NumberToMoneyString(self.currentRecipe["fee"]))                 
                return TRUE 

            else: 
            # °*È* Á¤º¸ ¼ÂÆÿ¡ ½ÇÆĞÇÏ¸é ¿Ã¸± ¼ö ¾ø´Â ¾ÆÀÌÅÛÀ¸·Î ÆÇ´Ü. 
                self.__PopUp(locale.DRAGON_SOUL_CANNOT_REFINE) 
                return FALSE 

    def __CanRefineStrength (self, vnum): 
        # ¿ëÈ¥¼®ÀÎ °æ¿ì, ´õ ÀÌ»ó strength °*È*¸¦ ÇÒ ¼ö ¾ø´ÂÁö üũÇؾßÇÔ. 
        if self.__IsDragonSoul(vnum): 
            ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum) 
             
            import dragon_soul_refine_settings 
            if strength >= dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["strength_max_table"][grade][step]: 
                self.__PopUp(locale.DRAGON_SOUL_CANNOT_REFINE_MORE) 
                return FALSE 

            else: 
                return TRUE 
         
        # strength °*È*ÀÇ °æ¿ì, refine_recipe°¡ ¿ëÈ¥¼®ÀÇ Á¾·ù°¡ ¾Æ´Ñ, °*È*¼®ÀÇ Á¾·ù¿¡ µû¶ó ´Ş¶óÁø´Ù. 
        # µû¶ó¼* ¿ëÈ¥¼®ÀÌ ¾Æ´Ï¶ó¸é,  
        # ÀÌ¹Ì ·¹½ÃÇÇ°¡ ÀÖ´Â °æ¿ì´Â, °*È*¼®ÀÌ °*È*â¿¡ ÀÖ´Ù´Â °ÍÀ̹ǷÎ, return FALSE 
        # ·¹½ÃÇÇ°¡ ¾ø´Â °æ¿ì´Â, °*È*¼®ÀÎÁö È®ÀÎÇÏ°í, ·¹½ÃÇǸ¦ ¼ÂÆÃÇÑ´Ù. 
        else: 
            if self.currentRecipe: 
                self.__PopUp(locale.DRAGON_SOUL_IS_NOT_DRAGON_SOUL) 
                return FALSE 
            else: 
                refineRecipe = self.__GetRefineStrengthInfo(vnum) 
                if refineRecipe: 
                    self.currentRecipe = refineRecipe 
                    self.wndMoney.SetText(locale.NumberToMoneyString(self.currentRecipe["fee"])) 
                    return TRUE 
                else: 
                # ·¹½ÃÇǸ¦ ¼ÂÆÃÇÒ ¼ö ¾ø´Â °æ¿ì 
                    self.__PopUp(locale.DRAGON_SOUL_NOT_DRAGON_SOUL_REFINE_STONE) 
                    return FALSE 

    def __GetRefineGradeRecipe (self, vnum): 
        ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum) 
        try: 
            import dragon_soul_refine_settings 

            return    { 
                "ds_info"        : (ds_type, grade, step, strength), 
                "need_count"    : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["grade_need_count"][grade], 
                "fee"            : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["grade_fee"][grade] 
                    } 
        except: 
            return None 

    def __GetRefineStepRecipe (self, vnum): 
        ds_type, grade, step, strength = self.__GetDragonSoulTypeInfo(vnum) 
        try: 
            import dragon_soul_refine_settings 
     
            return    { 
                "ds_info"        : (ds_type, grade, step, strength), 
                "need_count"    : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["step_need_count"][step], 
                "fee"            : dragon_soul_refine_settings.dragon_soul_refine_info[ds_type]["step_fee"][step] 
                    } 
        except: 
            return None 
         
    # strength °*È*ÀÇ °æ¿ì, refineInfo´Â °*È*¼®¿¡ µû¶ó ´Ş¶óÁø´Ù. 
    def __GetRefineStrengthInfo (self, itemVnum): 
        try: 
            # À̳ğÀÇ À§Ä¡¸¦ ¾îÂîÇÏÁö.... 
            # °*È*¼®ÀÌ ¾Æ´Ï¸é ¾ÈµÊ. 
            item.SelectItem(itemVnum) 
            if not (item.ITEM_TYPE_MATERIAL == item.GetItemType() \ 
                    and (item.MATERIAL_DS_REFINE_NORMAL <= item.GetItemSubType() and item.GetItemSubType() <= item.MATERIAL_DS_REFINE_HOLLY)): 
                return None 

            import dragon_soul_refine_settings 
            return { "fee" : dragon_soul_refine_settings.strength_fee[item.GetItemSubType()] } 
        except: 
            return None 

    def __IsDragonSoul(self, vnum): 
        item.SelectItem(vnum) 
        return item.GetItemType() == item.ITEM_TYPE_DS 
         
    # ¿ëÈ¥¼® Vnum¿¡ ´ëÇÑ comment     
    # ITEM VNUMÀ» 10¸¸ ÀÚ¸®ºÎÅÍ, FEDCBA¶ó°í ÇÑ´Ù¸é 
    # FE : ¿ëÈ¥¼® Á¾·ù.    D : µî±Ş 
    # C : ´Ü°è            B : °*È*         
    # A : ¿©¹úÀÇ ¹øÈ£µé...      
    def __GetDragonSoulTypeInfo(self, vnum): 
        if not self.__IsDragonSoul(vnum): 
            return DragonSoulRefineWindow.INVALID_DRAGON_SOUL_INFO  
        ds_type = vnum / 10000 
        grade = vnum % 10000 /1000 
        step = vnum % 1000 / 100 
        strength = vnum % 100 / 10 
         
        return (ds_type, grade, step, strength) 
     
    def __MakeDragonSoulVnum(self, ds_type, grade, step, strength): 
        return ds_type * 10000 + grade * 1000 + step * 100 + strength * 10 

     ## ºó ½½·Ô ¼±Åà Event 
    def __SelectRefineEmptySlot(self, selectedSlotPos): 
        try: 
            if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1: 
                return 
             
            if selectedSlotPos >= self.refineSlotLockStartIndex: 
                return 
      
            if mouseModule.mouseController.isAttached(): 
                attachedSlotType = mouseModule.mouseController.GetAttachedType() 
                attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber() 
                attachedItemCount = mouseModule.mouseController.GetAttachedItemCount() 
                attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex() 
                mouseModule.mouseController.DeattachObject() 

                if uiPrivateShopBuilder.IsBuildingPrivateShop(): 
                    chat.AppendChat(chat.CHAT_TYPE_INFO, locale.MOVE_ITEM_FAILURE_PRIVATE_SHOP) 
                    return 

                attachedInvenType = player.SlotTypeToInvenType(attachedSlotType) 

                if player.INVENTORY == attachedInvenType and player.IsEquipmentSlot(attachedSlotPos): 
                    return 

                if player.INVENTORY != attachedInvenType and player.DRAGON_SOUL_INVENTORY != attachedInvenType: 
                    return 

                if TRUE == self.__SetItem((attachedInvenType, attachedSlotPos), selectedSlotPos, attachedItemCount): 
                    self.Refresh() 

        except Exception, e: 
            import dbg 
            dbg.TraceError("Exception : __SelectRefineEmptySlot, %s" % e) 

    # Ŭ¸¯À¸·Î ½½·Ô¿¡¼* »èÁ¦. 
    def __SelectRefineItemSlot(self, selectedSlotPos): 
        if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1: 
            return 

        try: 
            if not selectedSlotPos in self.refineItemInfo: 
                # »õ·Î¿î ¾ÆÀÌÅÛÀ» °*È*â¿¡ ¿Ã¸®´Â ÀÛ¾÷. 
                if mouseModule.mouseController.isAttached(): 
                    attachedSlotType = mouseModule.mouseController.GetAttachedType() 
                    attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber() 
                    attachedItemCount = mouseModule.mouseController.GetAttachedItemCount() 
                    attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex() 
                    mouseModule.mouseController.DeattachObject() 

                    if uiPrivateShopBuilder.IsBuildingPrivateShop(): 
                        chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP) 
                        return 

                    attachedInvenType = player.SlotTypeToInvenType(attachedSlotType) 

                    if player.INVENTORY == attachedInvenType and player.IsEquipmentSlot(attachedSlotPos): 
                        return 

                    if player.INVENTORY != attachedInvenType and player.DRAGON_SOUL_INVENTORY != attachedInvenType: 
                        return 

                    self.AutoSetItem((attachedInvenType, attachedSlotPos), 1) 
                return 
            elif mouseModule.mouseController.isAttached(): 
                return 
  
            attachedInvenType, attachedSlotPos, attachedItemCount = self.refineItemInfo[selectedSlotPos] 
            selectedItemVnum = player.GetItemIndex(attachedInvenType, attachedSlotPos) 
                 
            # °*È*â¿¡¼* »èÁ¦ ¹× ¿ø·¡ Àκ¥ÀÇ ¾ÆÀÌÅÛ Ä«¿îÆ® ȸº¹ 
            invenType, invenPos, itemCount = self.refineItemInfo[selectedSlotPos] 
            remainCount = player.GetItemCount(invenType, invenPos) 
            player.SetItemCount(invenType, invenPos, remainCount + itemCount) 
            del self.refineItemInfo[selectedSlotPos] 
                 
            # °*È*âÀÌ ºñ¾ú´Ù¸é, ÃʱâÈ* 
            if not self.refineItemInfo: 
                self.__Initialize() 
            else: 
                item.SelectItem(selectedItemVnum) 
                # ¾ø¾Ø ¾ÆÀÌÅÛÀÌ °*È*¼®À̾ú´Ù¸é °*È* ·¹Çǽà ÃʱâÈ* 
                if (item.ITEM_TYPE_MATERIAL == item.GetItemType() \ 
                    and (item.MATERIAL_DS_REFINE_NORMAL <= item.GetItemSubType() and item.GetItemSubType() <= item.MATERIAL_DS_REFINE_HOLLY)): 
                    self.currentRecipe = {} 
                    self.wndMoney.SetText(localeInfo.NumberToMoneyString(0)) 
                # ¿ëÈ¥¼®À̾ú´Ù¸é,  
                # strength°*È*°¡ ¾Æ´Ñ °æ¿ì, °*È*â¿¡ ´Ù¸¥ ¿ëÈ¥¼®ÀÌ ³²¾ÆÀÖÀ¸¹Ç·Î, ·¹½ÃÇǸ¦ ÃʱâÈ*ÇÏ¸é ¾ÈµÊ. 
                # strength°*È*ÀÇ °æ¿ì, °*È* ·¹½ÃÇÇ´Â °*È*¼®¿¡ Á¾¼ÓµÈ °ÍÀ̹ǷΠ´Ù¸¥ ó¸®ÇÒ ÇÊ¿ä°¡ ¾øÀ½. 
                else: 
                    pass 
                     
        except Exception, e: 
            import dbg 
            dbg.TraceError("Exception : __SelectRefineItemSlot, %s" % e) 
         
        self.Refresh() 
     
    def __OverInRefineItem(self, slotIndex): 
        if self.refineItemInfo.has_key(slotIndex): 
            inven_type, inven_pos, item_count = self.refineItemInfo[slotIndex] 
            self.tooltipItem.SetInventoryItem(inven_pos, inven_type) 

    def __OverInResultItem(self, slotIndex): 
        if self.resultItemInfo.has_key(slotIndex): 
            inven_type, inven_pos, item_count = self.resultItemInfo[slotIndex] 
            self.tooltipItem.SetInventoryItem(inven_pos, inven_type) 
         
    def __OverOutItem(self): 
        if self.tooltipItem: 
            self.tooltipItem.HideToolTip() 

    def __PressDoRefineButton(self): 
        for i in xrange(self.refineSlotLockStartIndex): 
            if not i in self.refineItemInfo: 
                self.wndPopupDialog.SetText(locale.DRAGON_SOUL_NOT_ENOUGH_MATERIAL) 
                self.wndPopupDialog.Open() 
                 
                return 
  
        player.SendDragonSoulRefine(DragonSoulRefineWindow.DS_SUB_HEADER_DIC[self.currentRefineType], self.refineItemInfo) 
             
    def OnPressEscapeKey(self): 
        self.Close() 
        return TRUE 
     
    def Refresh(self): 
        self.__RefreshRefineItemSlot() 
        self.__ClearResultItemSlot() 
             
    def __RefreshRefineItemSlot(self): 
        try: 
            for slotPos in xrange(self.wndRefineSlot.GetSlotCount()): 
                self.wndRefineSlot.ClearSlot(slotPos) 
                if slotPos < self.refineSlotLockStartIndex: 
                    # self.refineItemInfo[slotPos]ÀÇ Á¤º¸È®ÀÎ 
                    # (½ÇÁ¦·Î ¾ÆÀÌÅÛÀÌ Á¸ÀçÇÏ´ÂÁö È®ÀÎ) 
                    # Á¸Àç -> ¾ÆÀÌÅÛ ¾ÆÀÌÄÜÀ» ½½·Ô¿¡ ¼ÂÆÃ. 
                    # ºñÁ¸Àç -> ¾ÆÀÌÅÛÀÌ ¾øÀ¸¹Ç·Î °*È*â¿¡¼* »èÁ¦. 
                    if slotPos in self.refineItemInfo: 
                        invenType, invenPos, itemCount = self.refineItemInfo[slotPos] 
                        itemVnum = player.GetItemIndex(invenType, invenPos) 

                        # if itemVnum: 
                        if itemVnum: 
                            self.wndRefineSlot.SetItemSlot(slotPos, player.GetItemIndex(invenType, invenPos), itemCount) 
                        else: 
                            del self.refineItemInfo[slotPos] 

                    # ºó ½½·Ô¿¡ reference ¾ÆÀÌÄÜÀ» alpha 0.5·Î ¼ÂÆÃ. 
                    if not slotPos in self.refineItemInfo: 
                        try: 
                            reference_vnum = 0 
                            # strength °*È*ÀÏ ¶§´Â, 
                            # 0¹ø ½½·Ô¿¡ °*È*¼®À», 1¹ø ½½·Ô¿¡ ¿ëÈ¥¼®À» ³õ´Â´Ù. 
                            if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType: 
                                if DragonSoulRefineWindow.REFINE_STONE_SLOT == slotPos: 
                                    reference_vnum = 100300 
                            else: 
                                reference_vnum = self.__MakeDragonSoulVnum(*self.currentRecipe["ds_info"]) 
                            if 0 != reference_vnum: 
                                item.SelectItem(reference_vnum) 
                                itemIcon = item.GetIconImage() 
                                (width, height) = item.GetItemSize() 
                                self.wndRefineSlot.SetSlot(slotPos, 0, width, height, itemIcon, (1.0, 1.0, 1.0, 0.5)) 
                                # slot ¿ìÃø ÇÏ´Ü¿¡ ¼ıÀÚ ¶ß¸é ¾È ¿¹»İ... 
                                self.wndRefineSlot.SetSlotCount(slotPos, 0) 
                        except: 
                            pass 
                    # refineSlotLockStartIndex º¸´Ù ÀÛÀº ½½·ÔÀº ´İÈù À̹ÌÁö¸¦ º¸¿©ÁÖ¸é ¾ÈµÊ. 
                    self.wndRefineSlot.HideSlotBaseImage(slotPos) 
                # slotPos >= self.refineSlotLockStartIndex: 
                else: 
                    # Á¤»óÀûÀÎ °æ¿ì¶ó¸é ÀÌ if¹®¿¡ µé¾î°¥ ÀÏÀº ¾ø°ÚÁö¸¸, 
                    # (¾ÖÃÊ¿¡ À妽º°¡ refineSlotLockStartIndex ÀÌ»óÀÎ ½½·Ô¿¡´Â ¾ÆÀÌÅÛÀ» ³ÖÁö ¸øÇÏ°Ô Ç߱⠶§¹®) 
                    # Ȥ½Ã ¸ğ¸¦ ¿¡·¯¿¡ ´ëºñÇÔ. 
                    if slotPos in self.refineItemInfo: 
                        invenType, invenPos, itemCount = self.refineItemInfo[slotPos] 
                        remainCount = player.GetItemCount(invenType, invenPos) 
                        player.SetItemCount(invenType, invenPos, remainCount + itemCount) 
                        del self.refineItemInfo[selectedSlotPos] 
                    # refineSlotLockStartIndex ÀÌ»óÀÎ ½½·ÔÀº ´İÈù À̹ÌÁö¸¦ º¸¿©Áà¾ßÇÔ. 
                    self.wndRefineSlot.ShowSlotBaseImage(slotPos) 
             
            # °*È*â¿¡ ¾Æ¹«·± ¾ÆÀÌÅÛÀÌ ¾ø´Ù¸é, ÃʱâÈ*ÇØÁÜ. 
            # À§¿¡¼* Áß°£ Áß°£¿¡ "del self.refineItemInfo[slotPos]"¸¦ Ç߱⠶§¹®¿¡, 
            # ¿©±â¼* Çѹø üũÇØÁà¾ßÇÔ. 
            if not self.refineItemInfo: 
                self.__Initialize() 
  
            self.wndRefineSlot.RefreshSlot() 
        except Exception, e: 
            import dbg 
            dbg.TraceError("Exception : __RefreshRefineItemSlot, %s" % e) 
     
    def __GetEmptySlot(self, itemVnum = 0): 
         # STRENGTH °*È*ÀÇ °æ¿ì, ¿ëÈ¥¼® ½½·Ô°ú °*È*¼® ½½·ÔÀÌ ±¸ºĞµÇ¾îÀֱ⠋š¹®¿¡ 
         # vnumÀ» ¾Ë¾Æ¾ß ÇÑ´Ù. 
         if DragonSoulRefineWindow.REFINE_TYPE_STRENGTH == self.currentRefineType: 
             if 0 == itemVnum: 
                return -1 
             
            if self.__IsDragonSoul(itemVnum): 
                if not DragonSoulRefineWindow.DRAGON_SOUL_SLOT in self.refineItemInfo: 
                    return DragonSoulRefineWindow.DRAGON_SOUL_SLOT 
            else: 
                if not DragonSoulRefineWindow.REFINE_STONE_SLOT in self.refineItemInfo: 
                    return DragonSoulRefineWindow.REFINE_STONE_SLOT 
        else: 
            for slotPos in xrange(self.wndRefineSlot.GetSlotCount()): 
                if not slotPos in self.refineItemInfo: 
                    return slotPos 
         
        return -1 

     def AutoSetItem(self, (invenType, invenPos), itemCount): 
         itemVnum = player.GetItemIndex(invenType, invenPos) 
        emptySlot = self.__GetEmptySlot(itemVnum) 
        if -1 == emptySlot: 
            return 
         
        self.__SetItem((invenType, invenPos), emptySlot, itemCount) 

    def __ClearResultItemSlot(self): 
        self.wndResultSlot.ClearSlot(0) 
        self.resultItemInfo = {} 
     
    def RefineSucceed(self, inven_type, inven_pos): 
        self.__Initialize() 
        self.Refresh() 
         
        itemCount = player.GetItemCount(inven_type, inven_pos) 
        if itemCount > 0: 
            self.resultItemInfo[0] = (inven_type, inven_pos, itemCount) 
            self.wndResultSlot.SetItemSlot(0, player.GetItemIndex(inven_type, inven_pos), itemCount) 
     
    def    RefineFail(self, reason, inven_type, inven_pos):

Şimdi Game.py'yi Açıp İçinde ## Inventory


Aratıyoruz Ve Onun Bitişinin Hemen Altına .

## DragonSoul             elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType: 
                self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex) 
             
            mouseModule.mouseController.DeattachObject() 

        else: 
            hyperlink = ui.GetHyperlink() 
            if hyperlink: 
                if app.IsPressed(app.DIK_LALT): 
                    link = chat.GetLinkFromHyperlink(hyperlink) 
                    ime.PasteString(link) 
                else: 
                    self.interface.MakeHyperlinkTooltip(hyperlink) 
                return 
            else: 
                player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK) 

        #player.EndMouseWalking() 
        return TRUE 

    def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID): 
        if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType: 
            attachedInvenType = player.SlotTypeToInvenType(attachedType) 
            if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID: 
                if player.IsEquipmentSlot(attachedItemSlotPos): 
                    self.stream.popupWindow.Close() 
                    self.stream.popupWindow.Open(locale.EXCHANGE_FAILURE_EQUIP_ITEM, 0, locale.UI_OK) 
                else: 
                    if chr.IsNPC(dstChrID): 
                        net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount) 
                    else: 
                        net.SendExchangeStartPacket(dstChrID) 
                        net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0) 
            else: 
                self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)

Daha Sonra Game.py İçerisinde # END_OF_CUBE

Ve Hemen Altına

# ¿ëÈ¥¼®         def BINARY_Highlight_Item(self, inven_type, inven_pos): 
        self.interface.Highligt_Item(inven_type, inven_pos) 
     
    def BINARY_DragonSoulGiveQuilification(self): 
        self.interface.DragonSoulGiveQuilification() 
         
    def BINARY_DragonSoulRefineWindow_Open(self): 
        self.interface.OpenDragonSoulRefineWindow() 

    def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos): 
        self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos) 

    def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos): 
        self.interface.SucceedDragonSoulRefine(inven_type, inven_pos) 
     
    # END of DRAGON SOUL REFINE WINDOW

Tekrar Game.py'den onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()


Bunu Aratıyoruz Ve Hemen Altına

        onPressKeyDict[app.DIK_O]            = lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()

Daha Sonra Game.py'den # UNKNOWN_UPDATE Buluyoruz Ve Verdiğim Linkteki Txt Dosyasındaki Yazan Kodlarla Değiştiriyoruz

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

Şimdi Gelelim UiScript Packımızı Açıyoruz Ve İçine Bu Linkteki Dosyaları Atıyoruz ;

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

Ardından Locale/ui'ye Gelip Bunu Atıyoruz ;

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

Ardından Eternexusla Tüm Packları Kapatıyoruz Ve Oyun Klasörümüze Atıp Giriş Yapıyoruz ;

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

Virüs Total Linkleri ;



Crafting.rar ;

https://www.virustotal.com/tr/file/4d44c9da7994b2ccc94e3a70d956bbabb0ead3d0080c8449e39111c7662c9af1/analysis/

Crafting2.rar

https://www.virustotal.com/tr/file/8f7f10a65763fc4e8747d31b43d57107124f4f36c500b0ab2d611199d5718ae2/analysis/

New_Bg.Rar

https://www.virustotal.com/tr/file/5783bcbd71402022aa8da1074d2d2316e146fa47ab3165eb34604bc1aefd0b7d/analysis/

UNKNOWN RAR

https://www.virustotal.com/tr/file/d6e2a8a82c43673eb5ddfd5bf8798a333df5113bdce8d328d86778b444d38cda/analysis/

1 Teşekkürü Çok Görmeyin
​

 

[sau reng]

konudaki dragon soul dosyalarıyla crafting sisteminin arasındaki bağlantı ne bunu bi açıklarmısın hem dragon soul binary leri 34k ve 36k exelerde ekli deil bu sistemi ekleyince çalışçağını nasıl garanti edebilirsin

 

[Vectors]

konudaki dragon soul dosyalarıyla crafting sisteminin arasındaki bağlantı ne bunu bi açıklarmısın hem dragon soul binary leri 34k ve 36k exelerde ekli deil bu sistemi ekleyince çalışçağını nasıl garanti edebilirsin

sanki denemedik

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

 

[sau reng]

sanki denemedik

Linkleri görebilmek için Turkmmo Forumuna ÜYE olmanız gerekmektedir.

hacı bu binary ler ile 34k filese oluyosa bu ne diyim cd:VfG:fv

 

[Vectors]

hacı bu binary ler ile 34k filese oluyosa bu ne diyim cd:VfG:fv

uysa zaten biz napalım 40k filesi az özete dursun