Won sistemini eklerken sorun yaşıyorum YARDIM LÜTFEN

BGame · 27 Ara 2020

uitaskbar.py de eklemem gereken yerlerin bir kısmı yok nasıl ekleyeceğim bilemiyorum birtek burası kaldı bana yardım ederseniz çok sevinirim

uitaskbar.py Benimki:

import ui
import net
import item
import skill
import localeInfo
import wndMgr
import player
import constInfo
import mouseModule
import uiScriptLocale
import app

MOUSE_SETTINGS = [0, 0]

def InitMouseButtonSettings(left, right):
    global MOUSE_SETTINGS
    MOUSE_SETTINGS = [left, right]

def SetMouseButtonSetting(dir, event):
    global MOUSE_SETTINGS
    MOUSE_SETTINGS[dir] = event
    
def GetMouseButtonSettings():
    global MOUSE_SETTINGS
    return MOUSE_SETTINGS

def SaveMouseButtonSettings():
    global MOUSE_SETTINGS
    open("mouse.cfg", "w").write("%s\t%s" % tuple(MOUSE_SETTINGS))

def LoadMouseButtonSettings():
    global MOUSE_SETTINGS
    tokens = open("mouse.cfg", "r").read().split()

    if len(tokens) != 2:
        raise RuntimeError, "MOUSE_SETTINGS_FILE_ERROR"

    MOUSE_SETTINGS[0] = int(tokens[0])
    MOUSE_SETTINGS[1] = int(tokens[1])

def unsigned32(n):
    return n & 0xFFFFFFFFL

#-------------------Giftbox Begin------------------------------

class GiftBox(ui.ScriptWindow):
    class TextToolTip(ui.Window):
        def __init__(self):
            ui.Window.__init__(self, "TOP_MOST")
            self.SetWindowName("GiftBox")
            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetHorizontalAlignCenter()
            textLine.SetOutline()
            textLine.Show()
            self.textLine = textLine

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

        def SetText(self, text):
            self.textLine.SetText(text)

        def OnRender(self):
            (mouseX, mouseY) = wndMgr.GetMousePosition()
            self.textLine.SetPosition(mouseX, mouseY - 15)

    def __init__(self):
        #print "NEW TASKBAR  ----------------------------------------------------------------------------"
        ui.ScriptWindow.__init__(self)
        self.tooltipGift = self.TextToolTip()
        self.tooltipGift.Show()
        
    def __del__(self):
        #print "---------------------------------------------------------------------------- DELETE TASKBAR"
        ui.ScriptWindow.__del__(self)

    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "giftbox.py")
        except:
            import exception
            exception.Abort("GiftBox.LoadWindow.LoadObject")       

        self.giftBoxIcon = self.GetChild("GiftBox_Icon")
        self.giftBoxToolTip = self.GetChild("GiftBox_ToolTip")
    
    def Destroy(self):       
        self.giftBoxIcon = 0
        self.giftBoxToolTip = 0       
            
#-------------------Giftbox End------------------------------

class EnergyBar(ui.ScriptWindow):
    class TextToolTip(ui.Window):
        def __init__(self):
            ui.Window.__init__(self, "TOP_MOST")
            self.SetWindowName("EnergyBar")
            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetHorizontalAlignCenter()
            textLine.SetOutline()
            textLine.Show()
            self.textLine = textLine

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

        def SetText(self, text):
            self.textLine.SetText(text)

        def OnRender(self):
            (mouseX, mouseY) = wndMgr.GetMousePosition()
            self.textLine.SetPosition(mouseX, mouseY - 15)

    def __init__(self):
        #print "NEW TASKBAR  ----------------------------------------------------------------------------"
        ui.ScriptWindow.__init__(self)
        self.tooltipEnergy = self.TextToolTip()
        self.tooltipEnergy.Show()
        
    def __del__(self):
        #print "---------------------------------------------------------------------------- DELETE TASKBAR"
        ui.ScriptWindow.__del__(self)

    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "EnergyBar.py")
        except:
            import exception
            exception.Abort("EnergyBar.LoadWindow.LoadObject")

        self.energyEmpty = self.GetChild("EnergyGauge_Empty")
        self.energyHungry = self.GetChild("EnergyGauge_Hungry")
        self.energyFull = self.GetChild("EnergyGauge_Full")

        self.energyGaugeBoard = self.GetChild("EnergyGauge_Board")
        self.energyGaugeToolTip = self.GetChild("EnergyGauge_ToolTip")

        
    def Destroy(self):       
        self.energyEmpty = None
        self.energyHungry = None
        self.energyFull = None
        self.energyGaugeBoard = 0
        self.energyGaugeToolTip = 0
        self.tooltipEnergy = 0

    ## Gauge
    def RefreshStatus(self):
        pointEnergy = player.GetStatus (player.ENERGY)
        leftTimeEnergy = player.GetStatus (player.ENERGY_END_TIME) - app.GetGlobalTimeStamp()
        # 충기환 지속 시간 = 2시간.
        self.SetEnergy (pointEnergy, leftTimeEnergy, 7200)
            
    def SetEnergy (self, point, leftTime, maxTime):
        leftTime = max (leftTime, 0)
        maxTime = max (maxTime, 0)
            
        self.energyEmpty.Hide()
        self.energyHungry.Hide()
        self.energyFull.Hide()
    
        if leftTime == 0:
            self.energyEmpty.Show()
        elif ((leftTime * 100) / maxTime) < 15:
            self.energyHungry.Show()
        else:
            self.energyFull.Show()
            
        self.tooltipEnergy.SetText("%s" % (localeInfo.TOOLTIP_ENERGY(point)))

    def OnUpdate(self):
        if True == self.energyGaugeToolTip.IsIn():
            self.RefreshStatus()
            self.tooltipEnergy.Show()
        else:
            self.tooltipEnergy.Hide()

