forked from metin-server/m2dev-client
1106 lines
32 KiB
Python
1106 lines
32 KiB
Python
import dbg
|
|
import app
|
|
import net
|
|
import ui
|
|
import ime
|
|
import snd
|
|
import wndMgr
|
|
import musicInfo
|
|
import serverInfo
|
|
import systemSetting
|
|
import ServerStateChecker
|
|
import localeInfo
|
|
import constInfo
|
|
import uiCommon
|
|
import time
|
|
import serverCommandParser
|
|
import ime
|
|
import uiScriptLocale
|
|
import debugInfo
|
|
|
|
# Multi-language hot-reload system
|
|
from uilocaleselector import LocaleSelector
|
|
|
|
LOGIN_DELAY_SEC = 0.0
|
|
SKIP_LOGIN_PHASE = False
|
|
SKIP_LOGIN_PHASE_SUPPORT_CHANNEL = False
|
|
FULL_BACK_IMAGE = False
|
|
|
|
VIRTUAL_KEYBOARD_NUM_KEYS = 46
|
|
VIRTUAL_KEYBOARD_RAND_KEY = True
|
|
|
|
def Suffle(src):
|
|
if VIRTUAL_KEYBOARD_RAND_KEY:
|
|
items = [item for item in src]
|
|
|
|
itemCount = len(items)
|
|
for oldPos in range(itemCount):
|
|
newPos = app.GetRandom(0, itemCount-1)
|
|
items[newPos], items[oldPos] = items[oldPos], items[newPos]
|
|
|
|
return "".join(items)
|
|
else:
|
|
return src
|
|
|
|
def IsLoginDelay():
|
|
global LOGIN_DELAY_SEC
|
|
if LOGIN_DELAY_SEC > 0.0:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def GetLoginDelay():
|
|
global LOGIN_DELAY_SEC
|
|
return LOGIN_DELAY_SEC
|
|
|
|
app.SetGuildMarkPath("test")
|
|
|
|
###############################################################################
|
|
# Multi-Language Hot-Reload System
|
|
# All locale selector and hot-reload logic moved to:
|
|
# - uilocaleselector.py (UI component)
|
|
# - uilocalechange.py (hot-reload manager)
|
|
###############################################################################
|
|
|
|
class ConnectingDialog(ui.ScriptWindow):
|
|
|
|
def __init__(self):
|
|
ui.ScriptWindow.__init__(self)
|
|
self.__LoadDialog()
|
|
self.eventTimeOver = lambda *arg: None
|
|
self.eventExit = lambda *arg: None
|
|
|
|
def __del__(self):
|
|
ui.ScriptWindow.__del__(self)
|
|
|
|
def __LoadDialog(self):
|
|
try:
|
|
PythonScriptLoader = ui.PythonScriptLoader()
|
|
PythonScriptLoader.LoadScriptFile(self, "UIScript/ConnectingDialog.py")
|
|
|
|
self.board = self.GetChild("board")
|
|
self.message = self.GetChild("message")
|
|
self.countdownMessage = self.GetChild("countdown_message")
|
|
|
|
except:
|
|
import exception
|
|
exception.Abort("ConnectingDialog.LoadDialog.BindObject")
|
|
|
|
def Open(self, waitTime):
|
|
curTime = time.clock()
|
|
self.endTime = curTime + waitTime
|
|
|
|
self.Lock()
|
|
self.SetCenterPosition()
|
|
self.SetTop()
|
|
self.Show()
|
|
|
|
def Close(self):
|
|
self.Unlock()
|
|
self.Hide()
|
|
|
|
def Destroy(self):
|
|
self.Hide()
|
|
self.ClearDictionary()
|
|
|
|
def SetText(self, text):
|
|
self.message.SetText(text)
|
|
|
|
def SetCountDownMessage(self, waitTime):
|
|
self.countdownMessage.SetText("%.0f%s" % (waitTime, localeInfo.SECOND))
|
|
|
|
def SAFE_SetTimeOverEvent(self, event):
|
|
self.eventTimeOver = ui.__mem_func__(event)
|
|
|
|
def SAFE_SetExitEvent(self, event):
|
|
self.eventExit = ui.__mem_func__(event)
|
|
|
|
def OnUpdate(self):
|
|
lastTime = max(0, self.endTime - time.clock())
|
|
if 0 == lastTime:
|
|
self.Close()
|
|
self.eventTimeOver()
|
|
else:
|
|
self.SetCountDownMessage(self.endTime - time.clock())
|
|
|
|
def OnPressExitKey(self):
|
|
#self.eventExit()
|
|
return True
|
|
|
|
class LoginWindow(ui.ScriptWindow):
|
|
def __init__(self, stream):
|
|
print("NEW LOGIN WINDOW ----------------------------------------------------------------------------")
|
|
ui.ScriptWindow.__init__(self)
|
|
net.SetPhaseWindow(net.PHASE_WINDOW_LOGIN, self)
|
|
net.SetAccountConnectorHandler(self)
|
|
|
|
self.lastLoginTime = 0
|
|
self.inputDialog = None
|
|
self.connectingDialog = None
|
|
self.stream=stream
|
|
self.isNowCountDown=False
|
|
self.isStartError=False
|
|
|
|
self.xServerBoard = 0
|
|
self.yServerBoard = 0
|
|
|
|
self.loadingImage = None
|
|
|
|
self.virtualKeyboard = None
|
|
self.virtualKeyboardMode = "ALPHABET"
|
|
self.virtualKeyboardIsUpper = False
|
|
self.timeOutMsg = False #Fix
|
|
|
|
# Multi-language hot-reload system
|
|
self.localeSelector = None
|
|
|
|
def __del__(self):
|
|
net.ClearPhaseWindow(net.PHASE_WINDOW_LOGIN, self)
|
|
net.SetAccountConnectorHandler(0)
|
|
ui.ScriptWindow.__del__(self)
|
|
print("---------------------------------------------------------------------------- DELETE LOGIN WINDOW")
|
|
|
|
def Open(self):
|
|
ServerStateChecker.Create(self)
|
|
|
|
print("LOGIN WINDOW OPEN ----------------------------------------------------------------------------")
|
|
|
|
self.loginFailureMsgDict={
|
|
#"DEFAULT" : localeInfo.LOGIN_FAILURE_UNKNOWN,
|
|
|
|
"ALREADY" : localeInfo.LOGIN_FAILURE_ALREAY,
|
|
"NOID" : localeInfo.LOGIN_FAILURE_NOT_EXIST_ID,
|
|
"WRONGPWD" : localeInfo.LOGIN_FAILURE_WRONG_PASSWORD,
|
|
"FULL" : localeInfo.LOGIN_FAILURE_TOO_MANY_USER,
|
|
"SHUTDOWN" : localeInfo.LOGIN_FAILURE_SHUTDOWN,
|
|
"REPAIR" : localeInfo.LOGIN_FAILURE_REPAIR_ID,
|
|
"BLOCK" : localeInfo.LOGIN_FAILURE_BLOCK_ID,
|
|
"BESAMEKEY" : localeInfo.LOGIN_FAILURE_BE_SAME_KEY,
|
|
"NOTAVAIL" : localeInfo.LOGIN_FAILURE_NOT_AVAIL,
|
|
"NOBILL" : localeInfo.LOGIN_FAILURE_NOBILL,
|
|
"BLKLOGIN" : localeInfo.LOGIN_FAILURE_BLOCK_LOGIN,
|
|
"WEBBLK" : localeInfo.LOGIN_FAILURE_WEB_BLOCK,
|
|
"BADSCLID" : localeInfo.LOGIN_FAILURE_WRONG_SOCIALID,
|
|
"AGELIMIT" : localeInfo.LOGIN_FAILURE_SHUTDOWN_TIME,
|
|
}
|
|
|
|
self.loginFailureFuncDict = {
|
|
"WRONGPWD" : self.__DisconnectAndInputPassword,
|
|
"QUIT" : app.Exit,
|
|
}
|
|
|
|
self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())
|
|
self.SetWindowName("LoginWindow")
|
|
|
|
if app.IsRTL():
|
|
selectPath = uiScriptLocale.LOCALE_UISCRIPT_PATH + "LoginWindow.py"
|
|
else:
|
|
selectPath = "UIScript/LoginWindow.py"
|
|
|
|
if not self.__LoadScript(selectPath):
|
|
dbg.TraceError("SelectCharacterWindow.Open - __LoadScript Error")
|
|
return
|
|
|
|
# Changed .xml -> .py because pack.Get does not allow .xml extension
|
|
self.__LoadLoginInfo("loginInfo.py")
|
|
|
|
if app.loggined:
|
|
self.loginFailureFuncDict = {
|
|
"WRONGPWD" : app.Exit,
|
|
"WRONGMAT" : app.Exit,
|
|
"QUIT" : app.Exit,
|
|
}
|
|
|
|
if musicInfo.loginMusic != "":
|
|
snd.SetMusicVolume(systemSetting.GetMusicVolume())
|
|
snd.FadeInMusic("BGM/"+musicInfo.loginMusic)
|
|
|
|
snd.SetSoundVolume(systemSetting.GetSoundVolume())
|
|
|
|
# pevent key "[" "]"
|
|
ime.AddExceptKey(91)
|
|
ime.AddExceptKey(93)
|
|
|
|
self.Show()
|
|
|
|
global SKIP_LOGIN_PHASE
|
|
if SKIP_LOGIN_PHASE:
|
|
if self.isStartError:
|
|
self.connectBoard.Hide()
|
|
self.loginBoard.Hide()
|
|
self.serverBoard.Hide()
|
|
self.PopupNotifyMessage(localeInfo.LOGIN_CONNECT_FAILURE, self.__ExitGame)
|
|
return
|
|
|
|
if self.loginInfo:
|
|
self.serverBoard.Hide()
|
|
else:
|
|
self.__RefreshServerList()
|
|
self.__OpenServerBoard()
|
|
else:
|
|
connectingIP = self.stream.GetConnectAddr()
|
|
if connectingIP:
|
|
self.__OpenLoginBoard()
|
|
else:
|
|
self.__RefreshServerList()
|
|
self.__OpenServerBoard()
|
|
|
|
app.ShowCursor()
|
|
|
|
def Close(self):
|
|
|
|
if self.connectingDialog:
|
|
self.connectingDialog.Close()
|
|
self.connectingDialog = None
|
|
|
|
ServerStateChecker.Initialize(self)
|
|
|
|
print("---------------------------------------------------------------------------- CLOSE LOGIN WINDOW ")
|
|
#
|
|
# Check both since BGM stops if selectMusic is not set.
|
|
#
|
|
if musicInfo.loginMusic != "" and musicInfo.selectMusic != "":
|
|
snd.FadeOutMusic("BGM/"+musicInfo.loginMusic)
|
|
|
|
## NOTE : idEditLine and pwdEditLine have interconnected events
|
|
## Events must be forcibly initialized - [levites]
|
|
self.idEditLine.SetTabEvent(0)
|
|
self.idEditLine.SetReturnEvent(0)
|
|
self.pwdEditLine.SetReturnEvent(0)
|
|
self.pwdEditLine.SetTabEvent(0)
|
|
|
|
self.connectBoard = None
|
|
self.loginBoard = None
|
|
self.idEditLine = None
|
|
self.pwdEditLine = None
|
|
self.inputDialog = None
|
|
self.connectingDialog = None
|
|
self.loadingImage = None
|
|
|
|
if self.localeSelector:
|
|
self.localeSelector.Destroy()
|
|
self.localeSelector = None
|
|
|
|
self.serverBoard = None
|
|
self.serverList = None
|
|
self.channelList = None
|
|
|
|
self.VIRTUAL_KEY_ALPHABET_LOWERS = None
|
|
self.VIRTUAL_KEY_ALPHABET_UPPERS = None
|
|
self.VIRTUAL_KEY_SYMBOLS = None
|
|
self.VIRTUAL_KEY_NUMBERS = None
|
|
|
|
# VIRTUAL_KEYBOARD_BUG_FIX
|
|
if self.virtualKeyboard:
|
|
for keyIndex in range(0, VIRTUAL_KEYBOARD_NUM_KEYS+1):
|
|
key = self.GetChild2("key_%d" % keyIndex)
|
|
if key:
|
|
key.SetEvent(None)
|
|
|
|
self.GetChild("key_space").SetEvent(None)
|
|
self.GetChild("key_backspace").SetEvent(None)
|
|
self.GetChild("key_enter").SetEvent(None)
|
|
self.GetChild("key_shift").SetToggleDownEvent(None)
|
|
self.GetChild("key_shift").SetToggleUpEvent(None)
|
|
self.GetChild("key_at").SetToggleDownEvent(None)
|
|
self.GetChild("key_at").SetToggleUpEvent(None)
|
|
|
|
self.virtualKeyboard = None
|
|
|
|
self.KillFocus()
|
|
self.Hide()
|
|
|
|
self.stream.popupWindow.Close()
|
|
self.loginFailureFuncDict=None
|
|
|
|
ime.ClearExceptKey()
|
|
|
|
app.HideCursor()
|
|
|
|
def __SaveChannelInfo(self):
|
|
try:
|
|
with open("config/channel.inf", "w") as file:
|
|
file.write("%d %d %d" % (self.__GetServerID(), self.__GetChannelID(), self.__GetRegionID()))
|
|
except:
|
|
print("LoginWindow.__SaveChannelInfo - SaveError")
|
|
|
|
def __LoadChannelInfo(self):
|
|
try:
|
|
with open("config/channel.inf", "r") as file:
|
|
lines=file.readlines()
|
|
|
|
if len(lines)>0:
|
|
tokens=lines[0].split()
|
|
|
|
selServerID=int(tokens[0])
|
|
selChannelID=int(tokens[1])
|
|
|
|
if len(tokens) == 3:
|
|
regionID = int(tokens[2])
|
|
|
|
return regionID, selServerID, selChannelID
|
|
|
|
except:
|
|
print("LoginWindow.__LoadChannelInfo - OpenError")
|
|
return -1, -1, -1
|
|
|
|
def __ExitGame(self):
|
|
app.Exit()
|
|
|
|
def SetIDEditLineFocus(self):
|
|
if self.idEditLine != None:
|
|
self.idEditLine.SetFocus()
|
|
|
|
def SetPasswordEditLineFocus(self):
|
|
if self.pwdEditLine != None:
|
|
self.pwdEditLine.SetFocus()
|
|
|
|
def OnEndCountDown(self):
|
|
self.isNowCountDown = False
|
|
self.timeOutMsg = False
|
|
self.OnConnectFailure()
|
|
|
|
def OnConnectFailure(self):
|
|
|
|
if self.isNowCountDown:
|
|
return
|
|
|
|
snd.PlaySound("sound/ui/loginfail.wav")
|
|
|
|
if self.connectingDialog:
|
|
self.connectingDialog.Close()
|
|
self.connectingDialog = None
|
|
|
|
if app.loggined:
|
|
self.PopupNotifyMessage(localeInfo.LOGIN_CONNECT_FAILURE, self.__ExitGame)
|
|
elif self.timeOutMsg:
|
|
self.PopupNotifyMessage(localeInfo.LOGIN_FAILURE_TIMEOUT, self.SetPasswordEditLineFocus)
|
|
else:
|
|
self.PopupNotifyMessage(localeInfo.LOGIN_CONNECT_FAILURE, self.SetPasswordEditLineFocus)
|
|
|
|
def OnHandShake(self):
|
|
if not IsLoginDelay():
|
|
snd.PlaySound("sound/ui/loginok.wav")
|
|
self.PopupDisplayMessage(localeInfo.LOGIN_CONNECT_SUCCESS)
|
|
|
|
def OnLoginStart(self):
|
|
if not IsLoginDelay():
|
|
self.PopupDisplayMessage(localeInfo.LOGIN_PROCESSING)
|
|
|
|
def OnLoginFailure(self, error):
|
|
if self.connectingDialog:
|
|
self.connectingDialog.Close()
|
|
self.connectingDialog = None
|
|
|
|
try:
|
|
loginFailureMsg = self.loginFailureMsgDict[error]
|
|
except KeyError:
|
|
loginFailureMsg = localeInfo.LOGIN_FAILURE_UNKNOWN + error
|
|
|
|
|
|
#0000685: [M2EU] ID/password guessing bug fix: always set focus to password field
|
|
loginFailureFunc=self.loginFailureFuncDict.get(error, self.SetPasswordEditLineFocus)
|
|
|
|
if app.loggined:
|
|
self.PopupNotifyMessage(loginFailureMsg, self.__ExitGame)
|
|
else:
|
|
self.PopupNotifyMessage(loginFailureMsg, loginFailureFunc)
|
|
|
|
snd.PlaySound("sound/ui/loginfail.wav")
|
|
|
|
def __DisconnectAndInputID(self):
|
|
if self.connectingDialog:
|
|
self.connectingDialog.Close()
|
|
self.connectingDialog = None
|
|
|
|
self.SetIDEditLineFocus()
|
|
net.Disconnect()
|
|
|
|
def __DisconnectAndInputPassword(self):
|
|
if self.connectingDialog:
|
|
self.connectingDialog.Close()
|
|
self.connectingDialog = None
|
|
|
|
self.SetPasswordEditLineFocus()
|
|
net.Disconnect()
|
|
|
|
def __LoadScript(self, fileName):
|
|
import dbg
|
|
try:
|
|
pyScrLoader = ui.PythonScriptLoader()
|
|
pyScrLoader.LoadScriptFile(self, fileName)
|
|
except:
|
|
import exception
|
|
exception.Abort("LoginWindow.__LoadScript.LoadObject")
|
|
try:
|
|
GetObject=self.GetChild
|
|
self.serverBoard = GetObject("ServerBoard")
|
|
self.serverList = GetObject("ServerList")
|
|
self.channelList = GetObject("ChannelList")
|
|
self.serverSelectButton = GetObject("ServerSelectButton")
|
|
self.serverExitButton = GetObject("ServerExitButton")
|
|
self.connectBoard = GetObject("ConnectBoard")
|
|
self.loginBoard = GetObject("LoginBoard")
|
|
self.idText = GetObject("ID_Text")
|
|
self.idEditLine = GetObject("ID_EditLine")
|
|
self.pwdText = GetObject("Password_Text")
|
|
self.pwdEditLine = GetObject("Password_EditLine")
|
|
self.serverInfo = GetObject("ConnectName")
|
|
self.selectConnectButton = GetObject("SelectConnectButton")
|
|
self.loginButton = GetObject("LoginButton")
|
|
self.loginExitButton = GetObject("LoginExitButton")
|
|
|
|
self.virtualKeyboard = self.GetChild2("VirtualKeyboard")
|
|
|
|
if self.virtualKeyboard:
|
|
self.VIRTUAL_KEY_ALPHABET_UPPERS = Suffle(localeInfo.VIRTUAL_KEY_ALPHABET_UPPERS)
|
|
self.VIRTUAL_KEY_ALPHABET_LOWERS = "".join([localeInfo.VIRTUAL_KEY_ALPHABET_LOWERS[localeInfo.VIRTUAL_KEY_ALPHABET_UPPERS.index(e)] for e in self.VIRTUAL_KEY_ALPHABET_UPPERS])
|
|
self.VIRTUAL_KEY_SYMBOLS = Suffle(localeInfo.VIRTUAL_KEY_SYMBOLS)
|
|
self.VIRTUAL_KEY_NUMBERS = Suffle(localeInfo.VIRTUAL_KEY_NUMBERS)
|
|
self.__VirtualKeyboard_SetAlphabetMode()
|
|
|
|
self.GetChild("key_space").SetEvent(lambda : self.__VirtualKeyboard_PressKey(' '))
|
|
self.GetChild("key_backspace").SetEvent(lambda : self.__VirtualKeyboard_PressBackspace())
|
|
self.GetChild("key_enter").SetEvent(lambda : self.__VirtualKeyboard_PressReturn())
|
|
self.GetChild("key_shift").SetToggleDownEvent(lambda : self.__VirtualKeyboard_SetUpperMode())
|
|
self.GetChild("key_shift").SetToggleUpEvent(lambda : self.__VirtualKeyboard_SetLowerMode())
|
|
self.GetChild("key_at").SetToggleDownEvent(lambda : self.__VirtualKeyboard_SetSymbolMode())
|
|
self.GetChild("key_at").SetToggleUpEvent(lambda : self.__VirtualKeyboard_SetAlphabetMode())
|
|
|
|
# Create locale selector (only if it doesn't exist - during hot-reload we keep the old one)
|
|
if not self.localeSelector:
|
|
self.localeSelector = LocaleSelector()
|
|
self.localeSelector.Create(self)
|
|
self.localeSelector.SetLocaleChangedEvent(ui.__mem_func__(self.__OnLocaleChanged))
|
|
|
|
except:
|
|
import exception
|
|
exception.Abort("LoginWindow.__LoadScript.BindObject")
|
|
|
|
self.selectConnectButton.SetEvent(ui.__mem_func__(self.__OnClickSelectConnectButton))
|
|
|
|
self.serverBoard.OnKeyUp = ui.__mem_func__(self.__ServerBoard_OnKeyUp)
|
|
self.xServerBoard, self.yServerBoard = self.serverBoard.GetLocalPosition()
|
|
|
|
self.serverSelectButton.SetEvent(ui.__mem_func__(self.__OnClickSelectServerButton))
|
|
self.serverExitButton.SetEvent(ui.__mem_func__(self.__OnClickExitButton))
|
|
|
|
self.loginButton.SetEvent(ui.__mem_func__(self.__OnClickLoginButton))
|
|
self.loginExitButton.SetEvent(ui.__mem_func__(self.__OnClickExitButton))
|
|
|
|
self.serverList.SetEvent(ui.__mem_func__(self.__OnSelectServer))
|
|
|
|
self.idEditLine.SetReturnEvent(ui.__mem_func__(self.pwdEditLine.SetFocus))
|
|
self.idEditLine.SetTabEvent(ui.__mem_func__(self.pwdEditLine.SetFocus))
|
|
|
|
self.pwdEditLine.SetReturnEvent(ui.__mem_func__(self.__OnClickLoginButton))
|
|
self.pwdEditLine.SetTabEvent(ui.__mem_func__(self.idEditLine.SetFocus))
|
|
self.pwdEditLine.SetSecretMode(1)
|
|
return 1
|
|
|
|
def __VirtualKeyboard_SetKeys(self, keyCodes):
|
|
uiDefFontBackup = localeInfo.UI_DEF_FONT
|
|
localeInfo.UI_DEF_FONT = localeInfo.UI_DEF_FONT_LARGE
|
|
|
|
keyIndex = 1
|
|
for keyCode in keyCodes:
|
|
key = self.GetChild2("key_%d" % keyIndex)
|
|
if key:
|
|
key.SetEvent(lambda x=keyCode: self.__VirtualKeyboard_PressKey(x))
|
|
key.SetText(keyCode)
|
|
key.ButtonText.SetFontColor(0, 0, 0)
|
|
keyIndex += 1
|
|
|
|
for keyIndex in range(keyIndex, VIRTUAL_KEYBOARD_NUM_KEYS+1):
|
|
key = self.GetChild2("key_%d" % keyIndex)
|
|
if key:
|
|
key.SetEvent(lambda x=' ': self.__VirtualKeyboard_PressKey(x))
|
|
key.SetText(' ')
|
|
|
|
localeInfo.UI_DEF_FONT = uiDefFontBackup
|
|
|
|
def __VirtualKeyboard_PressKey(self, code):
|
|
ime.PasteString(code)
|
|
|
|
#if self.virtualKeyboardMode == "ALPHABET" and self.virtualKeyboardIsUpper:
|
|
# self.__VirtualKeyboard_SetLowerMode()
|
|
|
|
def __VirtualKeyboard_PressBackspace(self):
|
|
ime.PasteBackspace()
|
|
|
|
def __VirtualKeyboard_PressReturn(self):
|
|
ime.PasteReturn()
|
|
|
|
def __VirtualKeyboard_SetUpperMode(self):
|
|
self.virtualKeyboardIsUpper = True
|
|
|
|
if self.virtualKeyboardMode == "ALPHABET":
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_ALPHABET_UPPERS)
|
|
elif self.virtualKeyboardMode == "NUMBER":
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_SYMBOLS)
|
|
else:
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_NUMBERS)
|
|
|
|
def __VirtualKeyboard_SetLowerMode(self):
|
|
self.virtualKeyboardIsUpper = False
|
|
|
|
if self.virtualKeyboardMode == "ALPHABET":
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_ALPHABET_LOWERS)
|
|
elif self.virtualKeyboardMode == "NUMBER":
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_NUMBERS)
|
|
else:
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_SYMBOLS)
|
|
|
|
def __VirtualKeyboard_SetAlphabetMode(self):
|
|
self.virtualKeyboardIsUpper = False
|
|
self.virtualKeyboardMode = "ALPHABET"
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_ALPHABET_LOWERS)
|
|
|
|
def __VirtualKeyboard_SetNumberMode(self):
|
|
self.virtualKeyboardIsUpper = False
|
|
self.virtualKeyboardMode = "NUMBER"
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_NUMBERS)
|
|
|
|
def __VirtualKeyboard_SetSymbolMode(self):
|
|
self.virtualKeyboardIsUpper = False
|
|
self.virtualKeyboardMode = "SYMBOL"
|
|
self.__VirtualKeyboard_SetKeys(self.VIRTUAL_KEY_SYMBOLS)
|
|
|
|
def Connect(self, id, pwd):
|
|
|
|
if IsLoginDelay():
|
|
loginDelay = GetLoginDelay()
|
|
self.connectingDialog = ConnectingDialog()
|
|
self.connectingDialog.Open(loginDelay)
|
|
self.connectingDialog.SAFE_SetTimeOverEvent(self.OnEndCountDown)
|
|
self.connectingDialog.SAFE_SetExitEvent(self.OnPressExitKey)
|
|
self.isNowCountDown = True
|
|
|
|
else:
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(localeInfo.LOGIN_CONNETING, self.SetPasswordEditLineFocus, localeInfo.UI_CANCEL)
|
|
|
|
self.stream.SetLoginInfo(id, pwd)
|
|
self.stream.Connect()
|
|
|
|
def __OnClickExitButton(self):
|
|
self.stream.SetPhaseWindow(0)
|
|
|
|
def __OnLocaleChanged(self, newLocaleCode):
|
|
"""Handle locale change - save config, reload, and refresh UI"""
|
|
import dbg
|
|
|
|
# 1) Save locale code to config/locale.cfg
|
|
try:
|
|
import os
|
|
if not os.path.exists("config"):
|
|
os.makedirs("config")
|
|
with open("config/locale.cfg", "w") as f:
|
|
f.write(newLocaleCode)
|
|
dbg.TraceError("Saved new locale to config: %s" % newLocaleCode)
|
|
except Exception as e:
|
|
dbg.TraceError("Failed to save locale.cfg: %s" % str(e))
|
|
return
|
|
|
|
# 2) Call C++ to reload locale data (C++ data + Python modules)
|
|
if not app.ReloadLocale():
|
|
dbg.TraceError("app.ReloadLocale() failed")
|
|
return
|
|
|
|
dbg.TraceError("Locale changed successfully, refreshing UI...")
|
|
|
|
# 3) Refresh all UI text elements with new locale
|
|
self.__RefreshLocaleUI()
|
|
|
|
def __RefreshLocaleUI(self):
|
|
"""
|
|
Refresh all UI text elements after locale change
|
|
|
|
Uses the generic uiLocaleRefresh module to update all visible text elements
|
|
without needing to reload the entire UI.
|
|
"""
|
|
import uiScriptLocale
|
|
import uiLocaleRefresh
|
|
|
|
try:
|
|
# Refresh button and text elements using element mapping
|
|
elementMapping = {
|
|
self.serverInfo: "LOGIN_DEFAULT_SERVERADDR",
|
|
self.selectConnectButton: "LOGIN_SELECT_BUTTON",
|
|
self.loginButton: "LOGIN_CONNECT",
|
|
self.loginExitButton: "LOGIN_EXIT",
|
|
self.serverSelectButton: "OK",
|
|
self.serverExitButton: "LOGIN_SELECT_EXIT",
|
|
self.idText: "LOGIN_ID",
|
|
self.pwdText: "LOGIN_PASSWORD",
|
|
}
|
|
uiLocaleRefresh.RefreshByMapping(elementMapping)
|
|
|
|
# Refresh ServerBoard Title (special case - accessed via GetChild)
|
|
try:
|
|
serverBoardTitle = self.GetChild("Title")
|
|
serverBoardTitle.SetText(uiScriptLocale.LOGIN_SELECT_TITLE)
|
|
except:
|
|
pass
|
|
|
|
# Rebuild login error message dictionary with new locale strings
|
|
loginFailureTemplate = {
|
|
"ALREADY" : "LOGIN_FAILURE_ALREAY",
|
|
"NOID" : "LOGIN_FAILURE_NOT_EXIST_ID",
|
|
"WRONGPWD" : "LOGIN_FAILURE_WRONG_PASSWORD",
|
|
"FULL" : "LOGIN_FAILURE_TOO_MANY_USER",
|
|
"SHUTDOWN" : "LOGIN_FAILURE_SHUTDOWN",
|
|
"REPAIR" : "LOGIN_FAILURE_REPAIR_ID",
|
|
"BLOCK" : "LOGIN_FAILURE_BLOCK_ID",
|
|
"BESAMEKEY" : "LOGIN_FAILURE_BE_SAME_KEY",
|
|
"NOTAVAIL" : "LOGIN_FAILURE_NOT_AVAIL",
|
|
"NOBILL" : "LOGIN_FAILURE_NOBILL",
|
|
"BLKLOGIN" : "LOGIN_FAILURE_BLOCK_LOGIN",
|
|
"WEBBLK" : "LOGIN_FAILURE_WEB_BLOCK",
|
|
"BADSCLID" : "LOGIN_FAILURE_WRONG_SOCIALID",
|
|
"AGELIMIT" : "LOGIN_FAILURE_SHUTDOWN_TIME",
|
|
}
|
|
self.loginFailureMsgDict = uiLocaleRefresh.RebuildDictionary(loginFailureTemplate, "localeInfo")
|
|
|
|
# Recreate locale selector to ensure it's on top with updated text
|
|
if self.localeSelector:
|
|
self.localeSelector.Destroy()
|
|
self.localeSelector = None
|
|
|
|
self.localeSelector = LocaleSelector()
|
|
self.localeSelector.Create(self)
|
|
self.localeSelector.SetLocaleChangedEvent(ui.__mem_func__(self.__OnLocaleChanged))
|
|
self.localeSelector.Show()
|
|
self.localeSelector.SetTop()
|
|
|
|
except:
|
|
# import dbg
|
|
# dbg.TraceError("LoginWindow.__RefreshLocaleUI failed")
|
|
pass
|
|
|
|
def __SetServerInfo(self, name):
|
|
net.SetServerInfo(name.strip())
|
|
self.serverInfo.SetText(name)
|
|
|
|
def __LoadLoginInfo(self, loginInfoFileName):
|
|
# This should not work in production
|
|
if not debugInfo.IsDebugMode():
|
|
app.loggined = FALSE
|
|
else:
|
|
try:
|
|
loginInfo={}
|
|
exec(compile(open(loginInfoFileName, "rb").read(), loginInfoFileName, 'exec'), loginInfo)
|
|
except IOError:
|
|
print((\
|
|
"For automatic login, please create" + loginInfoFileName + "file\n"\
|
|
"\n"\
|
|
"Contents:\n"\
|
|
"================================================================\n"\
|
|
"addr=address\n"\
|
|
"port=port number\n"\
|
|
"id=user ID\n"\
|
|
"pwd=password\n"\
|
|
"slot=character selection index (if absent or -1, no auto-selection)\n"\
|
|
"autoLogin=enable auto login\n"
|
|
"autoSelect=enable auto select\n"
|
|
"locale=(ymir) works as ymir for LC_Ymir. Works as korea if not specified\n"
|
|
));
|
|
|
|
id=loginInfo.get("id", "")
|
|
pwd=loginInfo.get("pwd", "")
|
|
|
|
addr=loginInfo.get("addr", "")
|
|
port=loginInfo.get("port", 0)
|
|
account_addr=loginInfo.get("account_addr", addr)
|
|
account_port=loginInfo.get("account_port", port)
|
|
|
|
locale = loginInfo.get("locale", "")
|
|
|
|
if addr and port:
|
|
net.SetMarkServer(addr, port)
|
|
|
|
net.SetServerInfo(addr+":"+str(port))
|
|
self.serverInfo.SetText("K:"+addr+":"+str(port))
|
|
|
|
slot=loginInfo.get("slot", 0)
|
|
isAutoLogin=loginInfo.get("auto", 0)
|
|
isAutoLogin=loginInfo.get("autoLogin", 0)
|
|
isAutoSelect=loginInfo.get("autoSelect", 0)
|
|
|
|
self.stream.SetCharacterSlot(slot)
|
|
self.stream.SetConnectInfo(addr, port, account_addr, account_port)
|
|
self.stream.isAutoLogin=isAutoLogin
|
|
self.stream.isAutoSelect=isAutoSelect
|
|
|
|
self.id = None
|
|
self.pwd = None
|
|
self.loginnedServer = None
|
|
self.loginnedChannel = None
|
|
app.loggined = FALSE
|
|
|
|
self.loginInfo = loginInfo
|
|
|
|
if self.id and self.pwd:
|
|
app.loggined = TRUE
|
|
|
|
if isAutoLogin:
|
|
self.Connect(id, pwd)
|
|
|
|
print("==================================================================================")
|
|
print(("Auto login: %s - %s:%d %s" % (loginInfoFileName, addr, port, id)))
|
|
print("==================================================================================")
|
|
|
|
|
|
def PopupDisplayMessage(self, msg):
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(msg)
|
|
|
|
def PopupNotifyMessage(self, msg, func=0):
|
|
if not func:
|
|
func=self.EmptyFunc
|
|
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(msg, func, localeInfo.UI_OK)
|
|
|
|
def __OnCloseInputDialog(self):
|
|
if self.inputDialog:
|
|
self.inputDialog.Close()
|
|
self.inputDialog = None
|
|
return True
|
|
|
|
def OnPressExitKey(self):
|
|
self.stream.popupWindow.Close()
|
|
self.stream.SetPhaseWindow(0)
|
|
return True
|
|
|
|
def OnExit(self):
|
|
self.stream.popupWindow.Close()
|
|
|
|
def OnUpdate(self):
|
|
ServerStateChecker.Update()
|
|
|
|
def EmptyFunc(self):
|
|
pass
|
|
|
|
#####################################################################################
|
|
|
|
def __ServerBoard_OnKeyUp(self, key):
|
|
if self.serverBoard.IsShow():
|
|
if app.DIK_RETURN==key:
|
|
self.__OnClickSelectServerButton()
|
|
return True
|
|
|
|
def __GetRegionID(self):
|
|
return 0
|
|
|
|
def __GetServerID(self):
|
|
return self.serverList.GetSelectedItem()
|
|
|
|
def __GetChannelID(self):
|
|
return self.channelList.GetSelectedItem()
|
|
|
|
# SEVER_LIST_BUG_FIX
|
|
def __ServerIDToServerIndex(self, regionID, targetServerID):
|
|
try:
|
|
regionDict = serverInfo.REGION_DICT[regionID]
|
|
except KeyError:
|
|
return -1
|
|
|
|
retServerIndex = 0
|
|
for eachServerID, regionDataDict in list(regionDict.items()):
|
|
if eachServerID == targetServerID:
|
|
return retServerIndex
|
|
|
|
retServerIndex += 1
|
|
|
|
return -1
|
|
|
|
def __ChannelIDToChannelIndex(self, channelID):
|
|
return channelID - 1
|
|
# END_OF_SEVER_LIST_BUG_FIX
|
|
|
|
def __OpenServerBoard(self):
|
|
|
|
loadRegionID, loadServerID, loadChannelID = self.__LoadChannelInfo()
|
|
|
|
serverIndex = self.__ServerIDToServerIndex(loadRegionID, loadServerID)
|
|
channelIndex = self.__ChannelIDToChannelIndex(loadChannelID)
|
|
|
|
self.serverList.SelectItem(serverIndex)
|
|
|
|
if channelIndex >= 0:
|
|
self.channelList.SelectItem(channelIndex)
|
|
|
|
## Temporary fix for Show/Hide code issue - [levites]
|
|
self.serverBoard.SetPosition(self.xServerBoard, self.yServerBoard)
|
|
self.serverBoard.Show()
|
|
self.connectBoard.Hide()
|
|
self.loginBoard.Hide()
|
|
|
|
if self.virtualKeyboard:
|
|
self.virtualKeyboard.Hide()
|
|
|
|
if app.loggined and not SKIP_LOGIN_PHASE_SUPPORT_CHANNEL:
|
|
self.serverList.SelectItem(self.loginnedServer-1)
|
|
self.channelList.SelectItem(self.loginnedChannel-1)
|
|
self.__OnClickSelectServerButton()
|
|
|
|
def __OpenLoginBoard(self):
|
|
|
|
# self.serverExitButton.SetEvent(ui.__mem_func__(self.__OnClickExitServerButton))
|
|
self.serverExitButton.SetText(localeInfo.UI_CLOSE)
|
|
|
|
self.serverBoard.SetPosition(self.xServerBoard, wndMgr.GetScreenHeight())
|
|
self.serverBoard.Hide()
|
|
|
|
if self.virtualKeyboard:
|
|
self.virtualKeyboard.Show()
|
|
|
|
if app.loggined:
|
|
self.Connect(self.id, self.pwd)
|
|
self.connectBoard.Hide()
|
|
self.loginBoard.Hide()
|
|
elif not self.stream.isAutoLogin:
|
|
self.connectBoard.Show()
|
|
self.loginBoard.Show()
|
|
|
|
## if users have the login infomation, then don't initialize.2005.9 haho
|
|
if self.idEditLine == None:
|
|
self.idEditLine.SetText("")
|
|
if self.pwdEditLine == None:
|
|
self.pwdEditLine.SetText("")
|
|
|
|
self.idEditLine.SetFocus()
|
|
|
|
global SKIP_LOGIN_PHASE
|
|
if SKIP_LOGIN_PHASE:
|
|
if not self.loginInfo:
|
|
self.connectBoard.Hide()
|
|
|
|
def __OnSelectRegionGroup(self):
|
|
self.__RefreshServerList()
|
|
|
|
def __OnSelectSettlementArea(self):
|
|
# SEVER_LIST_BUG_FIX
|
|
regionID = self.__GetRegionID()
|
|
serverID = self.serverListOnRegionBoard.GetSelectedItem()
|
|
|
|
serverIndex = self.__ServerIDToServerIndex(regionID, serverID)
|
|
self.serverList.SelectItem(serverIndex)
|
|
# END_OF_SEVER_LIST_BUG_FIX
|
|
|
|
self.__OnSelectServer()
|
|
|
|
def __RefreshServerList(self):
|
|
regionID = self.__GetRegionID()
|
|
|
|
if regionID not in serverInfo.REGION_DICT:
|
|
return
|
|
|
|
self.serverList.ClearItem()
|
|
|
|
regionDict = serverInfo.REGION_DICT[regionID]
|
|
|
|
# SEVER_LIST_BUG_FIX
|
|
visible_index = 1
|
|
for id, regionDataDict in list(regionDict.items()):
|
|
name = regionDataDict.get("name", "noname")
|
|
try:
|
|
server_id = serverInfo.SERVER_ID_DICT[id]
|
|
except:
|
|
server_id = visible_index
|
|
|
|
self.serverList.InsertItem(id, " %02d. %s" % (int(server_id), name))
|
|
visible_index += 1
|
|
# END_OF_SEVER_LIST_BUG_FIX
|
|
|
|
def __OnSelectServer(self):
|
|
self.__OnCloseInputDialog()
|
|
self.__RequestServerStateList()
|
|
self.__RefreshServerStateList()
|
|
|
|
def __RequestServerStateList(self):
|
|
regionID = self.__GetRegionID()
|
|
serverID = self.__GetServerID()
|
|
|
|
try:
|
|
channelDict = serverInfo.REGION_DICT[regionID][serverID]["channel"]
|
|
except:
|
|
print((" __RequestServerStateList - serverInfo.REGION_DICT(%d, %d)" % (regionID, serverID)))
|
|
return
|
|
|
|
ServerStateChecker.Initialize();
|
|
for id, channelDataDict in list(channelDict.items()):
|
|
key=channelDataDict["key"]
|
|
ip=channelDataDict["ip"]
|
|
udp_port=channelDataDict["udp_port"]
|
|
ServerStateChecker.AddChannel(key, ip, udp_port)
|
|
|
|
ServerStateChecker.Request()
|
|
|
|
def __RefreshServerStateList(self):
|
|
|
|
regionID = self.__GetRegionID()
|
|
serverID = self.__GetServerID()
|
|
bakChannelID = self.channelList.GetSelectedItem()
|
|
|
|
self.channelList.ClearItem()
|
|
|
|
try:
|
|
channelDict = serverInfo.REGION_DICT[regionID][serverID]["channel"]
|
|
except:
|
|
print((" __RequestServerStateList - serverInfo.REGION_DICT(%d, %d)" % (regionID, serverID)))
|
|
return
|
|
|
|
for channelID, channelDataDict in list(channelDict.items()):
|
|
channelName = channelDataDict["name"]
|
|
channelState = channelDataDict["state"]
|
|
self.channelList.InsertItem(channelID, " %s %s" % (channelName, channelState))
|
|
|
|
self.channelList.SelectItem(bakChannelID-1)
|
|
|
|
def __GetChannelName(self, regionID, selServerID, selChannelID):
|
|
try:
|
|
return serverInfo.REGION_DICT[regionID][selServerID]["channel"][selChannelID]["name"]
|
|
except KeyError:
|
|
if 9==selChannelID:
|
|
return localeInfo.CHANNEL_PVP
|
|
else:
|
|
return localeInfo.CHANNEL_NORMAL % (selChannelID)
|
|
|
|
def NotifyChannelState(self, addrKey, state):
|
|
try:
|
|
stateName=serverInfo.STATE_DICT[state]
|
|
except:
|
|
stateName=serverInfo.STATE_NONE
|
|
|
|
regionID=self.__GetRegionID()
|
|
serverID=self.__GetServerID()
|
|
channelID=addrKey%10
|
|
|
|
try:
|
|
serverInfo.REGION_DICT[regionID][serverID]["channel"][channelID]["state"] = stateName
|
|
self.__RefreshServerStateList()
|
|
|
|
except:
|
|
import exception
|
|
exception.Abort(localeInfo.CHANNEL_NOT_FIND_INFO)
|
|
|
|
def __OnClickExitServerButton(self):
|
|
print("exit server")
|
|
self.__OpenLoginBoard()
|
|
|
|
def __OnClickSelectRegionButton(self):
|
|
regionID = self.__GetRegionID()
|
|
serverID = self.__GetServerID()
|
|
|
|
if (regionID not in serverInfo.REGION_DICT):
|
|
self.PopupNotifyMessage(localeInfo.CHANNEL_SELECT_REGION)
|
|
return
|
|
|
|
if (serverID not in serverInfo.REGION_DICT[regionID]):
|
|
self.PopupNotifyMessage(localeInfo.CHANNEL_SELECT_SERVER)
|
|
return
|
|
|
|
self.__SaveChannelInfo()
|
|
|
|
self.serverExitButton.SetEvent(ui.__mem_func__(self.__OnClickExitServerButton))
|
|
self.serverExitButton.SetText(localeInfo.UI_CLOSE)
|
|
|
|
self.__RefreshServerList()
|
|
self.__OpenServerBoard()
|
|
|
|
def __OnClickSelectServerButton(self):
|
|
regionID = self.__GetRegionID()
|
|
serverID = self.__GetServerID()
|
|
channelID = self.__GetChannelID()
|
|
|
|
if (regionID not in serverInfo.REGION_DICT):
|
|
self.PopupNotifyMessage(localeInfo.CHANNEL_SELECT_REGION)
|
|
return
|
|
|
|
if (serverID not in serverInfo.REGION_DICT[regionID]):
|
|
self.PopupNotifyMessage(localeInfo.CHANNEL_SELECT_SERVER)
|
|
return
|
|
|
|
try:
|
|
channelDict = serverInfo.REGION_DICT[regionID][serverID]["channel"]
|
|
except KeyError:
|
|
return
|
|
|
|
try:
|
|
state = channelDict[channelID]["state"]
|
|
except KeyError:
|
|
self.PopupNotifyMessage(localeInfo.CHANNEL_SELECT_CHANNEL)
|
|
return
|
|
|
|
# Entry is prohibited if status equals FULL
|
|
if state == serverInfo.STATE_DICT[3]:
|
|
self.PopupNotifyMessage(localeInfo.CHANNEL_NOTIFY_FULL)
|
|
return
|
|
|
|
self.__SaveChannelInfo()
|
|
|
|
try:
|
|
serverName = serverInfo.REGION_DICT[regionID][serverID]["name"]
|
|
channelName = serverInfo.REGION_DICT[regionID][serverID]["channel"][channelID]["name"]
|
|
addrKey = serverInfo.REGION_DICT[regionID][serverID]["channel"][channelID]["key"]
|
|
except:
|
|
print((" ERROR __OnClickSelectServerButton(%d, %d, %d)" % (regionID, serverID, channelID)))
|
|
serverName = localeInfo.CHANNEL_EMPTY_SERVER
|
|
channelName = localeInfo.CHANNEL_NORMAL % channelID
|
|
|
|
self.__SetServerInfo("%s, %s " % (serverName, channelName))
|
|
|
|
try:
|
|
ip = serverInfo.REGION_DICT[regionID][serverID]["channel"][channelID]["ip"]
|
|
tcp_port = serverInfo.REGION_DICT[regionID][serverID]["channel"][channelID]["tcp_port"]
|
|
except:
|
|
import exception
|
|
exception.Abort("LoginWindow.__OnClickSelectServerButton - server selection failed")
|
|
|
|
try:
|
|
account_ip = serverInfo.REGION_AUTH_SERVER_DICT[regionID][serverID]["ip"]
|
|
account_port = serverInfo.REGION_AUTH_SERVER_DICT[regionID][serverID]["port"]
|
|
except:
|
|
account_ip = 0
|
|
account_port = 0
|
|
|
|
try:
|
|
markKey = regionID*1000 + serverID*10
|
|
markAddrValue=serverInfo.MARKADDR_DICT[markKey]
|
|
net.SetMarkServer(markAddrValue["ip"], markAddrValue["tcp_port"])
|
|
app.SetGuildMarkPath(markAddrValue["mark"])
|
|
# GUILD_SYMBOL
|
|
app.SetGuildSymbolPath(markAddrValue["symbol_path"])
|
|
# END_OF_GUILD_SYMBOL
|
|
|
|
except:
|
|
import exception
|
|
exception.Abort("LoginWindow.__OnClickSelectServerButton - mark information missing")
|
|
|
|
self.stream.SetConnectInfo(ip, tcp_port, account_ip, account_port)
|
|
self.__OpenLoginBoard()
|
|
|
|
def __OnClickSelectConnectButton(self):
|
|
self.__RefreshServerList()
|
|
self.__OpenServerBoard()
|
|
|
|
def __OnClickLoginButton(self):
|
|
id = self.idEditLine.GetText()
|
|
pwd = self.pwdEditLine.GetText()
|
|
|
|
if len(id)==0:
|
|
self.PopupNotifyMessage(localeInfo.LOGIN_INPUT_ID, self.SetIDEditLineFocus)
|
|
return
|
|
|
|
if len(pwd)==0:
|
|
self.PopupNotifyMessage(localeInfo.LOGIN_INPUT_PASSWORD, self.SetPasswordEditLineFocus)
|
|
return
|
|
|
|
self.Connect(id, pwd)
|
|
|
|
def SameLogin_OpenUI(self):
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(localeInfo.LOGIN_FAILURE_SAMELOGIN, 0, localeInfo.UI_OK)
|