Erory syserr

Cukycuky · 05 Mar 2017, 22:14

Am niste erori in syserr dupa ce ma conectez , ma scoate din client si iau asa

0305 22:08:15006 :: 
networkModule.py(line:200) SetSelectCharacterPhase
system.py(line:130) __pack_import
system.py(line:110) _process_result
introSelect.py(line:28) <module>
system.py(line:130) __pack_import
system.py(line:110) _process_result
interfaceModule.py(line:12) <module>
system.py(line:137) __pack_import

networkModule.SetSelectCharacterPhase - <type 'exceptions.ImportError'>:No module named uiTaskBar

NETWORKMODULE.PY

SYSTEM.py

INTERFACEMODULE.py

[Tupeu] · 06 Mar 2017, 16:31

Cukycuky scrie:Am niste erori in syserr dupa ce ma conectez , ma scoate din client si iau asa
Cod: Selectaţi tot
0305 22:08:15006 :: 
networkModule.py(line:200) SetSelectCharacterPhase
system.py(line:130) __pack_import
system.py(line:110) _process_result
introSelect.py(line:28) <module>
system.py(line:130) __pack_import
system.py(line:110) _process_result
interfaceModule.py(line:12) <module>
system.py(line:137) __pack_import

networkModule.SetSelectCharacterPhase - <type 'exceptions.ImportError'>:No module named uiTaskBar
NETWORKMODULE.PY
###################################################################################################
# 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(128*1024)
net.SetTCPSendBufferSize(4096)
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 SetLogoPhase(self):
net.Disconnect()

import introLogo
self.SetPhaseWindow(introLogo.LogoWindow(self))

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
SYSTEM.py
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"

app.__COMMAND_LINE__ = __COMMAND_LINE__
RunMainScript("prototype.py")
INTERFACEMODULE.py

##
## Interface
##

import constInfo
import systemSetting
import wndMgr
import chat
import app
import player
import uiAcce
import uiTaskBar
import uiCharacter
import uiInventory
import uiDragonSoul
import uiChat
import uiMessenger
import guild
import time

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
import miniMap
# ACCESSORY_REFINE_ADD_METIN_STONE
import uiSelectItem
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
import uiScriptLocale

import event
import locale
import uiCharacter_new
import uiGuild_new

IsQBHide = 0
class Interface(object):
CHARACTER_STATUS_TAB = 1
CHARACTER_SKILL_TAB = 2

def __init__(self):
systemSetting.SetInterfaceHandler(self)
self.windowOpenPosition = 0
self.utilizareInventar = time.clock() + 4
self.dlgWhisperWithoutTarget = None
self.inputDialog = None
self.tipBoard = None
self.bigBoard = None

# ITEM_MALL
self.mallPageDlg = None
# END_OF_ITEM_MALL

self.wndguild = uiGuild_new.GuildWindow()
self.wndchar2 = uiCharacter_new.CharacterWindow()
self.wndWeb = None
self.wndchar2 = None
self.wndTaskBar = None
self.wndCharacter = None
self.wndInventory = None
self.wndExpandedTaskBar = None
self.wndDragonSoul = None
self.wndDragonSoulRefine = None
self.wndChat = None
self.wndMessenger = None
self.wndMiniMap = None
self.wndGuild = None
self.wndGuildBuilding = None

self.listGMName = {}
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):

wndChat = uiChat.ChatWindow()

wndChat.SetSize(wndChat.CHAT_WINDOW_WIDTH, 0)
wndChat.SetPosition(wndMgr.GetScreenWidth()/2-10 - wndChat.CHAT_WINDOW_WIDTH/2, wndMgr.GetScreenHeight() +5 - wndChat.EDIT_LINE_HEIGHT - 57)
wndChat.SetHeight(200)
wndChat.Refresh()
wndChat.Show()
wndChat.SetTop()

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))
if uiTaskBar.TaskBar.IS_EXPANDED:
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_EXPAND, ui.__mem_func__(self.ToggleExpandedButton))
self.wndExpandedTaskBar = uiTaskBar.ExpandedTaskBar()
self.wndExpandedTaskBar.LoadWindow()
self.wndExpandedTaskBar.SetToggleButtonEvent(uiTaskBar.ExpandedTaskBar.BUTTON_DRAGON_SOUL, ui.__mem_func__(self.ToggleDragonSoulWindow))

else:
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_CHAT, ui.__mem_func__(self.ToggleChat))