class ExpandedTaskBar(ui.ScriptWindow):
    BUTTON_DRAGON_SOUL = 0
    def __init__(self):
        ui.Window.__init__(self)
        self.SetWindowName("ExpandedTaskBar")
    
    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "ExpandedTaskBar.py")
        except:
            import exception
            exception.Abort("ExpandedTaskBar.LoadWindow.LoadObject")

        self.expandedTaskBarBoard = self.GetChild("ExpanedTaskBar_Board")

        self.toggleButtonDict = {}
        self.toggleButtonDict[ExpandedTaskBar.BUTTON_DRAGON_SOUL] = self.GetChild("DragonSoulButton")
        self.toggleButtonDict[ExpandedTaskBar.BUTTON_DRAGON_SOUL].SetParent(self)
    
    def SetTop(self):
        super(ExpandedTaskBar, self).SetTop()   
        for button in self.toggleButtonDict.values():
            button.SetTop()
    
    def Show(self):
        ui.ScriptWindow.Show(self)
    
    def Close(self):
        self.Hide()
    
    def SetToolTipText(self, eButton, text):
        self.toggleButtonDict[eButton].SetToolTipText(text)
        
    def SetToggleButtonEvent(self, eButton, kEventFunc):
        self.toggleButtonDict[eButton].SetEvent(kEventFunc)

    def OnPressEscapeKey(self):
        self.Close()
        return True
    
