Hi Leute,
wenn ich mich einloggen möchte kommt "Anmeldevorgang läuft " und dann schliest sich der Client.
In der Syserr steht das hier :
Meine networkModule.py:
Meine system.py :
Meine introSelect.py:
Meine interfaceModule.py
Meine uiRestart.py:
Wer mein Problem löst gebührt mein Respekt!
Viel Spaß beim tüfteln ;)
wenn ich mich einloggen möchte kommt "Anmeldevorgang läuft " und dann schliest sich der Client.
In der Syserr steht das hier :
Hier sind die Python Datein die von der Syserr erwähnt wurden:Quote:
0218 12:53:05472 ::
networkModule.py(line:194) SetSelectCharacterPhase
system.py(line:130) __pack_import
system.py(line:110) _process_result
introSelect.py(line:27) ?
system.py(line:130) __pack_import
system.py(line:110) _process_result
interfaceModule.py(line:26) ?
system.py(line:130) __pack_import
system.py(line:110) _process_result
uiRestart.py(line:4) ?
system.py(line:130) __pack_import
networkModule.SetSelectCharacterPhase - exceptions.IndentationError:expected an indented block (line 487)
0218 12:53:05473 :: ================================================== ================================================== ========
0218 12:53:05473 :: Abort!!!!
Meine networkModule.py:
PHP Code:
###################################################################################################
# Network
import app
import chr
import dbg
import net
import snd
import chr
import chrmgr
import background
import player
import playerSettingModule
import ui
import uiPhaseCurtain
import locale
class PopupDialog(ui.ScriptWindow):
def __init__(self):
print "NEW POPUP DIALOG ----------------------------------------------------------------------------"
ui.ScriptWindow.__init__(self)
self.CloseEvent = 0
def __del__(self):
print "---------------------------------------------------------------------------- DELETE POPUP DIALOG "
ui.ScriptWindow.__del__(self)
def LoadDialog(self):
PythonScriptLoader = ui.PythonScriptLoader()
PythonScriptLoader.LoadScriptFile(self, "UIScript/PopupDialog.py")
def Open(self, Message, event = 0, ButtonName = locale.UI_CANCEL):
if TRUE == self.IsShow():
self.Close()
self.Lock()
self.SetTop()
self.CloseEvent = event
AcceptButton = self.GetChild("accept")
AcceptButton.SetText(ButtonName)
AcceptButton.SetEvent(ui.__mem_func__(self.Close))
self.GetChild("message").SetText(Message)
self.Show()
def Close(self):
if FALSE == self.IsShow():
self.CloseEvent = 0
return
self.Unlock()
self.Hide()
if 0 != self.CloseEvent:
self.CloseEvent()
self.CloseEvent = 0
def Destroy(self):
self.Close()
self.ClearDictionary()
def OnPressEscapeKey(self):
self.Close()
return TRUE
def OnIMEReturn(self):
self.Close()
return TRUE
##
## Main Stream
##
class MainStream(object):
isChrData=0
def __init__(self):
print "NEWMAIN STREAM ----------------------------------------------------------------------------"
net.SetHandler(self)
net.SetTCPRecvBufferSize(64*1024)
net.SetTCPSendBufferSize(1024)
net.SetUDPRecvBufferSize(4096)
self.id=""
self.pwd=""
self.addr=""
self.port=0
self.account_addr=0
self.account_port=0
self.slot=0
self.isAutoSelect=0
self.isAutoLogin=0
self.curtain = 0
self.curPhaseWindow = 0
self.newPhaseWindow = 0
def __del__(self):
print "---------------------------------------------------------------------------- DELETE MAIN STREAM "
def Destroy(self):
if self.curPhaseWindow:
self.curPhaseWindow.Close()
self.curPhaseWindow = 0
if self.newPhaseWindow:
self.newPhaseWindow.Close()
self.newPhaseWindow = 0
self.popupWindow.Destroy()
self.popupWindow = 0
self.curtain = 0
def Create(self):
self.CreatePopupDialog()
self.curtain = uiPhaseCurtain.PhaseCurtain()
def SetPhaseWindow(self, newPhaseWindow):
if self.newPhaseWindow:
#print "ÀÌ¹Ì »õ·Î¿î À©µµ¿ì·Î ¹Ù²Û»óÅ¿¡¼* ¶Ç ¹Ù²Þ", newPhaseWindow
self.__ChangePhaseWindow()
self.newPhaseWindow=newPhaseWindow
if self.curPhaseWindow:
#print "ÆäÀÌµå ¾Æ¿ôµÇ¸é ¹Ù²Þ"
self.curtain.FadeOut(self.__ChangePhaseWindow)
else:
#print "ÇöÀç À©µµ¿ì°¡ ¾ø´Â »óŶó ¹Ù·Î ¹Ù²Þ"
self.__ChangePhaseWindow()
def __ChangePhaseWindow(self):
oldPhaseWindow=self.curPhaseWindow
newPhaseWindow=self.newPhaseWindow
self.curPhaseWindow=0
self.newPhaseWindow=0
if oldPhaseWindow:
oldPhaseWindow.Close()
if newPhaseWindow:
newPhaseWindow.Open()
self.curPhaseWindow=newPhaseWindow
if self.curPhaseWindow:
self.curtain.FadeIn()
else:
app.Exit()
def CreatePopupDialog(self):
self.popupWindow = PopupDialog()
self.popupWindow.LoadDialog()
self.popupWindow.SetCenterPosition()
self.popupWindow.Hide()
## SelectPhase
##########################################################################################
def SetLoginPhase(self):
net.Disconnect()
import introLogin
self.SetPhaseWindow(introLogin.LoginWindow(self))
def SetSelectEmpirePhase(self):
try:
import introEmpire
self.SetPhaseWindow(introEmpire.SelectEmpireWindow(self))
except:
import exception
exception.Abort("networkModule.SetSelectEmpirePhase")
def SetReselectEmpirePhase(self):
try:
import introEmpire
self.SetPhaseWindow(introEmpire.ReselectEmpireWindow(self))
except:
import exception
exception.Abort("networkModule.SetReselectEmpirePhase")
def SetSelectCharacterPhase(self):
try:
locale.LoadLocaleData()
import introSelect
self.popupWindow.Close()
self.SetPhaseWindow(introSelect.SelectCharacterWindow(self))
except:
import exception
exception.Abort("networkModule.SetSelectCharacterPhase")
def SetCreateCharacterPhase(self):
try:
import introCreate
self.SetPhaseWindow(introCreate.CreateCharacterWindow(self))
except:
import exception
exception.Abort("networkModule.SetCreateCharacterPhase")
def SetTestGamePhase(self, x, y):
try:
import introLoading
loadingPhaseWindow=introLoading.LoadingWindow(self)
loadingPhaseWindow.LoadData(x, y)
self.SetPhaseWindow(loadingPhaseWindow)
except:
import exception
exception.Abort("networkModule.SetLoadingPhase")
def SetLoadingPhase(self):
try:
import introLoading
self.SetPhaseWindow(introLoading.LoadingWindow(self))
except:
import exception
exception.Abort("networkModule.SetLoadingPhase")
def SetGamePhase(self):
try:
import game
self.popupWindow.Close()
self.SetPhaseWindow(game.GameWindow(self))
except:
raise
import exception
exception.Abort("networkModule.SetGamePhase")
################################
# Functions used in python
## Login
def Connect(self):
import constInfo
if constInfo.KEEP_ACCOUNT_CONNETION_ENABLE:
net.ConnectToAccountServer(self.addr, self.port, self.account_addr, self.account_port)
else:
net.ConnectTCP(self.addr, self.port)
#net.ConnectUDP(IP, Port)
def SetConnectInfo(self, addr, port, account_addr=0, account_port=0):
self.addr = addr
self.port = port
self.account_addr = account_addr
self.account_port = account_port
def GetConnectAddr(self):
return self.addr
def SetLoginInfo(self, id, pwd):
self.id = id
self.pwd = pwd
net.SetLoginInfo(id, pwd)
def CancelEnterGame(self):
pass
## Select
def SetCharacterSlot(self, slot):
self.slot=slot
def GetCharacterSlot(self):
return self.slot
## Empty
def EmptyFunction(self):
pass
Meine system.py :
PHP Code:
import sys
import app
import dbg
sys.path.append("lib")
class TraceFile:
def write(self, msg):
dbg.Trace(msg)
class TraceErrorFile:
def write(self, msg):
dbg.TraceError(msg)
dbg.RegisterExceptionString(msg)
class LogBoxFile:
def __init__(self):
self.stderrSave = sys.stderr
self.msg = ""
def __del__(self):
self.restore()
def restore(self):
sys.stderr = self.stderrSave
def write(self, msg):
self.msg = self.msg + msg
def show(self):
dbg.LogBox(self.msg,"Error")
sys.stdout = TraceFile()
sys.stderr = TraceErrorFile()
#
# pack file support (must move to system.py, systemrelease.pyc)
#
import marshal
import imp
import pack
class pack_file_iterator(object):
def __init__(self, packfile):
self.pack_file = packfile
def next(self):
tmp = self.pack_file.readline()
if tmp:
return tmp
raise StopIteration
_chr = __builtins__.chr
class pack_file(object):
def __init__(self, filename, mode = 'rb'):
assert mode in ('r', 'rb')
if not pack.Exist(filename):
raise IOError, 'No file or directory'
self.data = pack.Get(filename)
if mode == 'r':
self.data=_chr(10).join(self.data.split(_chr(13)+_chr(10)))
def __iter__(self):
return pack_file_iterator(self)
def read(self, len = None):
if not self.data:
return ''
if len:
tmp = self.data[:len]
self.data = self.data[len:]
return tmp
else:
tmp = self.data
self.data = ''
return tmp
def readline(self):
return self.read(self.data.find(_chr(10))+1)
def readlines(self):
return [x for x in self]
__builtins__.pack_open = pack_open = pack_file
_ModuleType = type(sys)
old_import = __import__
def _process_result(code, fqname):
# did get_code() return an actual module? (rather than a code object)
is_module = isinstance(code, _ModuleType)
# use the returned module, or create a new one to exec code into
if is_module:
module = code
else:
module = imp.new_module(fqname)
# insert additional values into the module (before executing the code)
#module.__dict__.update(values)
# the module is almost ready... make it visible
sys.modules[fqname] = module
# execute the code within the module's namespace
if not is_module:
exec code in module.__dict__
# fetch from sys.modules instead of returning module directly.
# also make module's __name__ agree with fqname, in case
# the "exec code in module.__dict__" played games on us.
module = sys.modules[fqname]
module.__name__ = fqname
return module
module_do = lambda x:None
def __pack_import(name,globals=None,locals=None,fromlist=None):
if name in sys.modules:
return sys.modules[name]
filename = name + '.py'
if pack.Exist(filename):
dbg.Trace('importing from pack %s\\n' % name)
newmodule = _process_result(compile(pack_file(filename,'r').read(),filename,'exec'),name)
module_do(newmodule)
return newmodule
#return imp.load_module(name, pack_file(filename,'r'),filename,('.py','r',imp.PY_SOURCE))
else:
dbg.Trace('importing from lib %s\\n' % name)
return old_import(name,globals,locals,fromlist)
def splitext(p):
root, ext = '', ''
for c in p:
if c in ['/']:
root, ext = root + ext + c, ''
elif c == '.':
if ext:
root, ext = root + ext, c
else:
ext = c
elif ext:
ext = ext + c
else:
root = root + c
return root, ext
class PythonExecutioner:
def Run(kPESelf, sFileName, kDict):
if kPESelf.__IsCompiledFile__(sFileName):
kCode=kPESelf.__LoadCompiledFile__(sFileName)
else:
kCode=kPESelf.__LoadTextFile__(sFileName)
exec(kCode, kDict)
def __IsCompiledFile__(kPESelf, sFileName):
sBase, sExt = splitext(sFileName)
sExt=sExt.lower()
if sExt==".pyc" or sExt==".pyo":
return 1
else:
return 0
def __LoadTextFile__(kPESelf, sFileName):
sText=pack_open(sFileName,'r').read()
return compile(sText, sFileName, "exec")
def __LoadCompiledFile__(kPESelf, sFileName):
kFile=pack_open(sFileName)
if kFile.read(4)!=imp.get_magic():
raise
kFile.read(4)
kData=kFile.read()
return marshal.loads(kData)
def execfile(fileName, dict):
kPE=PythonExecutioner()
kPE.Run(fileName, dict)
def exec_add_module_do(mod):
global execfile
mod.__dict__['execfile'] = execfile
import __builtin__
__builtin__.__import__ = __pack_import
module_do = exec_add_module_do
"""
#
# PSYCO installation (must move to system.py, systemrelease.pyc)
#
try:
import psyco
#from psyco.classes import *
def bind_me(bindable_list):
try:
for x in bindable_list:
try:
psyco.bind(x)
except:
pass
except:
pass
_prev_psyco_old_module_do = module_do
def module_bind(module):
_prev_psyco_old_module_do(module)
#print 'start binding' + str(module)
try:
psyco.bind(module)
except:
pass
for x in module.__dict__.itervalues():
try:
psyco.bind(x)
except:
pass
#print 'end binding'
dbg.Trace("PSYCO installed\\n")
except Exception, msg:
bind_me = lambda x:None
dbg.Trace("No PSYCO support : %s\\n" % msg)
"""
def GetExceptionString(excTitle):
(excType, excMsg, excTraceBack)=sys.exc_info()
excText=""
excText+=_chr(10)
import traceback
traceLineList=traceback.extract_tb(excTraceBack)
for traceLine in traceLineList:
if traceLine[3]:
excText+="%s(line:%d) %s - %s" % (traceLine[0], traceLine[1], traceLine[2], traceLine[3])
else:
excText+="%s(line:%d) %s" % (traceLine[0], traceLine[1], traceLine[2])
excText+=_chr(10)
excText+=_chr(10)
excText+="%s - %s:%s" % (excTitle, excType, excMsg)
excText+=_chr(10)
return excText
def ShowException(excTitle):
excText=GetExceptionString(excTitle)
dbg.TraceError(excText)
app.Abort()
return 0
def RunMainScript(name):
try:
execfile(name, __main__.__dict__)
except RuntimeError, msg:
msg = str(msg)
import locale
if locale.error:
msg = locale.error.get(msg, msg)
dbg.LogBox(msg)
app.Abort()
except:
msg = GetExceptionString("Run")
dbg.LogBox(msg)
app.Abort()
import debugInfo
debugInfo.SetDebugMode(__DEBUG__)
loginMark = "-cs"
if debugInfo.IsDebugMode() and ""!=__COMMAND_LINE__ and __COMMAND_LINE__[0:3] != loginMark:
RunMainScript(__COMMAND_LINE__)
else:
app.__COMMAND_LINE__ = __COMMAND_LINE__
RunMainScript("prototype.py")
Meine introSelect.py:
PHP Code:
import chr
import grp
import app
import math
import wndMgr
import snd
import net
import systemSetting
import locale
import ui
import uiScriptLocale
import networkModule
import musicInfo
import playerSettingModule
####################################
# ºü¸¥ ½ÇÇàÀ» À§ÇÑ ¸ðµâ ·Îµù ºÐ´ã
####################################
import uiCommon
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
import consoleModule
import interfaceModule
import uiTaskBar
import uiInventory
###################################
LEAVE_BUTTON_FOR_POTAL = FALSE
NOT_NEED_DELETE_CODE = FALSE
ENABLE_ENGNUM_DELETE_CODE = FALSE
if locale.IsJAPAN():
NOT_NEED_DELETE_CODE = TRUE
elif locale.IsHONGKONG():
ENABLE_ENGNUM_DELETE_CODE = TRUE
elif locale.IsNEWCIBN():
ENABLE_ENGNUM_DELETE_CODE = TRUE
elif locale.IsEUROPE():
ENABLE_ENGNUM_DELETE_CODE = TRUE
###################################
class SelectCharacterWindow(ui.Window):
# SLOT4
#SLOT_ROTATION = ( 140.0, 260.0, 20.0 )
#SLOT_COUNT = 3
SLOT_ROTATION = [135.0, 225.0, 315.0, 45.0]
SLOT_COUNT = 4
CHARACTER_TYPE_COUNT = 4
EMPIRE_NAME = {
net.EMPIRE_A : locale.EMPIRE_A,
net.EMPIRE_B : locale.EMPIRE_B,
net.EMPIRE_C : locale.EMPIRE_C
}
class CharacterRenderer(ui.Window):
def OnRender(self):
grp.ClearDepthBuffer()
grp.SetGameRenderState()
grp.PushState()
grp.SetOmniLight()
screenWidth = wndMgr.GetScreenWidth()
screenHeight = wndMgr.GetScreenHeight()
newScreenWidth = float(screenWidth - 270)
newScreenHeight = float(screenHeight)
grp.SetViewport(270.0/screenWidth, 0.0, newScreenWidth/screenWidth, newScreenHeight/screenHeight)
app.SetCenterPosition(0.0, 0.0, 0.0)
app.SetCamera(1550.0, 15.0, 180.0, 95.0)
grp.SetPerspective(10.0, newScreenWidth/newScreenHeight, 1000.0, 3000.0)
(x, y) = app.GetCursorPosition()
grp.SetCursorPosition(x, y)
chr.Deform()
chr.Render()
grp.RestoreViewport()
grp.PopState()
grp.SetInterfaceRenderState()
def __init__(self, stream):
ui.Window.__init__(self)
net.SetPhaseWindow(net.PHASE_WINDOW_SELECT, self)
self.stream=stream
self.slot = self.stream.GetCharacterSlot()
self.openLoadingFlag = FALSE
self.startIndex = -1
self.startReservingTime = 0
self.flagDict = {}
self.curRotation = []
self.destRotation = []
for rot in self.SLOT_ROTATION:
self.curRotation.append(rot)
self.destRotation.append(rot)
self.curNameAlpha = []
self.destNameAlpha = []
for i in xrange(self.CHARACTER_TYPE_COUNT):
self.curNameAlpha.append(0.0)
self.destNameAlpha.append(0.0)
self.curGauge = [0.0, 0.0, 0.0, 0.0]
self.destGauge = [0.0, 0.0, 0.0, 0.0]
self.dlgBoard = 0
self.changeNameFlag = FALSE
self.nameInputBoard = None
self.sendedChangeNamePacket = FALSE
self.startIndex = -1
self.isLoad = 0
def __del__(self):
ui.Window.__del__(self)
net.SetPhaseWindow(net.PHASE_WINDOW_SELECT, 0)
def Open(self):
if not self.__LoadBoardDialog(uiScriptLocale.LOCALE_UISCRIPT_PATH + "selectcharacterwindow.py"):
dbg.TraceError("SelectCharacterWindow.Open - __LoadScript Error")
return
if not self.__LoadQuestionDialog("uiscript/questiondialog.py"):
return
playerSettingModule.LoadGameData("INIT")
self.InitCharacterBoard()
self.btnStart.Enable()
self.btnCreate.Enable()
self.btnDelete.Enable()
self.btnExit.Enable()
self.btnLeft.Enable()
self.btnRight.Enable()
self.dlgBoard.Show()
self.SetWindowName("SelectCharacterWindow")
self.Show()
if self.slot>=0:
self.SelectSlot(self.slot)
if musicInfo.selectMusic != "":
snd.SetMusicVolume(systemSetting.GetMusicVolume())
snd.FadeInMusic("BGM/"+musicInfo.selectMusic)
app.SetCenterPosition(0.0, 0.0, 0.0)
app.SetCamera(1550.0, 15.0, 180.0, 95.0)
self.isLoad=1
self.Refresh()
if self.stream.isAutoSelect:
chrSlot=self.stream.GetCharacterSlot()
self.SelectSlot(chrSlot)
self.StartGame()
self.HideAllFlag()
self.SetEmpire(net.GetEmpireID())
app.ShowCursor()
def Close(self):
if musicInfo.selectMusic != "":
snd.FadeOutMusic("BGM/"+musicInfo.selectMusic)
self.stream.popupWindow.Close()
if self.dlgBoard:
self.dlgBoard.ClearDictionary()
self.empireName = None
self.flagDict = {}
self.dlgBoard = None
self.btnStart = None
self.btnCreate = None
self.btnDelete = None
self.btnExit = None
self.btnLeft = None
self.btnRight = None
self.backGround = None
self.dlgQuestion.ClearDictionary()
self.dlgQuestion = None
self.dlgQuestionText = None
self.dlgQuestionAcceptButton = None
self.dlgQuestionCancelButton = None
self.privateInputBoard = None
self.nameInputBoard = None
chr.DeleteInstance(0)
chr.DeleteInstance(1)
chr.DeleteInstance(2)
chr.DeleteInstance(3)
self.Hide()
self.KillFocus()
app.HideCursor()
def SetEmpire(self, id):
self.empireName.SetText(self.EMPIRE_NAME.get(id, ""))
if self.flagDict.has_key(id):
self.flagDict[id].Show()
def HideAllFlag(self):
for flag in self.flagDict.values():
flag.Hide()
def Refresh(self):
if not self.isLoad:
return
# SLOT4
indexArray = (3, 2, 1, 0)
for index in indexArray:
id=net.GetAccountCharacterSlotDataInteger(index, net.ACCOUNT_CHARACTER_SLOT_ID)
race=net.GetAccountCharacterSlotDataInteger(index, net.ACCOUNT_CHARACTER_SLOT_RACE)
form=net.GetAccountCharacterSlotDataInteger(index, net.ACCOUNT_CHARACTER_SLOT_FORM)
name=net.GetAccountCharacterSlotDataString(index, net.ACCOUNT_CHARACTER_SLOT_NAME)
hair=net.GetAccountCharacterSlotDataInteger(index, net.ACCOUNT_CHARACTER_SLOT_HAIR)
if id:
self.MakeCharacter(index, id, name, race, form, hair)
self.SelectSlot(index)
self.SelectSlot(self.slot)
def GetCharacterSlotID(self, slotIndex):
return net.GetAccountCharacterSlotDataInteger(slotIndex, net.ACCOUNT_CHARACTER_SLOT_ID)
def __LoadQuestionDialog(self, fileName):
self.dlgQuestion = ui.ScriptWindow()
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self.dlgQuestion, fileName)
except:
import exception
exception.Abort("SelectCharacterWindow.LoadQuestionDialog.LoadScript")
try:
GetObject=self.dlgQuestion.GetChild
self.dlgQuestionText=GetObject("message")
self.dlgQuestionAcceptButton=GetObject("accept")
self.dlgQuestionCancelButton=GetObject("cancel")
except:
import exception
exception.Abort("SelectCharacterWindow.LoadQuestionDialog.BindObject")
self.dlgQuestionText.SetText(locale.SELECT_DO_YOU_DELETE_REALLY)
self.dlgQuestionAcceptButton.SetEvent(ui.__mem_func__(self.RequestDeleteCharacter))
self.dlgQuestionCancelButton.SetEvent(ui.__mem_func__(self.dlgQuestion.Hide))
return 1
def __LoadBoardDialog(self, fileName):
self.dlgBoard = ui.ScriptWindow()
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self.dlgBoard, fileName)
except:
import exception
exception.Abort("SelectCharacterWindow.LoadBoardDialog.LoadScript")
try:
GetObject=self.dlgBoard.GetChild
self.btnStart = GetObject("start_button")
self.btnCreate = GetObject("create_button")
self.btnDelete = GetObject("delete_button")
self.btnExit = GetObject("exit_button")
self.CharacterName = GetObject("character_name_value")
self.CharacterLevel = GetObject("character_level_value")
self.PlayTime = GetObject("character_play_time_value")
self.CharacterHTH = GetObject("character_hth_value")
self.CharacterINT = GetObject("character_int_value")
self.CharacterSTR = GetObject("character_str_value")
self.CharacterDEX = GetObject("character_dex_value")
self.GuildName = GetObject("GuildName")
self.NameList = []
self.NameList.append(GetObject("name_warrior"))
self.NameList.append(GetObject("name_assassin"))
self.NameList.append(GetObject("name_sura"))
self.NameList.append(GetObject("name_shaman"))
self.GaugeList = []
self.GaugeList.append(GetObject("gauge_hth"))
self.GaugeList.append(GetObject("gauge_int"))
self.GaugeList.append(GetObject("gauge_str"))
self.GaugeList.append(GetObject("gauge_dex"))
self.btnLeft = GetObject("left_button")
self.btnRight = GetObject("right_button")
self.empireName = GetObject("EmpireName")
self.flagDict[net.EMPIRE_A] = GetObject("EmpireFlag_A")
self.flagDict[net.EMPIRE_B] = GetObject("EmpireFlag_B")
self.flagDict[net.EMPIRE_C] = GetObject("EmpireFlag_C")
self.backGround = GetObject("BackGround")
except:
import exception
exception.Abort("SelectCharacterWindow.LoadBoardDialog.BindObject")
for name in self.NameList:
name.SetAlpha(0.0)
self.btnStart.SetEvent(ui.__mem_func__(self.StartGame))
self.btnCreate.SetEvent(ui.__mem_func__(self.CreateCharacter))
self.btnExit.SetEvent(ui.__mem_func__(self.ExitSelect))
if NOT_NEED_DELETE_CODE:
self.btnDelete.SetEvent(ui.__mem_func__(self.PopupDeleteQuestion))
else:
self.btnDelete.SetEvent(ui.__mem_func__(self.InputPrivateCode))
self.btnLeft.SetEvent(ui.__mem_func__(self.DecreaseSlotIndex))
self.btnRight.SetEvent(ui.__mem_func__(self.IncreaseSlotIndex))
self.chrRenderer = self.CharacterRenderer()
self.chrRenderer.SetParent(self.backGround)
self.chrRenderer.Show()
return 1
def MakeCharacter(self, index, id, name, race, form, hair):
if 0 == id:
return
chr.CreateInstance(index)
chr.SelectInstance(index)
chr.SetVirtualID(index)
chr.SetNameString(name)
chr.SetRace(race)
chr.SetArmor(form)
chr.SetHair(hair)
chr.Refresh()
chr.SetMotionMode(chr.MOTION_MODE_GENERAL)
chr.SetLoopMotion(chr.MOTION_INTRO_WAIT)
chr.SetRotation(0.0)
## Manage Character
def StartGame(self):
if self.sendedChangeNamePacket:
return
if self.changeNameFlag:
self.OpenChangeNameDialog()
return
if -1 != self.startIndex:
return
if musicInfo.selectMusic != "":
snd.FadeLimitOutMusic("BGM/"+musicInfo.selectMusic, (systemSetting.GetMusicVolume()/5.0)*0.05)
self.btnStart.SetUp()
self.btnCreate.SetUp()
self.btnDelete.SetUp()
self.btnExit.SetUp()
self.btnLeft.SetUp()
self.btnRight.SetUp()
self.btnStart.Disable()
self.btnCreate.Disable()
self.btnDelete.Disable()
self.btnExit.Disable()
self.btnLeft.Disable()
self.btnRight.Disable()
self.dlgQuestion.Hide()
self.stream.SetCharacterSlot(self.slot)
self.startIndex = self.slot
self.startReservingTime = app.GetTime()
for i in xrange(self.SLOT_COUNT):
if FALSE == chr.HasInstance(i):
continue
chr.SelectInstance(i)
if i == self.slot:
self.slot=self.slot
chr.PushOnceMotion(chr.MOTION_INTRO_SELECTED, 0.1)
continue
chr.PushOnceMotion(chr.MOTION_INTRO_NOT_SELECTED, 0.1)
def OpenChangeNameDialog(self):
import uiCommon
nameInputBoard = uiCommon.InputDialogWithDescription()
nameInputBoard.SetTitle(locale.SELECT_CHANGE_NAME_TITLE)
nameInputBoard.SetAcceptEvent(ui.__mem_func__(self.AcceptInputName))
nameInputBoard.SetCancelEvent(ui.__mem_func__(self.CancelInputName))
nameInputBoard.SetMaxLength(12)
nameInputBoard.SetBoardWidth(200)
nameInputBoard.SetDescription(locale.SELECT_INPUT_CHANGING_NAME)
nameInputBoard.Open()
nameInputBoard.slot = self.slot
self.nameInputBoard = nameInputBoard
def OnChangeName(self, id, name):
self.SelectSlot(id)
self.sendedChangeNamePacket = FALSE
self.PopupMessage(locale.SELECT_CHANGED_NAME)
def AcceptInputName(self):
changeName = self.nameInputBoard.GetText()
if not changeName:
return
self.sendedChangeNamePacket = TRUE
net.SendChangeNamePacket(self.nameInputBoard.slot, changeName)
return self.CancelInputName()
def CancelInputName(self):
self.nameInputBoard.Close()
self.nameInputBoard = None
return TRUE
def OnCreateFailure(self, type):
self.sendedChangeNamePacket = FALSE
if 0 == type:
self.PopupMessage(locale.SELECT_CHANGE_FAILURE_STRANGE_NAME)
elif 1 == type:
self.PopupMessage(locale.SELECT_CHANGE_FAILURE_ALREADY_EXIST_NAME)
elif 100 == type:
self.PopupMessage(locale.SELECT_CHANGE_FAILURE_STRANGE_INDEX)
def CreateCharacter(self):
id = self.GetCharacterSlotID(self.slot)
if 0==id:
self.stream.SetCharacterSlot(self.slot)
EMPIRE_MODE = 1
if EMPIRE_MODE:
if self.__AreAllSlotEmpty():
self.stream.SetReselectEmpirePhase()
else:
self.stream.SetCreateCharacterPhase()
else:
self.stream.SetCreateCharacterPhase()
def __AreAllSlotEmpty(self):
for iSlot in xrange(self.SLOT_COUNT):
if 0!=net.GetAccountCharacterSlotDataInteger(iSlot, net.ACCOUNT_CHARACTER_SLOT_ID):
return 0
return 1
def PopupDeleteQuestion(self):
id = self.GetCharacterSlotID(self.slot)
if 0 == id:
return
self.dlgQuestion.Show()
self.dlgQuestion.SetTop()
def RequestDeleteCharacter(self):
self.dlgQuestion.Hide()
id = self.GetCharacterSlotID(self.slot)
if 0 == id:
self.PopupMessage(locale.SELECT_EMPTY_SLOT)
return
net.SendDestroyCharacterPacket(self.slot, "1234567")
self.PopupMessage(locale.SELECT_DELEING)
def InputPrivateCode(self):
import uiCommon
privateInputBoard = uiCommon.InputDialogWithDescription()
privateInputBoard.SetTitle(locale.INPUT_PRIVATE_CODE_DIALOG_TITLE)
privateInputBoard.SetAcceptEvent(ui.__mem_func__(self.AcceptInputPrivateCode))
privateInputBoard.SetCancelEvent(ui.__mem_func__(self.CancelInputPrivateCode))
if ENABLE_ENGNUM_DELETE_CODE:
pass
else:
privateInputBoard.SetNumberMode()
privateInputBoard.SetSecretMode()
if locale.IsSINGAPORE():
privateInputBoard.SetMaxLength(6)
else:
privateInputBoard.SetMaxLength(7)
privateInputBoard.SetBoardWidth(250)
privateInputBoard.SetDescription(locale.INPUT_PRIVATE_CODE_DIALOG_DESCRIPTION)
privateInputBoard.Open()
self.privateInputBoard = privateInputBoard
def AcceptInputPrivateCode(self):
privateCode = self.privateInputBoard.GetText()
if not privateCode:
return
id = self.GetCharacterSlotID(self.slot)
if 0 == id:
self.PopupMessage(locale.SELECT_EMPTY_SLOT)
return
net.SendDestroyCharacterPacket(self.slot, privateCode)
self.PopupMessage(locale.SELECT_DELEING)
self.CancelInputPrivateCode()
return TRUE
def CancelInputPrivateCode(self):
self.privateInputBoard = None
return TRUE
def OnDeleteSuccess(self, slot):
self.PopupMessage(locale.SELECT_DELETED)
self.DeleteCharacter(slot)
def OnDeleteFailure(self):
self.PopupMessage(locale.SELECT_CAN_NOT_DELETE)
def DeleteCharacter(self, index):
chr.DeleteInstance(index)
self.SelectSlot(self.slot)
def ExitSelect(self):
self.dlgQuestion.Hide()
if LEAVE_BUTTON_FOR_POTAL:
if app.loggined:
self.stream.SetPhaseWindow(0)
else:
self.stream.setloginphase()
else:
self.stream.SetLoginPhase()
self.Hide()
def GetSlotIndex(self):
return self.slot
def DecreaseSlotIndex(self):
slotIndex = (self.GetSlotIndex() - 1 + self.SLOT_COUNT) % self.SLOT_COUNT
self.SelectSlot(slotIndex)
def IncreaseSlotIndex(self):
slotIndex = (self.GetSlotIndex() + 1) % self.SLOT_COUNT
self.SelectSlot(slotIndex)
def SelectSlot(self, index):
if index < 0:
return
if index >= self.SLOT_COUNT:
return
self.slot = index
chr.SelectInstance(self.slot)
for i in xrange(self.CHARACTER_TYPE_COUNT):
self.destNameAlpha[i] = 0.0
for i in xrange(self.SLOT_COUNT):
self.destRotation[(i+self.slot)%self.SLOT_COUNT] = self.SLOT_ROTATION[i]
self.destGauge = [0.0, 0.0, 0.0, 0.0]
id=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_ID)
if 0 != id:
self.btnStart.Show()
self.btnDelete.Show()
self.btnCreate.Hide()
playTime=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_PLAYTIME)
level=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_LEVEL)
race=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_RACE)
valueHTH=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_HTH)
valueINT=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_INT)
valueSTR=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_STR)
valueDEX=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_DEX)
name=net.GetAccountCharacterSlotDataString(self.slot, net.ACCOUNT_CHARACTER_SLOT_NAME)
guildID=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_GUILD_ID)
guildName=net.GetAccountCharacterSlotDataString(self.slot, net.ACCOUNT_CHARACTER_SLOT_GUILD_NAME)
self.changeNameFlag=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_CHANGE_NAME_FLAG)
job = chr.RaceToJob(race)
if job >= 0 and job < self.CHARACTER_TYPE_COUNT:
self.destNameAlpha[job] = 1.0
self.CharacterName.SetText(name)
self.CharacterLevel.SetText(str(level))
self.PlayTime.SetText(str(playTime))
self.CharacterHTH.SetText(str(valueHTH))
self.CharacterINT.SetText(str(valueINT))
self.CharacterSTR.SetText(str(valueSTR))
self.CharacterDEX.SetText(str(valueDEX))
if guildName:
self.GuildName.SetText(guildName)
else:
self.GuildName.SetText(locale.SELECT_NOT_JOIN_GUILD)
statesSummary = float(valueHTH + valueINT + valueSTR + valueDEX)
if statesSummary > 0.0:
self.destGauge = [
float(valueHTH) / statesSummary,
float(valueINT) / statesSummary,
float(valueSTR) / statesSummary,
float(valueDEX) / statesSummary
]
else:
self.InitCharacterBoard()
def InitCharacterBoard(self):
self.btnStart.Hide()
self.btnDelete.Hide()
self.btnCreate.Show()
self.CharacterName.SetText("")
self.CharacterLevel.SetText("")
self.PlayTime.SetText("")
self.CharacterHTH.SetText("")
self.CharacterINT.SetText("")
self.CharacterSTR.SetText("")
self.CharacterDEX.SetText("")
self.GuildName.SetText(locale.SELECT_NOT_JOIN_GUILD)
## Event
def OnKeyDown(self, key):
if 1 == key:
self.ExitSelect()
if 2 == key:
self.SelectSlot(0)
if 3 == key:
self.SelectSlot(1)
if 4 == key:
self.SelectSlot(2)
if 28 == key:
id = net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_ID)
if 0 == id:
self.CreateCharacter()
else:
self.StartGame()
if 203 == key:
self.slot = (self.GetSlotIndex() - 1 + self.SLOT_COUNT) % self.SLOT_COUNT
self.SelectSlot(self.slot)
if 205 == key:
self.slot = (self.GetSlotIndex() + 1) % self.SLOT_COUNT
self.SelectSlot(self.slot)
return TRUE
def OnUpdate(self):
chr.Update()
for i in xrange(4):
self.curGauge[i] += (self.destGauge[i] - self.curGauge[i]) / 10.0
if abs(self.curGauge[i] - self.destGauge[i]) < 0.005:
self.curGauge[i] = self.destGauge[i]
self.GaugeList[i].SetPercentage(self.curGauge[i], 1.0)
for i in xrange(self.CHARACTER_TYPE_COUNT):
self.curNameAlpha[i] += (self.destNameAlpha[i] - self.curNameAlpha[i]) / 10.0
self.NameList[i].SetAlpha(self.curNameAlpha[i])
for i in xrange(self.SLOT_COUNT):
if FALSE == chr.HasInstance(i):
continue
chr.SelectInstance(i)
distance = 50.0
rotRadian = self.curRotation[i] * (math.pi*2) / 360.0
x = distance*math.sin(rotRadian) + distance*math.cos(rotRadian)
y = distance*math.cos(rotRadian) - distance*math.sin(rotRadian)
chr.SetPixelPosition(int(x), int(y), 30)
#####
dir = app.GetRotatingDirection(self.destRotation[i], self.curRotation[i])
rot = app.GetDegreeDifference(self.destRotation[i], self.curRotation[i])
if app.DEGREE_DIRECTION_RIGHT == dir:
self.curRotation[i] += rot / 10.0
elif app.DEGREE_DIRECTION_LEFT == dir:
self.curRotation[i] -= rot / 10.0
self.curRotation[i] = (self.curRotation[i] + 360.0) % 360.0
#######################################################
if -1 != self.startIndex:
## Temporary
## BackGroundLoadingÀÌ Áö¿ø µÉ¶§±îÁö Àӽ÷Î..
if app.GetTime() - self.startReservingTime > 3.0:
if FALSE == self.openLoadingFlag:
chrSlot=self.stream.GetCharacterSlot()
net.DirectEnter(chrSlot)
self.openLoadingFlag = TRUE
playTime=net.GetAccountCharacterSlotDataInteger(self.slot, net.ACCOUNT_CHARACTER_SLOT_PLAYTIME)
import player
player.SetPlayTime(playTime)
import chat
chat.Clear() ## µé¾î°¥¶§ Chat À» ÃʱâÈ*. Àӽà Pos.
## Temporary
#######################################################
def EmptyFunc(self):
pass
def PopupMessage(self, msg, func=0):
if not func:
func=self.EmptyFunc
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(msg, func, locale.UI_OK)
def OnPressExitKey(self):
self.ExitSelect()
return TRUE
Meine interfaceModule.py
PHP Code:
##
## Interface
##
import constInfo
import systemSetting
import wndMgr
import chat
import app
import player
import uiTaskBar
import uiCharacter
import uiInventory
import uiChat
import uiMessenger
import guild
import ui
import uiHelp
import uiWhisper
import uiPointReset
import uiShop
import uiExchange
import uiSystem
import uiRestart
import uiToolTip
import uiMiniMap
import uiParty
import uiSafebox
import uiGuild
import uiQuest
import uiPrivateShopBuilder
import uiCommon
import uiRefine
import uiEquipmentDialog
import uiGameButton
import uiTip
import uiCube
# ACCESSORY_REFINE_ADD_METIN_STONE
import uiSelectItem
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
import event
import locale
class Interface(object):
CHARACTER_STATUS_TAB = 1
CHARACTER_SKILL_TAB = 2
def __init__(self):
systemSetting.SetInterfaceHandler(self)
self.windowOpenPosition = 0
self.dlgWhisperWithoutTarget = None
self.inputDialog = None
self.tipBoard = None
self.bigBoard = None
# ITEM_MALL
self.mallPageDlg = None
# END_OF_ITEM_MALL
self.wndWeb = None
self.wndTaskBar = None
self.wndCharacter = None
self.wndInventory = None
self.wndChat = None
self.wndMessenger = None
self.wndMiniMap = None
self.wndGuild = None
self.wndGuildBuilding = None
self.wndQuestWindow = []
self.privateShopAdvertisementBoardDict = {}
self.guildScoreBoardDict = {}
self.equipmentDialogDict = {}
event.SetInterfaceWindow(self)
def __del__(self):
systemSetting.DestroyInterfaceHandler()
event.SetInterfaceWindow(None)
################################
## Make Windows & Dialogs
def __MakeUICurtain(self):
wndUICurtain = ui.Bar("TOP_MOST")
wndUICurtain.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())
wndUICurtain.SetColor(0x77000000)
wndUICurtain.Hide()
self.wndUICurtain = wndUICurtain
def __MakeMessengerWindow(self):
self.wndMessenger = uiMessenger.MessengerWindow()
from _weakref import proxy
self.wndMessenger.SetWhisperButtonEvent(lambda n,i=proxy(self):i.OpenWhisperDialog(n))
self.wndMessenger.SetGuildButtonEvent(ui.__mem_func__(self.ToggleGuildWindow))
def __MakeGuildWindow(self):
self.wndGuild = uiGuild.GuildWindow()
def __MakeChatWindow(self):
CHAT_WINDOW_WIDTH = 600
wndChat = uiChat.ChatWindow()
wndChat.SetSize(CHAT_WINDOW_WIDTH, 25)
wndChat.SetPosition(wndMgr.GetScreenWidth()/2 - CHAT_WINDOW_WIDTH/2, wndMgr.GetScreenHeight() - wndChat.GetHeight() - 37)
wndChat.SetHeight(200)
wndChat.Refresh()
wndChat.Show()
self.wndChat = wndChat
self.wndChat.BindInterface(self)
self.wndChat.SetSendWhisperEvent(ui.__mem_func__(self.OpenWhisperDialogWithoutTarget))
self.wndChat.SetOpenChatLogEvent(ui.__mem_func__(self.ToggleChatLogWindow))
def __MakeTaskBar(self):
wndTaskBar = uiTaskBar.TaskBar()
wndTaskBar.LoadWindow()
self.wndTaskBar = wndTaskBar
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_CHARACTER, ui.__mem_func__(self.ToggleCharacterWindowStatusPage))
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_INVENTORY, ui.__mem_func__(self.ToggleInventoryWindow))
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_MESSENGER, ui.__mem_func__(self.ToggleMessenger))
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_SYSTEM, ui.__mem_func__(self.ToggleSystemDialog))
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_CHAT, ui.__mem_func__(self.ToggleChat))
def __MakeParty(self):
wndParty = uiParty.PartyWindow()
wndParty.Hide()
self.wndParty = wndParty
def __MakeGameButtonWindow(self):
wndGameButton = uiGameButton.GameButtonWindow()
wndGameButton.SetTop()
wndGameButton.Show()
wndGameButton.SetButtonEvent("STATUS", ui.__mem_func__(self.__OnClickStatusPlusButton))
wndGameButton.SetButtonEvent("SKILL", ui.__mem_func__(self.__OnClickSkillPlusButton))
wndGameButton.SetButtonEvent("QUEST", ui.__mem_func__(self.__OnClickQuestButton))
wndGameButton.SetButtonEvent("HELP", ui.__mem_func__(self.__OnClickHelpButton))
wndGameButton.SetButtonEvent("BUILD", ui.__mem_func__(self.__OnClickBuildButton))
self.wndGameButton = wndGameButton
def __IsChatOpen(self):
return TRUE
def __MakeWindows(self):
wndCharacter = uiCharacter.CharacterWindow()
wndInventory = uiInventory.InventoryWindow()
wndMiniMap = uiMiniMap.MiniMap()
wndSafebox = uiSafebox.SafeboxWindow()
# ITEM_MALL
wndMall = uiSafebox.MallWindow()
self.wndMall = wndMall
# END_OF_ITEM_MALL
wndChatLog = uiChat.ChatLogWindow()
wndChatLog.BindInterface(self)
self.wndCharacter = wndCharacter
self.wndInventory = wndInventory
self.wndMiniMap = wndMiniMap
self.wndSafebox = wndSafebox
self.wndChatLog = wndChatLog
def __MakeDialogs(self):
self.dlgExchange = uiExchange.ExchangeDialog()
self.dlgExchange.LoadDialog()
self.dlgExchange.SetCenterPosition()
self.dlgExchange.Hide()
self.dlgPointReset = uiPointReset.PointResetDialog()
self.dlgPointReset.LoadDialog()
self.dlgPointReset.Hide()
self.dlgShop = uiShop.ShopDialog()
self.dlgShop.LoadDialog()
self.dlgShop.Hide()
self.dlgRestart = uiRestart.RestartDialog()
self.dlgRestart.LoadDialog()
self.dlgRestart.Hide()
self.dlgSystem = uiSystem.SystemDialog()
self.dlgSystem.LoadDialog()
self.dlgSystem.SetOpenHelpWindowEvent(ui.__mem_func__(self.OpenHelpWindow))
self.dlgSystem.Hide()
self.dlgPassword = uiSafebox.PasswordDialog()
self.dlgPassword.Hide()
self.hyperlinkItemTooltip = uiToolTip.HyperlinkItemToolTip()
self.hyperlinkItemTooltip.Hide()
self.tooltipItem = uiToolTip.ItemToolTip()
self.tooltipItem.Hide()
self.tooltipSkill = uiToolTip.SkillToolTip()
self.tooltipSkill.Hide()
self.privateShopBuilder = uiPrivateShopBuilder.PrivateShopBuilder()
self.privateShopBuilder.Hide()
self.dlgRefineNew = uiRefine.RefineDialogNew()
self.dlgRefineNew.Hide()
def __MakeHelpWindow(self):
self.wndHelp = uiHelp.HelpWindow()
self.wndHelp.LoadDialog()
self.wndHelp.SetCloseEvent(ui.__mem_func__(self.CloseHelpWindow))
self.wndHelp.Hide()
def __MakeTipBoard(self):
self.tipBoard = uiTip.TipBoard()
self.tipBoard.Hide()
self.bigBoard = uiTip.BigBoard()
self.bigBoard.Hide()
def __MakeWebWindow(self):
if constInfo.IN_GAME_SHOP_ENABLE:
import uiWeb
self.wndWeb = uiWeb.WebWindow()
self.wndWeb.LoadWindow()
self.wndWeb.Hide()
def __MakeCubeWindow(self):
self.wndCube = uiCube.CubeWindow()
self.wndCube.LoadWindow()
self.wndCube.Hide()
def __MakeCubeResultWindow(self):
self.wndCubeResult = uiCube.CubeResultWindow()
self.wndCubeResult.LoadWindow()
self.wndCubeResult.Hide()
# ACCESSORY_REFINE_ADD_METIN_STONE
def __MakeItemSelectWindow(self):
self.wndItemSelect = uiSelectItem.SelectItemWindow()
self.wndItemSelect.Hide()
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
def MakeInterface(self):
self.__MakeMessengerWindow()
self.__MakeGuildWindow()
self.__MakeChatWindow()
self.__MakeParty()
self.__MakeWindows()
self.__MakeDialogs()
self.__MakeUICurtain()
self.__MakeTaskBar()
self.__MakeGameButtonWindow()
self.__MakeHelpWindow()
self.__MakeTipBoard()
self.__MakeWebWindow()
self.__MakeCubeWindow()
self.__MakeCubeResultWindow()
# ACCESSORY_REFINE_ADD_METIN_STONE
self.__MakeItemSelectWindow()
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
self.questButtonList = []
self.whisperButtonList = []
self.whisperDialogDict = {}
self.privateShopAdvertisementBoardDict = {}
self.wndInventory.SetItemToolTip(self.tooltipItem)
self.wndSafebox.SetItemToolTip(self.tooltipItem)
self.wndCube.SetItemToolTip(self.tooltipItem)
self.wndCubeResult.SetItemToolTip(self.tooltipItem)
# ITEM_MALL
self.wndMall.SetItemToolTip(self.tooltipItem)
# END_OF_ITEM_MALL
self.wndCharacter.SetSkillToolTip(self.tooltipSkill)
self.wndTaskBar.SetItemToolTip(self.tooltipItem)
self.wndTaskBar.SetSkillToolTip(self.tooltipSkill)
self.wndGuild.SetSkillToolTip(self.tooltipSkill)
# ACCESSORY_REFINE_ADD_METIN_STONE
self.wndItemSelect.SetItemToolTip(self.tooltipItem)
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
self.dlgShop.SetItemToolTip(self.tooltipItem)
self.dlgExchange.SetItemToolTip(self.tooltipItem)
self.privateShopBuilder.SetItemToolTip(self.tooltipItem)
self.__InitWhisper()
def MakeHyperlinkTooltip(self, hyperlink):
tokens = hyperlink.split(":")
if tokens and len(tokens):
type = tokens[0]
if "item" == type:
self.hyperlinkItemTooltip.SetHyperlinkItem(tokens)
## Make Windows & Dialogs
################################
def Close(self):
if self.dlgWhisperWithoutTarget:
self.dlgWhisperWithoutTarget.Destroy()
del self.dlgWhisperWithoutTarget
if uiQuest.QuestDialog.__dict__.has_key("QuestCurtain"):
uiQuest.QuestDialog.QuestCurtain.Close()
if self.wndQuestWindow:
for eachQuestWindow in self.wndQuestWindow:
eachQuestWindow.nextCurtainMode = -1
eachQuestWindow.CloseSelf()
eachQuestWindow = None
if self.wndChat:
self.wndChat.Destroy()
if self.wndTaskBar:
self.wndTaskBar.Destroy()
if self.wndCharacter:
self.wndCharacter.Destroy()
if self.wndInventory:
self.wndInventory.Destroy()
if self.dlgExchange:
self.dlgExchange.Destroy()
if self.dlgPointReset:
self.dlgPointReset.Destroy()
if self.dlgShop:
self.dlgShop.Destroy()
if self.dlgRestart:
self.dlgRestart.Destroy()
if self.dlgSystem:
self.dlgSystem.Destroy()
if self.dlgPassword:
self.dlgPassword.Destroy()
if self.wndMiniMap:
self.wndMiniMap.Destroy()
if self.wndSafebox:
self.wndSafebox.Destroy()
if self.wndWeb:
self.wndWeb.Destroy()
self.wndWeb = None
if self.wndMall:
self.wndMall.Destroy()
if self.wndParty:
self.wndParty.Destroy()
if self.wndHelp:
self.wndHelp.Destroy()
if self.wndCube:
self.wndCube.Destroy()
if self.wndCubeResult:
self.wndCubeResult.Destroy()
if self.wndMessenger:
self.wndMessenger.Destroy()
if self.wndGuild:
self.wndGuild.Destroy()
if self.privateShopBuilder:
self.privateShopBuilder.Destroy()
if self.dlgRefineNew:
self.dlgRefineNew.Destroy()
if self.wndGuildBuilding:
self.wndGuildBuilding.Destroy()
if self.wndGameButton:
self.wndGameButton.Destroy()
# ITEM_MALL
if self.mallPageDlg:
self.mallPageDlg.Destroy()
# END_OF_ITEM_MALL
# ACCESSORY_REFINE_ADD_METIN_STONE
if self.wndItemSelect:
self.wndItemSelect.Destroy()
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
self.wndChatLog.Destroy()
for btn in self.questButtonList:
btn.SetEvent(0)
for btn in self.whisperButtonList:
btn.SetEvent(0)
for dlg in self.whisperDialogDict.itervalues():
dlg.Destroy()
for brd in self.guildScoreBoardDict.itervalues():
brd.Destroy()
for dlg in self.equipmentDialogDict.itervalues():
dlg.Destroy()
# ITEM_MALL
del self.mallPageDlg
# END_OF_ITEM_MALL
del self.wndGuild
del self.wndMessenger
del self.wndUICurtain
del self.wndChat
del self.wndTaskBar
del self.wndCharacter
del self.wndInventory
del self.dlgExchange
del self.dlgPointReset
del self.dlgShop
del self.dlgRestart
del self.dlgSystem
del self.dlgPassword
del self.hyperlinkItemTooltip
del self.tooltipItem
del self.tooltipSkill
del self.wndMiniMap
del self.wndSafebox
del self.wndMall
del self.wndParty
del self.wndHelp
del self.wndCube
del self.wndCubeResult
del self.privateShopBuilder
del self.inputDialog
del self.wndChatLog
del self.dlgRefineNew
del self.wndGuildBuilding
del self.wndGameButton
del self.tipBoard
del self.bigBoard
del self.wndItemSelect
self.questButtonList = []
self.whisperButtonList = []
self.whisperDialogDict = {}
self.privateShopAdvertisementBoardDict = {}
self.guildScoreBoardDict = {}
self.equipmentDialogDict = {}
uiChat.DestroyChatInputSetWindow()
## Skill
def OnUseSkill(self, slotIndex, coolTime):
self.wndCharacter.OnUseSkill(slotIndex, coolTime)
self.wndTaskBar.OnUseSkill(slotIndex, coolTime)
self.wndGuild.OnUseSkill(slotIndex, coolTime)
def OnActivateSkill(self, slotIndex):
self.wndCharacter.OnActivateSkill(slotIndex)
self.wndTaskBar.OnActivateSkill(slotIndex)
def OnDeactivateSkill(self, slotIndex):
self.wndCharacter.OnDeactivateSkill(slotIndex)
self.wndTaskBar.OnDeactivateSkill(slotIndex)
def OnChangeCurrentSkill(self, skillSlotNumber):
self.wndTaskBar.OnChangeCurrentSkill(skillSlotNumber)
def SelectMouseButtonEvent(self, dir, event):
self.wndTaskBar.SelectMouseButtonEvent(dir, event)
## Refresh
def RefreshAlignment(self):
self.wndCharacter.RefreshAlignment()
def RefreshStatus(self):
self.wndTaskBar.RefreshStatus()
self.wndCharacter.RefreshStatus()
self.wndInventory.RefreshStatus()
def RefreshStamina(self):
self.wndTaskBar.RefreshStamina()
def RefreshSkill(self):
self.wndCharacter.RefreshSkill()
self.wndTaskBar.RefreshSkill()
def RefreshInventory(self):
self.wndTaskBar.RefreshQuickSlot()
self.wndInventory.RefreshItemSlot()
def RefreshCharacter(self): ## Character ÆäÀÌÁöÀÇ ¾ó±¼, Inventory ÆäÀÌÁöÀÇ Àü½Å ±×¸² µîÀÇ Refresh
self.wndCharacter.RefreshCharacter()
self.wndTaskBar.RefreshQuickSlot()
def RefreshQuest(self):
self.wndCharacter.RefreshQuest()
def RefreshSafebox(self):
self.wndSafebox.RefreshSafebox()
# ITEM_MALL
def RefreshMall(self):
self.wndMall.RefreshMall()
def OpenItemMall(self):
if not self.mallPageDlg:
self.mallPageDlg = uiShop.MallPageDialog()
self.mallPageDlg.Open()
# END_OF_ITEM_MALL
def RefreshMessenger(self):
self.wndMessenger.RefreshMessenger()
def RefreshGuildInfoPage(self):
self.wndGuild.RefreshGuildInfoPage()
def RefreshGuildBoardPage(self):
self.wndGuild.RefreshGuildBoardPage()
def RefreshGuildMemberPage(self):
self.wndGuild.RefreshGuildMemberPage()
def RefreshGuildMemberPageGradeComboBox(self):
self.wndGuild.RefreshGuildMemberPageGradeComboBox()
def RefreshGuildSkillPage(self):
self.wndGuild.RefreshGuildSkillPage()
def RefreshGuildGradePage(self):
self.wndGuild.RefreshGuildGradePage()
def DeleteGuild(self):
self.wndMessenger.ClearGuildMember()
self.wndGuild.DeleteGuild()
def RefreshMobile(self):
self.dlgSystem.RefreshMobile()
def OnMobileAuthority(self):
self.dlgSystem.OnMobileAuthority()
def OnBlockMode(self, mode):
self.dlgSystem.OnBlockMode(mode)
## Calling Functions
# PointReset
def OpenPointResetDialog(self):
self.dlgPointReset.Show()
self.dlgPointReset.SetTop()
def ClosePointResetDialog(self):
self.dlgPointReset.Close()
# Shop
def OpenShopDialog(self, vid):
self.wndInventory.Show()
self.wndInventory.SetTop()
self.dlgShop.Open(vid)
self.dlgShop.SetTop()
def CloseShopDialog(self):
self.dlgShop.Close()
def RefreshShopDialog(self):
self.dlgShop.Refresh()
## Quest
def OpenCharacterWindowQuestPage(self):
self.wndCharacter.Show()
self.wndCharacter.SetState("QUEST")
def OpenQuestWindow(self, skin, idx):
wnds = ()
q = uiQuest.QuestDialog(skin, idx)
q.SetWindowName("QuestWindow" + str(idx))
q.Show()
if skin:
q.Lock()
wnds = self.__HideWindows()
# UNKNOWN_UPDATE
q.SetOnDoneEvent(lambda tmp_self, args=wnds: self.__ShowWindows(args))
# END_OF_UNKNOWN_UPDATE
if skin:
q.AddOnCloseEvent(q.Unlock)
q.AddOnCloseEvent(lambda s = self, qw = q: s.__dict__.__getitem__("wndQuestWindow").remove(qw))
# UNKNOWN_UPDATE
self.wndQuestWindow.append(q)
# END_OF_UNKNOWN_UPDATE
## Exchange
def StartExchange(self):
self.dlgExchange.OpenDialog()
self.dlgExchange.Refresh()
def EndExchange(self):
self.dlgExchange.CloseDialog()
def RefreshExchange(self):
self.dlgExchange.Refresh()
## Party
def AddPartyMember(self, pid, name):
self.wndParty.AddPartyMember(pid, name)
self.__ArrangeQuestButton()
def UpdatePartyMemberInfo(self, pid):
self.wndParty.UpdatePartyMemberInfo(pid)
def RemovePartyMember(self, pid):
self.wndParty.RemovePartyMember(pid)
##!! 20061026.levites.Äù½ºÆ®_À§Ä¡_º¸Á¤
self.__ArrangeQuestButton()
def LinkPartyMember(self, pid, vid):
self.wndParty.LinkPartyMember(pid, vid)
def UnlinkPartyMember(self, pid):
self.wndParty.UnlinkPartyMember(pid)
def UnlinkAllPartyMember(self):
self.wndParty.UnlinkAllPartyMember()
def ExitParty(self):
self.wndParty.ExitParty()
##!! 20061026.levites.Äù½ºÆ®_À§Ä¡_º¸Á¤
self.__ArrangeQuestButton()
def PartyHealReady(self):
self.wndParty.PartyHealReady()
def ChangePartyParameter(self, distributionMode):
self.wndParty.ChangePartyParameter(distributionMode)
## Safebox
def AskSafeboxPassword(self):
if self.wndSafebox.IsShow():
return
# SAFEBOX_PASSWORD
self.dlgPassword.SetTitle(locale.PASSWORD_TITLE)
self.dlgPassword.SetSendMessage("/safebox_password ")
# END_OF_SAFEBOX_PASSWORD
self.dlgPassword.ShowDialog()
def OpenSafeboxWindow(self, size):
self.dlgPassword.CloseDialog()
self.wndSafebox.ShowWindow(size)
def RefreshSafeboxMoney(self):
self.wndSafebox.RefreshSafeboxMoney()
def CommandCloseSafebox(self):
self.wndSafebox.CommandCloseSafebox()
# ITEM_MALL
def AskMallPassword(self):
if self.wndMall.IsShow():
return
self.dlgPassword.SetTitle(locale.MALL_PASSWORD_TITLE)
self.dlgPassword.SetSendMessage("/mall_password ")
self.dlgPassword.ShowDialog()
def OpenMallWindow(self, size):
self.dlgPassword.CloseDialog()
self.wndMall.ShowWindow(size)
def CommandCloseMall(self):
self.wndMall.CommandCloseMall()
# END_OF_ITEM_MALL
## Guild
def OnStartGuildWar(self, guildSelf, guildOpp):
self.wndGuild.OnStartGuildWar(guildSelf, guildOpp)
guildWarScoreBoard = uiGuild.GuildWarScoreBoard()
guildWarScoreBoard.Open(guildSelf, guildOpp)
guildWarScoreBoard.Show()
self.guildScoreBoardDict[uiGuild.GetGVGKey(guildSelf, guildOpp)] = guildWarScoreBoard
def OnEndGuildWar(self, guildSelf, guildOpp):
self.wndGuild.OnEndGuildWar(guildSelf, guildOpp)
key = uiGuild.GetGVGKey(guildSelf, guildOpp)
if not self.guildScoreBoardDict.has_key(key):
return
self.guildScoreBoardDict[key].Destroy()
del self.guildScoreBoardDict[key]
# GUILDWAR_MEMBER_COUNT
def UpdateMemberCount(self, gulidID1, memberCount1, guildID2, memberCount2):
key = uiGuild.GetGVGKey(gulidID1, guildID2)
if not self.guildScoreBoardDict.has_key(key):
return
self.guildScoreBoardDict[key].UpdateMemberCount(gulidID1, memberCount1, guildID2, memberCount2)
# END_OF_GUILDWAR_MEMBER_COUNT
def OnRecvGuildWarPoint(self, gainGuildID, opponentGuildID, point):
key = uiGuild.GetGVGKey(gainGuildID, opponentGuildID)
if not self.guildScoreBoardDict.has_key(key):
return
guildBoard = self.guildScoreBoardDict[key]
guildBoard.SetScore(gainGuildID, opponentGuildID, point)
## PK Mode
def OnChangePKMode(self):
self.wndCharacter.RefreshAlignment()
self.dlgSystem.OnChangePKMode()
## Refine
def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, type):
self.dlgRefineNew.Open(targetItemPos, nextGradeItemVnum, cost, prob, type)
def AppendMaterialToRefineDialog(self, vnum, count):
self.dlgRefineNew.AppendMaterial(vnum, count)
## Show & Hide
def ShowDefaultWindows(self):
self.wndTaskBar.Show()
self.wndMiniMap.Show()
self.wndMiniMap.ShowMiniMap()
def ShowAllWindows(self):
self.wndTaskBar.Show()
self.wndCharacter.Show()
self.wndInventory.Show()
self.wndChat.Show()
self.wndMiniMap.Show()
def HideAllWindows(self):
if self.wndTaskBar:
self.wndTaskBar.Hide()
if self.wndCharacter:
self.wndCharacter.Hide()
if self.wndInventory:
self.wndInventory.Hide()
if self.wndChat:
self.wndChat.Hide()
if self.wndMiniMap:
self.wndMiniMap.Hide()
if self.wndMessenger:
self.wndMessenger.Hide()
if self.wndGuild:
self.wndGuild.Hide()
def ShowMouseImage(self):
self.wndTaskBar.ShowMouseImage()
def HideMouseImage(self):
self.wndTaskBar.HideMouseImage()
def ToggleChat(self):
if TRUE == self.wndChat.IsEditMode():
self.wndChat.CloseChat()
else:
# À¥ÆäÀÌÁö°¡ ¿*·ÈÀ»¶§´Â äÆà ÀÔ·ÂÀÌ ¾ÈµÊ
if self.wndWeb and self.wndWeb.IsShow():
pass
else:
self.wndChat.OpenChat()
def IsOpenChat(self):
return self.wndChat.IsEditMode()
def SetChatFocus(self):
self.wndChat.SetChatFocus()
def OpenRestartDialog(self):
self.dlgRestart.OpenDialog()
self.dlgRestart.SetTop()
def CloseRestartDialog(self):
self.dlgRestart.Close()
def ToggleSystemDialog(self):
if FALSE == self.dlgSystem.IsShow():
self.dlgSystem.OpenDialog()
self.dlgSystem.SetTop()
else:
self.dlgSystem.Close()
def OpenSystemDialog(self):
self.dlgSystem.OpenDialog()
self.dlgSystem.SetTop()
def ToggleMessenger(self):
if self.wndMessenger.IsShow():
self.wndMessenger.Hide()
else:
self.wndMessenger.SetTop()
self.wndMessenger.Show()
def ToggleMiniMap(self):
if app.IsPressed(app.DIK_LSHIFT) or app.IsPressed(app.DIK_RSHIFT):
if FALSE == self.wndMiniMap.isShowMiniMap():
self.wndMiniMap.ShowMiniMap()
self.wndMiniMap.SetTop()
else:
self.wndMiniMap.HideMiniMap()
else:
self.wndMiniMap.ToggleAtlasWindow()
def PressMKey(self):
if app.IsPressed(app.DIK_LALT) or app.IsPressed(app.DIK_RALT):
self.ToggleMessenger()
else:
self.ToggleMiniMap()
def SetMapName(self, mapName):
self.wndMiniMap.SetMapName(mapName)
def MiniMapScaleUp(self):
self.wndMiniMap.ScaleUp()
def MiniMapScaleDown(self):
self.wndMiniMap.ScaleDown()
def ToggleCharacterWindow(self, state):
if FALSE == player.IsObserverMode():
if FALSE == self.wndCharacter.IsShow():
self.OpenCharacterWindowWithState(state)
else:
if state == self.wndCharacter.GetState():
self.wndCharacter.OverOutItem()
self.wndCharacter.Hide()
else:
self.wndCharacter.SetState(state)
def OpenCharacterWindowWithState(self, state):
if FALSE == player.IsObserverMode():
self.wndCharacter.SetState(state)
self.wndCharacter.Show()
self.wndCharacter.SetTop()
def ToggleCharacterWindowStatusPage(self):
self.ToggleCharacterWindow("STATUS")
def ToggleInventoryWindow(self):
if FALSE == player.IsObserverMode():
if FALSE == self.wndInventory.IsShow():
self.wndInventory.Show()
self.wndInventory.SetTop()
else:
self.wndInventory.OverOutItem()
self.wndInventory.Hide()
def ToggleGuildWindow(self):
if not self.wndGuild.IsShow():
if self.wndGuild.CanOpen():
self.wndGuild.Open()
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GUILD_YOU_DO_NOT_JOIN)
else:
self.wndGuild.OverOutItem()
self.wndGuild.Hide()
def ToggleChatLogWindow(self):
if self.wndChatLog.IsShow():
self.wndChatLog.Hide()
else:
self.wndChatLog.Show()
def CheckGameButton(self):
if self.wndGameButton:
self.wndGameButton.CheckGameButton()
def __OnClickStatusPlusButton(self):
self.ToggleCharacterWindow("STATUS")
def __OnClickSkillPlusButton(self):
self.ToggleCharacterWindow("SKILL")
def __OnClickQuestButton(self):
self.ToggleCharacterWindow("QUEST")
def __OnClickHelpButton(self):
player.SetPlayTime(1)
self.CheckGameButton()
self.OpenHelpWindow()
def __OnClickBuildButton(self):
self.BUILD_OpenWindow()
def OpenHelpWindow(self):
self.wndUICurtain.Show()
self.wndHelp.Open()
def CloseHelpWindow(self):
self.wndUICurtain.Hide()
self.wndHelp.Close()
def OpenWebWindow(self, url):
self.wndWeb.Open(url)
# À¥ÆäÀÌÁö¸¦ ¿*¸é äÆÃÀ» ´Ý´Â´Ù
self.wndChat.CloseChat()
def CloseWebWindow(self):
self.wndWeb.Close()
def OpenCubeWindow(self):
self.wndCube.Open()
if FALSE == self.wndInventory.IsShow():
self.wndInventory.Show()
def CloseCubeWindow(self):
self.wndCube.Close()
def SucceedCubeWork(self, itemVnum, count):
self.wndCube.Clear()
print "Å¥ºê Á¦ÀÛ ¼º°ø! [%d:%d]" % (itemVnum, count)
if 0: # °á°ú ¸Þ½ÃÁö Ãâ·ÂÀº »ý·« ÇÑ´Ù
self.wndCubeResult.SetPosition(*self.wndCube.GetGlobalPosition())
self.wndCubeResult.SetCubeResultItem(itemVnum, count)
self.wndCubeResult.Open()
self.wndCubeResult.SetTop()
def __HideWindows(self):
hideWindows = self.wndTaskBar,\
self.wndCharacter,\
self.wndInventory,\
self.wndMiniMap,\
self.wndGuild,\
self.wndMessenger,\
self.wndChat,\
self.wndParty,\
self.wndGameButton,
hideWindows = filter(lambda x:x.IsShow(), hideWindows)
map(lambda x:x.Hide(), hideWindows)
self.HideAllQuestButton()
self.HideAllWhisperButton()
if self.wndChat.IsEditMode():
self.wndChat.CloseChat()
return hideWindows
def __ShowWindows(self, wnds):
map(lambda x:x.Show(), wnds)
self.ShowAllQuestButton()
self.ShowAllWhisperButton()
def BINARY_OpenAtlasWindow(self):
self.wndMiniMap.AtlasWindow.Show()
def BINARY_SetObserverMode(self, flag):
self.wndGameButton.SetObserverMode(flag)
# ACCESSORY_REFINE_ADD_METIN_STONE
def BINARY_OpenSelectItemWindow(self):
self.wndItemSelect.Open()
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
#####################################################################################
### Private Shop ###
def OpenPrivateShopInputNameDialog(self):
#if player.IsInSafeArea():
# chat.AppendChat(chat.CHAT_TYPE_INFO, locale.CANNOT_OPEN_PRIVATE_SHOP_IN_SAFE_AREA)
# return
inputDialog = uiCommon.InputDialog()
inputDialog.Open()
inputDialog.SetTitle(locale.PRIVATE_SHOP_INPUT_NAME_DIALOG_TITLE)
inputDialog.SetMaxLength(32)
inputDialog.SetAcceptEvent(ui.__mem_func__(self.OpenPrivateShopBuilder))
inputDialog.SetCancelEvent(ui.__mem_func__(self.ClosePrivateShopInputNameDialog))
self.inputDialog = inputDialog
def ClosePrivateShopInputNameDialog(self):
self.inputDialog = None
return TRUE
def OpenPrivateShopBuilder(self):
if not self.inputDialog:
return TRUE
if not len(self.inputDialog.GetText()):
return TRUE
self.privateShopBuilder.Open(self.inputDialog.GetText())
self.ClosePrivateShopInputNameDialog()
return TRUE
def AppearPrivateShop(self, vid, text):
board = uiPrivateShopBuilder.PrivateShopAdvertisementBoard()
board.Open(vid, text)
self.privateShopAdvertisementBoardDict[vid] = board
def DisappearPrivateShop(self, vid):
if not self.privateShopAdvertisementBoardDict.has_key(vid):
return
del self.privateShopAdvertisementBoardDict[vid]
#####################################################################################
### Equipment ###
def OpenEquipmentDialog(self, vid):
dlg = uiEquipmentDialog.EquipmentDialog()
dlg.SetItemToolTip(self.tooltipItem)
dlg.SetCloseEvent(ui.__mem_func__(self.CloseEquipmentDialog))
dlg.Open(vid)
self.equipmentDialogDict[vid] = dlg
def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
if not vid in self.equipmentDialogDict:
return
self.equipmentDialogDict[vid].SetEquipmentDialogItem(slotIndex, vnum, count)
def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
if not vid in self.equipmentDialogDict:
return
self.equipmentDialogDict[vid].SetEquipmentDialogSocket(slotIndex, socketIndex, value)
def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
if not vid in self.equipmentDialogDict:
return
self.equipmentDialogDict[vid].SetEquipmentDialogAttr(slotIndex, attrIndex, type, value)
def CloseEquipmentDialog(self, vid):
if not vid in self.equipmentDialogDict:
return
del self.equipmentDialogDict[vid]
#####################################################################################
#####################################################################################
### Quest ###
def BINARY_ClearQuest(self, index):
btn = self.__FindQuestButton(index)
if 0 != btn:
self.__DestroyQuestButton(btn)
def RecvQuest(self, index, name):
# QUEST_LETTER_IMAGE
self.BINARY_RecvQuest(index, name, "file", locale.GetLetterImageName())
# END_OF_QUEST_LETTER_IMAGE
def BINARY_RecvQuest(self, index, name, iconType, iconName):
btn = self.__FindQuestButton(index)
if 0 != btn:
self.__DestroyQuestButton(btn)
btn = uiWhisper.WhisperButton()
# QUEST_LETTER_IMAGE
##!! 20061026.levites.Äù½ºÆ®_À̹ÌÁö_±³Ã¼
import item
if "item"==iconType:
item.SelectItem(int(iconName))
buttonImageFileName=item.GetIconImageFileName()
else:
buttonImageFileName=iconName
if locale.IsEUROPE():
btn.SetUpVisual(locale.GetLetterCloseImageName())
btn.SetOverVisual(locale.GetLetterOpenImageName())
btn.SetDownVisual(locale.GetLetterOpenImageName())
else:
btn.SetUpVisual(buttonImageFileName)
btn.SetOverVisual(buttonImageFileName)
btn.SetDownVisual(buttonImageFileName)
btn.Flash()
# END_OF_QUEST_LETTER_IMAGE
btn.SetToolTipText(name, -20, 35)
btn.ToolTipText.SetHorizontalAlignLeft()
btn.SetEvent(ui.__mem_func__(self.__StartQuest), btn)
btn.Show()
btn.index = index
btn.name = name
self.questButtonList.insert(0, btn)
self.__ArrangeQuestButton()
#chat.AppendChat(chat.CHAT_TYPE_NOTICE, locale.QUEST_APPEND)
def __ArrangeQuestButton(self):
screenWidth = wndMgr.GetScreenWidth()
screenHeight = wndMgr.GetScreenHeight()
##!! 20061026.levites.Äù½ºÆ®_À§Ä¡_º¸Á¤
if self.wndParty.IsShow():
xPos = 100 + 30
else:
xPos = 20
yPos = 170 * screenHeight / 600
yCount = (screenHeight - 330) / 63
count = 0
for btn in self.questButtonList:
btn.SetPosition(xPos + (int(count/yCount) * 100), yPos + (count%yCount * 63))
count += 1
def __StartQuest(self, btn):
event.QuestButtonClick(btn.index)
self.__DestroyQuestButton(btn)
def __FindQuestButton(self, index):
for btn in self.questButtonList:
if btn.index == index:
return btn
return 0
def __DestroyQuestButton(self, btn):
btn.SetEvent(0)
self.questButtonList.remove(btn)
self.__ArrangeQuestButton()
def HideAllQuestButton(self):
for btn in self.questButtonList:
btn.Hide()
def ShowAllQuestButton(self):
for btn in self.questButtonList:
btn.Show()
#####################################################################################
#####################################################################################
### Whisper ###
def __InitWhisper(self):
chat.InitWhisper(self)
## äÆÃâÀÇ "¸Þ½ÃÁö º¸³»±â"¸¦ ´*·¶À»¶§ À̸§ ¾ø´Â ´ëÈ*âÀ» ¿©´Â ÇÔ¼ö
## À̸§ÀÌ ¾ø±â ¶§¹®¿¡ ±âÁ¸ÀÇ WhisperDialogDict ¿Í º°µµ·Î °ü¸®µÈ´Ù.
def OpenWhisperDialogWithoutTarget(self):
if not self.dlgWhisperWithoutTarget:
dlgWhisper = uiWhisper.WhisperDialog(self.MinimizeWhisperDialog, self.CloseWhisperDialog)
dlgWhisper.BindInterface(self)
dlgWhisper.LoadDialog()
dlgWhisper.OpenWithoutTarget(self.RegisterTemporaryWhisperDialog)
dlgWhisper.SetPosition(self.windowOpenPosition*30,self.windowOpenPosition*30)
dlgWhisper.Show()
self.dlgWhisperWithoutTarget = dlgWhisper
self.windowOpenPosition = (self.windowOpenPosition+1) % 5
else:
self.dlgWhisperWithoutTarget.SetTop()
self.dlgWhisperWithoutTarget.OpenWithoutTarget(self.RegisterTemporaryWhisperDialog)
## À̸§ ¾ø´Â ´ëÈ*â¿¡¼* À̸§À» °áÁ¤ÇßÀ»¶§ WhisperDialogDict¿¡ âÀ» ³Ö¾îÁÖ´Â ÇÔ¼ö
def RegisterTemporaryWhisperDialog(self, name):
if not self.dlgWhisperWithoutTarget:
return
btn = self.__FindWhisperButton(name)
if 0 != btn:
self.__DestroyWhisperButton(btn)
elif self.whisperDialogDict.has_key(name):
oldDialog = self.whisperDialogDict[name]
oldDialog.Destroy()
del self.whisperDialogDict[name]
self.whisperDialogDict[name] = self.dlgWhisperWithoutTarget
self.dlgWhisperWithoutTarget.OpenWithTarget(name)
self.dlgWhisperWithoutTarget = None
## ij¸¯ÅÍ ¸Þ´ºÀÇ 1:1 ´ëÈ* Çϱ⸦ ´*·¶À»¶§ À̸§À» °¡Áö°í ¹Ù·Î âÀ» ¿©´Â ÇÔ¼ö
def OpenWhisperDialog(self, name):
if not self.whisperDialogDict.has_key(name):
dlg = self.__MakeWhisperDialog(name)
dlg.OpenWithTarget(name)
dlg.chatLine.SetFocus()
dlg.Show()
btn = self.__FindWhisperButton(name)
if 0 != btn:
self.__DestroyWhisperButton(btn)
## ´Ù¸¥ ij¸¯ÅͷκÎÅÍ ¸Þ¼¼Áö¸¦ ¹Þ¾ÒÀ»¶§ ÀÏ´Ü ¹öÆ°¸¸ ¶ç¿ö µÎ´Â ÇÔ¼ö
def RecvWhisper(self, name):
if not self.whisperDialogDict.has_key(name):
btn = self.__FindWhisperButton(name)
if 0 == btn:
btn = self.__MakeWhisperButton(name)
btn.Flash()
chat.AppendChat(chat.CHAT_TYPE_NOTICE, locale.RECEIVE_MESSAGE % (name))
else:
btn.Flash()
def MakeWhisperButton(self, name):
self.__MakeWhisperButton(name)
## ¹öÆ°À» ´*·¶À»¶§ âÀ» ¿©´Â ÇÔ¼ö
def ShowWhisperDialog(self, btn):
try:
self.__MakeWhisperDialog(btn.name)
dlgWhisper = self.whisperDialogDict[btn.name]
dlgWhisper.OpenWithTarget(btn.name)
dlgWhisper.Show()
except:
import dbg
dbg.TraceError("interface.ShowWhisperDialog - Failed to find key")
## ¹öÆ° ÃʱâÈ*
self.__DestroyWhisperButton(btn)
## WhisperDialog â¿¡¼* ÃÖ¼ÒÈ* ¸í·ÉÀ» ¼öÇàÇßÀ»¶§ È£ÃâµÇ´Â ÇÔ¼ö
## âÀ» ÃÖ¼ÒÈ* ÇÕ´Ï´Ù.
def MinimizeWhisperDialog(self, name):
if 0 != name:
self.__MakeWhisperButton(name)
self.CloseWhisperDialog(name)
## WhisperDialog â¿¡¼* ´Ý±â ¸í·ÉÀ» ¼öÇàÇßÀ»¶§ È£ÃâµÇ´Â ÇÔ¼ö
## âÀ» Áö¿ó´Ï´Ù.
def CloseWhisperDialog(self, name):
if 0 == name:
if self.dlgWhisperWithoutTarget:
self.dlgWhisperWithoutTarget.Destroy()
self.dlgWhisperWithoutTarget = None
return
try:
dlgWhisper = self.whisperDialogDict[name]
dlgWhisper.Destroy()
del self.whisperDialogDict[name]
except:
import dbg
dbg.TraceError("interface.CloseWhisperDialog - Failed to find key")
## ¹öÆ°ÀÇ °³¼ö°¡ ¹Ù²î¾úÀ»¶§ ¹öÆ°À» ÀçÁ¤·Ä ÇÏ´Â ÇÔ¼ö
def __ArrangeWhisperButton(self):
screenWidth = wndMgr.GetScreenWidth()
screenHeight = wndMgr.GetScreenHeight()
xPos = screenWidth - 70
yPos = 170 * screenHeight / 600
yCount = (screenHeight - 330) / 63
#yCount = (screenHeight - 285) / 63
count = 0
for button in self.whisperButtonList:
button.SetPosition(xPos + (int(count/yCount) * -50), yPos + (count%yCount * 63))
count += 1
## À̸§À¸·Î Whisper ¹öÆ°À» ã¾Æ ¸®ÅÏÇØ ÁÖ´Â ÇÔ¼ö
## ¹öÆ°Àº µñ¼Å³Ê¸®·Î ÇÏÁö ¾Ê´Â °ÍÀº Á¤·Ä µÇ¾î ¹ö·Á ¼ø¼*°¡ À¯Áö µÇÁö ¾ÊÀ¸¸ç
## ÀÌ·Î ÀÎÇØ ToolTipµéÀÌ ´Ù¸¥ ¹öÆ°µé¿¡ ÀÇÇØ °¡·ÁÁö±â ¶§¹®ÀÌ´Ù.
def __FindWhisperButton(self, name):
for button in self.whisperButtonList:
if button.name == name:
return button
return 0
## âÀ» ¸¸µì´Ï´Ù.
def __MakeWhisperDialog(self, name):
dlgWhisper = uiWhisper.WhisperDialog(self.MinimizeWhisperDialog, self.CloseWhisperDialog)
dlgWhisper.BindInterface(self)
dlgWhisper.LoadDialog()
dlgWhisper.SetPosition(self.windowOpenPosition*30,self.windowOpenPosition*30)
self.whisperDialogDict[name] = dlgWhisper
self.windowOpenPosition = (self.windowOpenPosition+1) % 5
return dlgWhisper
## ¹öÆ°À» ¸¸µì´Ï´Ù.
def __MakeWhisperButton(self, name):
whisperButton = uiWhisper.WhisperButton()
whisperButton.SetUpVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
whisperButton.SetOverVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
whisperButton.SetDownVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
whisperButton.SetToolTipText(name)
whisperButton.ToolTipText.SetHorizontalAlignCenter()
whisperButton.SetEvent(ui.__mem_func__(self.ShowWhisperDialog), whisperButton)
whisperButton.Show()
whisperButton.name = name
self.whisperButtonList.insert(0, whisperButton)
self.__ArrangeWhisperButton()
return whisperButton
def __DestroyWhisperButton(self, button):
button.SetEvent(0)
self.whisperButtonList.remove(button)
self.__ArrangeWhisperButton()
def HideAllWhisperButton(self):
for btn in self.whisperButtonList:
btn.Hide()
def ShowAllWhisperButton(self):
for btn in self.whisperButtonList:
btn.Show()
#####################################################################################
#####################################################################################
### Guild Building ###
def BUILD_OpenWindow(self):
self.wndGuildBuilding = uiGuild.BuildGuildBuildingWindow()
self.wndGuildBuilding.Open()
self.wndGuildBuilding.wnds = self.__HideWindows()
self.wndGuildBuilding.SetCloseEvent(ui.__mem_func__(self.BUILD_CloseWindow))
def BUILD_CloseWindow(self):
self.__ShowWindows(self.wndGuildBuilding.wnds)
self.wndGuildBuilding = None
def BUILD_OnUpdate(self):
if not self.wndGuildBuilding:
return
if self.wndGuildBuilding.IsPositioningMode():
import background
x, y, z = background.GetPickingPoint()
self.wndGuildBuilding.SetBuildingPosition(x, y, z)
def BUILD_OnMouseLeftButtonDown(self):
if not self.wndGuildBuilding:
return
# GUILD_BUILDING
if self.wndGuildBuilding.IsPositioningMode():
self.wndGuildBuilding.SettleCurrentPosition()
return TRUE
elif self.wndGuildBuilding.IsPreviewMode():
pass
else:
return TRUE
# END_OF_GUILD_BUILDING
return FALSE
def BUILD_OnMouseLeftButtonUp(self):
if not self.wndGuildBuilding:
return
if not self.wndGuildBuilding.IsPreviewMode():
return TRUE
return FALSE
def BULID_EnterGuildArea(self, areaID):
# GUILD_BUILDING
mainCharacterName = player.GetMainCharacterName()
masterName = guild.GetGuildMasterName()
if mainCharacterName != masterName:
return
if areaID != player.GetGuildID():
return
# END_OF_GUILD_BUILDING
self.wndGameButton.ShowBuildButton()
def BULID_ExitGuildArea(self, areaID):
self.wndGameButton.HideBuildButton()
#####################################################################################
def IsEditLineFocus(self):
if self.ChatWindow.chatLine.IsFocus():
return 1
if self.ChatWindow.chatToLine.IsFocus():
return 1
return 0
def EmptyFunction(self):
pass
if __name__ == "__main__":
import app
import wndMgr
import systemSetting
import mouseModule
import grp
import ui
import locale
app.SetMouseHandler(mouseModule.mouseController)
app.SetHairColorEnable(TRUE)
wndMgr.SetMouseHandler(mouseModule.mouseController)
wndMgr.SetScreenSize(systemSetting.GetWidth(), systemSetting.GetHeight())
app.Create("METIN2", systemSetting.GetWidth(), systemSetting.GetHeight(), 1)
mouseModule.mouseController.Create()
class TestGame(ui.Window):
def __init__(self):
ui.Window.__init__(self)
locale.LoadLocaleData()
player.SetItemData(0, 27001, 10)
player.SetItemData(1, 27004, 10)
self.interface = Interface()
self.interface.MakeInterface()
self.interface.ShowDefaultWindows()
self.interface.RefreshInventory()
#self.interface.OpenCubeWindow()
def __del__(self):
ui.Window.__del__(self)
def OnUpdate(self):
app.UpdateGame()
def OnRender(self):
app.RenderGame()
grp.PopState()
grp.SetInterfaceRenderState()
game = TestGame()
game.SetSize(systemSetting.GetWidth(), systemSetting.GetHeight())
game.Show()
app.Loop()
Meine uiRestart.py:
PHP Code:
import dbg
import app
import net
import game
import ui
###################################################################################################
## Restart
class RestartDialog(ui.ScriptWindow):
def __init__(self):
ui.ScriptWindow.__init__(self)
def __del__(self):
ui.ScriptWindow.__del__(self)
def LoadDialog(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "uiscript/restartdialog.py")
except Exception, msg:
(type, msg, tb)=sys.exc_info()
dbg.TraceError("RestartDialog.LoadDialog - %s:%s" % (type, msg))
app.Abort()
return 0
try:
self.restartHereButton=self.GetChild("restart_here_button")
self.restartTownButton=self.GetChild("restart_town_button")
self.restartGhostButton=self.GetChild("restart_ghost_button")
except:
import sys
(type, msg, tb)=sys.exc_info()
dbg.TraceError("RestartDialog.LoadDialog - %s:%s" % (type, msg))
app.Abort()
return 0
self.restartHereButton.SetEvent(ui.__mem_func__(self.RestartHere))
self.restartTownButton.SetEvent(ui.__mem_func__(self.RestartTown))
self.restartGhostButton.SetEvent(ui.__mem_func__(self.RestartGhost))
return 1
def Destroy(self):
self.restartHereButton=0
self.restartTownButton=0
self.ClearDictionary()
def OpenDialog(self):
self.Show()
def Close(self):
self.Hide()
return TRUE
def RestartHere(self):
net.SendChatPacket("/restart_here")
def RestartTown(self):
net.SendChatPacket("/restart_town")
def RestartGhost(self):
import chr
chr.Revive()
def OnPressExitKey(self):
return TRUE
def OnPressEscapeKey(self):
return TRUE
Wer mein Problem löst gebührt mein Respekt!
Viel Spaß beim tüfteln ;)