Syserr Bonus Board

Teratos · 23. Januar 2019

Hallo zusammen,

ich bekomme folgende syserr Meldung beim einloggen (client stürzt dann ab):

Habe versucht das Bonus Board DE einzufügen.

Code

0123 18:13:05752 ::
networkModule.py(line:208) SetSelectCharacterPhase
system.py(line:130) __pack_import
system.py(line:110) _process_result
introSelect.py(line:25) ?
system.py(line:130) __pack_import
system.py(line:110) _process_result
uiCharacter.py(line:18) ?
system.py(line:130) __pack_import
networkModule.SetSelectCharacterPhase - exceptions.SyntaxError:invalid syntax (line 242)
0123 18:13:05752 :: ============================================================================================================
0123 18:13:05752 :: Abort!!!!

Alles anzeigen

uicharacter.py:

Code

import ui
import uiScriptLocale
import app
import net
import dbg
import snd
import player
import mouseModule
import wndMgr
import skill
import playerSettingModule
import quest
import localeInfo
import uiToolTip
import constInfo
import emotion
import chr
import uiCharacterDetails
SHOW_ONLY_ACTIVE_SKILL = FALSE
SHOW_LIMIT_SUPPORT_SKILL_LIST = []
HIDE_SUPPORT_SKILL_POINT = FALSE
if localeInfo.IsYMIR():
SHOW_LIMIT_SUPPORT_SKILL_LIST = [121, 122, 123, 124, 126, 127, 129, 128, 131, 137, 138, 139, 140,141,142]
if not localeInfo.IsCHEONMA():
HIDE_SUPPORT_SKILL_POINT = TRUE
SHOW_LIMIT_SUPPORT_SKILL_LIST = [121, 122, 123, 124, 126, 127, 129, 128, 131, 137, 138, 139, 140,141,142]
elif localeInfo.IsJAPAN() or (localeInfo.IsEUROPE() and app.GetLocalePath() != "locale/ca") and (localeInfo.IsEUROPE() and app.GetLocalePath() != "locale/br"):
HIDE_SUPPORT_SKILL_POINT = TRUE
SHOW_LIMIT_SUPPORT_SKILL_LIST = [121, 122, 123, 124, 126, 127, 129, 128, 131, 137, 138, 139, 140]
else:
HIDE_SUPPORT_SKILL_POINT = TRUE
FACE_IMAGE_DICT = {
playerSettingModule.RACE_WARRIOR_M : "icon/face/warrior_m.tga",
playerSettingModule.RACE_WARRIOR_W : "icon/face/warrior_w.tga",
playerSettingModule.RACE_ASSASSIN_M : "icon/face/assassin_m.tga",
playerSettingModule.RACE_ASSASSIN_W : "icon/face/assassin_w.tga",
playerSettingModule.RACE_SURA_M : "icon/face/sura_m.tga",
playerSettingModule.RACE_SURA_W : "icon/face/sura_w.tga",
playerSettingModule.RACE_SHAMAN_M : "icon/face/shaman_m.tga",
playerSettingModule.RACE_SHAMAN_W : "icon/face/shaman_w.tga",
}
def unsigned32(n):
return n & 0xFFFFFFFFL
class CharacterWindow(ui.ScriptWindow):
ACTIVE_PAGE_SLOT_COUNT = 8
SUPPORT_PAGE_SLOT_COUNT = 12
PAGE_SLOT_COUNT = 12
PAGE_HORSE = 2
SKILL_GROUP_NAME_DICT = {
playerSettingModule.JOB_WARRIOR : { 1 : localeInfo.SKILL_GROUP_WARRIOR_1, 2 : localeInfo.SKILL_GROUP_WARRIOR_2, },
playerSettingModule.JOB_ASSASSIN : { 1 : localeInfo.SKILL_GROUP_ASSASSIN_1, 2 : localeInfo.SKILL_GROUP_ASSASSIN_2, },
playerSettingModule.JOB_SURA : { 1 : localeInfo.SKILL_GROUP_SURA_1, 2 : localeInfo.SKILL_GROUP_SURA_2, },
playerSettingModule.JOB_SHAMAN : { 1 : localeInfo.SKILL_GROUP_SHAMAN_1, 2 : localeInfo.SKILL_GROUP_SHAMAN_2, },
}
STAT_DESCRIPTION = {
"HTH" : localeInfo.STAT_TOOLTIP_CON,
"INT" : localeInfo.STAT_TOOLTIP_INT,
"STR" : localeInfo.STAT_TOOLTIP_STR,
"DEX" : localeInfo.STAT_TOOLTIP_DEX,
}
STAT_MINUS_DESCRIPTION = localeInfo.STAT_MINUS_DESCRIPTION
def __init__(self):
self.chDetailsWnd = None
self.isOpenedDetailsWnd = FALSE
ui.ScriptWindow.__init__(self)
self.state = "STATUS"
self.isLoaded = 0
self.toolTipSkill = 0
self.__Initialize()
self.__LoadWindow()
self.statusPlusCommandDict={
"HTH" : "/stat ht",
"INT" : "/stat iq",
"STR" : "/stat st",
"DEX" : "/stat dx",
}
self.statusMinusCommandDict={
"HTH-" : "/stat- ht",
"INT-" : "/stat- iq",
"STR-" : "/stat- st",
"DEX-" : "/stat- dx",
}
def __del__(self):
ui.ScriptWindow.__del__(self)
def __Initialize(self):
self.refreshToolTip = 0
self.curSelectedSkillGroup = 0
self.canUseHorseSkill = -1
self.toolTip = None
self.toolTipJob = None
self.toolTipAlignment = None
self.toolTipSkill = None
self.faceImage = None
self.statusPlusLabel = None
self.statusPlusValue = None
self.activeSlot = None
self.tabDict = None
self.tabButtonDict = None
self.pageDict = None
self.titleBarDict = None
self.statusPlusButtonDict = None
self.statusMinusButtonDict = None
self.skillPageDict = None
self.questShowingStartIndex = 0
self.questScrollBar = None
self.questSlot = None
self.questNameList = None
self.questLastTimeList = None
self.questLastCountList = None
self.skillGroupButton = ()
self.activeSlot = None
self.activeSkillPointValue = None
self.supportSkillPointValue = None
self.skillGroupButton1 = None
self.skillGroupButton2 = None
self.activeSkillGroupName = None
self.guildNameSlot = None
self.guildNameValue = None
self.characterNameSlot = None
self.characterNameValue = None
self.emotionToolTip = None
self.soloEmotionSlot = None
self.dualEmotionSlot = None
def OnTop(self):
if self.chDetailsWnd:
self.chDetailsWnd.SetTop()
def Hide(self):
if self.chDetailsWnd:
self.isOpenedDetailsWnd = self.chDetailsWnd.IsShow()
self.chDetailsWnd.Close()
wndMgr.Hide(self.hWnd)
def Show(self):
self.__LoadWindow()
self.__InitCharacterDetailsUIButton()
if self.chDetailsWnd and self.isOpenedDetailsWnd:
self.chDetailsWnd.Show()
ui.ScriptWindow.Show(self)
def __LoadScript(self, fileName):
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, fileName)
def __BindObject(self):
self.toolTip = uiToolTip.ToolTip()
self.toolTipJob = uiToolTip.ToolTip()
self.toolTipAlignment = uiToolTip.ToolTip(130)
self.faceImage = self.GetChild("Face_Image")
faceSlot=self.GetChild("Face_Slot")
if 949 == app.GetDefaultCodePage():
faceSlot.SAFE_SetStringEvent("MOUSE_OVER_IN", self.__ShowJobToolTip)
faceSlot.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.__HideJobToolTip)
self.statusPlusLabel = self.GetChild("Status_Plus_Label")
self.statusPlusValue = self.GetChild("Status_Plus_Value")
self.characterNameSlot = self.GetChild("Character_Name_Slot")
self.characterNameValue = self.GetChild("Character_Name")
self.guildNameSlot = self.GetChild("Guild_Name_Slot")
self.guildNameValue = self.GetChild("Guild_Name")
self.characterNameSlot.SAFE_SetStringEvent("MOUSE_OVER_IN", self.__ShowAlignmentToolTip)
self.characterNameSlot.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.__HideAlignmentToolTip)
self.activeSlot = self.GetChild("Skill_Active_Slot")
self.activeSkillPointValue = self.GetChild("Active_Skill_Point_Value")
self.supportSkillPointValue = self.GetChild("Support_Skill_Point_Value")
self.skillGroupButton1 = self.GetChild("Skill_Group_Button_1")
self.skillGroupButton2 = self.GetChild("Skill_Group_Button_2")
self.activeSkillGroupName = self.GetChild("Active_Skill_Group_Name")
self.tabDict = {
"STATUS" : self.GetChild("Tab_01"),
"SKILL" : self.GetChild("Tab_02"),
"EMOTICON" : self.GetChild("Tab_03"),
"QUEST" : self.GetChild("Tab_04"),
}
self.tabButtonDict = {
"STATUS" : self.GetChild("Tab_Button_01"),
"SKILL" : self.GetChild("Tab_Button_02"),
"EMOTICON" : self.GetChild("Tab_Button_03"),
"QUEST" : self.GetChild("Tab_Button_04")
}
self.pageDict = {
"STATUS" : self.GetChild("Character_Page"),
"SKILL" : self.GetChild("Skill_Page"),
"EMOTICON" : self.GetChild("Emoticon_Page"),
"QUEST" : self.GetChild("Quest_Page")
}
self.titleBarDict = {
"STATUS" : self.GetChild("Character_TitleBar"),
"SKILL" : self.GetChild("Skill_TitleBar"),
"EMOTICON" : self.GetChild("Emoticon_TitleBar"),
"QUEST" : self.GetChild("Quest_TitleBar")
}
self.statusPlusButtonDict = {
"HTH" : self.GetChild("HTH_Plus"),
"INT" : self.GetChild("INT_Plus"),
"STR" : self.GetChild("STR_Plus"),
"DEX" : self.GetChild("DEX_Plus"),
}
self.statusMinusButtonDict = {
"HTH-" : self.GetChild("HTH_Minus"),
"INT-" : self.GetChild("INT_Minus"),
"STR-" : self.GetChild("STR_Minus"),
"DEX-" : self.GetChild("DEX_Minus"),
}
self.skillPageDict = {
"ACTIVE" : self.GetChild("Skill_Active_Slot"),
"SUPPORT" : self.GetChild("Skill_ETC_Slot"),
"HORSE" : self.GetChild("Skill_Active_Slot"),
}
self.skillPageStatDict = {
"SUPPORT" : player.SKILL_SUPPORT,
"ACTIVE" : player.SKILL_ACTIVE,
"HORSE" : player.SKILL_HORSE,
}
self.skillGroupButton = (
self.GetChild("Skill_Group_Button_1"),
self.GetChild("Skill_Group_Button_2"),
)
global SHOW_ONLY_ACTIVE_SKILL
global HIDE_SUPPORT_SKILL_POINT
if SHOW_ONLY_ACTIVE_SKILL or HIDE_SUPPORT_SKILL_POINT:
self.GetChild("Support_Skill_Point_Label").Hide()
self.soloEmotionSlot = self.GetChild("SoloEmotionSlot")
self.dualEmotionSlot = self.GetChild("DualEmotionSlot")
self.__SetEmotionSlot()
self.questShowingStartIndex = 0
self.questScrollBar = self.GetChild("Quest_ScrollBar")
self.questScrollBar.SetScrollEvent(ui.__mem_func__(self.OnQuestScroll))
self.questSlot = self.GetChild("Quest_Slot")
for i in xrange(quest.QUEST_MAX_NUM):
self.questSlot.HideSlotBaseImage(i)
self.questSlot.SetCoverButton(i,\
"d:/ymir work/ui/game/quest/slot_button_01.sub",\
"d:/ymir work/ui/game/quest/slot_button_02.sub",\
"d:/ymir work/ui/game/quest/slot_button_03.sub",\
"d:/ymir work/ui/game/quest/slot_button_03.sub", TRUE)
self.questNameList = []
self.questLastTimeList = []
self.questLastCountList = []
for i in xrange(quest.QUEST_MAX_NUM):
self.questNameList.append(self.GetChild("Quest_Name_0" + str(i)))
self.questLastTimeList.append(self.GetChild("Quest_LastTime_0" + str(i)))
self.questLastCountList.append(self.GetChild("Quest_LastCount_0" + str(i)))
self.MainBoard = self.GetChild("board")
self.ExpandBtn = ui.MakeButton(self.MainBoard, 240, 120, "", "d:/ymir work/ui/game/belt_inventory/", "btn_minimize_normal.tga", "btn_minimize_over.tga", "btn_minimize_down.tga")
self.ExpandBtn.SetEvent(ui.__mem_func__(self.__ClickExpandButton))
self.MinimizeBtn = ui.MakeButton(self.MainBoard, 240, 120, "", "d:/ymir work/ui/game/belt_inventory/", "btn_expand_normal.tga", "btn_expand_over.tga", "btn_expand_down.tga")
self.MinimizeBtn.SetEvent(ui.__mem_func__(self.__ClickMinimizeButton))
def __InitCharacterDetailsUIButton(self):
self.ExpandBtn.Show()
self.MinimizeBtn.Hide()
def __ClickExpandButton(self):
if not self.chDetailsWnd:
self.chDetailsWnd = uiCharacterDetails.CharacterDetailsUI(self)
self.chDetailsWnd.Show()
else:
self.chDetailsWnd.Show()
self.ExpandBtn.Hide()
self.MinimizeBtn.Show()
def __ClickMinimizeButton(self):
self.chDetailsWnd.Hide()
self.MinimizeBtn.Hide()
self.ExpandBtn.Show()
def OnMoveWindow(self, x, y):
if self.chDetailsWnd:
self.chDetailsWnd.AdjustPosition(x, y)
def __SetSkillSlotEvent(self):
for skillPageValue in self.skillPageDict.itervalues():
skillPageValue.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
skillPageValue.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectSkill))
skillPageValue.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
skillPageValue.SetUnselectItemSlotEvent(ui.__mem_func__(self.ClickSkillSlot))
skillPageValue.SetUseSlotEvent(ui.__mem_func__(self.ClickSkillSlot))
skillPageValue.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
skillPageValue.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
skillPageValue.SetPressedSlotButtonEvent(ui.__mem_func__(self.OnPressedSlotButton))
skillPageValue.AppendSlotButton("d:/ymir work/ui/game/windows/btn_plus_up.sub",\
"d:/ymir work/ui/game/windows/btn_plus_over.sub",\
"d:/ymir work/ui/game/windows/btn_plus_down.sub")
def __SetEmotionSlot(self):
self.emotionToolTip = uiToolTip.ToolTip()
for slot in (self.soloEmotionSlot, self.dualEmotionSlot):
slot.SetSlotStyle(wndMgr.SLOT_STYLE_NONE)
slot.SetSelectItemSlotEvent(ui.__mem_func__(self.__SelectEmotion))
slot.SetUnselectItemSlotEvent(ui.__mem_func__(self.__ClickEmotionSlot))
slot.SetUseSlotEvent(ui.__mem_func__(self.__ClickEmotionSlot))
slot.SetOverInItemEvent(ui.__mem_func__(self.__OverInEmotion))
slot.SetOverOutItemEvent(ui.__mem_func__(self.__OverOutEmotion))
slot.AppendSlotButton("d:/ymir work/ui/game/windows/btn_plus_up.sub",\
"d:/ymir work/ui/game/windows/btn_plus_over.sub",\
"d:/ymir work/ui/game/windows/btn_plus_down.sub")
for slotIdx, datadict in emotion.EMOTION_DICT.items():
emotionIdx = slotIdx
slot = self.soloEmotionSlot
if slotIdx > 50:
slot = self.dualEmotionSlot
slot.SetEmotionSlot(slotIdx, emotionIdx)
slot.SetCoverButton(slotIdx)
def __SelectEmotion(self, slotIndex):
if not slotIndex in emotion.EMOTION_DICT:
return
if app.IsPressed(app.DIK_LCONTROL):
player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_EMOTION, slotIndex)
return
mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_EMOTION, slotIndex, slotIndex)
def __ClickEmotionSlot(self, slotIndex):
print "click emotion"
if not slotIndex in emotion.EMOTION_DICT:
return
print "check acting"
if player.IsActingEmotion():
return
command = emotion.EMOTION_DICT[slotIndex]["command"]
print "command", command
if slotIndex > 50:
vid = player.GetTargetVID()
if 0 == vid or vid == player.GetMainCharacterIndex() or chr.IsNPC(vid) or chr.IsEnemy(vid):
import chat
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EMOTION_CHOOSE_ONE)
return
command += " " + chr.GetNameByVID(vid)
print "send_command", command
net.SendChatPacket(command)
def ActEmotion(self, emotionIndex):
self.__ClickEmotionSlot(emotionIndex)
def __OverInEmotion(self, slotIndex):
if self.emotionToolTip:
if not slotIndex in emotion.EMOTION_DICT:
return
self.emotionToolTip.ClearToolTip()
self.emotionToolTip.SetTitle(emotion.EMOTION_DICT[slotIndex]["name"])
self.emotionToolTip.AlignHorizonalCenter()
self.emotionToolTip.ShowToolTip()
def __OverOutEmotion(self):
if self.emotionToolTip:
self.emotionToolTip.HideToolTip()
def __BindEvent(self):
for i in xrange(len(self.skillGroupButton)):
self.skillGroupButton[i].SetEvent(lambda arg=i: self.__SelectSkillGroup(arg))
self.RefreshQuest()
self.__HideJobToolTip()
for (tabKey, tabButton) in self.tabButtonDict.items():
tabButton.SetEvent(ui.__mem_func__(self.__OnClickTabButton), tabKey)
for (statusPlusKey, statusPlusButton) in self.statusPlusButtonDict.items():
statusPlusButton.SAFE_SetEvent(self.__OnClickStatusPlusButton, statusPlusKey)
statusPlusButton.ShowToolTip = lambda arg=statusPlusKey: self.__OverInStatButton(arg)
statusPlusButton.HideToolTip = lambda arg=statusPlusKey: self.__OverOutStatButton()
for (statusMinusKey, statusMinusButton) in self.statusMinusButtonDict.items():
statusMinusButton.SAFE_SetEvent(self.__OnClickStatusMinusButton, statusMinusKey)
statusMinusButton.ShowToolTip = lambda arg=statusMinusKey: self.__OverInStatMinusButton(arg)
statusMinusButton.HideToolTip = lambda arg=statusMinusKey: self.__OverOutStatMinusButton()
for titleBarValue in self.titleBarDict.itervalues():
titleBarValue.SetCloseEvent(ui.__mem_func__(self.Close))
self.questSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.__SelectQuest))
def __LoadWindow(self):
if self.isLoaded == 1:
return
self.isLoaded = 1
try:
if localeInfo.IsARABIC() or localeInfo.IsVIETNAM() or localeInfo.IsJAPAN():
self.__LoadScript(uiScriptLocale.LOCALE_UISCRIPT_PATH + "CharacterWindow.py")
else:
self.__LoadScript("UIScript/CharacterWindow.py")
self.__BindObject()
self.__BindEvent()
except:
import exception
exception.Abort("CharacterWindow.__LoadWindow")
#self.tabButtonDict["EMOTICON"].Disable()
self.SetState("STATUS")
def Destroy(self):
self.ClearDictionary()
self.__Initialize()
def Close(self):
if 0 != self.toolTipSkill:
self.toolTipSkill.Hide()
if self.chDetailsWnd and self.chDetailsWnd.IsShow():
self.chDetailsWnd.Hide()
self.Hide()
def SetSkillToolTip(self, toolTipSkill):
self.toolTipSkill = toolTipSkill
def __OnClickStatusPlusButton(self, statusKey):
try:
statusPlusCommand=self.statusPlusCommandDict[statusKey]
net.SendChatPacket(statusPlusCommand)
except KeyError, msg:
dbg.TraceError("CharacterWindow.__OnClickStatusPlusButton KeyError: %s", msg)
def __OnClickStatusMinusButton(self, statusKey):
try:
statusMinusCommand=self.statusMinusCommandDict[statusKey]
net.SendChatPacket(statusMinusCommand)
except KeyError, msg:
dbg.TraceError("CharacterWindow.__OnClickStatusMinusButton KeyError: %s", msg)
def __OnClickTabButton(self, stateKey):
self.SetState(stateKey)
def SetState(self, stateKey):
self.state = stateKey
for (tabKey, tabButton) in self.tabButtonDict.items():
if stateKey!=tabKey:
tabButton.SetUp()
for tabValue in self.tabDict.itervalues():
tabValue.Hide()
for pageValue in self.pageDict.itervalues():
pageValue.Hide()
for titleBarValue in self.titleBarDict.itervalues():
titleBarValue.Hide()
self.titleBarDict[stateKey].Show()
self.tabDict[stateKey].Show()
self.pageDict[stateKey].Show()
def GetState(self):
return self.state
def __GetTotalAtkText(self):
minAtk=player.GetStatus(player.ATT_MIN)
maxAtk=player.GetStatus(player.ATT_MAX)
atkBonus=player.GetStatus(player.ATT_BONUS)
attackerBonus=player.GetStatus(player.ATTACKER_BONUS)
if minAtk==maxAtk:
return "%d" % (minAtk+atkBonus+attackerBonus)
else:
return "%d-%d" % (minAtk+atkBonus+attackerBonus, maxAtk+atkBonus+attackerBonus)
def __GetTotalMagAtkText(self):
minMagAtk=player.GetStatus(player.MAG_ATT)+player.GetStatus(player.MIN_MAGIC_WEP)
maxMagAtk=player.GetStatus(player.MAG_ATT)+player.GetStatus(player.MAX_MAGIC_WEP)
if minMagAtk==maxMagAtk:
return "%d" % (minMagAtk)
else:
return "%d-%d" % (minMagAtk, maxMagAtk)
def __GetTotalDefText(self):
defValue=player.GetStatus(player.DEF_GRADE)
if constInfo.ADD_DEF_BONUS_ENABLE:
defValue+=player.GetStatus(player.DEF_BONUS)
return "%d" % (defValue)
def RefreshStatus(self):
if self.isLoaded==0:
return
try:
self.GetChild("Level_Value").SetText(str(player.GetStatus(player.LEVEL)))
self.GetChild("Exp_Value").SetText(str(unsigned32(player.GetEXP())))
self.GetChild("RestExp_Value").SetText(str(unsigned32(player.GetStatus(player.NEXT_EXP)) - unsigned32(player.GetStatus(player.EXP))))
self.GetChild("HP_Value").SetText(str(player.GetStatus(player.HP)) + '/' + str(player.GetStatus(player.MAX_HP)))
self.GetChild("SP_Value").SetText(str(player.GetStatus(player.SP)) + '/' + str(player.GetStatus(player.MAX_SP)))
self.GetChild("STR_Value").SetText(str(player.GetStatus(player.ST)))
self.GetChild("DEX_Value").SetText(str(player.GetStatus(player.DX)))
self.GetChild("HTH_Value").SetText(str(player.GetStatus(player.HT)))
self.GetChild("INT_Value").SetText(str(player.GetStatus(player.IQ)))
self.GetChild("ATT_Value").SetText(self.__GetTotalAtkText())
self.GetChild("DEF_Value").SetText(self.__GetTotalDefText())
self.GetChild("MATT_Value").SetText(self.__GetTotalMagAtkText())
#self.GetChild("MATT_Value").SetText(str(player.GetStatus(player.MAG_ATT)))
self.GetChild("MDEF_Value").SetText(str(player.GetStatus(player.MAG_DEF)))
self.GetChild("ASPD_Value").SetText(str(player.GetStatus(player.ATT_SPEED)))
self.GetChild("MSPD_Value").SetText(str(player.GetStatus(player.MOVING_SPEED)))
self.GetChild("CSPD_Value").SetText(str(player.GetStatus(player.CASTING_SPEED)))
self.GetChild("ER_Value").SetText(str(player.GetStatus(player.EVADE_RATE)))
except:
#import exception
#exception.Abort("CharacterWindow.RefreshStatus.BindObject")
## 게임이 튕겨 버림
pass
self.__RefreshStatusPlusButtonList()
self.__RefreshStatusMinusButtonList()
self.RefreshAlignment()
if self.refreshToolTip:
self.refreshToolTip()
if self.chDetailsWnd and self.chDetailsWnd.IsShow():
self.chDetailsWnd.RefreshLabel()
def __RefreshStatusPlusButtonList(self):
if self.isLoaded==0:
return
statusPlusPoint=player.GetStatus(player.STAT)
if statusPlusPoint>0:
self.statusPlusValue.SetText(str(statusPlusPoint))
self.statusPlusLabel.Show()
self.ShowStatusPlusButtonList()
else:
self.statusPlusValue.SetText(str(0))
self.statusPlusLabel.Hide()
self.HideStatusPlusButtonList()
def __RefreshStatusMinusButtonList(self):
if self.isLoaded==0:
return
statusMinusPoint=self.__GetStatMinusPoint()
if statusMinusPoint>0:
self.__ShowStatusMinusButtonList()
else:
self.__HideStatusMinusButtonList()
def RefreshAlignment(self):
point, grade = player.GetAlignmentData()
import colorInfo
COLOR_DICT = { 0 : colorInfo.TITLE_RGB_GOOD_4,
1 : colorInfo.TITLE_RGB_GOOD_3,
2 : colorInfo.TITLE_RGB_GOOD_2,
3 : colorInfo.TITLE_RGB_GOOD_1,
4 : colorInfo.TITLE_RGB_NORMAL,
5 : colorInfo.TITLE_RGB_EVIL_1,
6 : colorInfo.TITLE_RGB_EVIL_2,
7 : colorInfo.TITLE_RGB_EVIL_3,
8 : colorInfo.TITLE_RGB_EVIL_4, }
colorList = COLOR_DICT.get(grade, colorInfo.TITLE_RGB_NORMAL)
gradeColor = ui.GenerateColor(colorList[0], colorList[1], colorList[2])
self.toolTipAlignment.ClearToolTip()
self.toolTipAlignment.AutoAppendTextLine(localeInfo.TITLE_NAME_LIST[grade], gradeColor)
self.toolTipAlignment.AutoAppendTextLine(localeInfo.ALIGNMENT_NAME + str(point))
self.toolTipAlignment.AlignHorizonalCenter()
def __ShowStatusMinusButtonList(self):
for (stateMinusKey, statusMinusButton) in self.statusMinusButtonDict.items():
statusMinusButton.Show()
def __HideStatusMinusButtonList(self):
for (stateMinusKey, statusMinusButton) in self.statusMinusButtonDict.items():
statusMinusButton.Hide()
def ShowStatusPlusButtonList(self):
for (statePlusKey, statusPlusButton) in self.statusPlusButtonDict.items():
statusPlusButton.Show()
def HideStatusPlusButtonList(self):
for (statePlusKey, statusPlusButton) in self.statusPlusButtonDict.items():
statusPlusButton.Hide()
def SelectSkill(self, skillSlotIndex):
mouseController = mouseModule.mouseController
if FALSE == mouseController.isAttached():
srcSlotIndex = self.__RealSkillSlotToSourceSlot(skillSlotIndex)
selectedSkillIndex = player.GetSkillIndex(srcSlotIndex)
if skill.CanUseSkill(selectedSkillIndex):
if app.IsPressed(app.DIK_LCONTROL):
player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_SKILL, srcSlotIndex)
return
mouseController.AttachObject(self, player.SLOT_TYPE_SKILL, srcSlotIndex, selectedSkillIndex)
else:
mouseController.DeattachObject()
def SelectEmptySlot(self, SlotIndex):
mouseModule.mouseController.DeattachObject()
## ToolTip
def OverInItem(self, slotNumber):
if mouseModule.mouseController.isAttached():
return
if 0 == self.toolTipSkill:
return
srcSlotIndex = self.__RealSkillSlotToSourceSlot(slotNumber)
skillIndex = player.GetSkillIndex(srcSlotIndex)
skillLevel = player.GetSkillLevel(srcSlotIndex)
skillGrade = player.GetSkillGrade(srcSlotIndex)
skillType = skill.GetSkillType(skillIndex)
## ACTIVE
if skill.SKILL_TYPE_ACTIVE == skillType:
overInSkillGrade = self.__GetSkillGradeFromSlot(slotNumber)
if overInSkillGrade == skill.SKILL_GRADE_COUNT-1 and skillGrade == skill.SKILL_GRADE_COUNT:
self.toolTipSkill.SetSkillNew(srcSlotIndex, skillIndex, skillGrade, skillLevel)
elif overInSkillGrade == skillGrade:
self.toolTipSkill.SetSkillNew(srcSlotIndex, skillIndex, overInSkillGrade, skillLevel)
else:
self.toolTipSkill.SetSkillOnlyName(srcSlotIndex, skillIndex, overInSkillGrade)
else:
self.toolTipSkill.SetSkillNew(srcSlotIndex, skillIndex, skillGrade, skillLevel)
def OverOutItem(self):
if 0 != self.toolTipSkill:
self.toolTipSkill.HideToolTip()
## Quest
def __SelectQuest(self, slotIndex):
questIndex = quest.GetQuestIndex(self.questShowingStartIndex+slotIndex)
import event
event.QuestButtonClick(-2147483648 + questIndex)
def RefreshQuest(self):
if self.isLoaded==0:
return
questCount = quest.GetQuestCount()
questRange = range(quest.QUEST_MAX_NUM)
if questCount > quest.QUEST_MAX_NUM:
self.questScrollBar.Show()
else:
self.questScrollBar.Hide()
for i in questRange[:questCount]:
(questName, questIcon, questCounterName, questCounterValue) = quest.GetQuestData(self.questShowingStartIndex+i)
self.questNameList[i].SetText(questName)
self.questNameList[i].Show()
self.questLastCountList[i].Show()
self.questLastTimeList[i].Show()
if len(questCounterName) > 0:
self.questLastCountList[i].SetText("%s : %d" % (questCounterName, questCounterValue))
else:
self.questLastCountList[i].SetText("")
## Icon
self.questSlot.SetSlot(i, i, 1, 1, questIcon)
for i in questRange[questCount:]:
self.questNameList[i].Hide()
self.questLastTimeList[i].Hide()
self.questLastCountList[i].Hide()
self.questSlot.ClearSlot(i)
self.questSlot.HideSlotBaseImage(i)
self.__UpdateQuestClock()
def __UpdateQuestClock(self):
if "QUEST" == self.state:
# QUEST_LIMIT_COUNT_BUG_FIX
for i in xrange(min(quest.GetQuestCount(), quest.QUEST_MAX_NUM)):
# END_OF_QUEST_LIMIT_COUNT_BUG_FIX
(lastName, lastTime) = quest.GetQuestLastTime(i)
clockText = localeInfo.QUEST_UNLIMITED_TIME
if len(lastName) > 0:
if lastTime <= 0:
clockText = localeInfo.QUEST_TIMEOVER
else:
questLastMinute = lastTime / 60
questLastSecond = lastTime % 60
clockText = lastName + " : "
if questLastMinute > 0:
clockText += str(questLastMinute) + localeInfo.QUEST_MIN
if questLastSecond > 0:
clockText += " "
if questLastSecond > 0:
clockText += str(questLastSecond) + localeInfo.QUEST_SEC
self.questLastTimeList[i].SetText(clockText)
def __GetStatMinusPoint(self):
POINT_STAT_RESET_COUNT = 112
return player.GetStatus(POINT_STAT_RESET_COUNT)
def __OverInStatMinusButton(self, stat):
try:
self.__ShowStatToolTip(self.STAT_MINUS_DESCRIPTION[stat] % self.__GetStatMinusPoint())
except KeyError:
pass
self.refreshToolTip = lambda arg=stat: self.__OverInStatMinusButton(arg)
def __OverOutStatMinusButton(self):
self.__HideStatToolTip()
self.refreshToolTip = 0
def __OverInStatButton(self, stat):
try:
self.__ShowStatToolTip(self.STAT_DESCRIPTION[stat])
except KeyError:
pass
def __OverOutStatButton(self):
self.__HideStatToolTip()
def __ShowStatToolTip(self, statDesc):
self.toolTip.ClearToolTip()
self.toolTip.AppendTextLine(statDesc)
self.toolTip.Show()
def __HideStatToolTip(self):
self.toolTip.Hide()
def OnPressEscapeKey(self):
self.Close()
return TRUE
def OnUpdate(self):
self.__UpdateQuestClock()
## Skill Process
def __RefreshSkillPage(self, name, slotCount):
global SHOW_LIMIT_SUPPORT_SKILL_LIST
skillPage = self.skillPageDict[name]
startSlotIndex = skillPage.GetStartIndex()
if "ACTIVE" == name:
if self.PAGE_HORSE == self.curSelectedSkillGroup:
startSlotIndex += slotCount
getSkillType=skill.GetSkillType
getSkillIndex=player.GetSkillIndex
getSkillGrade=player.GetSkillGrade
getSkillLevel=player.GetSkillLevel
getSkillLevelUpPoint=skill.GetSkillLevelUpPoint
getSkillMaxLevel=skill.GetSkillMaxLevel
for i in xrange(slotCount+1):
slotIndex = i + startSlotIndex
skillIndex = getSkillIndex(slotIndex)
for j in xrange(skill.SKILL_GRADE_COUNT):
skillPage.ClearSlot(self.__GetRealSkillSlot(j, i))
if 0 == skillIndex:
continue
skillGrade = getSkillGrade(slotIndex)
skillLevel = getSkillLevel(slotIndex)
skillType = getSkillType(skillIndex)
## 승마 스킬 예외 처리
if player.SKILL_INDEX_RIDING == skillIndex:
if 1 == skillGrade:
skillLevel += 19
elif 2 == skillGrade:
skillLevel += 29
elif 3 == skillGrade:
skillLevel = 40
skillPage.SetSkillSlotNew(slotIndex, skillIndex, max(skillLevel-1, 0), skillLevel)
skillPage.SetSlotCount(slotIndex, skillLevel)
## ACTIVE
elif skill.SKILL_TYPE_ACTIVE == skillType:
for j in xrange(skill.SKILL_GRADE_COUNT):
realSlotIndex = self.__GetRealSkillSlot(j, slotIndex)
skillPage.SetSkillSlotNew(realSlotIndex, skillIndex, j, skillLevel)
skillPage.SetCoverButton(realSlotIndex)
if (skillGrade == skill.SKILL_GRADE_COUNT) and j == (skill.SKILL_GRADE_COUNT-1):
skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)
elif (not self.__CanUseSkillNow()) or (skillGrade != j):
skillPage.SetSlotCount(realSlotIndex, 0)
skillPage.DisableCoverButton(realSlotIndex)
else:
skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)
## 그외
else:
if not SHOW_LIMIT_SUPPORT_SKILL_LIST or skillIndex in SHOW_LIMIT_SUPPORT_SKILL_LIST:
realSlotIndex = self.__GetETCSkillRealSlotIndex(slotIndex)
skillPage.SetSkillSlot(realSlotIndex, skillIndex, skillLevel)
skillPage.SetSlotCountNew(realSlotIndex, skillGrade, skillLevel)
if skill.CanUseSkill(skillIndex):
skillPage.SetCoverButton(realSlotIndex)
skillPage.RefreshSlot()
def RefreshSkill(self):
if self.isLoaded==0:
return
if self.__IsChangedHorseRidingSkillLevel():
self.RefreshCharacter()
return
global SHOW_ONLY_ACTIVE_SKILL
if SHOW_ONLY_ACTIVE_SKILL:
self.__RefreshSkillPage("ACTIVE", self.ACTIVE_PAGE_SLOT_COUNT)
else:
self.__RefreshSkillPage("ACTIVE", self.ACTIVE_PAGE_SLOT_COUNT)
self.__RefreshSkillPage("SUPPORT", self.SUPPORT_PAGE_SLOT_COUNT)
self.RefreshSkillPlusButtonList()
def CanShowPlusButton(self, skillIndex, skillLevel, curStatPoint):
## 스킬이 있으면
if 0 == skillIndex:
return FALSE
## 레벨업 조건을 만족한다면
if not skill.CanLevelUpSkill(skillIndex, skillLevel):
return FALSE
return TRUE
def __RefreshSkillPlusButton(self, name):
global HIDE_SUPPORT_SKILL_POINT
if HIDE_SUPPORT_SKILL_POINT and "SUPPORT" == name:
return
slotWindow = self.skillPageDict[name]
slotWindow.HideAllSlotButton()
slotStatType = self.skillPageStatDict[name]
if 0 == slotStatType:
return
statPoint = player.GetStatus(slotStatType)
startSlotIndex = slotWindow.GetStartIndex()
if "HORSE" == name:
startSlotIndex += self.ACTIVE_PAGE_SLOT_COUNT
if statPoint > 0:
for i in xrange(self.PAGE_SLOT_COUNT):
slotIndex = i + startSlotIndex
skillIndex = player.GetSkillIndex(slotIndex)
skillGrade = player.GetSkillGrade(slotIndex)
skillLevel = player.GetSkillLevel(slotIndex)
if skillIndex == 0:
continue
if skillGrade != 0:
continue
if name == "HORSE":
if player.GetStatus(player.LEVEL) >= skill.GetSkillLevelLimit(skillIndex):
if skillLevel < 20:
slotWindow.ShowSlotButton(self.__GetETCSkillRealSlotIndex(slotIndex))
else:
if "SUPPORT" == name:
if not SHOW_LIMIT_SUPPORT_SKILL_LIST or skillIndex in SHOW_LIMIT_SUPPORT_SKILL_LIST:
if self.CanShowPlusButton(skillIndex, skillLevel, statPoint):
slotWindow.ShowSlotButton(slotIndex)
else:
if self.CanShowPlusButton(skillIndex, skillLevel, statPoint):
slotWindow.ShowSlotButton(slotIndex)
def RefreshSkillPlusButtonList(self):
if self.isLoaded==0:
return
self.RefreshSkillPlusPointLabel()
if not self.__CanUseSkillNow():
return
try:
if self.PAGE_HORSE == self.curSelectedSkillGroup:
self.__RefreshSkillPlusButton("HORSE")
else:
self.__RefreshSkillPlusButton("ACTIVE")
self.__RefreshSkillPlusButton("SUPPORT")
except:
import exception
exception.Abort("CharacterWindow.RefreshSkillPlusButtonList.BindObject")
def RefreshSkillPlusPointLabel(self):
if self.isLoaded==0:
return
if self.PAGE_HORSE == self.curSelectedSkillGroup:
activeStatPoint = player.GetStatus(player.SKILL_HORSE)
self.activeSkillPointValue.SetText(str(activeStatPoint))
else:
activeStatPoint = player.GetStatus(player.SKILL_ACTIVE)
self.activeSkillPointValue.SetText(str(activeStatPoint))
supportStatPoint = max(0, player.GetStatus(player.SKILL_SUPPORT))
self.supportSkillPointValue.SetText(str(supportStatPoint))
## Skill Level Up Button
def OnPressedSlotButton(self, slotNumber):
srcSlotIndex = self.__RealSkillSlotToSourceSlot(slotNumber)
skillIndex = player.GetSkillIndex(srcSlotIndex)
curLevel = player.GetSkillLevel(srcSlotIndex)
maxLevel = skill.GetSkillMaxLevel(skillIndex)
net.SendChatPacket("/skillup " + str(skillIndex))
## Use Skill
def ClickSkillSlot(self, slotIndex):
srcSlotIndex = self.__RealSkillSlotToSourceSlot(slotIndex)
skillIndex = player.GetSkillIndex(srcSlotIndex)
skillType = skill.GetSkillType(skillIndex)
if not self.__CanUseSkillNow():
if skill.SKILL_TYPE_ACTIVE == skillType:
return
for slotWindow in self.skillPageDict.values():
if slotWindow.HasSlot(slotIndex):
if skill.CanUseSkill(skillIndex):
player.ClickSkillSlot(srcSlotIndex)
return
mouseModule.mouseController.DeattachObject()
## FIXME : 스킬을 사용했을때 슬롯 번호를 가지고 해당 슬롯을 찾아서 업데이트 한다.
## 매우 불합리. 구조 자체를 개선해야 할듯.
def OnUseSkill(self, slotIndex, coolTime):
skillIndex = player.GetSkillIndex(slotIndex)
skillType = skill.GetSkillType(skillIndex)
## ACTIVE
if skill.SKILL_TYPE_ACTIVE == skillType:
skillGrade = player.GetSkillGrade(slotIndex)
slotIndex = self.__GetRealSkillSlot(skillGrade, slotIndex)
## ETC
else:
slotIndex = self.__GetETCSkillRealSlotIndex(slotIndex)
for slotWindow in self.skillPageDict.values():
if slotWindow.HasSlot(slotIndex):
slotWindow.SetSlotCoolTime(slotIndex, coolTime)
return
def OnActivateSkill(self, slotIndex):
skillGrade = player.GetSkillGrade(slotIndex)
slotIndex = self.__GetRealSkillSlot(skillGrade, slotIndex)
for slotWindow in self.skillPageDict.values():
if slotWindow.HasSlot(slotIndex):
slotWindow.ActivateSlot(slotIndex)
return
def OnDeactivateSkill(self, slotIndex):
skillGrade = player.GetSkillGrade(slotIndex)
slotIndex = self.__GetRealSkillSlot(skillGrade, slotIndex)
for slotWindow in self.skillPageDict.values():
if slotWindow.HasSlot(slotIndex):
slotWindow.DeactivateSlot(slotIndex)
return
def __ShowJobToolTip(self):
self.toolTipJob.ShowToolTip()
def __HideJobToolTip(self):
self.toolTipJob.HideToolTip()
def __SetJobText(self, mainJob, subJob):
if player.GetStatus(player.LEVEL)<5:
subJob=0
if 949 == app.GetDefaultCodePage():
self.toolTipJob.ClearToolTip()
try:
jobInfoTitle=localeInfo.JOBINFO_TITLE[mainJob][subJob]
jobInfoData=localeInfo.JOBINFO_DATA_LIST[mainJob][subJob]
except IndexError:
print "uiCharacter.CharacterWindow.__SetJobText(mainJob=%d, subJob=%d)" % (mainJob, subJob)
return
self.toolTipJob.AutoAppendTextLine(jobInfoTitle)
self.toolTipJob.AppendSpace(5)
for jobInfoDataLine in jobInfoData:
self.toolTipJob.AutoAppendTextLine(jobInfoDataLine)
self.toolTipJob.AlignHorizonalCenter()
def __ShowAlignmentToolTip(self):
self.toolTipAlignment.ShowToolTip()
def __HideAlignmentToolTip(self):
self.toolTipAlignment.HideToolTip()
def RefreshCharacter(self):
if self.isLoaded==0:
return
## Name
try:
characterName = player.GetName()
guildName = player.GetGuildName()
self.characterNameValue.SetText(characterName)
self.guildNameValue.SetText(guildName)
if not guildName:
if localeInfo.IsARABIC():
self.characterNameSlot.SetPosition(190, 34)
else:
self.characterNameSlot.SetPosition(109, 34)
self.guildNameSlot.Hide()
else:
if localeInfo.IsJAPAN():
self.characterNameSlot.SetPosition(143, 34)
else:
self.characterNameSlot.SetPosition(153, 34)
self.guildNameSlot.Show()
except:
import exception
exception.Abort("CharacterWindow.RefreshCharacter.BindObject")
race = net.GetMainActorRace()
group = net.GetMainActorSkillGroup()
empire = net.GetMainActorEmpire()
## Job Text
job = chr.RaceToJob(race)
self.__SetJobText(job, group)
## FaceImage
try:
faceImageName = FACE_IMAGE_DICT[race]
try:
self.faceImage.LoadImage(faceImageName)
except:
print "CharacterWindow.RefreshCharacter(race=%d, faceImageName=%s)" % (race, faceImageName)
self.faceImage.Hide()
except KeyError:
self.faceImage.Hide()
## GroupName
self.__SetSkillGroupName(race, group)
## Skill
if 0 == group:
self.__SelectSkillGroup(0)
else:
self.__SetSkillSlotData(race, group, empire)
if self.__CanUseHorseSkill():
self.__SelectSkillGroup(0)
def __SetSkillGroupName(self, race, group):
job = chr.RaceToJob(race)
if not self.SKILL_GROUP_NAME_DICT.has_key(job):
return
nameList = self.SKILL_GROUP_NAME_DICT[job]
if 0 == group:
self.skillGroupButton1.SetText(nameList[1])
self.skillGroupButton2.SetText(nameList[2])
self.skillGroupButton1.Show()
self.skillGroupButton2.Show()
self.activeSkillGroupName.Hide()
else:
if self.__CanUseHorseSkill():
self.activeSkillGroupName.Hide()
self.skillGroupButton1.SetText(nameList.get(group, "Noname"))
self.skillGroupButton2.SetText(localeInfo.SKILL_GROUP_HORSE)
self.skillGroupButton1.Show()
self.skillGroupButton2.Show()
else:
self.activeSkillGroupName.SetText(nameList.get(group, "Noname"))
self.activeSkillGroupName.Show()
self.skillGroupButton1.Hide()
self.skillGroupButton2.Hide()
def __SetSkillSlotData(self, race, group, empire=0):
## SkillIndex
playerSettingModule.RegisterSkill(race, group, empire)
## Event
self.__SetSkillSlotEvent()
## Refresh
self.RefreshSkill()
def __SelectSkillGroup(self, index):
for btn in self.skillGroupButton:
btn.SetUp()
self.skillGroupButton[index].Down()
if self.__CanUseHorseSkill():
if 0 == index:
index = net.GetMainActorSkillGroup()-1
elif 1 == index:
index = self.PAGE_HORSE
self.curSelectedSkillGroup = index
self.__SetSkillSlotData(net.GetMainActorRace(), index+1, net.GetMainActorEmpire())
def __CanUseSkillNow(self):
if 0 == net.GetMainActorSkillGroup():
return FALSE
return TRUE
def __CanUseHorseSkill(self):
slotIndex = player.GetSkillSlotIndex(player.SKILL_INDEX_RIDING)
if not slotIndex:
return FALSE
grade = player.GetSkillGrade(slotIndex)
level = player.GetSkillLevel(slotIndex)
if level < 0:
level *= -1
if grade >= 1 and level >= 1:
return TRUE
return FALSE
def __IsChangedHorseRidingSkillLevel(self):
ret = FALSE
if -1 == self.canUseHorseSkill:
self.canUseHorseSkill = self.__CanUseHorseSkill()
if self.canUseHorseSkill != self.__CanUseHorseSkill():
ret = TRUE
self.canUseHorseSkill = self.__CanUseHorseSkill()
return ret
def __GetRealSkillSlot(self, skillGrade, skillSlot):
return skillSlot + min(skill.SKILL_GRADE_COUNT-1, skillGrade)*skill.SKILL_GRADE_STEP_COUNT
def __GetETCSkillRealSlotIndex(self, skillSlot):
if skillSlot > 100:
return skillSlot
return skillSlot % self.ACTIVE_PAGE_SLOT_COUNT
def __RealSkillSlotToSourceSlot(self, realSkillSlot):
if realSkillSlot > 100:
return realSkillSlot
if self.PAGE_HORSE == self.curSelectedSkillGroup:
return realSkillSlot + self.ACTIVE_PAGE_SLOT_COUNT
return realSkillSlot % skill.SKILL_GRADE_STEP_COUNT
def __GetSkillGradeFromSlot(self, skillSlot):
return int(skillSlot / skill.SKILL_GRADE_STEP_COUNT)
def SelectSkillGroup(self, index):
self.__SelectSkillGroup(index)
def OnQuestScroll(self):
questCount = quest.GetQuestCount()
scrollLineCount = max(0, questCount - quest.QUEST_MAX_NUM)
startIndex = int(scrollLineCount * self.questScrollBar.GetPos())
if startIndex != self.questShowingStartIndex:
self.questShowingStartIndex = startIndex
self.RefreshQuest()