class TaskBar(ui.ScriptWindow):

    BUTTON_CHARACTER = 0
    BUTTON_INVENTORY = 1
    BUTTON_MESSENGER = 2
    BUTTON_SYSTEM = 3
    BUTTON_CHAT = 4
    BUTTON_EXPAND = 4
    IS_EXPANDED = False

    MOUSE_BUTTON_LEFT = 0
    MOUSE_BUTTON_RIGHT = 1
    NONE = 255

    EVENT_MOVE = 0
    EVENT_ATTACK = 1
    EVENT_MOVE_AND_ATTACK = 2
    EVENT_CAMERA = 3
    EVENT_SKILL = 4
    EVENT_AUTO = 5

    GAUGE_WIDTH = 95
    GAUGE_HEIGHT = 13

    QUICKPAGE_NUMBER_FILENAME = [
        "d:/ymir work/ui/game/taskbar/1.sub",
        "d:/ymir work/ui/game/taskbar/2.sub",
        "d:/ymir work/ui/game/taskbar/3.sub",
        "d:/ymir work/ui/game/taskbar/4.sub",
    ]

    #gift icon show and hide
    def ShowGift(self):
        if not localeInfo.IsBRAZIL():
            self.wndGiftBox.Show()
    
    def HideGift(self):
        self.wndGiftBox.Hide()

    class TextToolTip(ui.Window):
        def __init__(self):
            ui.Window.__init__(self, "TOP_MOST")

            textLine = ui.TextLine()
            textLine.SetParent(self)
            textLine.SetHorizontalAlignCenter()
            textLine.SetOutline()
            textLine.Show()
            self.textLine = textLine

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

        def SetText(self, text):
            self.textLine.SetText(text)

        def OnRender(self):
            (mouseX, mouseY) = wndMgr.GetMousePosition()
            self.textLine.SetPosition(mouseX, mouseY - 15)

    class SkillButton(ui.SlotWindow):

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

            self.event = 0
            self.arg = 0

            self.slotIndex = 0
            self.skillIndex = 0

            slotIndex = 0
            wndMgr.SetSlotBaseImage(self.hWnd, "d:/ymir work/ui/public/slot_base.sub", 1.0, 1.0, 1.0, 1.0)
            wndMgr.AppendSlot(self.hWnd, slotIndex, 0, 0, 32, 32)
            self.SetCoverButton(slotIndex,    "d:/ymir work/ui/public/slot_cover_button_01.sub",\
                                            "d:/ymir work/ui/public/slot_cover_button_02.sub",\
                                            "d:/ymir work/ui/public/slot_cover_button_03.sub",\
                                            "d:/ymir work/ui/public/slot_cover_button_04.sub", True, False)
            self.SetSize(32, 32)

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

        def Destroy(self):
            if 0 != self.tooltipSkill:
                self.tooltipSkill.HideToolTip()

        def RefreshSkill(self):
            if 0 != self.slotIndex:
                self.SetSkill(self.slotIndex)

        def SetSkillToolTip(self, tooltip):
            self.tooltipSkill = tooltip

        def SetSkill(self, skillSlotNumber):
            slotNumber = 0
            skillIndex = player.GetSkillIndex(skillSlotNumber)
            skillGrade = player.GetSkillGrade(skillSlotNumber)
            skillLevel = player.GetSkillLevel(skillSlotNumber)
            skillType = skill.GetSkillType(skillIndex)

            self.skillIndex = skillIndex
            if 0 == self.skillIndex:
                self.ClearSlot(slotNumber)
                return

            self.slotIndex = skillSlotNumber

            self.SetSkillSlotNew(slotNumber, skillIndex, skillGrade, skillLevel)
            self.SetSlotCountNew(slotNumber, skillGrade, skillLevel)

            ## NOTE : CoolTime 체크
            if player.IsSkillCoolTime(skillSlotNumber):
                (coolTime, elapsedTime) = player.GetSkillCoolTime(skillSlotNumber)
                self.SetSlotCoolTime(slotNumber, coolTime, elapsedTime)

            ## NOTE : Activate 되어 있다면 아이콘도 업데이트
            if player.IsSkillActive(skillSlotNumber):
                self.ActivateSlot(slotNumber)

        def SetSkillEvent(self, event, arg=0):
            self.event = event
            self.arg = arg

        def GetSkillIndex(self):
            return self.skillIndex

        def GetSlotIndex(self):
            return self.slotIndex

        def Activate(self, coolTime):
            self.SetSlotCoolTime(0, coolTime)

            if skill.IsToggleSkill(self.skillIndex):
                self.ActivateSlot(0)

        def Deactivate(self):
            if skill.IsToggleSkill(self.skillIndex):
                self.DeactivateSlot(0)

        def OnOverInItem(self, dummy):
            self.tooltipSkill.SetSkill(self.skillIndex)

        def OnOverOutItem(self):
            self.tooltipSkill.HideToolTip()

        def OnSelectItemSlot(self, dummy):
            if 0 != self.event:
                if 0 != self.arg:
                    self.event(self.arg)
                else:
                    self.event()

    def __init__(self):
        #print "NEW TASKBAR  ----------------------------------------------------------------------------"

        ui.ScriptWindow.__init__(self, "TOP_MOST")

        self.quickPageNumImageBox = None
        self.tooltipItem = 0
        self.tooltipSkill = 0
        self.mouseModeButtonList = [ ui.ScriptWindow("TOP_MOST"), ui.ScriptWindow("TOP_MOST") ]

        self.tooltipHP = self.TextToolTip()
        self.tooltipHP.Show()
        self.tooltipSP = self.TextToolTip()
        self.tooltipSP.Show()
        self.tooltipST = self.TextToolTip()
        self.tooltipST.Show()
        self.tooltipEXP = self.TextToolTip()
        self.tooltipEXP.Show()
        
        self.skillCategoryNameList = [ "ACTIVE_1", "ACTIVE_2", "ACTIVE_3" ]
        self.skillPageStartSlotIndexDict = {
            "ACTIVE_1" : 1,
            "ACTIVE_2" : 21,
            "ACTIVE_3" : 41,
        }

        self.selectSkillButtonList = []
        
        self.lastUpdateQuickSlot = 0
        self.SetWindowName("TaskBar")

    def __del__(self):
        #print "---------------------------------------------------------------------------- DELETE TASKBAR"
        ui.ScriptWindow.__del__(self)

    def LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()

            if constInfo.IN_GAME_SHOP_ENABLE:
                pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "TaskBar.py")
            else:
                pyScrLoader.LoadScriptFile(self, "UIScript/TaskBar.py")
            pyScrLoader.LoadScriptFile(self.mouseModeButtonList[self.MOUSE_BUTTON_LEFT], "UIScript/MouseButtonWindow.py")
            pyScrLoader.LoadScriptFile(self.mouseModeButtonList[self.MOUSE_BUTTON_RIGHT], "UIScript/RightMouseButtonWindow.py")
        except:
            import exception
            exception.Abort("TaskBar.LoadWindow.LoadObject")

        self.quickslot = []
        self.quickslot.append(self.GetChild("quick_slot_1"))
        self.quickslot.append(self.GetChild("quick_slot_2"))
        for slot in self.quickslot:
            slot.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
            slot.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptyQuickSlot))
            slot.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemQuickSlot))
            slot.SetUnselectItemSlotEvent(ui.__mem_func__(self.UnselectItemQuickSlot))
            slot.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
            slot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

        toggleButtonDict = {}
        toggleButtonDict[TaskBar.BUTTON_CHARACTER]=self.GetChild("CharacterButton")
        toggleButtonDict[TaskBar.BUTTON_INVENTORY]=self.GetChild("InventoryButton")
        toggleButtonDict[TaskBar.BUTTON_MESSENGER]=self.GetChild("MessengerButton")
        toggleButtonDict[TaskBar.BUTTON_SYSTEM]=self.GetChild("SystemButton")
        
        # ChatButton, ExpandButton 둘 중 하나는 반드시 존재한다.
        try:
            toggleButtonDict[TaskBar.BUTTON_CHAT]=self.GetChild("ChatButton")
        except:
            toggleButtonDict[TaskBar.BUTTON_EXPAND]=self.GetChild("ExpandButton")
            TaskBar.IS_EXPANDED = True
        

        if localeInfo.IsARABIC():
            systemButton = toggleButtonDict[TaskBar.BUTTON_SYSTEM]
            if systemButton.ToolTipText:
                tx, ty = systemButton.ToolTipText.GetLocalPosition()
                tw = systemButton.ToolTipText.GetWidth()
                systemButton.ToolTipText.SetPosition(-tw/2, ty)


        expGauge = []
        expGauge.append(self.GetChild("EXPGauge_01"))
        expGauge.append(self.GetChild("EXPGauge_02"))
        expGauge.append(self.GetChild("EXPGauge_03"))
        expGauge.append(self.GetChild("EXPGauge_04"))

        for exp in expGauge:
            exp.SetSize(0, 0)

      
        self.quickPageNumImageBox=self.GetChild("QuickPageNumber")

        self.GetChild("QuickPageUpButton").SetEvent(ui.__mem_func__(self.__OnClickQuickPageUpButton))
        self.GetChild("QuickPageDownButton").SetEvent(ui.__mem_func__(self.__OnClickQuickPageDownButton))

        mouseLeftButtonModeButton = self.GetChild("LeftMouseButton")
        mouseRightButtonModeButton = self.GetChild("RightMouseButton")
        mouseLeftButtonModeButton.SetEvent(ui.__mem_func__(self.ToggleLeftMouseButtonModeWindow))       
        mouseRightButtonModeButton.SetEvent(ui.__mem_func__(self.ToggleRightMouseButtonModeWindow))
        self.curMouseModeButton = [ mouseLeftButtonModeButton, mouseRightButtonModeButton ]

        (xLocalRight, yLocalRight) = mouseRightButtonModeButton.GetLocalPosition()
        self.curSkillButton = self.SkillButton()
        self.curSkillButton.SetParent(self)
        self.curSkillButton.SetPosition(xLocalRight, 3)
        self.curSkillButton.SetSkillEvent(ui.__mem_func__(self.ToggleRightMouseButtonModeWindow))
        self.curSkillButton.Hide()

        (xLeft, yLeft) = mouseLeftButtonModeButton.GetGlobalPosition()
        (xRight, yRight) = mouseRightButtonModeButton.GetGlobalPosition()
        leftModeButtonList = self.mouseModeButtonList[self.MOUSE_BUTTON_LEFT]
        leftModeButtonList.SetPosition(xLeft, yLeft - leftModeButtonList.GetHeight()-5)
        rightModeButtonList = self.mouseModeButtonList[self.MOUSE_BUTTON_RIGHT]
        rightModeButtonList.SetPosition(xRight - rightModeButtonList.GetWidth() + 32, yRight - rightModeButtonList.GetHeight()-5)
        rightModeButtonList.GetChild("button_skill").SetEvent(lambda adir=self.MOUSE_BUTTON_RIGHT, aevent=self.EVENT_SKILL: self.SelectMouseButtonEvent(adir, aevent))
        rightModeButtonList.GetChild("button_skill").Hide()

        mouseImage = ui.ImageBox("TOP_MOST")
        mouseImage.AddFlag("float")
        mouseImage.LoadImage("d:/ymir work/ui/game/taskbar/mouse_button_camera_01.sub")
        mouseImage.SetPosition(xRight, wndMgr.GetScreenHeight() - 34)
        mouseImage.Hide()
        self.mouseImage = mouseImage

        dir = self.MOUSE_BUTTON_LEFT
        wnd = self.mouseModeButtonList[dir]
        wnd.GetChild("button_move_and_attack").SetEvent(lambda adir=dir, aevent=self.EVENT_MOVE_AND_ATTACK: self.SelectMouseButtonEvent(adir, aevent))
        wnd.GetChild("button_auto_attack").SetEvent(lambda adir=dir, aevent=self.EVENT_AUTO: self.SelectMouseButtonEvent(adir, aevent))
        wnd.GetChild("button_camera").SetEvent(lambda adir=dir, aevent=self.EVENT_CAMERA: self.SelectMouseButtonEvent(adir, aevent))

        dir = self.MOUSE_BUTTON_RIGHT
        wnd = self.mouseModeButtonList[dir]
        wnd.GetChild("button_move_and_attack").SetEvent(lambda adir=dir, aevent=self.EVENT_MOVE_AND_ATTACK: self.SelectMouseButtonEvent(adir, aevent))
        wnd.GetChild("button_camera").SetEvent(lambda adir=dir, aevent=self.EVENT_CAMERA: self.SelectMouseButtonEvent(adir, aevent))

        self.toggleButtonDict = toggleButtonDict
        self.expGauge = expGauge

        if constInfo.IN_GAME_SHOP_ENABLE:
            self.rampageGauge1  = self.GetChild("RampageGauge")
            self.rampageGauge1.OnMouseOverIn = ui.__mem_func__(self.__RampageGauge_OverIn)
            self.rampageGauge2 = self.GetChild("RampageGauge2")
            self.rampageGauge2.OnMouseOverOut = ui.__mem_func__(self.__RampageGauge_OverOut)
            self.rampageGauge2.OnMouseLeftButtonUp = ui.__mem_func__(self.__RampageGauge_Click)
            print "[DEBUG]: constInfo.IN_GAME_SHOP_ENABLE / self.rampageGauge1",constInfo.IN_GAME_SHOP_ENABLE, self.rampageGauge1
            self.__RampageGauge_OverOut()

        self.hpGauge = self.GetChild("HPGauge")
        self.mpGauge = self.GetChild("SPGauge")
        self.stGauge = self.GetChild("STGauge")
        self.hpRecoveryGaugeBar = self.GetChild("HPRecoveryGaugeBar")
        self.spRecoveryGaugeBar = self.GetChild("SPRecoveryGaugeBar")

        self.hpGaugeBoard=self.GetChild("HPGauge_Board")
        self.mpGaugeBoard=self.GetChild("SPGauge_Board")
        self.stGaugeBoard=self.GetChild("STGauge_Board")
        self.expGaugeBoard=self.GetChild("EXP_Gauge_Board")
        
        #giftbox object
        wndGiftBox = GiftBox()
        wndGiftBox.LoadWindow()
        self.wndGiftBox = wndGiftBox
    
        self.__LoadMouseSettings()
        self.RefreshStatus()
        self.RefreshQuickSlot()

    def __RampageGauge_OverIn(self):
        print "rampage_over_in"
        self.rampageGauge2.Show()
        self.rampageGauge1.Hide()

    def __RampageGauge_OverOut(self):
        print "rampage_over_out"
        self.rampageGauge2.Hide()
        self.rampageGauge1.Show()

    def __RampageGauge_Click(self):
        print "rampage_up"
        net.SendChatPacket("/in_game_mall")
        # gift icon hide when click mall icon
        self.wndGiftBox.Hide()   

    def __LoadMouseSettings(self):
        try:
            LoadMouseButtonSettings()
            (mouseLeftButtonEvent, mouseRightButtonEvent) = GetMouseButtonSettings()
            if not self.__IsInSafeMouseButtonSettingRange(mouseLeftButtonEvent) or not self.__IsInSafeMouseButtonSettingRange(mouseRightButtonEvent):
                    raise RuntimeError, "INVALID_MOUSE_BUTTON_SETTINGS"
        except:
            InitMouseButtonSettings(self.EVENT_MOVE_AND_ATTACK, self.EVENT_CAMERA)
            (mouseLeftButtonEvent, mouseRightButtonEvent) = GetMouseButtonSettings()

        try:
            self.SelectMouseButtonEvent(self.MOUSE_BUTTON_LEFT,    mouseLeftButtonEvent)
            self.SelectMouseButtonEvent(self.MOUSE_BUTTON_RIGHT,    mouseRightButtonEvent)
        except:
            InitMouseButtonSettings(self.EVENT_MOVE_AND_ATTACK, self.EVENT_CAMERA)
            (mouseLeftButtonEvent, mouseRightButtonEvent) = GetMouseButtonSettings()

            self.SelectMouseButtonEvent(self.MOUSE_BUTTON_LEFT,    mouseLeftButtonEvent)
            self.SelectMouseButtonEvent(self.MOUSE_BUTTON_RIGHT,    mouseRightButtonEvent)



    def __IsInSafeMouseButtonSettingRange(self, arg):
        return arg >= self.EVENT_MOVE and arg <= self.EVENT_AUTO

    def Destroy(self):       
        SaveMouseButtonSettings()

        self.ClearDictionary()
        self.mouseModeButtonList[0].ClearDictionary()
        self.mouseModeButtonList[1].ClearDictionary()
        self.mouseModeButtonList = 0
        self.curMouseModeButton = 0
        self.curSkillButton = 0
        self.selectSkillButtonList = 0


        self.expGauge = None
        self.hpGauge = None
        self.mpGauge = None
        self.stGauge = None
        self.hpRecoveryGaugeBar = None
        self.spRecoveryGaugeBar = None
    
        self.tooltipItem = 0
        self.tooltipSkill = 0
        self.quickslot = 0
        self.toggleButtonDict = 0

        self.hpGaugeBoard = 0
        self.mpGaugeBoard = 0
        self.stGaugeBoard = 0
        
        self.expGaugeBoard = 0

        self.tooltipHP = 0
        self.tooltipSP = 0
        self.tooltipST = 0
        self.tooltipEXP = 0

        self.mouseImage = None

    def __OnClickQuickPageUpButton(self):
        player.SetQuickPage(player.GetQuickPage()-1)

    def __OnClickQuickPageDownButton(self):
        player.SetQuickPage(player.GetQuickPage()+1)

    def SetToggleButtonEvent(self, eButton, kEventFunc):
        self.toggleButtonDict[eButton].SetEvent(kEventFunc)

    def SetItemToolTip(self, tooltipItem):
        self.tooltipItem = tooltipItem

    def SetSkillToolTip(self, tooltipSkill):
        self.tooltipSkill = tooltipSkill
        self.curSkillButton.SetSkillToolTip(self.tooltipSkill)

    ## Mouse Image
    def ShowMouseImage(self):
        self.mouseImage.SetTop()
        self.mouseImage.Show()

    def HideMouseImage(self):
        player.SetQuickCameraMode(False)
        self.mouseImage.Hide()

    ## Gauge
    def RefreshStatus(self):
        curHP = player.GetStatus(player.HP)
        maxHP = player.GetStatus(player.MAX_HP)
        curSP = player.GetStatus(player.SP)
        maxSP = player.GetStatus(player.MAX_SP)
        curEXP = unsigned32(player.GetStatus(player.EXP))
        nextEXP = unsigned32(player.GetStatus(player.NEXT_EXP))
        recoveryHP = player.GetStatus(player.HP_RECOVERY)
        recoverySP = player.GetStatus(player.SP_RECOVERY)
        
        self.RefreshStamina()

        self.SetHP(curHP, recoveryHP, maxHP)
        self.SetSP(curSP, recoverySP, maxSP)
        self.SetExperience(curEXP, nextEXP)
        
    def RefreshStamina(self):
        curST = player.GetStatus(player.STAMINA)
        maxST = player.GetStatus(player.MAX_STAMINA)
        self.SetST(curST, maxST)

    def RefreshSkill(self):
        self.curSkillButton.RefreshSkill()
        for button in self.selectSkillButtonList:
            button.RefreshSkill()

    def SetHP(self, curPoint, recoveryPoint, maxPoint):
        curPoint = min(curPoint, maxPoint)
        if maxPoint > 0:
            self.hpGauge.SetPercentage(curPoint, maxPoint)
            self.tooltipHP.SetText("%s : %d / %d" % (localeInfo.TASKBAR_HP, curPoint, maxPoint))

            if 0 == recoveryPoint:
                self.hpRecoveryGaugeBar.Hide()
            else:
                destPoint = min(maxPoint, curPoint + recoveryPoint)
                newWidth = int(self.GAUGE_WIDTH * (float(destPoint) / float(maxPoint)))
                self.hpRecoveryGaugeBar.SetSize(newWidth, self.GAUGE_HEIGHT)
                self.hpRecoveryGaugeBar.Show()

    def SetSP(self, curPoint, recoveryPoint, maxPoint):
        curPoint = min(curPoint, maxPoint)
        if maxPoint > 0:
            self.mpGauge.SetPercentage(curPoint, maxPoint)
            self.tooltipSP.SetText("%s : %d / %d" % (localeInfo.TASKBAR_SP, curPoint, maxPoint))

            if 0 == recoveryPoint:
                self.spRecoveryGaugeBar.Hide()
            else:
                destPoint = min(maxPoint, curPoint + recoveryPoint)
                newWidth = int(self.GAUGE_WIDTH * (float(destPoint) / float(maxPoint)))
                self.spRecoveryGaugeBar.SetSize(newWidth, self.GAUGE_HEIGHT)
                self.spRecoveryGaugeBar.Show()

    def SetST(self, curPoint, maxPoint):
        curPoint = min(curPoint, maxPoint)
        if maxPoint > 0:
            self.stGauge.SetPercentage(curPoint, maxPoint)
            self.tooltipST.SetText("%s : %d / %d" % (localeInfo.TASKBAR_ST, curPoint, maxPoint))

    def SetExperience(self, curPoint, maxPoint):

        curPoint = min(curPoint, maxPoint)
        curPoint = max(curPoint, 0)
        maxPoint = max(maxPoint, 0)

        quarterPoint = maxPoint / 4
        FullCount = 0

        if 0 != quarterPoint:
            FullCount = min(4, curPoint / quarterPoint)

        for i in xrange(4):
            self.expGauge[i].Hide()

        for i in xrange(FullCount):
            self.expGauge[i].SetRenderingRect(0.0, 0.0, 0.0, 0.0)
            self.expGauge[i].Show()

        if 0 != quarterPoint:
            if FullCount < 4:
                Percentage = float(curPoint % quarterPoint) / quarterPoint - 1.0
                self.expGauge[FullCount].SetRenderingRect(0.0, Percentage, 0.0, 0.0)
                self.expGauge[FullCount].Show()

        #####
        self.tooltipEXP.SetText("%s : %.2f%%" % (localeInfo.TASKBAR_EXP, float(curPoint) / max(1, float(maxPoint)) * 100))
    
        
    ## QuickSlot
    def RefreshQuickSlot(self):

        pageNum = player.GetQuickPage()

        try:
            self.quickPageNumImageBox.LoadImage(TaskBar.QUICKPAGE_NUMBER_FILENAME[pageNum])
        except:
            pass

        startNumber = 0
        for slot in self.quickslot:

            for i in xrange(4):

                slotNumber = i+startNumber

                (Type, Position) = player.GetLocalQuickSlot(slotNumber)

                if player.SLOT_TYPE_NONE == Type:
                    slot.ClearSlot(slotNumber)
                    continue

                if player.SLOT_TYPE_INVENTORY == Type:

                    itemIndex = player.GetItemIndex(Position)
                    itemCount = player.GetItemCount(Position)
                    if itemCount <= 1:
                        itemCount = 0
                    
                    ## 자동물약 (#72723, #72724) 특수처리 - 아이템인데도 슬롯에 활성화/비활성화 표시를 위한 작업임 - [hyo]
                    if constInfo.IS_AUTO_POTION(itemIndex):
                        # metinSocket - [0] : 활성화 여부, [1] : 사용한 양, [2] : 최대 용량
                        metinSocket = [player.GetItemMetinSocket(Position, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]
                        
                        if 0 != int(metinSocket[0]):
                            slot.ActivateSlot(slotNumber)
                        else:
                            slot.DeactivateSlot(slotNumber)
                    
                    slot.SetItemSlot(slotNumber, itemIndex, itemCount)

                elif player.SLOT_TYPE_SKILL == Type:

                    skillIndex = player.GetSkillIndex(Position)
                    if 0 == skillIndex:
                        slot.ClearSlot(slotNumber)
                        continue

                    skillType = skill.GetSkillType(skillIndex)
                    if skill.SKILL_TYPE_GUILD == skillType:
                        import guild
                        skillGrade = 0
                        skillLevel = guild.GetSkillLevel(Position)

                    else:
                        skillGrade = player.GetSkillGrade(Position)
                        skillLevel = player.GetSkillLevel(Position)

                    slot.SetSkillSlotNew(slotNumber, skillIndex, skillGrade, skillLevel)
                    slot.SetSlotCountNew(slotNumber, skillGrade, skillLevel)
                    slot.SetCoverButton(slotNumber)

                    ## NOTE : CoolTime 체크
                    if player.IsSkillCoolTime(Position):
                        (coolTime, elapsedTime) = player.GetSkillCoolTime(Position)
                        slot.SetSlotCoolTime(slotNumber, coolTime, elapsedTime)

                    ## NOTE : Activate 되어 있다면 아이콘도 업데이트
                    if player.IsSkillActive(Position):
                        slot.ActivateSlot(slotNumber)

                elif player.SLOT_TYPE_EMOTION == Type:

                    emotionIndex = Position
                    slot.SetEmotionSlot(slotNumber, emotionIndex)
                    slot.SetCoverButton(slotNumber)
                    slot.SetSlotCount(slotNumber, 0)

            slot.RefreshSlot()
            startNumber += 4

    def canAddQuickSlot(self, Type, slotNumber):

        if player.SLOT_TYPE_INVENTORY == Type:

            itemIndex = player.GetItemIndex(slotNumber)
            return item.CanAddToQuickSlotItem(itemIndex)

        return True

    def AddQuickSlot(self, localSlotIndex):
        AttachedSlotType = mouseModule.mouseController.GetAttachedType()
        AttachedSlotNumber = mouseModule.mouseController.GetAttachedSlotNumber()
        AttachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

        if player.SLOT_TYPE_QUICK_SLOT == AttachedSlotType:
            player.RequestMoveGlobalQuickSlotToLocalQuickSlot(AttachedSlotNumber, localSlotIndex)

        elif player.SLOT_TYPE_EMOTION == AttachedSlotType:

            player.RequestAddLocalQuickSlot(localSlotIndex, AttachedSlotType, AttachedItemIndex)

        elif True == self.canAddQuickSlot(AttachedSlotType, AttachedSlotNumber):

            ## Online Code
            player.RequestAddLocalQuickSlot(localSlotIndex, AttachedSlotType, AttachedSlotNumber)
        
        mouseModule.mouseController.DeattachObject()
        self.RefreshQuickSlot()

    def SelectEmptyQuickSlot(self, slotIndex):

        if True == mouseModule.mouseController.isAttached():
            self.AddQuickSlot(slotIndex)

    def SelectItemQuickSlot(self, localQuickSlotIndex):

        if True == mouseModule.mouseController.isAttached():
            self.AddQuickSlot(localQuickSlotIndex)

        else:
            globalQuickSlotIndex=player.LocalQuickSlotIndexToGlobalQuickSlotIndex(localQuickSlotIndex)
            mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_QUICK_SLOT, globalQuickSlotIndex, globalQuickSlotIndex)

    def UnselectItemQuickSlot(self, localSlotIndex):

        if False == mouseModule.mouseController.isAttached():
            player.RequestUseLocalQuickSlot(localSlotIndex)
            return

        elif mouseModule.mouseController.isAttached():
            mouseModule.mouseController.DeattachObject()
            return


    def OnUseSkill(self, usedSlotIndex, coolTime):

        QUICK_SLOT_SLOT_COUNT = 4
        slotIndex = 0

        ## Current Skill Button
        if usedSlotIndex == self.curSkillButton.GetSlotIndex():
            self.curSkillButton.Activate(coolTime)

        ## Quick Slot
        for slotWindow in self.quickslot:

            for i in xrange(QUICK_SLOT_SLOT_COUNT):

                (Type, Position) = player.GetLocalQuickSlot(slotIndex)

                if Type == player.SLOT_TYPE_SKILL:
                    if usedSlotIndex == Position:
                        slotWindow.SetSlotCoolTime(slotIndex, coolTime)
                        return

                slotIndex += 1

    def OnActivateSkill(self, usedSlotIndex):
        slotIndex = 0

        ## Current Skill Button
        if usedSlotIndex == self.curSkillButton.GetSlotIndex():
            self.curSkillButton.Deactivate()

        ## Quick Slot
        for slotWindow in self.quickslot:

            for i in xrange(4):

                (Type, Position) = player.GetLocalQuickSlot(slotIndex)

                if Type == player.SLOT_TYPE_SKILL:
                    if usedSlotIndex == Position:
                        slotWindow.ActivateSlot(slotIndex)
                        return

                slotIndex += 1

    def OnDeactivateSkill(self, usedSlotIndex):
        slotIndex = 0

        ## Current Skill Button
        if usedSlotIndex == self.curSkillButton.GetSlotIndex():
            self.curSkillButton.Deactivate()

        ## Quick Slot
        for slotWindow in self.quickslot:

            for i in xrange(4):

                (Type, Position) = player.GetLocalQuickSlot(slotIndex)

                if Type == player.SLOT_TYPE_SKILL:
                    if usedSlotIndex == Position:
                        slotWindow.DeactivateSlot(slotIndex)
                        return

                slotIndex += 1

    ## ToolTip
    def OverInItem(self, slotNumber):
        if mouseModule.mouseController.isAttached():
            return

        (Type, Position) = player.GetLocalQuickSlot(slotNumber)

        if player.SLOT_TYPE_INVENTORY == Type:
            self.tooltipItem.SetInventoryItem(Position)
            self.tooltipSkill.HideToolTip()

        elif player.SLOT_TYPE_SKILL == Type:

            skillIndex = player.GetSkillIndex(Position)
            skillType = skill.GetSkillType(skillIndex)

            if skill.SKILL_TYPE_GUILD == skillType:
                import guild
                skillGrade = 0
                skillLevel = guild.GetSkillLevel(Position)

            else:
                skillGrade = player.GetSkillGrade(Position)
                skillLevel = player.GetSkillLevel(Position)

            self.tooltipSkill.SetSkillNew(Position, skillIndex, skillGrade, skillLevel)
            self.tooltipItem.HideToolTip()

    def OverOutItem(self):
        if 0 != self.tooltipItem:
            self.tooltipItem.HideToolTip()
        if 0 != self.tooltipSkill:
            self.tooltipSkill.HideToolTip()

    def OnUpdate(self):
        if app.GetGlobalTime() - self.lastUpdateQuickSlot > 500:
            self.lastUpdateQuickSlot = app.GetGlobalTime()
            self.RefreshQuickSlot()

        if True == self.hpGaugeBoard.IsIn():
            self.tooltipHP.Show()
        else:
            self.tooltipHP.Hide()

        if True == self.mpGaugeBoard.IsIn():
            self.tooltipSP.Show()
        else:
            self.tooltipSP.Hide()

        if True == self.stGaugeBoard.IsIn():
            self.tooltipST.Show()
        else:
            self.tooltipST.Hide()
        
        if True == self.expGaugeBoard.IsIn():
            self.tooltipEXP.Show()
        else:
            self.tooltipEXP.Hide()
        
    ## Skill
    def ToggleLeftMouseButtonModeWindow(self):

        wndMouseButtonMode = self.mouseModeButtonList[self.MOUSE_BUTTON_LEFT]

        if True == wndMouseButtonMode.IsShow():

            wndMouseButtonMode.Hide()

        else:
            wndMouseButtonMode.Show()

    def ToggleRightMouseButtonModeWindow(self):

        wndMouseButtonMode = self.mouseModeButtonList[self.MOUSE_BUTTON_RIGHT]

        if True == wndMouseButtonMode.IsShow():

            wndMouseButtonMode.Hide()
            self.CloseSelectSkill()

        else:
            wndMouseButtonMode.Show()
            self.OpenSelectSkill()

    def OpenSelectSkill(self):

        PAGE_SLOT_COUNT = 6

        (xSkillButton, y) = self.curSkillButton.GetGlobalPosition()
        y -= (37 + 32 + 1)

        for key in self.skillCategoryNameList:

            appendCount = 0
            startNumber = self.skillPageStartSlotIndexDict[key]
            x = xSkillButton

            getSkillIndex=player.GetSkillIndex
            getSkillLevel=player.GetSkillLevel
            for i in xrange(PAGE_SLOT_COUNT):

                skillIndex = getSkillIndex(startNumber+i)
                skillLevel = getSkillLevel(startNumber+i)

                if 0 == skillIndex:
                    continue
                if 0 == skillLevel:
                    continue
                if skill.IsStandingSkill(skillIndex):
                    continue

                ## FIXME : 스킬 하나당 슬롯 하나씩 할당하는건 아무리 봐도 부하가 크다.
                ##         이 부분은 시간을 나면 고치도록. - [levites]
                skillButton = self.SkillButton()
                skillButton.SetSkill(startNumber+i)
                skillButton.SetPosition(x, y)
                skillButton.SetSkillEvent(ui.__mem_func__(self.CloseSelectSkill), startNumber+i+1)
                skillButton.SetSkillToolTip(self.tooltipSkill)
                skillButton.SetTop()
                skillButton.Show()
                self.selectSkillButtonList.append(skillButton)

                appendCount += 1
                x -= 32

            if appendCount > 0:
                y -= 32

    def CloseSelectSkill(self, slotIndex=-1):

        self.mouseModeButtonList[self.MOUSE_BUTTON_RIGHT].Hide()
        for button in self.selectSkillButtonList:
            button.Destroy()

        self.selectSkillButtonList = []

        if -1 != slotIndex:
            self.curSkillButton.Show()
            self.curMouseModeButton[self.MOUSE_BUTTON_RIGHT].Hide()
            player.SetMouseFunc(player.MBT_RIGHT, player.MBF_SKILL)
            player.ChangeCurrentSkillNumberOnly(slotIndex-1)
        else:
            self.curSkillButton.Hide()
            self.curMouseModeButton[self.MOUSE_BUTTON_RIGHT].Show()

    def SelectMouseButtonEvent(self, dir, event):
        SetMouseButtonSetting(dir, event)

        self.CloseSelectSkill()
        self.mouseModeButtonList[dir].Hide()

        btn = 0
        type = self.NONE
        func = self.NONE
        tooltip_text = ""       
        
        if self.MOUSE_BUTTON_LEFT == dir:
            type = player.MBT_LEFT

        elif self.MOUSE_BUTTON_RIGHT == dir:
            type = player.MBT_RIGHT

        if self.EVENT_MOVE == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_move")
            func = player.MBF_MOVE
            tooltip_text = localeInfo.TASKBAR_MOVE
        elif self.EVENT_ATTACK == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_attack")
            func = player.MBF_ATTACK
            tooltip_text = localeInfo.TASKBAR_ATTACK
        elif self.EVENT_AUTO == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_auto_attack")
            func = player.MBF_AUTO
            tooltip_text = localeInfo.TASKBAR_AUTO
        elif self.EVENT_MOVE_AND_ATTACK == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_move_and_attack")
            func = player.MBF_SMART
            tooltip_text = localeInfo.TASKBAR_ATTACK
        elif self.EVENT_CAMERA == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_camera")
            func = player.MBF_CAMERA
            tooltip_text = localeInfo.TASKBAR_CAMERA
        elif self.EVENT_SKILL == event:
            btn = self.mouseModeButtonList[dir].GetChild("button_skill")
            func = player.MBF_SKILL
            tooltip_text = localeInfo.TASKBAR_SKILL

        if 0 != btn:
            self.curMouseModeButton[dir].SetToolTipText(tooltip_text, 0, -18)
            self.curMouseModeButton[dir].SetUpVisual(btn.GetUpVisualFileName())
            self.curMouseModeButton[dir].SetOverVisual(btn.GetOverVisualFileName())
            self.curMouseModeButton[dir].SetDownVisual(btn.GetDownVisualFileName())
            self.curMouseModeButton[dir].Show()

        player.SetMouseFunc(type, func)

    def OnChangeCurrentSkill(self, skillSlotNumber):
        self.curSkillButton.SetSkill(skillSlotNumber)
        self.curSkillButton.Show()
        self.curMouseModeButton[self.MOUSE_BUTTON_RIGHT].Hide()