#self.wndEnergyBar = None
#import app
#if app.ENABLE_ENERGY_SYSTEM:
#wndEnergyBar = uiTaskBar.EnergyBar()
#wndEnergyBar.LoadWindow()
#self.wndEnergyBar = wndEnergyBar

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()
self.wndchar2 = uiCharacter_new.CharacterWindow()
wndInventory = uiInventory.InventoryWindow()
wndInventory.BindInterfaceClass(self)
if app.ENABLE_DRAGON_SOUL_SYSTEM:
wndDragonSoul = uiDragonSoul.DragonSoulWindow()
wndDragonSoulRefine = uiDragonSoul.DragonSoulRefineWindow()
else:
wndDragonSoul = None
wndDragonSoulRefine = None

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.wndDragonSoul = wndDragonSoul
self.wndDragonSoulRefine = wndDragonSoulRefine
self.wndMiniMap = wndMiniMap
self.wndSafebox = wndSafebox
self.wndChatLog = wndChatLog

if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.SetDragonSoulRefineWindow(self.wndDragonSoulRefine)
self.wndDragonSoulRefine.SetInventoryWindows(self.wndInventory, self.wndDragonSoul)
self.wndInventory.SetDragonSoulRefineWindow(self.wndDragonSoulRefine)

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()
self.wndchar2 = uiCharacter_new.CharacterWindow()
self.wndchar2.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 __MakeAcceWindow(self):
self.wndAcce = uiAcce.AcceWindow()
self.wndAcce.LoadWindow()
self.wndAcce.Hide()
self.wndAcceAbs = uiAcce.AcceAbsorbWindow()
self.wndAcceAbs.LoadWindow()
self.wndAcceAbs.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.__MakeAcceWindow()
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)
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.SetItemToolTip(self.tooltipItem)
self.wndDragonSoulRefine.SetItemToolTip(self.tooltipItem)
self.wndSafebox.SetItemToolTip(self.tooltipItem)
self.wndAcce.SetItemToolTip(self.tooltipItem)
self.wndAcceAbs.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()
self.DRAGON_SOUL_IS_QUALIFIED = TRUE

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.wndExpandedTaskBar:
self.wndExpandedTaskBar.Destroy()

#if self.wndEnergyBar:
#self.wndEnergyBar.Destroy()

if self.wndCharacter:
self.wndCharacter.Destroy()

if self.wndchar2:
self.wndchar2.Destroy()

if self.wndInventory:
self.wndInventory.Destroy()

if self.wndDragonSoul:
self.wndDragonSoul.Destroy()

if self.wndDragonSoulRefine:
self.wndDragonSoulRefine.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.wndAcce:
self.wndAcce.Destroy()

if self.wndAcceAbs:
self.wndAcceAbs.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
if self.wndExpandedTaskBar:
del self.wndExpandedTaskBar
#del self.wndEnergyBar
del self.wndCharacter
del self.wndInventory
if self.wndDragonSoul:
del self.wndDragonSoul
if self.wndDragonSoulRefine:
del self.wndDragonSoulRefine
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.wndAcce
del self.wndAcceAbs
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()

## Self
def SetOpenBoniSwitcherEvent(self, event):
self.wndInventory.SetOpenBoniSwitcherEvent(event)