Alles anzeigen

uicharacterdetails.py:

Python

import ui
import localeInfo
import player
import item
import uiToolTip
import wndMgr
import app
class CharacterDetailsUI(ui.ScriptWindow):
def __init__(self, parent):
self.uiCharacterStatus = parent
ui.ScriptWindow.__init__(self)
self.toolTip = uiToolTip.ToolTip()
self.__LoadScript()
def __del__(self):
self.uiCharacterStatus = None
self.toolTip = None
ui.ScriptWindow.__del__(self)
def __LoadScript(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/CharacterDetailsWindow.py")
except:
import exception
exception.Abort("CharacterDetailsUI.__LoadScript")
self.Width = 253 - 3
self.GetChild("TitleBar").CloseButtonHide()
self.ScrollBar = self.GetChild("ScrollBar")
self.ScrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
self.UI_MAX_COUNT = 13
self.UI_MAX_VIEW_COUNT = 6
self.INFO_TEXT = 0
self.INFO_TOOLTIP = 1
self.INFO_VALUE = 2
self.CATEGORY_STARTLINE = -1
self.CATEGORY_ENDLINE = -2
self.labelList = []
self.labelValueList = []
self.labelTextList = []
self.horizonBarList = []
self.horizonBarNameList = []
for i in xrange(self.UI_MAX_COUNT):
self.labelList.append( self.GetChild("label%s"%i) )
self.labelValueList.append( self.GetChild("labelvalue%s"%i) )
self.labelTextList.append( self.GetChild("labelname%s"%i) )
self.horizonBarList.append( self.GetChild("horizontalbar%s"%i) )
self.horizonBarNameList.append( self.GetChild("horizontalbarName%s"%i) )
for i in xrange(self.UI_MAX_COUNT):
self.labelTextList[i].SetOverEvent( ui.__mem_func__(self.__ButtonOverIn), i )
self.labelTextList[i].SetOverOutEvent( ui.__mem_func__(self.__ButtonOverOut), i )
self.__Initialize()
def __Initialize(self):
self.InfoList = []
self.InfoList.append( [ localeInfo.DETAILS_CATE_1, "", self.CATEGORY_STARTLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_1, localeInfo.DETAILS_TOOLTIP_1, item.GetApplyPoint( item.APPLY_ATTBONUS_HUMAN ) ] )
self.InfoList.append( [ localeInfo.DETAILS_3, localeInfo.DETAILS_TOOLTIP_3, item.GetApplyPoint( item.APPLY_ATTBONUS_ORC ) ] )
self.InfoList.append( [ localeInfo.DETAILS_4, localeInfo.DETAILS_TOOLTIP_4, item.GetApplyPoint( item.APPLY_ATTBONUS_UNDEAD ) ] )
self.InfoList.append( [ localeInfo.DETAILS_5, localeInfo.DETAILS_TOOLTIP_5, item.GetApplyPoint( item.APPLY_ATTBONUS_MONSTER ) ] )
self.InfoList.append( [ localeInfo.DETAILS_7, localeInfo.DETAILS_TOOLTIP_7, item.GetApplyPoint( item.APPLY_ATTBONUS_ANIMAL ) ] )
self.InfoList.append( [ localeInfo.DETAILS_8, localeInfo.DETAILS_TOOLTIP_8, item.GetApplyPoint( item.APPLY_ATTBONUS_MILGYO ) ] )
self.InfoList.append( [ localeInfo.DETAILS_9, localeInfo.DETAILS_TOOLTIP_9, item.GetApplyPoint( item.APPLY_ATTBONUS_DEVIL ) ] )
self.InfoList.append( [ localeInfo.DETAILS_12, localeInfo.DETAILS_TOOLTIP_12, item.GetApplyPoint( item.APPLY_ATT_GRADE_BONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_13, localeInfo.DETAILS_TOOLTIP_13, item.GetApplyPoint( item.APPLY_DEF_GRADE_BONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_14, localeInfo.DETAILS_TOOLTIP_14, item.GetApplyPoint( item.APPLY_NORMAL_HIT_DAMAGE_BONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_15, localeInfo.DETAILS_TOOLTIP_15, item.GetApplyPoint( item.APPLY_NORMAL_HIT_DEFEND_BONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_16, localeInfo.DETAILS_TOOLTIP_16, item.GetApplyPoint( item.APPLY_SKILL_DAMAGE_BONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_17, localeInfo.DETAILS_TOOLTIP_17, item.GetApplyPoint( item.APPLY_SKILL_DEFEND_BONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_18, localeInfo.DETAILS_TOOLTIP_18, item.GetApplyPoint( item.APPLY_MELEE_MAGIC_ATTBONUS_PER ) ] )
self.InfoList.append( [ localeInfo.DETAILS_19, localeInfo.DETAILS_TOOLTIP_19, item.GetApplyPoint( item.APPLY_MAGIC_ATTBONUS_PER ) ] )
self.InfoList.append( [ localeInfo.DETAILS_20, localeInfo.DETAILS_TOOLTIP_20, item.GetApplyPoint( item.APPLY_CRITICAL_PCT ) ] )
self.InfoList.append( [ localeInfo.DETAILS_21, localeInfo.DETAILS_TOOLTIP_21, item.GetApplyPoint( item.APPLY_PENETRATE_PCT ) ] )
self.InfoList.append( [ localeInfo.DETAILS_22, localeInfo.DETAILS_TOOLTIP_22, item.GetApplyPoint( item.APPLY_ANTI_CRITICAL_PCT ) ] )
self.InfoList.append( [ localeInfo.DETAILS_23, localeInfo.DETAILS_TOOLTIP_23, item.GetApplyPoint( item.APPLY_ANTI_PENETRATE_PCT ) ] )
self.InfoList.append( [ "", "", self.CATEGORY_ENDLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_CATE_2, "", self.CATEGORY_STARTLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_76, localeInfo.DETAILS_TOOLTIP_76, item.GetApplyPoint( item.APPLY_RESIST_MAGIC ) ] )
self.InfoList.append( [ localeInfo.DETAILS_24, localeInfo.DETAILS_TOOLTIP_24, item.GetApplyPoint( item.APPLY_RESIST_ELEC ) ] )
self.InfoList.append( [ localeInfo.DETAILS_25, localeInfo.DETAILS_TOOLTIP_25, item.GetApplyPoint( item.APPLY_RESIST_ICE ) ] )
self.InfoList.append( [ localeInfo.DETAILS_26, localeInfo.DETAILS_TOOLTIP_26, item.GetApplyPoint( item.APPLY_RESIST_DARK ) ] )
self.InfoList.append( [ localeInfo.DETAILS_27, localeInfo.DETAILS_TOOLTIP_27, item.GetApplyPoint( item.APPLY_RESIST_FIRE ) ] )
self.InfoList.append( [ localeInfo.DETAILS_28, localeInfo.DETAILS_TOOLTIP_28, item.GetApplyPoint( item.APPLY_RESIST_WIND ) ] )
self.InfoList.append( [ localeInfo.DETAILS_29, localeInfo.DETAILS_TOOLTIP_29, item.GetApplyPoint( item.APPLY_RESIST_EARTH ) ] )
#self.InfoList.append( [ localeInfo.DETAILS_77, localeInfo.DETAILS_TOOLTIP_77, item.GetApplyPoint( item.APPLY_RESIST_MAGIC_REDUCTION ) ] )
self.InfoList.append( [ "", "", self.CATEGORY_ENDLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_CATE_3, "", self.CATEGORY_STARTLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_36, localeInfo.DETAILS_TOOLTIP_36, item.GetApplyPoint( item.APPLY_ATTBONUS_WARRIOR ) ] )
self.InfoList.append( [ localeInfo.DETAILS_37, localeInfo.DETAILS_TOOLTIP_37, item.GetApplyPoint( item.APPLY_ATTBONUS_ASSASSIN ) ] )
self.InfoList.append( [ localeInfo.DETAILS_38, localeInfo.DETAILS_TOOLTIP_38, item.GetApplyPoint( item.APPLY_ATTBONUS_SURA ) ] )
self.InfoList.append( [ localeInfo.DETAILS_39, localeInfo.DETAILS_TOOLTIP_39, item.GetApplyPoint( item.APPLY_ATTBONUS_SHAMAN ) ] )
#self.InfoList.append( [ localeInfo.DETAILS_40, localeInfo.DETAILS_TOOLTIP_40, item.GetApplyPoint( item.APPLY_ATTBONUS_WOLFMAN ) ] )
self.InfoList.append( [ localeInfo.DETAILS_41, localeInfo.DETAILS_TOOLTIP_41, item.GetApplyPoint( item.APPLY_RESIST_WARRIOR ) ] )
self.InfoList.append( [ localeInfo.DETAILS_42, localeInfo.DETAILS_TOOLTIP_42, item.GetApplyPoint( item.APPLY_RESIST_ASSASSIN ) ] )
self.InfoList.append( [ localeInfo.DETAILS_43, localeInfo.DETAILS_TOOLTIP_43, item.GetApplyPoint( item.APPLY_RESIST_SURA ) ] )
self.InfoList.append( [ localeInfo.DETAILS_44, localeInfo.DETAILS_TOOLTIP_44, item.GetApplyPoint( item.APPLY_RESIST_SHAMAN ) ] )
#self.InfoList.append( [ localeInfo.DETAILS_45, localeInfo.DETAILS_TOOLTIP_45, item.GetApplyPoint( item.APPLY_RESIST_WOLFMAN ) ] )
self.InfoList.append( [ "", "", self.CATEGORY_ENDLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_CATE_4, "", self.CATEGORY_STARTLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_46, localeInfo.DETAILS_TOOLTIP_46, item.GetApplyPoint( item.APPLY_RESIST_SWORD ) ] )
self.InfoList.append( [ localeInfo.DETAILS_47, localeInfo.DETAILS_TOOLTIP_47, item.GetApplyPoint( item.APPLY_RESIST_TWOHAND ) ] )
self.InfoList.append( [ localeInfo.DETAILS_48, localeInfo.DETAILS_TOOLTIP_48, item.GetApplyPoint( item.APPLY_RESIST_DAGGER ) ] )
#self.InfoList.append( [ localeInfo.DETAILS_49, localeInfo.DETAILS_TOOLTIP_49, item.GetApplyPoint( item.APPLY_RESIST_CLAW ) ] )
self.InfoList.append( [ localeInfo.DETAILS_50, localeInfo.DETAILS_TOOLTIP_50, item.GetApplyPoint( item.APPLY_RESIST_BELL ) ] )
self.InfoList.append( [ localeInfo.DETAILS_51, localeInfo.DETAILS_TOOLTIP_51, item.GetApplyPoint( item.APPLY_RESIST_FAN ) ] )
self.InfoList.append( [ localeInfo.DETAILS_52, localeInfo.DETAILS_TOOLTIP_52, item.GetApplyPoint( item.APPLY_RESIST_BOW ) ] )
self.InfoList.append( [ "", "", self.CATEGORY_ENDLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_CATE_5, "", self.CATEGORY_STARTLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_53, localeInfo.DETAILS_TOOLTIP_53, item.GetApplyPoint( item.APPLY_STUN_PCT ) ] )
self.InfoList.append( [ localeInfo.DETAILS_54, localeInfo.DETAILS_TOOLTIP_54, item.GetApplyPoint( item.APPLY_SLOW_PCT ) ] )
self.InfoList.append( [ localeInfo.DETAILS_55, localeInfo.DETAILS_TOOLTIP_55, item.GetApplyPoint( item.APPLY_POISON_PCT ) ] )
self.InfoList.append( [ localeInfo.DETAILS_56, localeInfo.DETAILS_TOOLTIP_56, item.GetApplyPoint( item.APPLY_POISON_REDUCE) ] )
#self.InfoList.append( [ localeInfo.DETAILS_57, localeInfo.DETAILS_TOOLTIP_57, item.GetApplyPoint( item.APPLY_BLEEDING_PCT ) ] )
#self.InfoList.append( [ localeInfo.DETAILS_58, localeInfo.DETAILS_TOOLTIP_58, item.GetApplyPoint( item.APPLY_BLEEDING_REDUCE ) ] )
self.InfoList.append( [ localeInfo.DETAILS_59, localeInfo.DETAILS_TOOLTIP_59, item.GetApplyPoint( item.APPLY_STEAL_HP ) ] )
self.InfoList.append( [ localeInfo.DETAILS_60, localeInfo.DETAILS_TOOLTIP_60, item.GetApplyPoint( item.APPLY_STEAL_SP ) ] )
self.InfoList.append( [ localeInfo.DETAILS_61, localeInfo.DETAILS_TOOLTIP_61, item.GetApplyPoint( item.APPLY_HP_REGEN ) ] )
self.InfoList.append( [ localeInfo.DETAILS_62, localeInfo.DETAILS_TOOLTIP_62, item.GetApplyPoint( item.APPLY_SP_REGEN ) ] )
self.InfoList.append( [ localeInfo.DETAILS_63, localeInfo.DETAILS_TOOLTIP_63, item.GetApplyPoint( item.APPLY_BLOCK ) ] )
self.InfoList.append( [ localeInfo.DETAILS_64, localeInfo.DETAILS_TOOLTIP_64, item.GetApplyPoint( item.APPLY_DODGE ) ] )
self.InfoList.append( [ localeInfo.DETAILS_65, localeInfo.DETAILS_TOOLTIP_65, item.GetApplyPoint( item.APPLY_REFLECT_MELEE ) ] )
self.InfoList.append( [ localeInfo.DETAILS_66, localeInfo.DETAILS_TOOLTIP_66, item.GetApplyPoint( item.APPLY_KILL_HP_RECOVER ) ] )
self.InfoList.append( [ localeInfo.DETAILS_67, localeInfo.DETAILS_TOOLTIP_67, item.GetApplyPoint( item.APPLY_KILL_SP_RECOVER ) ] )
self.InfoList.append( [ localeInfo.DETAILS_68, localeInfo.DETAILS_TOOLTIP_68, item.GetApplyPoint( item.APPLY_EXP_DOUBLE_BONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_69, localeInfo.DETAILS_TOOLTIP_69, item.GetApplyPoint( item.APPLY_GOLD_DOUBLE_BONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_70, localeInfo.DETAILS_TOOLTIP_70, item.GetApplyPoint( item.APPLY_ITEM_DROP_BONUS ) ] )
self.InfoList.append( [ "", "", self.CATEGORY_ENDLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_CATE_6, "", self.CATEGORY_STARTLINE ] )
self.InfoList.append( [ localeInfo.DETAILS_71, localeInfo.DETAILS_TOOLTIP_71, item.GetApplyPoint( item.APPLY_MALL_ATTBONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_72, localeInfo.DETAILS_TOOLTIP_72, item.GetApplyPoint( item.APPLY_MALL_DEFBONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_73, localeInfo.DETAILS_TOOLTIP_73, item.GetApplyPoint( item.APPLY_MALL_EXPBONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_74, localeInfo.DETAILS_TOOLTIP_74, item.GetApplyPoint( item.APPLY_MALL_ITEMBONUS ) ] )
self.InfoList.append( [ localeInfo.DETAILS_75, localeInfo.DETAILS_TOOLTIP_75, item.GetApplyPoint( item.APPLY_MALL_GOLDBONUS ) ] )
#self.InfoList.append( [ "", "", self.CATEGORY_ENDLINE ] )
self.Diff = len(self.InfoList) - (self.UI_MAX_VIEW_COUNT )
stepSize = 1.0 / self.Diff
self.ScrollBar.SetScrollStep( stepSize )
self.ScollPos = 0
self.RefreshLabel()
def Show(self):
ui.ScriptWindow.Show(self)
self.SetTop()
def Close(self):
self.Hide()
def AdjustPosition(self, x, y):
self.SetPosition(x + self.Width, y)
def OnScroll(self):
self.RefreshLabel()
def RefreshLabel(self):
self.ScollPos = int(self.ScrollBar.GetPos() * self.Diff)
self.LabelLineCount = 0
self.startline_endlinecount = 0
for i in xrange(self.UI_MAX_COUNT) :
idx = i + self.ScollPos
if idx < len(self.InfoList) :
text = self.InfoList[idx][self.INFO_TEXT]
type = self.InfoList[idx][self.INFO_VALUE]
if type == self.CATEGORY_STARTLINE:
self.__LabelTitleLine(i+self.LabelLineCount, text)
self.startline_endlinecount += 1
elif type == self.CATEGORY_ENDLINE:
self.__EmptyLine(i+self.LabelLineCount)
self.startline_endlinecount += 1
else:
value = player.GetStatus(type)
self.__LabelLine(i+self.LabelLineCount, text, value)
if i+self.LabelLineCount < self.UI_MAX_COUNT:
self.labelTextList[i+self.LabelLineCount].SetOverEvent( ui.__mem_func__(self.__ButtonOverIn), self.LabelLineCount + self.startline_endlinecount )
self.labelTextList[i+self.LabelLineCount].SetOverOutEvent( ui.__mem_func__(self.__ButtonOverOut), self.LabelLineCount + self.startline_endlinecount )
self.LabelLineCount += 1
else:
self.__EmptyLine(i+self.LabelLineCount)
def __LabelTitleLine(self, idx, text):
if(idx < self.UI_MAX_COUNT):
self.labelList[idx].Hide()
self.labelTextList[idx].Hide()
self.horizonBarList[idx].Show()
self.horizonBarNameList[idx].SetText( text )
def __EmptyLine(self, idx):
if(idx < self.UI_MAX_COUNT):
self.labelList[idx].Hide()
self.labelTextList[idx].Hide()
self.horizonBarList[idx].Hide()
def __LabelLine(self, idx, text, value):
if(idx < self.UI_MAX_COUNT):
self.labelTextList[idx].Show()
self.horizonBarList[idx].Hide()
self.labelList[idx].Hide()
self.labelTextList[idx].SetText( text )
if(idx+1 < self.UI_MAX_COUNT):
self.labelList[idx+1].Show()
self.horizonBarList[idx+1].Hide()
self.labelTextList[idx+1].Hide()
self.labelValueList[idx+1].SetText( str(value) )
def __ButtonOverIn(self, i):
idx = i + self.ScollPos
tooltip = self.InfoList[idx][self.INFO_TOOLTIP]
arglen = len(str(tooltip))
pos_x, pos_y = wndMgr.GetMousePosition()
self.toolTip.ClearToolTip()
self.toolTip.SetThinBoardSize(11 * arglen)
self.toolTip.SetToolTipPosition(pos_x + 50, pos_y + 50)
self.toolTip.AppendTextLine(tooltip, 0xffffff00)
self.toolTip.Show()
def __ButtonOverOut(self, idx):
self.toolTip.Hide()
def OnTop(self):
if self.uiCharacterStatus:
self.uiCharacterStatus.SetTop()

Alles anzeigen

Vielen Dank im Voraus.

Syserr Bonus Board

Bot 23. Februar 2019

[C++ & Python] 🍪🍪🍪Cookies Coding service [Fix System´s -Interface Coding -GUI Reworks -LUA]🍪🍪🍪

Ledania2 | Middle/Newschool-Server | Offical Start 16.02.2024 [DE & EN]

Ridack SHOP 3D & MAP & EFFECT & ANIMATION (NEW WEB : WWW.RiDACK-SERVICE.NET/COM) Since 2012 !

🦁 ~ASLAN-SYSTEMS~ 🦁 | ▶ BIOLOGIST SYSTEM + RARITY SYSTEM ◀

[Suche] GM PN Hinweis

NinjEye Anti-Cheat

[HowTo | C++] ItemProto/MobProto DB/MYsql "abschaffen"

Suche Fliege Files V3 (oder cleane Anfänger Files) Link

TuoraArts.net | PREMIUM GRAPHICS | ANIMATION | TRAILER SERVICES

[PORTOFOLIO] unqdesign

Ähnliche Themen

Sidebar Antiexp / Bonusboard

Metin2 Itemshop by Shang ERROR