forked from metin2/client
1168 lines
34 KiB
Python
1168 lines
34 KiB
Python
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()
|
||
# <20><><EFBFBD><EFBFBD>ȯ <20><><EFBFBD><EFBFBD> <20>ð<EFBFBD> = 2<>ð<EFBFBD>.
|
||
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(" " + localeInfo.SecondToHM(leftTime) + " - Energie +" + str(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):
|
||
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 <20>Ǿ<EFBFBD> <20>ִٸ<D6B4> <20><><EFBFBD><EFBFBD><EFBFBD>ܵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
|
||
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 <20><> <20><> <20>ϳ<EFBFBD><CFB3><EFBFBD> <20>ݵ<EFBFBD><DDB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
|
||
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))
|
||
|
||
########Anti Exp Button by Sanii##########
|
||
|
||
#self.antiexp = self.GetChild("AntiButton")
|
||
#self.antiexp.SetEvent(ui.__mem_func__(self.AntiExp))
|
||
|
||
#if constInfo.ANTI_EXP_STATE == 1:
|
||
#self.antiexp.SetText("-")
|
||
#self.antiexp.SetToolTipText("Anti-Erfahrung deaktivieren")
|
||
#else:
|
||
#self.antiexp.SetText("+")
|
||
#self.antiexp.SetToolTipText("Anti-Erfahrung aktivieren")
|
||
|
||
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)
|
||
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
|
||
|
||
## <20>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD> (#72723, #72724) Ư<><C6AF>ó<EFBFBD><C3B3> - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ε<EFBFBD><CEB5><EFBFBD> <20><><EFBFBD>Կ<EFBFBD> Ȱ<><C8B0>ȭ/<2F><>Ȱ<EFBFBD><C8B0>ȭ ǥ<>ø<EFBFBD> <20><><EFBFBD><EFBFBD> <20>۾<EFBFBD><DBBE><EFBFBD> - [hyo]
|
||
if constInfo.IS_AUTO_POTION(itemIndex):
|
||
# metinSocket - [0] : Ȱ<><C8B0>ȭ <20><><EFBFBD><EFBFBD>, [1] : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>, [2] : <20>ִ<EFBFBD> <20>뷮
|
||
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 <20>Ǿ<EFBFBD> <20>ִٸ<D6B4> <20><><EFBFBD><EFBFBD><EFBFBD>ܵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
|
||
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 : <20><>ų <20>ϳ<EFBFBD><CFB3><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ϳ<EFBFBD><CFB3><EFBFBD> <20>Ҵ<EFBFBD><D2B4>ϴ°<CFB4> <20>ƹ<EFBFBD><C6B9><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ϰ<EFBFBD> ũ<><C5A9>.
|
||
## <20><> <20>κ<EFBFBD><CEBA><EFBFBD> <20>ð<EFBFBD><C3B0><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1><EFBFBD><EFBFBD>. - [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()
|
||
|
||
|
||
########Anti Exp Button by Sanii##########
|
||
def AntiExp(self):
|
||
import constInfo
|
||
import event
|
||
import net
|
||
qid = constInfo.ANTI_EXP
|
||
state = constInfo.ANTI_EXP_STATE
|
||
if state == 0:
|
||
self.antiexp.SetText("-")
|
||
self.antiexp.SetToolTipText("Anti-Erfahrung deaktivieren")
|
||
event.QuestButtonClick(qid)
|
||
else:
|
||
self.antiexp.SetText("+")
|
||
self.antiexp.SetToolTipText("Anti-Erfahrung aktivieren")
|
||
event.QuestButtonClick(qid)
|
||
##########################################
|
||
|