## 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()
#if self.wndEnergyBar:
#self.wndEnergyBar.RefreshStatus()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.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()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.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 RefreshGuildCommentInfo(self):
self.wndGuild.OnRefreshComments()

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.AddOnDoneEvent(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()
# if self.wndEnergyBar:
# self.wndEnergyBar.Show()

def ShowAllWindows(self):
self.wndTaskBar.Show()
self.wndCharacter.Show()
self.wndInventory.Show()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.Show()
self.wndDragonSoulRefine.Show()
self.wndChat.Show()
# self.wndMiniMap.Show()
# if self.wndEnergyBar:
# self.wndEnergyBar.Show()
if self.wndExpandedTaskBar:
self.wndExpandedTaskBar.Show()
self.wndExpandedTaskBar.SetTop()

def HideAllWindows(self):
if self.wndTaskBar:
self.wndTaskBar.Hide()

# if self.wndEnergyBar:
# self.wndEnergyBar.Hide()

if self.wndCharacter:
self.wndCharacter.Hide()

if self.wndInventory:
self.wndInventory.Hide()

if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.Hide()
self.wndDragonSoulRefine.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()

if self.wndExpandedTaskBar:
self.wndExpandedTaskBar.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()
##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.wndTaskBar.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 self.wndchar2.IsShow():
self.wndchar2.OverOutItem()
self.wndchar2.Close()
else:
self.wndchar2.SetState(state)
self.wndchar2.Show()
self.wndchar2.SetTop()

def HideCharacterWindow_Illumina(self):
if self.wndchar2.IsShow():
self.wndchar2.OverOutItem()
self.wndchar2.Close()

def ToggleCharacterWindowStatusPage(self): #ASTA E?
self.wndchar2.SetState("STATUS")
self.wndchar2.Show()
self.wndchar2.SetTop()
# self.ToggleCharacterWindow("STATUS")

def ToggleInventoryWindow(self):
if time.clock() >= self.utilizareInventar:
if FALSE == player.IsObserverMode():
if FALSE == self.wndInventory.IsShow():
self.wndInventory.Show()
self.wndInventory.SetTop()
else:
self.wndInventory.OverOutItem()
self.wndInventory.Close()
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Mai asteapta cateva secunde pentru a putea folosi inventarul.")
# FINAL_BUG_ROUA_EUGEN_PRO_AREA

def ToggleExpandedButton(self):
if FALSE == player.IsObserverMode():
if FALSE == self.wndExpandedTaskBar.IsShow():
self.wndExpandedTaskBar.Show()
self.wndExpandedTaskBar.SetTop()
else:
self.wndExpandedTaskBar.Close()

# 용혼석
def DragonSoulActivate(self, deck):
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.ActivateDragonSoulByExtern(deck)

def DragonSoulDeactivate(self):
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.DeactivateDragonSoul()

def Highligt_Item(self, inven_type, inven_pos):
if player.DRAGON_SOUL_INVENTORY == inven_type:
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.HighlightSlot(inven_pos)

def DragonSoulGiveQuilification(self):
self.DRAGON_SOUL_IS_QUALIFIED = TRUE
self.wndExpandedTaskBar.SetToolTipText(uiTaskBar.ExpandedTaskBar.BUTTON_DRAGON_SOUL, uiScriptLocale.TASKBAR_DRAGON_SOUL)

def ToggleDragonSoulWindow(self):
if FALSE == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if FALSE == self.wndDragonSoul.IsShow():
if self.DRAGON_SOUL_IS_QUALIFIED:
self.wndDragonSoul.Show()
else:
try:
self.wndPopupDialog.SetText(locale.DRAGON_SOUL_UNQUALIFIED)
self.wndPopupDialog.Open()
except:
self.wndPopupDialog = uiCommon.PopupDialog()
self.wndPopupDialog.SetText(locale.DRAGON_SOUL_UNQUALIFIED)
self.wndPopupDialog.Open()
else:
self.wndDragonSoul.Close()

def ToggleDragonSoulWindowWithNoInfo(self):
if FALSE == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if FALSE == self.wndDragonSoul.IsShow():
if self.DRAGON_SOUL_IS_QUALIFIED:
self.wndDragonSoul.Show()
else:
self.wndDragonSoul.Close()

def FailDragonSoulRefine(self, reason, inven_type, inven_pos):
if FALSE == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if TRUE == self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.RefineFail(reason, inven_type, inven_pos)

def SucceedDragonSoulRefine(self, inven_type, inven_pos):
if FALSE == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if TRUE == self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.RefineSucceed(inven_type, inven_pos)

def OpenDragonSoulRefineWindow(self):
if FALSE == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if FALSE == self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.Show()
if None != self.wndDragonSoul:
if FALSE == self.wndDragonSoul.IsShow():
self.wndDragonSoul.Show()

def CloseDragonSoulRefineWindow(self):
if FALSE == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if TRUE == self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.Close()

# 용혼석 끝

def ToggleGuildWindow(self):
if self.wndguild.CanOpen():
self.wndguild.SetState(0)
self.wndguild.Show()
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GUILD_YOU_DO_NOT_JOIN)

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 OpenAcceWindow(self):
self.wndAcce.Open()
if self.wndInventory.IsShow() == FALSE:
self.wndInventory.Show()

def UpdateAcceInfo(self, gold, itemVnum, count, rItemVnum, rCount):
self.wndAcce.UpdateInfo(gold, itemVnum, count, rItemVnum, rCount)

def CloseAcceWindow(self):
self.wndAcce.Close()

def FailedAcceWork(self):
self.wndAcce.Clear()

def SucceedAcceWork(self, itemVnum, count):
self.wndAcce.ClearSuccess()
print "Making acce has succesfully! [%d:%d]" % (itemVnum, count)

def OpenAcceAbsWindow(self):
self.wndAcceAbs.Open()
if self.wndInventory.IsShow() == FALSE:
self.wndInventory.Show()

def SucceedAcceAbsWork(self):
self.wndAcceAbs.Clear()

def OpenWebWindow(self, url):
self.wndWeb.Open(url)

# 웹페이지를 열면 채팅을 닫는다
self.wndChat.CloseChat()