won sisteminde eklemem gerekenler:

#ARA :
            self.wndMoney = self.GetChild("Money")
            self.wndMoneySlot = self.GetChild("Money_Slot")
            self.wndMoneyIcon = self.GetChild("Money_Icon")
            self.wndMoneyIcon.SAFE_SetStringEvent("MOUSE_OVER_IN", self.__ShowMoneyTitleToolTip)
            self.wndMoneyIcon.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.__HideMoneyTitleToolTip)

#ALTINA EKLE :
            if app.ENABLE_CHEQUE_SYSTEM:
                self.wndCheque = self.GetChild("Cheque")
                self.wndChequeSlot = self.GetChild("Cheque_Slot")
                self.wndChequeSlotIcon = self.GetChild("Cheque_Icon")
                self.wndChequeSlotIcon.SAFE_SetStringEvent("MOUSE_OVER_IN", self.__ShowChequeTitleToolTip)
                self.wndChequeSlotIcon.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.__HideChequeTitleToolTip)

#ARA :
        self.wndMoneyIcon = 0
        self.wndMoney = 0
        self.wndMoneySlot = 0

#ALTINA EKLE :
        if app.ENABLE_CHEQUE_SYSTEM:
            self.wndChequeSlotIcon = 0
            self.wndCheque = 0
            self.wndChequeSlot = 0

