def __init__(self, stream):
ui.Window.__init__(self)
net.SetPhaseWindow(net.PHASE_WINDOW_SELECT, self)
self.stream = stream
##Init Value##
self.SelectSlot = M2_INIT_VALUE
self.SelectEmpire = False
self.ShowToolTip = False
self.select_job = M2_INIT_VALUE
self.select_race = M2_INIT_VALUE
self.LEN_STATPOINT = 4
self.descIndex = 0
self.statpoint = [0, 0, 0, 0]
self.curGauge = [0.0, 0.0, 0.0, 0.0]
self.Name_FontColor_Def = grp.GenerateColor(0.7215, 0.7215, 0.7215,
1.0)
self.Name_FontColor = grp.GenerateColor(197.0 / 255.0, 134.0 / 255.0,
101.0 / 255.0, 1.0)
self.Level_FontColor = grp.GenerateColor(250.0 / 255.0, 211.0 / 255.0,
136.0 / 255.0, 1.0)
self.Not_SelectMotion = False
self.MotionStart = False
self.MotionTime = 0.0
self.RealSlot = []
self.Disable = False
def __OverInMaterialSlot(self, trash, resultIndex, col):
self.tooltipItem.ClearToolTip()
self.tooltipItem.SetCannotUseItemForceSetDisableColor(FALSE)
resultIndex = resultIndex + self.firstSlotIndex
if resultIndex not in self.cubeMaterialInfos:
return
i = 0
materialInfo = self.cubeMaterialInfos[resultIndex]
materialCount = len(materialInfo[col])
for itemVnum, count in materialInfo[col]:
item.SelectItem(itemVnum)
if player.GetItemCountByVnum(itemVnum) >= count:
self.tooltipItem.AppendTextLine(
"%s" % (item.GetItemName()),
grp.GenerateColor(0.5411, 0.7254, 0.5568,
1.0)).SetFeather()
else:
self.tooltipItem.AppendTextLine(
"%s" % (item.GetItemName()),
grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)).SetFeather()
if i < materialCount - 1:
self.tooltipItem.AppendTextLine(
uiScriptLocale.CUBE_REQUIRE_MATERIAL_OR)
i = i + 1
self.tooltipItem.Show()
def OnUpdateHex(self, loadPreset=False, hexCode=""):
if loadPreset == True:
text = hexCode
else:
ui.EditLine.OnIMEUpdate(self.bg2CustomColorEditLine)
text = self.bg2CustomColorEditLine.GetText()
if len(text):
self.bg2CustomColorEditLine.SetText(str(text))
self.bgColorPickerDotImg.Hide()
strLen = len(str(text))
if strLen >= HEX_CODE_LENGTH - 1:
if text.find("#") == -1:
self.bg2CustomColorEditLine.SetText("")
self.bg2CustomColorEditLine.SetText("#" + str(text) + "")
color = str(self.bg2CustomColorEditLine.GetText()).split("#")
rgbColor = self.HexToRGB(str(color[1]))
if rgbColor[0] <= 20 and rgbColor[1] <= 20 and rgbColor[2] <= 20:
rgbColorNew = list(rgbColor)
rgbColorNew[0] = 0
rgbColorNew[1] = 0
rgbColorNew[2] = 0
rgbColor = tuple(rgbColorNew)
self.selectedColor = False
else:
self.selectedColor = True
r, g, b = (float(rgbColor[0]) / 255, float(rgbColor[1]) / 255,
float(rgbColor[2]) / 255)
self.genColor = (r, g, b)
if self.bgColorBar:
self.bgColorBar.SetColor(grp.GenerateColor(r, g, b, 1.0))
if self.bg2ColorPresetSaveButton:
self.bg2ColorPresetSaveButton.Enable()
self.bg2ColorPresetSaveButton.SetUp()
tmpR, tmpG, tmpB = (float(rgbColor[0]), float(rgbColor[1]),
float(rgbColor[2]))
self.skillColors[self.selectedColorTab] = grp.GenerateColor(
tmpR / 255, tmpG / 255, tmpB / 255, 0.0) # i think?
self.currentSkillColor[self.selectedColorTab] = grp.GenerateColor(
tmpR / 255, tmpG / 255, tmpB / 255, 0.0) # i think?
self.tmpGenColor = (tmpR, tmpG, tmpB)
else:
if self.bg2ColorPresetSaveButton:
self.bg2ColorPresetSaveButton.Disable()
self.bg2ColorPresetSaveButton.Down()
self.selectedColor = False
def LoadUI(self):
self.Board = ui.BoardWithTitleBar()
self.Board.SetSize(330, 185)
# self.Board.SetPosition(wndMgr.GetScreenWidth()/2-165,wndMgr.GetScreenHeight()-wndMgr.GetScreenHeight()+100)
self.Board.SetCenterPosition()
self.Board.AddFlag("movable")
self.Board.AddFlag("float")
self.Board.SetTitleName("Fehlerbericht senden")
self.Board.SetCloseEvent(self.Manage)
self.Board.Hide()
self.ReportBG = ui.Bar()
self.ReportBG.SetParent(self.Board)
self.ReportBG.SetPosition(15,35)
self.ReportBG.SetSize(300,100)
self.ReportBG.SetColor(grp.GenerateColor(0.0, 0.0, 0.0, 0.5))
self.ReportBG.Show()
self.ReportEditLine = ui.EditLine()
self.ReportEditLine.SetParent(self.Board)
self.ReportEditLine.SetPosition(20,40)
self.ReportEditLine.SetSize(300,95)
self.ReportEditLine.bCodePage = True
self.ReportEditLine.SetLimitWidth(295)
self.ReportEditLine.SetMultiLine()
self.ReportEditLine.SetMax(240)
self.ReportEditLine.Show()
self.ReportButtonBG = ui.Bar()
self.ReportButtonBG.SetParent(self.Board)
self.ReportButtonBG.SetPosition(15,138)
self.ReportButtonBG.SetSize(300,30)
self.ReportButtonBG.SetColor(grp.GenerateColor(0.0, 0.0, 0.0, 0.5))
self.ReportButtonBG.Show()
self.SendReportButton = ui.ToolTipButton()
self.SendReportButton.SetParent(self.Board)
self.SendReportButton.SetPosition(120,142)
self.SendReportButton.SetText("")
self.SendReportButton.SetButtonWidth(90)
self.SendReportButton.AppendToolTipTextLine("Falschmeldungen oder ausnutzen dieser Funktion führt zur Accountsperre!")
self.SendReportButton.ArrangeToolTip()
self.SendReportButton.SetUpVisual("d:/ymir work/ui/public/Large_Button_01.sub")
self.SendReportButton.SetOverVisual("d:/ymir work/ui/public/Large_Button_02.sub")
self.SendReportButton.SetDownVisual("d:/ymir work/ui/public/Large_Button_03.sub")
self.SendReportButton.SetEvent(self.__SendBugReport)
self.SendReportButton.Show()
self.SendReportButtonTextLine = ui.TextLine()
self.SendReportButtonTextLine.SetParent(self.Board)
self.SendReportButtonTextLine.SetPosition(165,145)
self.SendReportButtonTextLine.SetText("Senden...")
self.SendReportButtonTextLine.SetHorizontalAlignCenter()
self.SendReportButtonTextLine.Show()
def OnClickColorPicker(self):
rgbColor = self.GetRGBColor()
if rgbColor[0] <= 20 and rgbColor[1] <= 20 and rgbColor[2] <= 20:
rgbColorNew = list(rgbColor)
rgbColorNew[0] = 0
rgbColorNew[1] = 0
rgbColorNew[2] = 0
rgbColor = tuple(rgbColorNew)
self.selectedColor = False
else:
self.selectedColor = True
r, g, b = (float(rgbColor[0]) / 255, float(rgbColor[1]) / 255,
float(rgbColor[2]) / 255)
self.genColor = (r, g, b)
if self.bgColorBar:
self.bgColorBar.SetColor(grp.GenerateColor(r, g, b, 1.0))
if self.bg2ColorPresetSaveButton:
self.bg2ColorPresetSaveButton.Enable()
self.bg2ColorPresetSaveButton.SetUp()
if self.bgColorPickerDotImg:
self.bgColorPickerDotImg.SetPosition(
self.pickerPos[0] - (self.bgColorPickerDotImg.GetWidth() / 2),
self.pickerPos[1] - (self.bgColorPickerDotImg.GetHeight() / 2))
self.bgColorPickerDotImg.Show()
colorMarker = ui.TextLine()
colorMarker.SetParent(self.bgColorPickerDotImg)
colorMarker.SetPosition(5, -15)
colorMarker.SetHorizontalAlignCenter()
r, g, b = self.GetRGBColor()
hexCode = "#{:02x}{:02x}{:02x}".format(int(r), int(g), int(b))
colorMarker.SetText("%s" % hexCode)
colorMarker.Show()
self.colorMarker = colorMarker
tmpR, tmpG, tmpB = (float(rgbColor[0]), float(rgbColor[1]),
float(rgbColor[2]))
self.skillColors[self.selectedColorTab] = grp.GenerateColor(
tmpR / 255, tmpG / 255, tmpB / 255, 0.0)
self.currentSkillColor[self.selectedColorTab] = grp.GenerateColor(
tmpR / 255, tmpG / 255, tmpB / 255, 0.0) # i think?
self.tmpGenColor = (tmpR, tmpG, tmpB)
if self.bg2CustomColorEditLine:
r, g, b = (self.tmpGenColor[0], self.tmpGenColor[1],
self.tmpGenColor[2])
hexCode = "#{:02x}{:02x}{:02x}".format(int(r), int(g), int(b))
self.bg2CustomColorEditLine.SetText(str(hexCode))
class ResizingButton(ui.DragButton):
BUTTON_NORMAL_COLOR = grp.GenerateColor(0.3320, 0.2929, 0.2578, 1.0)
BUTTON_OVER_COLOR = grp.GenerateColor(0.5320, 0.4929, 0.4578, 1.0)
BUTTON_LIGHT_OUTLINE_COLOR = grp.GenerateColor(0.6666, 0.6509, 0.6313,
1.0)
BUTTON_DARK_OUTLINE_COLOR = grp.GenerateColor(0.1647, 0.1450, 0.1294,
1.0)
def __init__(self):
ui.DragButton.__init__(self)
self.AddFlag("limit")
self.AddFlag("restrict_x")
def __del__(self):
ui.DragButton.__del__(self)
def PetSkillTooltipShow(self, slot):
if self.arrytooltip[slot][0] > 0:
tokens = self.linespet[self.arrytooltip[slot][0]-1][:-1].split("\t")
tokens2 = self.linespetskill[self.arrytooltip[slot][0]-1][:-1].split("\t")
self.SkillTooltip.ClearToolTip()
self.SkillTooltip.AutoAppendTextLine(tokens[1], grp.GenerateColor(0.9490, 0.9058, 0.7568, 1.0))
self.SkillTooltip.AppendDescription(tokens[4], 26)
self.SkillTooltip.AppendSpace(5)
if self.arrytooltip[slot][0] != 10 and self.arrytooltip[slot][0] != 17 and self.arrytooltip[slot][0] != 18:
self.SkillTooltip.AutoAppendTextLine(GetAffectString(int(tokens2[1]), int(tokens2[self.arrytooltip[slot][1]+1])))
elif self.arrytooltip[slot][0] == 10:
self.SkillTooltip.AutoAppendTextLine("Hp Restored:" + str(tokens2[self.arrytooltip[slot][1]+1]))
elif self.arrytooltip[slot][0] == 17:
self.SkillTooltip.AutoAppendTextLine("Immortality Time:" + checkdiv(int(tokens2[self.arrytooltip[slot][1]+1])) + "s")
self.SkillTooltip.AutoAppendTextLine("Cooldown: "+tokens[5]+"s", grp.GenerateColor(1.0, 0.7843, 0.0, 1.0))
self.SkillTooltip.AlignHorizonalCenter()
self.SkillTooltip.ShowToolTip()
def initData(self):
if self.Loaded > 0:
self.Show()
return
self.Loaded = 1
self.Background = ui.Bar()
self.Background.SetParent(self)
self.Background.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())
self.Background.SetPosition(0,0)
self.Background.SetColor(grp.GenerateColor(0.0,0.0,0.0,150.0/255.0))
self.Background.Show()
self.MainImage = ui.ImageBox()
self.MainImage.SetParent(self.Background)
self.MainImage.LoadImage("d:/ymir work/ui/main.tga")
self.MainImage.SetSize(642,600)
self.MainImage.SetCenterPosition()
self.MainImage.Show()
self.CloseButton = ui.Button()
self.CloseButton.SetParent(self)
self.CloseButton.SetPosition(wndMgr.GetScreenWidth()/2-350, wndMgr.GetScreenHeight()/2+200)
self.CloseButton.SetUpVisual("d:/ymir work/ui/close_n.tga")
self.CloseButton.SetOverVisual("d:/ymir work/ui/close_h.tga")
self.CloseButton.SetDownVisual("d:/ymir work/ui/close_a.tga")
self.CloseButton.SetEvent(ui.__mem_func__(self.Open))
self.CloseButton.Show()
self.MapName = ui.ImageBox()
self.MapName.SetParent(self)
self.MapName.SetPosition(wndMgr.GetScreenWidth()/2+300, wndMgr.GetScreenHeight()/2+200)
self.MapName.LoadImage("d:/ymir work/ui/info.tga")
self.MapName.SetSize(162,50)
self.MapName.Hide()
self.MapNameText = ui.TextLine()
self.MapNameText.SetParent(self.MapName)
self.MapNameText.SetHorizontalAlignCenter()
self.MapNameText.SetPosition(81,18)
self.MapNameText.SetText("Teleportieren")
self.MapNameText.Show()
points = [[72,82],[94,172],[52,257],[124,232],[239,204],[301,153],[70,307],[157,326],[198,282],[322,199],[365,178],[419,98],[484,120],[540,153],[539,221],[454,199],[415,237],[452,261],[447,297],[457,365],[499,377],[517,412],[435,442],[368,497],[404,545],[258,370],[201,397],[304,282],[419,361],[367,300],[520,315]]
self.data = []
for pos in xrange(len(points)):
button = ui.Button()
button.SetParent(self.MainImage)
button.SetPosition(points[pos][0],points[pos][1])
button.SetUpVisual("d:/ymir work/ui/click_n.tga")
button.SetOverVisual("d:/ymir work/ui/click_h.tga")
button.SetDownVisual("d:/ymir work/ui/click_a.tga")
button.SetEvent(ui.__mem_func__(self.WarpPosition),pos)
button.Show()
self.data.append(button)
self.Show()
def AppendItem(self, questName, questIndex):
for i in xrange(len(self.__questList)):
if self.__questList[i].text.GetText(
) == questName and self.__questList[i].questIndex == questIndex:
return
bar = ui.Bar()
bar.SetParent(self.__parentWnd)
bar.SetSize(100, 10)
bar.SetColor(grp.GenerateColor(1.0, 1.0, 1.0, 0.0))
bar.OnMouseLeftButtonDown = lambda x=len(
self.__questList), arg=questIndex: self.__SelectQuest(x, arg)
bar.Hide()
bar.btn = ui.Button()
bar.btn.SetParent(bar)
bar.btn.SetUpVisual("Other/questcategory/quest_checkbox.tga")
bar.btn.SetOverVisual("Other/questcategory/quest_checkbox.tga")
bar.btn.SetDownVisual("Other/questcategory/quest_checkbox.tga")
bar.btn.SetPosition(0, 0)
bar.btn.Show()
bar.checked = ui.ImageBox()
bar.checked.SetParent(bar.btn)
bar.checked.LoadImage("Other/questcategory/quest_checked.tga")
bar.checked.SetPosition(0, -2)
bar.checked.Hide()
bar.text = ui.TextLine()
bar.text.SetParent(bar)
bar.text.SetText(questName)
bar.text.SetPosition(15, -2)
bar.text.SetWindowHorizontalAlignLeft()
bar.text.SetHorizontalAlignLeft()
bar.text.Show()
bar.text.clock = ui.TextLine()
bar.text.clock.SetParent(bar.text)
bar.text.clock.SetText(localeInfo.QUEST_UNLIMITED_TIME)
bar.text.clock.SetPosition(5, 10)
bar.text.clock.SetWindowHorizontalAlignLeft()
bar.text.clock.SetHorizontalAlignLeft()
bar.text.clock.Show()
bar.text.counter = ui.TextLine()
bar.text.counter.SetParent(bar.text)
bar.text.counter.SetText("")
bar.text.counter.SetPosition(5, 20)
bar.text.counter.SetWindowHorizontalAlignLeft()
bar.text.counter.SetHorizontalAlignLeft()
bar.text.counter.Show()
bar.questIndex = questIndex
self.__questList[len(self.__questList)] = bar
def ChangeColor(self, x, y):
if x > 255:
x = 255
if y > 255:
y = 255
rgbColor = self.GetRGBColor()
r, g, b = (float(rgbColor[0]) / 255, float(rgbColor[1]) / 255,
float(rgbColor[2]) / 255)
self.updatesSinceColorUpdate = 0
if self.bgColorBar:
self.bgColorBar.SetColor(grp.GenerateColor(r, g, b, 1.0))
def __init__(self):
ui.Bar.__init__(self)
self.AddFlag("not_pick")
self.tipList = []
self.curPos = 0
self.dstPos = 0
self.nextScrollTime = 0
self.SetPosition(0, 150)
self.SetSize(512, 55)
self.SetColor(grp.GenerateColor(0.0, 0.0, 0.0, 0.5))
self.SetWindowHorizontalAlignCenter()
self.__CreateTextBar()
self.__LoadFrameImages()
def StringColorToInt(colorstring):
import grp
colorstring = colorstring.strip()
if len(colorstring) != 8:
raise ValueError, "input #%s is not in #AARRGGBB format" % colorstring
a, r, g, b = colorstring[:2], colorstring[2:4], colorstring[
4:6], colorstring[6:8]
a, r, g, b = [int(n, 16) for n in (a, r, g, b)]
return grp.GenerateColor(
float(r) / 255.0,
float(g) / 255.0,
float(b) / 255.0,
float(a) / 255.0)
def __init__(self):
ui.Bar.__init__(self)
self.AddFlag("not_pick")
self.tipList = []
self.curPos = 0
self.dstPos = 0
self.nextScrollTime = 0
self.width = 370
self.SetPosition(0, 70)
self.SetSize(370, 20)
self.SetColor(grp.GenerateColor(0.0, 0.0, 0.0, 0.5))
self.SetWindowHorizontalAlignCenter()
self.__CreateTextBar()
def __PreviewColorPreset(self, hexCode):
if hexCode == "":
return
color = str(hexCode).split("#")
rgbColor = self.HexToRGB(str(color[1]))
if rgbColor[0] <= 20 and rgbColor[1] <= 20 and rgbColor[2] <= 20:
rgbColorNew = list(rgbColor)
rgbColorNew[0] = 0
rgbColorNew[1] = 0
rgbColorNew[2] = 0
rgbColor = tuple(rgbColorNew)
r, g, b = (float(rgbColor[0]) / 255, float(rgbColor[1]) / 255,
float(rgbColor[2]) / 255)
self.colorPresetPreview = True
if self.bgColorBar:
self.bgColorBar.SetColor(grp.GenerateColor(r, g, b, 1.0))
def TabControl(self, parent, width, heigh, *tabv):
self.tabs = []
for arg in tabv:
tab_item = {"TAB": arg[0], "TAB_NAME": arg[1]}
self.tabs.append(tab_item)
x = -70
self.tabPageList = {}
self.tabList = {}
for tabs in self.tabs:
x += 80
Tab = ui.RadioButton()
Tab.SetParent(parent)
Tab.SetPosition(x, 30)
Tab.SetUpVisual(
"d:/ymir work/ui/game/windows/tab_button_large_01.sub")
Tab.SetOverVisual(
"d:/ymir work/ui/game/windows/tab_button_large_02.sub")
Tab.SetDownVisual(
"d:/ymir work/ui/game/windows/tab_button_large_03.sub")
Tab.SetText(tabs["TAB_NAME"])
Tab.SetEvent(lambda arg=tabs["TAB"]: self.TabEvent(arg))
Tab.SetUp()
Tab.Show()
Page = ui.Box()
Page.SetParent(parent)
Page.SetPosition(8, 50)
Page.SetSize(width - 16, heigh - 60)
Page.SetColor(grp.GenerateColor(0.0, 0.0, 0.5, 0.3))
Page.Show()
self.tabList[tabs["TAB"]] = Tab
self.tabPageList[tabs["TAB"]] = Page
if self.tabs:
self.SetState(self.tabs[0]["TAB"])
return (self.tabPageList, self.tabList)
def LoadInfoBoard(self):
self.thinBoard = ui.ThinBoard()
self.thinBoard.SetParent(self)
self.thinBoard.SetSize(300, 50)
self.thinBoard.SetPosition(wndMgr.GetScreenWidth() - (300 + 30),
wndMgr.GetScreenHeight() - (50 + 50))
self.typeBiolog = ui.TextLine()
self.typeBiolog.SetParent(self.thinBoard)
self.typeBiolog.SetPackedFontColor(
grp.GenerateColor(1.0, 0.7843, 0.0, 1.0))
self.typeBiolog.SetText((pTableTranslate(3)))
self.typeBiolog.SetPosition(0, 8)
self.typeBiolog.SetHorizontalAlignCenter()
self.typeBiolog.SetWindowHorizontalAlignCenter()
self.timeExpired = ui.TextLine()
self.timeExpired.SetParent(self.thinBoard)
self.timeExpired.SetText((pTableTranslate(4)))
self.timeExpired.SetPosition(13, 25)
self.timeClosed = WaitingDialog()
self.timeClosed.Open(10.0)
self.timeClosed.SAFE_SetTimeOverEvent(self.Close)
class ChatWindow(ui.Window):
BOARD_START_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.0)
BOARD_END_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.8)
BOARD_MIDDLE_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.5)
CHAT_OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
EDIT_LINE_HEIGHT = 25
CHAT_WINDOW_WIDTH = 625
class ChatBackBoard(ui.Window):
def __init__(self):
ui.Window.__init__(self)
def __del__(self):
ui.Window.__del__(self)
class ChatButton(ui.DragButton):
def __init__(self):
ui.DragButton.__init__(self)
self.AddFlag("float")
self.AddFlag("movable")
self.AddFlag("restrict_x")
self.topFlag = False
self.SetWindowName("ChatWindow:ChatButton")
def __del__(self):
ui.DragButton.__del__(self)
def SetOwner(self, owner):
self.owner = owner
def OnMouseOverIn(self):
app.SetCursor(app.VSIZE)
def OnMouseOverOut(self):
app.SetCursor(app.NORMAL)
def OnTop(self):
if True == self.topFlag:
return
self.topFlag = True
self.owner.SetTop()
self.topFlag = False
def __init__(self):
ui.Window.__init__(self)
self.AddFlag("float")
self.SetWindowName("ChatWindow")
self.__RegisterChatColorDict()
self.boardState = chat.BOARD_STATE_VIEW
self.chatID = chat.CreateChatSet(chat.CHAT_SET_CHAT_WINDOW)
chat.SetBoardState(self.chatID, chat.BOARD_STATE_VIEW)
self.xBar = 0
self.yBar = 0
self.widthBar = 0
self.heightBar = 0
self.curHeightBar = 0
self.visibleLineCount = 0
self.scrollBarPos = 1.0
self.scrollLock = False
chatInputSet = ChatInputSet()
chatInputSet.SetParent(self)
chatInputSet.SetEscapeEvent(ui.__mem_func__(self.CloseChat))
chatInputSet.SetReturnEvent(ui.__mem_func__(self.CloseChat))
chatInputSet.SetSize(550, 25)
self.chatInputSet = chatInputSet
btnSendWhisper = ui.Button()
btnSendWhisper.SetParent(self)
btnSendWhisper.SetUpVisual(
"d:/ymir work/ui/game/taskbar/Send_Whisper_Button_01.sub")
btnSendWhisper.SetOverVisual(
"d:/ymir work/ui/game/taskbar/Send_Whisper_Button_02.sub")
btnSendWhisper.SetDownVisual(
"d:/ymir work/ui/game/taskbar/Send_Whisper_Button_03.sub")
btnSendWhisper.SetToolTipText(localeInfo.CHAT_SEND_MEMO)
btnSendWhisper.Hide()
self.btnSendWhisper = btnSendWhisper
import uilanguagesystem
wndFilterChat = uilanguagesystem.ChatFilterWindow()
wndFilterChat.AddFlag("float")
wndFilterChat.Hide()
self.wndFilterChat = wndFilterChat
btnFilterChat = ui.Button()
btnFilterChat.SetParent(self)
btnFilterChat.SetUpVisual(
"d:/ymir work/ui/game/taskbar/ignore_button_01.sub")
btnFilterChat.SetOverVisual(
"d:/ymir work/ui/game/taskbar/ignore_button_02.sub")
btnFilterChat.SetDownVisual(
"d:/ymir work/ui/game/taskbar/ignore_button_03.sub")
btnFilterChat.SetToolTipText(localeInfo.CHAT_FILTER)
btnFilterChat.SAFE_SetEvent(self.ToggleFilterChatWindow)
btnFilterChat.Hide()
self.btnFilterChat = btnFilterChat
btnChatLog = ui.Button()
btnChatLog.SetParent(self)
btnChatLog.SetUpVisual(
"d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_01.sub")
btnChatLog.SetOverVisual(
"d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_02.sub")
btnChatLog.SetDownVisual(
"d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_03.sub")
btnChatLog.SetToolTipText(localeInfo.CHAT_LOG)
btnChatLog.Hide()
self.btnChatLog = btnChatLog
btnChatSizing = self.ChatButton()
btnChatSizing.SetOwner(self)
btnChatSizing.SetMoveEvent(ui.__mem_func__(self.Refresh))
btnChatSizing.Hide()
self.btnChatSizing = btnChatSizing
imgChatBarLeft = ui.ImageBox()
imgChatBarLeft.SetParent(self.btnChatSizing)
imgChatBarLeft.AddFlag("not_pick")
imgChatBarLeft.LoadImage("d:/ymir work/ui/pattern/chat_bar_left.tga")
imgChatBarLeft.Show()
self.imgChatBarLeft = imgChatBarLeft
imgChatBarRight = ui.ImageBox()
imgChatBarRight.SetParent(self.btnChatSizing)
imgChatBarRight.AddFlag("not_pick")
imgChatBarRight.LoadImage("d:/ymir work/ui/pattern/chat_bar_right.tga")
imgChatBarRight.Show()
self.imgChatBarRight = imgChatBarRight
imgChatBarMiddle = ui.ExpandedImageBox()
imgChatBarMiddle.SetParent(self.btnChatSizing)
imgChatBarMiddle.AddFlag("not_pick")
imgChatBarMiddle.LoadImage(
"d:/ymir work/ui/pattern/chat_bar_middle.tga")
imgChatBarMiddle.Show()
self.imgChatBarMiddle = imgChatBarMiddle
scrollBar = ui.ScrollBar()
scrollBar.AddFlag("float")
scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
self.scrollBar = scrollBar
self.Refresh()
self.chatInputSet.RefreshPosition() # RTL 시 위치를 제대로 잡으려면 위치 갱신이 필요하다
def __del__(self):
ui.Window.__del__(self)
def __RegisterChatColorDict(self):
CHAT_COLOR_DICT = {
chat.CHAT_TYPE_TALKING: colorInfo.CHAT_RGB_TALK,
chat.CHAT_TYPE_INFO: colorInfo.CHAT_RGB_INFO,
chat.CHAT_TYPE_NOTICE: colorInfo.CHAT_RGB_NOTICE,
chat.CHAT_TYPE_PARTY: colorInfo.CHAT_RGB_PARTY,
chat.CHAT_TYPE_GUILD: colorInfo.CHAT_RGB_GUILD,
chat.CHAT_TYPE_COMMAND: colorInfo.CHAT_RGB_COMMAND,
chat.CHAT_TYPE_SHOUT: colorInfo.CHAT_RGB_SHOUT,
chat.CHAT_TYPE_WHISPER: colorInfo.CHAT_RGB_WHISPER,
chat.CHAT_TYPE_DEBUG: colorInfo.CHAT_RGB_WHISPER,
}
for colorItem in CHAT_COLOR_DICT.items():
type = colorItem[0]
rgb = colorItem[1]
chat.SetChatColor(type, rgb[0], rgb[1], rgb[2])
def Destroy(self):
self.chatInputSet.Destroy()
self.chatInputSet = None
self.wndFilterChat.Destroy()
self.wndFilterChat = None
self.btnFilterChat = 0
self.btnSendWhisper = 0
self.btnChatLog = 0
self.btnChatSizing = 0
################
## Open & Close
def OpenChat(self):
self.SetSize(self.CHAT_WINDOW_WIDTH, 25)
chat.SetBoardState(self.chatID, chat.BOARD_STATE_EDIT)
self.boardState = chat.BOARD_STATE_EDIT
(x, y, width, height) = self.GetRect()
(btnX, btnY) = self.btnChatSizing.GetGlobalPosition()
if localeInfo.IsARABIC():
chat.SetPosition(self.chatID, x + width - 10, y)
else:
chat.SetPosition(self.chatID, x + 10, y)
chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT + 100)
if self.IsShow():
self.btnChatSizing.Show()
self.Refresh()
self.wndFilterChat.GetGlobalPositionByChatParent(x + width, y)
self.wndFilterChat.SetTop()
self.wndFilterChat.UpdateRect()
self.btnFilterChat.SetPosition(self.GetWidth() - 75, 2)
self.btnFilterChat.Show()
self.btnSendWhisper.SetPosition(self.GetWidth() - 50, 2)
self.btnSendWhisper.Show()
self.btnChatLog.SetPosition(self.GetWidth() - 25, 2)
self.btnChatLog.Show()
self.chatInputSet.Open()
self.chatInputSet.SetTop()
self.SetTop()
def CloseChat(self):
chat.SetBoardState(self.chatID, chat.BOARD_STATE_VIEW)
self.boardState = chat.BOARD_STATE_VIEW
(x, y, width, height) = self.GetRect()
if localeInfo.IsARABIC():
chat.SetPosition(self.chatID, x + width - 10,
y + self.EDIT_LINE_HEIGHT)
else:
chat.SetPosition(self.chatID, x + 10, y + self.EDIT_LINE_HEIGHT)
self.SetSize(self.CHAT_WINDOW_WIDTH, 0)
self.chatInputSet.Close()
self.btnSendWhisper.Hide()
self.btnChatLog.Hide()
self.btnChatSizing.Hide()
self.btnFilterChat.Hide()
self.wndFilterChat.Hide()
self.Refresh()
def ToggleFilterChatWindow(self):
if (self.wndFilterChat.IsShow()):
self.wndFilterChat.Hide()
else:
self.wndFilterChat.Show()
self.wndFilterChat.SetTop()
def SetSendWhisperEvent(self, event):
self.btnSendWhisper.SetEvent(event)
def SetOpenChatLogEvent(self, event):
self.btnChatLog.SetEvent(event)
def IsEditMode(self):
if chat.BOARD_STATE_EDIT == self.boardState:
return True
return False
def __RefreshSizingBar(self):
(x, y, width, height) = self.GetRect()
gxChat, gyChat = self.btnChatSizing.GetGlobalPosition()
self.btnChatSizing.SetPosition(x, gyChat)
self.btnChatSizing.SetSize(width, 22)
self.imgChatBarLeft.SetPosition(0, 0)
self.imgChatBarRight.SetPosition(width - 64, 0)
self.imgChatBarMiddle.SetPosition(64, 0)
self.imgChatBarMiddle.SetRenderingRect(0.0, 0.0,
float(width - 128) / 64.0 - 1.0,
0.0)
def SetPosition(self, x, y):
ui.Window.SetPosition(self, x, y)
self.__RefreshSizingBar()
def SetSize(self, width, height):
ui.Window.SetSize(self, width, height)
self.__RefreshSizingBar()
def SetHeight(self, height):
gxChat, gyChat = self.btnChatSizing.GetGlobalPosition()
self.btnChatSizing.SetPosition(gxChat,
wndMgr.GetScreenHeight() - height)
###########
## Refresh
def Refresh(self):
if self.boardState == chat.BOARD_STATE_EDIT:
self.RefreshBoardEditState()
elif self.boardState == chat.BOARD_STATE_VIEW:
self.RefreshBoardViewState()
def RefreshBoardEditState(self):
(x, y, width, height) = self.GetRect()
(btnX, btnY) = self.btnChatSizing.GetGlobalPosition()
self.xBar = x
self.yBar = btnY
self.widthBar = width
self.heightBar = y - btnY + self.EDIT_LINE_HEIGHT
self.curHeightBar = self.heightBar
if localeInfo.IsARABIC():
chat.SetPosition(self.chatID, x + width - 10, y)
else:
chat.SetPosition(self.chatID, x + 10, y)
chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT)
chat.ArrangeShowingChat(self.chatID)
if btnY > y:
self.btnChatSizing.SetPosition(btnX, y)
self.heightBar = self.EDIT_LINE_HEIGHT
def RefreshBoardViewState(self):
(x, y, width, height) = self.GetRect()
(btnX, btnY) = self.btnChatSizing.GetGlobalPosition()
textAreaHeight = self.visibleLineCount * chat.GetLineStep(self.chatID)
if localeInfo.IsARABIC():
chat.SetPosition(self.chatID, x + width - 10,
y + self.EDIT_LINE_HEIGHT)
else:
chat.SetPosition(self.chatID, x + 10, y + self.EDIT_LINE_HEIGHT)
chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT + 100)
if self.boardState == chat.BOARD_STATE_EDIT:
textAreaHeight += 45
elif self.visibleLineCount != 0:
textAreaHeight += 10 + 10
self.xBar = x
self.yBar = y + self.EDIT_LINE_HEIGHT - textAreaHeight
self.widthBar = width
self.heightBar = textAreaHeight
self.scrollBar.Hide()
##########
## Render
def OnUpdate(self):
if self.boardState == chat.BOARD_STATE_EDIT:
chat.Update(self.chatID)
elif self.boardState == chat.BOARD_STATE_VIEW:
if systemSetting.IsViewChat():
chat.Update(self.chatID)
def OnRender(self):
if chat.GetVisibleLineCount(self.chatID) != self.visibleLineCount:
self.visibleLineCount = chat.GetVisibleLineCount(self.chatID)
self.Refresh()
if self.curHeightBar != self.heightBar:
self.curHeightBar += (self.heightBar - self.curHeightBar) / 10
if self.boardState == chat.BOARD_STATE_EDIT:
grp.SetColor(self.BOARD_MIDDLE_COLOR)
grp.RenderBar(
self.xBar,
self.yBar + (self.heightBar - self.curHeightBar) + 10,
self.widthBar, self.curHeightBar)
chat.Render(self.chatID)
elif self.boardState == chat.BOARD_STATE_VIEW:
if systemSetting.IsViewChat():
grp.RenderGradationBar(
self.xBar,
self.yBar + (self.heightBar - self.curHeightBar),
self.widthBar, self.curHeightBar, self.BOARD_START_COLOR,
self.BOARD_END_COLOR)
chat.Render(self.chatID)
##########
## Event
def OnTop(self):
self.btnChatSizing.SetTop()
self.scrollBar.SetTop()
self.wndFilterChat.SetTop()
def OnScroll(self):
if not self.scrollLock:
self.scrollBarPos = self.scrollBar.GetPos()
lineCount = chat.GetLineCount(self.chatID)
visibleLineCount = chat.GetVisibleLineCount(self.chatID)
endLine = visibleLineCount + int(
float(lineCount - visibleLineCount) * self.scrollBarPos)
chat.SetEndPos(self.chatID, self.scrollBarPos)
def OnChangeChatMode(self):
self.chatInputSet.OnChangeChatMode()
def SetChatFocus(self):
self.chatInputSet.SetChatFocus()
def BindInterface(self, interface):
self.chatInputSet.BindInterface(interface)
class ChatModeButton(ui.Window):
OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
OVER_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.3)
BUTTON_STATE_UP = 0
BUTTON_STATE_OVER = 1
BUTTON_STATE_DOWN = 2
def __init__(self):
ui.Window.__init__(self)
self.state = None
self.buttonText = None
self.event = None
self.SetWindowName("ChatModeButton")
GFHhg54GHGhh45GHGH.EnableChatInsultFilter(ENABLE_INSULT_CHECK)
def __del__(self):
ui.Window.__del__(self)
def SAFE_SetEvent(self, event):
self.event = ui.__mem_func__(event)
def SetText(self, text):
if None == self.buttonText:
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetWindowHorizontalAlignCenter()
textLine.SetWindowVerticalAlignCenter()
textLine.SetVerticalAlignCenter()
textLine.SetHorizontalAlignCenter()
textLine.SetPackedFontColor(self.OUTLINE_COLOR)
textLine.Show()
self.buttonText = textLine
self.buttonText.SetText(text)
def SetSize(self, width, height):
self.width = width
self.height = height
ui.Window.SetSize(self, width, height)
def OnMouseOverIn(self):
self.state = self.BUTTON_STATE_OVER
def OnMouseOverOut(self):
self.state = self.BUTTON_STATE_UP
def OnMouseLeftButtonDown(self):
self.state = self.BUTTON_STATE_DOWN
def OnMouseLeftButtonUp(self):
self.state = self.BUTTON_STATE_UP
if self.IsIn():
self.state = self.BUTTON_STATE_OVER
if None != self.event:
self.event()
def OnRender(self):
(x, y) = self.GetGlobalPosition()
grp.SetColor(self.OUTLINE_COLOR)
grp.RenderRoundBox(x, y, self.width, self.height)
if self.state >= self.BUTTON_STATE_OVER:
grp.RenderRoundBox(x + 1, y, self.width - 2, self.height)
grp.RenderRoundBox(x, y + 1, self.width, self.height - 2)
if self.BUTTON_STATE_DOWN == self.state:
grp.SetColor(self.OVER_COLOR)
grp.RenderBar(x + 1, y + 1, self.width - 2, self.height - 2)
class ChatInputSet(ui.Window):
CHAT_OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
def __init__(self):
ui.Window.__init__(self)
self.SetWindowName("ChatInputSet")
InsertChatInputSetWindow(self)
self.__Create()
def __del__(self):
ui.Window.__del__(self)
def __Create(self):
chatModeButton = ChatModeButton()
chatModeButton.SetParent(self)
chatModeButton.SetSize(40, 17)
chatModeButton.SetText(localeInfo.CHAT_NORMAL)
chatModeButton.SetPosition(7, 2)
chatModeButton.SAFE_SetEvent(self.OnChangeChatMode)
self.chatModeButton = chatModeButton
chatLine = ChatLine()
chatLine.SetParent(self)
chatLine.SetMax(512)
chatLine.SetUserMax(76)
chatLine.SetText("")
chatLine.SAFE_SetTabEvent(self.OnChangeChatMode)
chatLine.x = 0
chatLine.y = 0
chatLine.width = 0
chatLine.height = 0
self.chatLine = chatLine
btnSend = ui.Button()
btnSend.SetParent(self)
btnSend.SetUpVisual(
"d:/ymir work/ui/game/taskbar/Send_Chat_Button_01.sub")
btnSend.SetOverVisual(
"d:/ymir work/ui/game/taskbar/Send_Chat_Button_02.sub")
btnSend.SetDownVisual(
"d:/ymir work/ui/game/taskbar/Send_Chat_Button_03.sub")
btnSend.SetToolTipText(localeInfo.CHAT_SEND_CHAT)
btnSend.SAFE_SetEvent(self.chatLine.OnIMEReturn)
self.btnSend = btnSend
def Destroy(self):
self.chatModeButton = None
self.chatLine = None
self.btnSend = None
def Open(self):
self.chatLine.Show()
self.chatLine.SetPosition(57, 5)
self.chatLine.SetFocus()
self.chatLine.OpenChat()
self.chatModeButton.SetPosition(7, 2)
self.chatModeButton.Show()
self.btnSend.Show()
self.Show()
self.RefreshPosition()
return True
def Close(self):
self.chatLine.KillFocus()
self.chatLine.Hide()
self.chatModeButton.Hide()
self.btnSend.Hide()
self.Hide()
return True
def SetEscapeEvent(self, event):
self.chatLine.SetEscapeEvent(event)
def SetReturnEvent(self, event):
self.chatLine.SetReturnEvent(event)
def OnChangeChatMode(self):
RefreshChatMode()
def OnRefreshChatMode(self):
self.chatLine.ChangeChatMode()
self.chatModeButton.SetText(self.chatLine.GetCurrentChatModeName())
def SetChatFocus(self):
self.chatLine.SetFocus()
def KillChatFocus(self):
self.chatLine.KillFocus()
def SetChatMax(self, max):
self.chatLine.SetUserMax(max)
def RefreshPosition(self):
if localeInfo.IsARABIC():
self.chatLine.SetSize(self.GetWidth() - 93, 18)
else:
self.chatLine.SetSize(self.GetWidth() - 93, 13)
self.btnSend.SetPosition(self.GetWidth() - 25, 2)
(self.chatLine.x, self.chatLine.y, self.chatLine.width,
self.chatLine.height) = self.chatLine.GetRect()
def BindInterface(self, interface):
self.chatLine.BindInterface(interface)
def OnRender(self):
(x, y, width, height) = self.chatLine.GetRect()
ui.RenderRoundBox(x - 4, y - 3, width + 7, height + 4,
self.CHAT_OUTLINE_COLOR)
def SetAlpha(self, alpha): self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight()) color = grp.GenerateColor(0.0, 0.0, 0.0, alpha) self.SetColor(color)
class ConsoleWindow(ui.Window):
BACK_GROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.5)
EDIT_LINE_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
BUTTON_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
HEIGHT = 200
LINE_STEP = 15
MAX_LINE_COUNT = 50
class ConsoleEditLine(ui.EditLine):
def __init__(self):
ui.EditLine.__init__(self)
self.eventReturn = 0
self.eventEscape = 0
def __del__(self):
ui.EditLine.__del__(self)
def SetReturnEvent(self, event):
self.eventReturn = event
def SetEscapeEvent(self, event):
self.eventEscape = event
def OnIMEReturn(self):
text = self.GetText()
if len(text) > 0:
self.eventReturn(text)
else:
wndMgr.KillFocus()
self.eventEscape()
self.SetText("")
return TRUE
def OnPressEscapeKey(self):
self.SetText("")
wndMgr.KillFocus()
self.eventEscape()
return TRUE
class ResizingButton(ui.DragButton):
BUTTON_NORMAL_COLOR = grp.GenerateColor(0.3320, 0.2929, 0.2578, 1.0)
BUTTON_OVER_COLOR = grp.GenerateColor(0.5320, 0.4929, 0.4578, 1.0)
BUTTON_LIGHT_OUTLINE_COLOR = grp.GenerateColor(0.6666, 0.6509, 0.6313,
1.0)
BUTTON_DARK_OUTLINE_COLOR = grp.GenerateColor(0.1647, 0.1450, 0.1294,
1.0)
def __init__(self):
ui.DragButton.__init__(self)
self.AddFlag("limit")
self.AddFlag("restrict_x")
def __del__(self):
ui.DragButton.__del__(self)
def __init__(self):
ui.Window.__init__(self)
self.TextList = []
self.game = 0
self.Console = Console(self)
self.ResizingButton = self.ResizingButton()
self.ResizingButton.SetParent(self)
self.ResizingButton.SetSize(15, 15)
self.ResizingButton.SetPosition(100, 100)
self.ResizingButton.Show()
self.EditLine = self.ConsoleEditLine()
self.EditLine.SetParent(self)
self.EditLine.SetMax(100)
self.EditLine.SetFontName(locale.UI_DEF_FONT)
self.EditLine.SetText("")
self.EditLine.Show()
from _weakref import ref
self.ResizingButton.SetMoveEvent(
lambda s=ref(self): s().UpdatePosition())
self.EditLine.SetReturnEvent(
lambda x, s=ref(self): s().ProcessCommand(x))
self.EditLine.SetEscapeEvent(lambda s=ref(self): s().CloseWindow())
self.UpdatePosition()
self.functionDict = {}
self.InitFunction()
def __del__(self):
ui.Window.__del__(self)
def BindGameClass(self, game):
self.Console.BindGameClass(game)
def Close(self):
self.Console.Close()
self.ResizingButton = 0
self.EditLine = 0
def SetConsoleSize(self, width, height):
self.ResizingButton.SetPosition(width - 20, height - 20)
self.UpdatePosition()
def OnRender(self):
grp.SetColor(self.BACK_GROUND_COLOR)
grp.RenderBar(self.gx, self.gy, self.width, self.height)
grp.SetColor(ConsoleWindow.EDIT_LINE_COLOR)
grp.RenderBar(self.gxEditLine - 2, self.gyEditLine - 3,
self.width - 40, 17)
grp.SetColor(ConsoleWindow.BUTTON_COLOR)
grp.RenderBar(self.gxButton - 2, self.gyButton - 3, self.widthButton,
self.heightButton)
def UpdatePosition(self):
self.width = self.GetWidth()
self.height = self.GetHeight()
self.widthButton = self.ResizingButton.GetWidth()
self.heightButton = self.ResizingButton.GetHeight()
(self.gx, self.gy) = self.GetGlobalPosition()
(self.gxButton,
self.gyButton) = self.ResizingButton.GetGlobalPosition()
self.SetSize(self.gxButton - self.gx + 20,
self.gyButton - self.gy + 20)
self.EditLine.SetSize(self.width - 30, 16)
self.EditLine.SetPosition(7, self.height - 20)
(self.gxEditLine, self.gyEditLine) = self.EditLine.GetGlobalPosition()
#####
yPosition = (self.height - 20) - self.LINE_STEP
ItemCount = len(self.TextList)
for i in xrange(ItemCount):
TextLine = self.TextList[ItemCount - i - 1]
TextLine.SetPosition(10, yPosition)
yPosition -= self.LINE_STEP
if yPosition < 0:
TextLine.Hide()
else:
TextLine.Show()
def OpenWindow(self):
self.EditLine.SetFocus()
self.Show()
self.Console.RefreshPath()
def CloseWindow(self):
self.Hide()
## NOTE : 이곳에서 Command를 처리합니다 - [levites]
def ProcessCommand(self, text):
if '/' == text[0]:
net.SendChatPacket(text)
return
Console = self.Console
Console.Print(">> " + text)
lstsArg = text.split()
if len(lstsArg) == 0:
return
sCmd = lstsArg[0]
if self.functionDict.has_key(sCmd):
try:
self.functionDict[sCmd](self.Console, *lstsArg[1:])
except Exception, e:
Console.Print(str(e))
#self.Console.Print(e)
#self.Console.Print(self.functionDict[sCmd].__doc__)
else:
def SetUpVisualColor(self, r, g, b, l):
self.VISUAL_COLOR = grp.GenerateColor(r, g, b, l)
def OnRender(self):
if self.isSelected:
x, y = self.GetGlobalPosition()
grp.SetColor(grp.GenerateColor(0.0, 0.0, 0.7, 0.7))
grp.RenderBar(x + 16, y, self.GetWidth() - 16, self.GetHeight())
10,
"vertical_align":
"center",
"width":
BOARD_TYPE_WIDTH,
"height":
BOARD_TYPE_HEIGHT,
"children": (
{
"name": "backgroundBar",
"type": "bar",
"x": 9,
"y": 5,
"width": BOARD_TYPE_WIDTH - 17,
"height": BOARD_TYPE_HEIGHT - 12,
"color": grp.GenerateColor(0.0, 0.0, 0.0, 0.5),
},
{
"name": "btnNotice",
"type": "radio_button",
"x": 25,
"y": 7,
"text": localeInfo.ANNOUNCEMENT_MANAGER_NOTICE,
"default_image":
"d:/ymir work/ui/public/large_button_01.sub",
"over_image": "d:/ymir work/ui/public/large_button_02.sub",
"down_image": "d:/ymir work/ui/public/large_button_03.sub",
},
{
"name": "btnBigNotice",
"type": "radio_button",
def SetUpEdgeColor(self, r, g, b, l):
self.EDGE_COLOR = grp.GenerateColor(r, g, b, l)
class PartyMemberInfoBoard(ui.ScriptWindow):
if localeInfo.IsJAPAN():
BOARD_WIDTH = 130
else:
BOARD_WIDTH = 106
BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.5)
GAUGE_OUT_LINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.3)
LINK_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
UNLINK_COLOR = grp.GenerateColor(0.5, 0.5, 0.5, 1.0)
#UNLINK_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)
PARTY_AFFECT_EXPERIENCE = 0
PARTY_AFFECT_ATTACKER = 1
PARTY_AFFECT_TANKER = 2
PARTY_AFFECT_BUFFER = 3
PARTY_AFFECT_SKILL_MASTER = 4
PARTY_AFFECT_BERSERKER = 5
PARTY_AFFECT_DEFENDER = 6
#PARTY_AFFECT_TIME_BONUS = 5
#PARTY_AFFECT_REGEN_BONUS = 6
PARTY_AFFECT_INCREASE_AREA_150 = 7
PARTY_AFFECT_INCREASE_AREA_200 = 8
AFFECT_STRING_DICT = { PARTY_AFFECT_EXPERIENCE : localeInfo.PARTY_BONUS_EXP,
PARTY_AFFECT_ATTACKER : localeInfo.PARTY_BONUS_ATTACKER,
PARTY_AFFECT_TANKER : localeInfo.PARTY_BONUS_TANKER,
PARTY_AFFECT_BUFFER : localeInfo.PARTY_BONUS_BUFFER,
PARTY_AFFECT_SKILL_MASTER : localeInfo.PARTY_BONUS_SKILL_MASTER,
PARTY_AFFECT_BERSERKER : localeInfo.PARTY_BONUS_BERSERKER,
PARTY_AFFECT_DEFENDER : localeInfo.PARTY_BONUS_DEFENDER,
PARTY_AFFECT_INCREASE_AREA_150 : localeInfo.PARTY_INCREASE_AREA_150,
PARTY_AFFECT_INCREASE_AREA_200 : localeInfo.PARTY_INCREASE_AREA_200, }
PARTY_SKILL_HEAL = 1
PARTY_SKILL_WARP = 2
MEMBER_BUTTON_NORMAL = 10
MEMBER_BUTTON_WARP = 11
MEMBER_BUTTON_EXPEL = 12
MEMBER_BUTTON_PATH = "d:/ymir work/ui/game/windows/"
MEMBER_BUTTON_IMAGE_FILE_NAME_DICT = { player.PARTY_STATE_LEADER : "party_state_leader",
player.PARTY_STATE_ATTACKER : "party_state_attacker",
player.PARTY_STATE_BERSERKER : "party_state_berserker",
player.PARTY_STATE_TANKER : "party_state_tanker",
player.PARTY_STATE_DEFENDER : "party_state_defender",
player.PARTY_STATE_BUFFER : "party_state_buffer",
player.PARTY_STATE_SKILL_MASTER : "party_state_skill_master",
MEMBER_BUTTON_NORMAL : "party_state_normal",
MEMBER_BUTTON_WARP : "party_skill_warp",
MEMBER_BUTTON_EXPEL : "party_expel", }
STATE_NAME_DICT = { player.PARTY_STATE_ATTACKER : localeInfo.PARTY_SET_ATTACKER,
player.PARTY_STATE_BERSERKER : localeInfo.PARTY_SET_BERSERKER,
player.PARTY_STATE_TANKER : localeInfo.PARTY_SET_TANKER,
player.PARTY_STATE_DEFENDER : localeInfo.PARTY_SET_DEFENDER,
player.PARTY_STATE_BUFFER : localeInfo.PARTY_SET_BUFFER,
player.PARTY_STATE_SKILL_MASTER : localeInfo.PARTY_SET_SKILL_MASTER, }
def __init__(self):
ui.ScriptWindow.__init__(self)
self.pid = None
self.vid = None
self.partyAffectImageList = []
self.stateButtonDict = {}
self.affectValueDict = {}
self.state = -1
self.isShowStateButton = False
self.__LoadBoard()
self.__CreateAffectToolTip()
self.__CreateStateButton()
self.Show()
def __del__(self):
ui.ScriptWindow.__del__(self)
print " =============================== DESTROIED PartyMemberInfoBoard"
def __LoadBoard(self):
try:
pyScrLoader = ui.PythonScriptLoader()
if localeInfo.IsJAPAN():
pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "PartyMemberInfoBoard.py")
else:
pyScrLoader.LoadScriptFile(self, "UIScript/PartyMemberInfoBoard.py")
except:
import exception
exception.Abort("PartyMemberInfoBoard.__LoadBoard.LoadScript")
try:
self.nameTextLine = self.GetChild("NamePrint")
self.gauge = self.GetChild("Gauge")
self.stateButton = self.GetChild("StateButton")
self.partyAffectImageList.append(self.GetChild("ExperienceImage"))
self.partyAffectImageList.append(self.GetChild("AttackerImage"))
self.partyAffectImageList.append(self.GetChild("DefenderImage"))
self.partyAffectImageList.append(self.GetChild("BufferImage"))
self.partyAffectImageList.append(self.GetChild("SkillMasterImage"))
self.partyAffectImageList.append(self.GetChild("TimeBonusImage"))
self.partyAffectImageList.append(self.GetChild("RegenBonus"))
self.partyAffectImageList.append(self.GetChild("IncreaseArea150"))
self.partyAffectImageList.append(self.GetChild("IncreaseArea200"))
self.stateButton.SetEvent(ui.__mem_func__(self.OnMouseLeftButtonDown))
except:
import exception
exception.Abort("PartyMemberInfoBoard.__LoadBoard.BindObject")
self.__SetAffectsMouseEvent()
self.__HideAllAffects()
def Destroy(self):
self.ClearDictionary()
self.nameTextLine = None
self.gauge = None
self.stateButton = None
self.partyAffectImageList = []
self.stateButtonDict = {}
self.leaderButton = None
self.attackerButton = None
self.tankerButton = None
self.Hide()
def __SetAffectsMouseEvent(self):
for i in xrange(len(self.partyAffectImageList)):
self.partyAffectImageList[i].OnMouseOverIn = lambda selfArg = self, index = i: selfArg.OnAffectOverIn(index)
for i in xrange(len(self.partyAffectImageList)):
self.partyAffectImageList[i].OnMouseOverOut = lambda selfArg = self, index = i: selfArg.OnAffectOverOut(index)
def __HideAllAffects(self):
for img in self.partyAffectImageList:
img.Hide()
def __CreateAffectToolTip(self):
affectToolTip = uiToolTip.ToolTip(220)
affectToolTip.Hide()
self.affectToolTip = affectToolTip
def __CreateStateButton(self):
for key, name in self.MEMBER_BUTTON_IMAGE_FILE_NAME_DICT.items():
if key == player.PARTY_STATE_LEADER:
continue
button = ui.Button()
button.SetUpVisual(self.MEMBER_BUTTON_PATH + name + "_01.sub")
button.SetOverVisual(self.MEMBER_BUTTON_PATH + name + "_02.sub")
button.SetDownVisual(self.MEMBER_BUTTON_PATH + name + "_03.sub")
button.Hide()
self.stateButtonDict[key] = button
for state, name in self.STATE_NAME_DICT.items():
button = self.stateButtonDict[state]
button.SetToolTipText(name)
button.SetEvent(ui.__mem_func__(self.OnSelectState), state)
self.stateButtonDict[self.MEMBER_BUTTON_NORMAL].SetEvent(ui.__mem_func__(self.OnSelectState), -1)
self.stateButtonDict[self.MEMBER_BUTTON_NORMAL].SetToolTipText(localeInfo.PARTY_SET_NORMAL)
self.stateButtonDict[self.MEMBER_BUTTON_WARP].SetEvent(ui.__mem_func__(self.OnWarp))
self.stateButtonDict[self.MEMBER_BUTTON_WARP].SetToolTipText(localeInfo.PARTY_RECALL_MEMBER)
self.stateButtonDict[self.MEMBER_BUTTON_EXPEL].SetToolTipText(localeInfo.TARGET_BUTTON_EXCLUDE)
self.stateButtonDict[self.MEMBER_BUTTON_EXPEL].SetEvent(ui.__mem_func__(self.OnExpel))
def __GetPartySkillLevel(self):
slotIndex = player.GetSkillSlotIndex(player.SKILL_INDEX_TONGSOL)
skillGrade = player.GetSkillGrade(slotIndex)
skillLevel = player.GetSkillLevel(slotIndex)
return skillLevel + skillGrade*20
def __AppendStateButton(self, x, y, state):
if state == self.state:
button = self.stateButtonDict[self.MEMBER_BUTTON_NORMAL]
else:
button = self.stateButtonDict[state]
button.SetPosition(x, y)
button.Show()
def __ShowStateButton(self):
self.isShowStateButton = True
(x, y) = self.GetGlobalPosition()
xPos = x + 110
skillLevel = self.__GetPartySkillLevel()
## Tanker
if skillLevel >= 10:
self.__AppendStateButton(xPos, y, player.PARTY_STATE_ATTACKER)
xPos += 23
## Attacker
if skillLevel >= 20:
self.__AppendStateButton(xPos, y, player.PARTY_STATE_BERSERKER)
xPos += 23
## Tanker
if skillLevel >= 20:
self.__AppendStateButton(xPos, y, player.PARTY_STATE_TANKER)
xPos += 23
## Buffer
if skillLevel >= 25:
self.__AppendStateButton(xPos, y, player.PARTY_STATE_BUFFER)
xPos += 23
## Skill Master
if skillLevel >= 35:
self.__AppendStateButton(xPos, y, player.PARTY_STATE_SKILL_MASTER)
xPos += 23
## Defender
if skillLevel >= 40:
self.__AppendStateButton(xPos, y, player.PARTY_STATE_DEFENDER)
xPos += 23
## Warp
#if skillLevel >= 35:
# if self.stateButtonDict.has_key(self.MEMBER_BUTTON_WARP):
# button = self.stateButtonDict[self.MEMBER_BUTTON_WARP]
# button.SetPosition(xPos, y)
# button.Show()
# xPos += 23
## Expel
if self.stateButtonDict.has_key(self.MEMBER_BUTTON_EXPEL):
button = self.stateButtonDict[self.MEMBER_BUTTON_EXPEL]
button.SetPosition(xPos, y)
button.Show()
xPos += 23
def __HideStateButton(self):
self.isShowStateButton = False
for button in self.stateButtonDict.values():
button.Hide()
def __GetAffectNumber(self, img):
for i in xrange(self.partyAffectImageList):
if img == self.partyAffectImageList[i]:
return i
return -1
def SetCharacterName(self, name):
self.nameTextLine.SetText(name)
def GetCharacterName(self):
return self.nameTextLine.GetText()
def SetCharacterPID(self, pid):
self.pid = pid
def SetCharacterVID(self, vid):
self.vid = vid
def GetCharacterPID(self):
return self.pid
def GetCharacterVID(self):
return self.vid
def SetCharacterHP(self, hpPercentage):
hpPercentage = max(0, hpPercentage)
self.gauge.SetPercentage(hpPercentage, 100)
def SetCharacterState(self, state):
if self.state == state:
return
self.state = state
self.stateButton.Show()
name = self.MEMBER_BUTTON_IMAGE_FILE_NAME_DICT[self.MEMBER_BUTTON_NORMAL]
if self.MEMBER_BUTTON_IMAGE_FILE_NAME_DICT.has_key(state):
name = self.MEMBER_BUTTON_IMAGE_FILE_NAME_DICT[state]
self.stateButton.SetUpVisual(self.MEMBER_BUTTON_PATH + name + "_01.sub")
self.stateButton.SetOverVisual(self.MEMBER_BUTTON_PATH + name + "_02.sub")
self.stateButton.SetDownVisual(self.MEMBER_BUTTON_PATH + name + "_03.sub")
def SetAffect(self, affectSlotIndex, affectValue):
if affectSlotIndex >= len(self.partyAffectImageList):
return
if affectValue > 0:
self.partyAffectImageList[affectSlotIndex].Show()
else:
self.partyAffectImageList[affectSlotIndex].Hide()
self.affectValueDict[affectSlotIndex] = affectValue
def Link(self):
self.nameTextLine.SetPackedFontColor(self.LINK_COLOR)
self.gauge.Show()
def Unlink(self):
self.vid = None
self.nameTextLine.SetPackedFontColor(self.UNLINK_COLOR)
self.gauge.Hide()
self.__HideAllAffects()
def OnSelectState(self, state):
self.__HideStateButton()
if state <= 0:
net.SendPartySetStatePacket(self.pid, self.state, False)
else:
if self.state <= 0:
net.SendPartySetStatePacket(self.pid, state, True)
else:
net.SendPartySetStatePacket(self.pid, self.state, False)
net.SendPartySetStatePacket(self.pid, state, True)
def OnWarp(self):
self.__HideStateButton()
if self.vid:
net.SendPartyUseSkillPacket(self.PARTY_SKILL_WARP, self.vid)
def OnExpel(self):
self.__HideStateButton()
if not self.pid:
return
net.SendPartyRemovePacket(self.pid)
def OnMouseLeftButtonDown(self):
if self.vid:
player.SetTarget(self.vid)
player.OpenCharacterMenu(self.vid)
if mouseModule.mouseController.isAttached():
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
net.SendExchangeStartPacket(self.vid)
net.SendExchangeItemAddPacket(attachedSlotPos, 0)
mouseModule.mouseController.DeattachObject()
return
if player.IsPartyLeader(player.GetMainCharacterIndex()):
if player.PARTY_STATE_LEADER != self.state:
if self.isShowStateButton:
self.__HideStateButton()
else:
self.__ShowStateButton()
def OnMouseLeftButtonUp(self):
if self.vid:
player.SetTarget(self.vid)
player.OpenCharacterMenu(self.vid)
if mouseModule.mouseController.isAttached():
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
net.SendExchangeStartPacket(self.vid)
net.SendExchangeItemAddPacket(attachedSlotPos, 0)
mouseModule.mouseController.DeattachObject()
def OnMouseRightButtonDown(self):
self.OnMouseLeftButtonDown()
def OnAffectOverIn(self, index):
if not self.AFFECT_STRING_DICT.has_key(index):
return
if not self.affectValueDict.has_key(index):
return
(x, y) = self.GetGlobalPosition()
self.affectToolTip.ClearToolTip()
self.affectToolTip.SetTitle(self.AFFECT_STRING_DICT[index](self.affectValueDict[index]))
self.affectToolTip.SetToolTipPosition(x + index*12, y + 11)
self.affectToolTip.ShowToolTip()
def OnAffectOverOut(self, index):
self.affectToolTip.HideToolTip()
def SetOverVisualColor(self, r, g, b, l):
self.OVER_VISUAL_COLOR = grp.GenerateColor(r, g, b, l)
class ResizableButton(ui.Window):
VISUAL_COLOR = grp.GenerateColor(0.2, 0.2, 0.2, 1.0) #default
EDGE_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0) #default
OVER_VISUAL_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.1) # default
DOWN_VISUAL_COLOR = grp.GenerateColor(0.1, 0.1, 0.1, 1.0) # default
def __init__(self, layer="UI"):
ui.Window.__init__(self, layer)
self.eventFunc = None
self.eventArgs = None
self.ButtonText = None
self.ToolTipText = None
self.isOver = FALSE
self.isSelected = FALSE
self.isClicked = FALSE
self.width = 0
self.height = 0
def __del__(self):
ui.Window.__del__(self)
self.eventFunc = None
self.eventArgs = None
def SetSize(self, width, height):
ui.Window.SetSize(self, width, height)
self.width = width
self.height = height
def SetUpVisualColor(self, r, g, b, l):
self.VISUAL_COLOR = grp.GenerateColor(r, g, b, l)
def SetUpEdgeColor(self, r, g, b, l):
self.EDGE_COLOR = grp.GenerateColor(r, g, b, l)
def SetOverVisualColor(self, r, g, b, l):
self.OVER_VISUAL_COLOR = grp.GenerateColor(r, g, b, l)
def SetDownVisualColor(self, r, g, b, l):
self.DOWN_VISUAL_COLOR = grp.GenerateColor(r, g, b, l)
def SetEvent(self, func, *args):
self.eventFunc = func
self.eventArgs = args
def SetTextColor(self, color):
if not self.ButtonText:
return
self.ButtonText.SetPackedFontColor(color)
def SetText(self, text):
if not self.ButtonText:
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetPosition(self.GetWidth() / 2, self.GetHeight() / 2)
textLine.SetVerticalAlignCenter()
textLine.SetHorizontalAlignCenter()
textLine.SetOutline()
textLine.Show()
self.ButtonText = textLine
self.ButtonText.SetText(text)
def SetToolTipText(self, text, x=0, y=-19):
if not self.ToolTipText:
toolTip = ui.createToolTipWindowDict["TEXT"]()
toolTip.SetParent(self)
toolTip.SetSize(0, 0)
toolTip.SetHorizontalAlignCenter()
toolTip.SetOutline()
toolTip.Hide()
toolTip.SetPosition(x + self.GetWidth() / 2, y)
self.ToolTipText = toolTip
self.ToolTipText.SetText(text)
def ShowToolTip(self):
if self.ToolTipText:
self.ToolTipText.Show()
def HideToolTip(self):
if self.ToolTipText:
self.ToolTipText.Hide()
def OnMouseLeftButtonDown(self):
self.isSelected = TRUE
self.isClicked = TRUE
def OnMouseLeftButtonUp(self):
self.isSelected = FALSE
if self.eventFunc and self.IsIn() and self.isClicked:
apply(self.eventFunc, self.eventArgs)
def OnUpdate(self):
if self.IsIn():
self.isOver = TRUE
self.ShowToolTip()
else:
self.isClicked = FALSE
self.isOver = FALSE
self.HideToolTip()
def OnRender(self):
xRender, yRender = self.GetGlobalPosition()
widthRender = self.width
heightRender = self.height
if self.isOver:
if self.isSelected:
grp.SetColor(self.DOWN_VISUAL_COLOR)
grp.RenderBar(xRender, yRender, self.width, heightRender)
else:
grp.SetColor(self.OVER_VISUAL_COLOR)
grp.RenderBar(xRender, yRender, self.width, heightRender)
else:
grp.SetColor(self.VISUAL_COLOR)
grp.RenderBar(xRender, yRender, widthRender, heightRender)
grp.SetColor(self.EDGE_COLOR)
grp.RenderLine(xRender, yRender, widthRender, 0)
grp.RenderLine(xRender, yRender, 0, heightRender)
grp.RenderLine(xRender, yRender + heightRender, widthRender, 0)
grp.RenderLine(xRender + widthRender, yRender, 0, heightRender)
class AdventWindow(ui.ScriptWindow):
BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.51)
GET_TEXT_BASE_HEIGHT = 100
xAdventStart = 0
yAdventStart = 0
cday = 0
spamBlock = 0
cqi = 0
def __init__(self):
ui.ScriptWindow.__init__(self)
self.LoadWindow()
def __del__(self):
ui.ScriptWindow.__del__(self)
def LoadWindow(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "exscript/adventboard.py")
except:
import exception
exception.Abort("AdventWindow.LoadWindow.LoadObject")
# self.GetChild("Close_Button").SetEvent(self.Close)
self.rewardDialog = self.GetChild("reward_background")
self.rewardDialogTitle = self.GetChild("rewardTitle")
self.rewardDialogItemName = self.GetChild("rewardItemName")
self.rewardDialogInfo = self.GetChild("rewardDialogReminder")
self.rewardDialogItemImage = self.GetChild("rewardItemSlot")
self.rewardDialogCloseButton = self.GetChild(
"Close_RewardDialogButton")
i = 1
self.adventDayButtonDict = []
while i <= 24:
self.adventDayButtonDict.append(
self.GetChild("button_day_0" + str(i)))
self.adventDayButtonDict[i - 1].SetEvent(
lambda arg=i: self.OnClickAdventButton(arg))
self.adventDayButtonDict[
i -
1].ShowToolTip = lambda arg=i: self.__OverInAdventButton(arg)
self.adventDayButtonDict[
i -
1].HideToolTip = lambda arg=i: self.__OverOutAdventButton()
if ENABLE_DAY_TEXT_LINE:
self.adventDayButtonDict[i - 1].SetText(str(i))
self.adventDayButtonDict[i - 1].Hide()
i = i + 1
self.rewardDialog.SetColor(self.BOARD_COLOR)
self.rewardDialogItemName.SetFontColor(0.5411, 0.7254, 0.5568)
self.rewardDialogTitle.SetFontColor(0.9490, 0.9058, 0.7568)
self.rewardDialogCloseButton.SetEvent(self.CloseRewardDialog)
self.toolTip = uiToolTip.ToolTip()
# self.explodeTest = Explosion()
# self.explodeTest.SetParent(self)
# self.explodeTest.SetPosition(100,100)
##################
## DEV SPÄTER LÖSCHEN!!!
self.Open()
self.SetCurrentDay(5)
for i in xrange(24):
self.InitAdventButton(i + 1, app.GetRandom(1, 2))
self.OpenRewardDialog(27001, 1)
def CloseRewardDialog(self):
self.rewardDialog.Hide()
def OpenRewardDialog(self, itemVnum, itemCount):
item.SelectItem(itemVnum)
itemName = item.GetItemName()
get_text_pos = (item.GetItemSize()[1] * 20) + self.GET_TEXT_BASE_HEIGHT
self.rewardDialogItemName.SetText(
str(itemCount) + "x " + str(itemName))
self.rewardDialogItemName.SetPosition(337, get_text_pos)
self.rewardDialogInfo.SetPosition(337, get_text_pos + 20)
self.rewardDialogCloseButton.SetPosition(679 / 2 - 48,
get_text_pos + 20 + 30)
self.rewardDialogItemImage.LoadImage(item.GetIconImageFileName())
self.rewardDialog.Show()
def __OverInAdventButton(self, slot):
self.toolTip.ClearToolTip()
if slot == self.cday:
self.toolTip.toolTipWidth = self.toolTip.TOOL_TIP_WIDTH + 20
self.toolTip.AppendTextLine(
"Du kannst dieses Geschenk heute öffnen.",
self.toolTip.POSITIVE_COLOR)
else:
self.toolTip.toolTipWidth = self.toolTip.TOOL_TIP_WIDTH + 60
self.toolTip.AppendTextLine(
"Du kannst dieses Geschenk am " + str(slot) +
". Dezember öffnen.", self.toolTip.TITLE_COLOR)
self.toolTip.ResizeToolTip()
self.toolTip.ShowToolTip()
def __OverOutAdventButton(self):
self.toolTip.HideToolTip()
def SetCurrentDay(self, cday):
self.cday = cday
def InitAdventButton(self, index, enable):
if index == self.cday and ENABLE_BUTTON_FLASH:
self.adventDayButtonDict[index - 1].Flash()
if enable == 1:
self.adventDayButtonDict[index - 1].Enable()
else:
self.adventDayButtonDict[index - 1].Disable()
self.adventDayButtonDict[index - 1].Show()
def OnClickAdventButton(self, idx):
return
def OnPressEscapeKey(self):
self.Close()
return True
def Open(self):
if self.IsShow():
return
(self.xAdventStart, self.yAdventStart,
z) = player.GetMainCharacterPosition()
self.Show()
def Close(self):
self.rewardDialog.Hide()
self.Hide()
def OnUpdate(self):
if CLOSE_ADVENT_ON_DISTANCE:
USE_ADVENT_LIMIT_RANGE = 1000
(x, y, z) = player.GetMainCharacterPosition()
if abs(x - self.xAdventStart) > USE_ADVENT_LIMIT_RANGE or abs(
y - self.yAdventStart) > USE_ADVENT_LIMIT_RANGE:
self.Close()
def SetDownVisualColor(self, r, g, b, l):
self.DOWN_VISUAL_COLOR = grp.GenerateColor(r, g, b, l)