# show GIFT
def ShowGift(self):
self.wndTaskBar.ShowGift()

def CloseWbWindow(self):
self.wndWeb.Close()

def OpenCubeWindow(self):
self.wndCube.Open()

if FALSE == self.wndInventory.IsShow():
self.wndInventory.Show()

def UpdateCubeInfo(self, gold, itemVnum, count):
self.wndCube.UpdateInfo(gold, itemVnum, count)

def CloseCubeWindow(self):
self.wndCube.Close()

def FailedCubeWork(self):
self.wndCube.Refresh()

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,

# if self.wndEnergyBar:
#hideWindows += self.wndEnergyBar,

if self.wndExpandedTaskBar:
hideWindows += self.wndExpandedTaskBar,

if app.ENABLE_DRAGON_SOUL_SYSTEM:
hideWindows += self.wndDragonSoul,\
self.wndDragonSoulRefine,

hideWindows = filter(lambda x:x.IsShow(), hideWindows)
map(lambda x:x.Hide(), hideWindows)
import sys

self.HideAllQuestButton()
self.HideAllWhisperButton()

if self.wndChat.IsEditMode():
self.wndChat.CloseChat()

return hideWindows

def __ShowWindows(self, wnds):
import sys
map(lambda x:x.Show(), wnds)
global IsQBHide
if not IsQBHide:
self.ShowAllQuestButton()
else:
self.HideAllQuestButton()

self.ShowAllWhisperButton()

def BINARY_OpenAtlasWindow(self):
if self.wndMiniMap:
self.wndMiniMap.ShowAtlas()

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.SetTitle(locale.PRIVATE_SHOP_INPUT_NAME_DIALOG_TITLE)
inputDialog.SetMaxLength(50)
inputDialog.SetAcceptEvent(ui.__mem_func__(self.OpenPrivateShopBuilder))
inputDialog.SetCancelEvent(ui.__mem_func__(self.ClosePrivateShopInputNameDialog))
inputDialog.Open()
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]
uiPrivateShopBuilder.DeleteADBoard(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():
if "highlight" == iconType:
btn.SetUpVisual("locale/ymir_ui/highlighted_quest.tga")
btn.SetOverVisual("locale/ymir_ui/highlighted_quest_r.tga")
btn.SetDownVisual("locale/ymir_ui/highlighted_quest_r.tga")
else:
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

if locale.IsARABIC():
btn.SetToolTipText(name, 0, 35)
btn.ToolTipText.SetHorizontalAlignCenter()
else:
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

if locale.IsARABIC():
xPos = xPos + 15

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
global IsQBHide
if IsQBHide:
btn.Hide()
else:
btn.Show()

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
self.__CheckGameMaster(name)

## 캐릭터 메뉴의 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()

self.__CheckGameMaster(name)
btn = self.__FindWhisperButton(name)
if 0 != btn:
self.__DestroyWhisperButton(btn)

## 다른 캐릭터로부터 메세지를 받았을때 일단 버튼만 띄워 두는 함수
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()
elif self.IsGameMasterName(name):
dlg = self.whisperDialogDict[name]
dlg.SetGameMasterLook()

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()
self.__CheckGameMaster(btn.name)
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)

def OnPressEscapeKey(self):
#if self.wndchar2.IsShow():
self.wndchar2.Hide()

#elif self.wndguild.IsShow():
#self.wndguild.ForceClose()
return TRUE

## 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")
if self.IsGameMasterName(name):
whisperButton.SetToolTipTextWithColor(name, 0xffffa200)
else:
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()

def __CheckGameMaster(self, name):
if not self.listGMName.has_key(name):
return
if self.whisperDialogDict.has_key(name):
dlg = self.whisperDialogDict[name]
dlg.SetGameMasterLook()

def RegisterGameMasterName(self, name):
if self.listGMName.has_key(name):
return
self.listGMName[name] = "GM"

def IsGameMasterName(self, name):
if self.listGMName.has_key(name):
return TRUE
else:
return FALSE

def OnUpdate(self):
self.wndguild.OnUpdate()
self.wndchar2.OnUpdate()
#####################################################################################

#####################################################################################
### 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(locale.APP_TITLE, 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()

Ai fisierul uiTaskBar in root? Lasa fisierul introselect.py aici.

Pongo A.K.A Titan · 12 Mar 2017, 14:45

Subiect inactiv arhivat !

Erory syserr

Erory syserr client

Erory Mysql

dc pica sv erory sisre

erory syser rules v2

Cine este conectat

!	Mesaj de la: Pongo A.K.A Titan
	Cand credeati ca am sa mor M-am ridicat ca un invingator