#ARA :
        money = player.GetElk()
        self.wndMoney.SetText(localeInfo.NumberToMoney(money))

#ALTINA EKLE :
        if app.ENABLE_CHEQUE_SYSTEM:
            self.wndCheque.SetText(str(player.GetCheque()))

#ARA :
        self.toolTipMoneyTitle = uiToolTip.ToolTip(20)
        self.toolTipMoneyTitle.AutoAppendTextLine(localeInfo.MONEY_SYSTEM_UNIT_YANG, uiToolTip.ToolTip.PRICE_INFO_COLOR)
        self.toolTipMoneyTitle.AlignHorizonalCenter()

#ALTINA EKLE :
        self.toolTipChequeTitle = uiToolTip.ToolTip(20)
        self.toolTipChequeTitle.AutoAppendTextLine(localeInfo.MONEY_SYSTEM_UNIT_WON, uiToolTip.ToolTip.PRICE_INFO_COLOR)
        self.toolTipChequeTitle.AlignHorizonalCenter()

#ARA :
    def __ShowMoneyTitleToolTip(self):
        self.toolTipMoneyTitle.ShowToolTip()

    def __HideMoneyTitleToolTip(self):
        self.toolTipMoneyTitle.HideToolTip()

#ALTINA EKLE :
    def __ShowChequeTitleToolTip(self):
        self.toolTipChequeTitle.ShowToolTip()

    def __HideChequeTitleToolTip(self):
        self.toolTipChequeTitle.HideToolTip()

Eric Bloodaxe · 28 Ara 2020

Aradığınızı bulamamanızın sebebi yanlış dosyada arıyor olmanız.
Bu aramanız gereken fonksiyonlar uitaskbar.py'de değil uiinventory.py'de.

BGame · 28 Ara 2020

Eric Bloodaxe' Alıntı:
Aradığınızı bulamamanızın sebebi yanlış dosyada arıyor olmanız.

Eric Bloodaxe' Alıntı:

Aradığınızı bulamamanızın sebebi yanlış dosyada arıyor olmanız.
Bu aramanız gereken fonksiyonlar uitaskbar.py'de değil uiinventory.py'de.

Genişletmek için tıkla

oo kankam benim ya senin alt yapını kullanıyorum belki beni hatırlarsın murogram sen ben takılırdık bir ara ben bahri bana bi yardım edi ver ya senin ofline shop olmayan filesini kullanıyorum bunu bir türlü ekleyemedim won sistemini paylaşan arkadaş sermaye sistemine göre anlatım yapmış öyle kala kaldım

Hikayeler

Won sistemini eklerken sorun yaşıyorum YARDIM LÜTFEN

BGame

BGame.com.tr

Eric Bloodaxe

Özgürsün, onun için mahvoldun.

BGame

BGame.com.tr

Şu an konuyu görüntüleyenler (Toplam : 1, Üye: 0, Misafir: 1)

Benzer konular