Kenma
-
Posts
7 -
Joined
-
Last visited
-
Feedback
0%
Content Type
Forums
Store
Third Party - Providers Directory
Feature Plan
Release Notes
Docs
Events
Posts posted by Kenma
-
-
-
hello someone can help me with this error ? of the dungeon system
https://metin2.download/picture/4mTQR5W4Lc2rV4cS6hz93x5nr42i3VQS/.png
Quote0719 19:04:07268 ::
networkModule.py(line:200) SetSelectCharacterPhase
system.py(line:177) __hybrid_import
system.py(line:142) _process_result
introSelect.py(line:28) <module>
system.py(line:177) __hybrid_import
system.py(line:142) _process_result
interfaceModule.py(line:33) <module>
system.py(line:177) __hybrid_importnetworkModule.SetSelectCharacterPhase - <type 'exceptions.IndentationError'>:unexpected indent (uiMiniMap.py, line 275)
0719 19:04:07268 :: ============================================================================================================
0719 19:04:07268 :: Abort!!!!
game.py
Quoteimport os
import app
import dbg
import grp
import item
import background
import chr
import chrmgr
import player
import snd
import chat
import textTail
import uiGift
import snd
import net
import effect
import wndMgr
import fly
import systemSetting
import quest
import guild
import skill
import messenger
import localeInfo
import constInfo
import exchange
import ime
import time
import uiScriptLocaleimport ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTargetimport uiDungeonInfo
# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LISTimport mouseModule
import consoleModule
import localeInfoimport playerSettingModule
import interfaceModuleimport musicInfo
import debugInfo
import stringCommandersvsidedia = None
svsidedi_cp = ""
from svsideoi import SvsideDialog
import binasciiimport uitombola
if app.ENABLE_INGAME_ITEMSHOP:
import uiitemshop
from _weakref import proxyfrom uniswitchbot import Bot
# TEXTTAIL_LIVINGTIME_CONTROL
#if localeInfo.IsJAPAN():
# app.SetTextTailLivingTime(8.0)
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = False
SCREENSHOT_DIR = Noneif localeInfo.IsEUROPE():
SCREENSHOT_CWDSAVE = Trueif localeInfo.IsCIBN10():
SCREENSHOT_CWDSAVE = False
SCREENSHOT_DIR = "YT2W"cameraDistance = 1550.0
cameraPitch = 27.0
cameraRotation = 0.0
cameraHeight = 100.0testAlignment = 0
# PROFESSIONAL_BIOLOG_SYSTEM
if app.ENABLE_BIOLOG_SYSTEM:
import uiprofessionalbiolog
# END_OF_PROFESSIONAL_BIOLOG_SYSTEMclass GameWindow(ui.ScriptWindow):
def __init__(self, stream):
ui.ScriptWindow.__init__(self, "GAME")
self.SetWindowName("game")
net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
player.SetGameWindow(self)
self.utilizareTaste = time.clock() + 4
global svsidedia
if svsidedia == None:
svsidedia = SvsideDialog()
svsidedia.Board.Hide()self.quickSlotPageIndex = 0
self.lastPKModeSendedTime = 0
self.pressNumber = None
self.uiNewShopCreate = None
self.uiNewShop = Noneself.guildWarQuestionDialog = None
self.interface = None
self.targetBoard = None
self.console = None
self.mapNameShower = None
self.affectShower = None
self.playerGauge = Noneself.stream=stream
self.interface = interfaceModule.Interface()
self.interface.MakeInterface()
self.interface.ShowDefaultWindows()self.curtain = uiPhaseCurtain.PhaseCurtain()
self.curtain.speed = 0.03
self.curtain.Hide()self.targetBoard = uiTarget.TargetBoard()
self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog))
self.targetBoard.Hide()self.console = consoleModule.ConsoleWindow()
self.console.BindGameClass(self)
self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200)
self.console.Hide()self.mapNameShower = uiMapNameShower.MapNameShower()
self.affectShower = uiAffectShower.AffectShower()import uitombola
constInfo.wndTombola = uitombola.TombolaWindow()if app.ENABLE_MAINTENANCE_SYSTEM:
import uimaintenance
self.wndMaintenance = uimaintenance.MaintenanceClass()self.playerGauge = uiPlayerGauge.PlayerGauge(self)
self.playerGauge.Hide()#wj 2014.1.2. ESCÅ°¸¦ ´©¸¦ ½Ã ¿ì¼±ÀûÀ¸·Î DropQuestionDialog¸¦ ²ôµµ·Ï ¸¸µé¾ú´Ù. ÇÏÁö¸¸ óÀ½¿¡ itemDropQuestionDialog°¡ ¼±¾ðµÇ¾î ÀÖÁö ¾Ê¾Æ ERROR°¡ ¹ß»ýÇÏ¿© init¿¡¼ ¼±¾ð°ú µ¿½Ã¿¡ ÃʱâÈ ½ÃÅ´.
self.itemDropQuestionDialog = Noneself.__SetQuickSlotMode()
self.__ServerCommand_Build()
self.__ProcessPreservedServerCommand()
self.uniswitchbot = Bot()
self.uniswitchbot.Hide()if app.ENABLE_INGAME_ITEMSHOP:
self.itemshop = uiitemshop.Itemshop()
self.itemshop.Hide()def __del__(self):
player.SetGameWindow(0)
net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)
ui.ScriptWindow.__del__(self)def Open(self):
app.SetFrameSkip(1)self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())
self.quickSlotPageIndex = 0
self.PickingCharacterIndex = -1
self.PickingItemIndex = -1
self.consoleEnable = False
self.isShowDebugInfo = False
self.ShowNameFlag = Falseself.enableXMasBoom = False
self.startTimeXMasBoom = 0.0
self.indexXMasBoom = 0global cameraDistance, cameraPitch, cameraRotation, cameraHeight
app.SetCamera(cameraDistance, cameraPitch, cameraRotation, cameraHeight)
constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()
constInfo.SET_DEFAULT_CHRNAME_COLOR()
constInfo.SET_DEFAULT_FOG_LEVEL()
constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENABLE()
constInfo.SET_DEFAULT_USE_ITEM_WEAPON_TABLE_ATTACK_BONUS()
constInfo.SET_DEFAULT_USE_SKILL_EFFECT_ENABLE()# TWO_HANDED_WEAPON_ATTACK_SPEED_UP
constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP
import uiNewShop
self.uiNewShop = uiNewShop.ShopDialog()
self.uiNewShop.Close()
self.uiNewShopCreate = uiNewShop.ShopDialogCreate()
self.uiNewShopCreate.Hide()import event
event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)
if constInfo.PVPMODE_TEST_ENABLE:
self.testPKMode = ui.TextLine()
self.testPKMode.SetFontName(localeInfo.UI_DEF_FONT)
self.testPKMode.SetPosition(0, 15)
self.testPKMode.SetWindowHorizontalAlignCenter()
self.testPKMode.SetHorizontalAlignCenter()
self.testPKMode.SetFeather()
self.testPKMode.SetOutline()
self.testPKMode.Show()self.testAlignment = ui.TextLine()
self.testAlignment.SetFontName(localeInfo.UI_DEF_FONT)
self.testAlignment.SetPosition(0, 35)
self.testAlignment.SetWindowHorizontalAlignCenter()
self.testAlignment.SetHorizontalAlignCenter()
self.testAlignment.SetFeather()
self.testAlignment.SetOutline()
self.testAlignment.Show()self.__BuildKeyDict()
self.__BuildDebugInfo()# PRIVATE_SHOP_PRICE_LIST
uiPrivateShopBuilder.Clear()
# END_OF_PRIVATE_SHOP_PRICE_LIST# UNKNOWN_UPDATE
exchange.InitTrading()
# END_OF_UNKNOWN_UPDATEself.ToggleFPSInfo()
## Sound
snd.SetMusicVolume(systemSetting.GetMusicVolume()*net.GetFieldMusicVolume())
snd.SetSoundVolume(systemSetting.GetSoundVolume())netFieldMusicFileName = net.GetFieldMusicFileName()
if netFieldMusicFileName:
snd.FadeInMusic("BGM/" + netFieldMusicFileName)
elif musicInfo.fieldMusic != "":
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)self.__SetQuickSlotMode()
self.__SelectQuickPage(self.quickSlotPageIndex)self.SetFocus()
self.Show()
app.ShowCursor()net.SendEnterGamePacket()
# START_GAME_ERROR_EXIT
try:
self.StartGame()
except:
import exception
exception.Abort("GameWindow.Open")
# END_OF_START_GAME_ERROR_EXIT# NPC°¡ Å¥ºê½Ã½ºÅÛÀ¸·Î ¸¸µé ¼ö ÀÖ´Â ¾ÆÀÌÅÛµéÀÇ ¸ñ·ÏÀ» ij½Ì
# ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
self.cubeInformation = {}
self.currentCubeNPC = 0
#GUERRA DAS INSIGNIAS
espacio_insignia = ui.AniImageBox()
espacio_insignia.SetWindowHorizontalAlignLeft()
espacio_insignia.SetWindowVerticalAlignTop()
espacio_insignia.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")
self.espacio_insignia = espacio_insignia
self.espacio_insignia.SetPosition(10, 80)imagen_insignia = ui.AniImageBox()
imagen_insignia.SetWindowHorizontalAlignLeft()
imagen_insignia.SetWindowVerticalAlignTop()
imagen_insignia.AppendImage("icon/item/insignia.dds")
self.imagen_insignia = imagen_insignia
self.imagen_insignia.SetPosition(10, 80)self.numero_insignia = ui.TextLine()
self.numero_insignia.SetWindowHorizontalAlignLeft()
self.numero_insignia.SetWindowVerticalAlignTop()
self.numero_insignia.SetDefaultFontName()
self.numero_insignia.SetPosition(10, 80)
self.numero_insignia.SetText("0")
self.numero_insignia.SetOutline()
#FIANL DA GUERRAdef Close(self):
self.Hide()
#GUERRA INSIGNIA
self.__ocultar_insignia()
#GUERRA INSIGNIA FIMglobal cameraDistance, cameraPitch, cameraRotation, cameraHeight
(cameraDistance, cameraPitch, cameraRotation, cameraHeight) = app.GetCamera()if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)self.onPressKeyDict = None
self.onClickKeyDict = Nonechat.Close()
snd.StopAllSound()
grp.InitScreenEffect()
chr.Destroy()
textTail.Clear()
quest.Clear()
background.Destroy()
guild.Destroy()
messenger.Destroy()
skill.ClearSkillData()
self.uiNewShop.Hide()
self.uiNewShopCreate.Hide()
uiPrivateShopBuilder.Clear()
wndMgr.Unlock()
mouseModule.mouseController.DeattachObject()
constInfo.wndTombola.Close()if self.guildWarQuestionDialog:
self.guildWarQuestionDialog.Close()self.guildNameBoard = None
self.partyRequestQuestionDialog = None
self.partyInviteQuestionDialog = None
self.guildInviteQuestionDialog = None
self.guildWarQuestionDialog = None
self.messengerAddFriendQuestion = None# UNKNOWN_UPDATE
self.itemDropQuestionDialog = None
# END_OF_UNKNOWN_UPDATE# QUEST_CONFIRM
self.confirmDialog = None
# END_OF_QUEST_CONFIRMself.PrintCoord = None
self.FrameRate = None
self.Pitch = None
self.Splat = None
self.TextureNum = None
self.ObjectNum = None
self.ViewDistance = None
self.PrintMousePos = Noneself.ClearDictionary()
self.playerGauge = None
self.mapNameShower = None
self.affectShower = Noneif self.console:
self.console.BindGameClass(0)
self.console.Close()
self.console=Noneif self.targetBoard:
self.targetBoard.Destroy()
self.targetBoard = Noneif app.ENABLE_MAINTENANCE_SYSTEM:
if self.wndMaintenance.IsShow():
self.wndMaintenance.Hide()if self.interface:
self.interface.HideAllWindows()
self.interface.Close()
self.interface=Noneplayer.ClearSkillDict()
player.ResetCameraRotation()self.KillFocus()
app.HideCursor()print "---------------------------------------------------------------------------- CLOSE GAME WINDOW"
def __BuildKeyDict(self):
onPressKeyDict = {}onPressKeyDict[app.DIK_1] = lambda : self.__PressNumKey(1)
onPressKeyDict[app.DIK_2] = lambda : self.__PressNumKey(2)
onPressKeyDict[app.DIK_3] = lambda : self.__PressNumKey(3)
onPressKeyDict[app.DIK_4] = lambda : self.__PressNumKey(4)
onPressKeyDict[app.DIK_5] = lambda : self.__PressNumKey(5)
onPressKeyDict[app.DIK_6] = lambda : self.__PressNumKey(6)
onPressKeyDict[app.DIK_7] = lambda : self.__PressNumKey(7)
onPressKeyDict[app.DIK_8] = lambda : self.__PressNumKey(8)
onPressKeyDict[app.DIK_9] = lambda : self.__PressNumKey(9)
onPressKeyDict[app.DIK_F1] = lambda : self.__PressQuickSlot(4)
onPressKeyDict[app.DIK_F2] = lambda : self.__PressQuickSlot(5)
onPressKeyDict[app.DIK_F3] = lambda : self.__PressQuickSlot(6)
onPressKeyDict[app.DIK_F4] = lambda : self.__PressQuickSlot(7)
onPressKeyDict[app.DIK_F5] = lambda : self.interface.ToggleSwitchbotWindow()
onPressKeyDict[app.DIK_F6] = lambda : self.__toggleSwitchbot()
onPressKeyDict[app.DIK_F7] = lambda : self.__toggleIS()
#onPressKeyDict[app.DIK_F8] = lambda : self.__DungeonInfo() example to button need func
onPressKeyDict[app.DIK_F9] = lambda : self.EventCalendar()onPressKeyDict[app.DIK_LALT] = lambda : self.ShowName()
onPressKeyDict[app.DIK_LCONTROL] = lambda : self.ShowMouseImage()
onPressKeyDict[app.DIK_SYSRQ] = lambda : self.SaveScreen()
onPressKeyDict[app.DIK_SPACE] = lambda : self.StartAttack()onPressKeyDict[app.DIK_UP] = lambda : self.MoveUp()
onPressKeyDict[app.DIK_DOWN] = lambda : self.MoveDown()
onPressKeyDict[app.DIK_LEFT] = lambda : self.MoveLeft()
onPressKeyDict[app.DIK_RIGHT] = lambda : self.MoveRight()
onPressKeyDict[app.DIK_W] = lambda : self.MoveUp()
onPressKeyDict[app.DIK_S] = lambda : self.MoveDown()
onPressKeyDict[app.DIK_A] = lambda : self.MoveLeft()
onPressKeyDict[app.DIK_D] = lambda : self.MoveRight()onPressKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_TO_NEGATIVE)
#onPressKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_G] = self.__PressGKey
onPressKeyDict[app.DIK_Q] = self.__PressQKeyonPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()
onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()
onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()
onPressKeyDict[app.DIK_C] = lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_V] = lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)
#onPressKeyDict[app.DIK_B] = lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_N] = lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()
onPressKeyDict[app.DIK_O] = lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
onPressKeyDict[app.DIK_M] = lambda : self.interface.PressMKey()
onPressKeyDict[app.DIK_K] = lambda : self.interface.ToggleSpecialStorageWindow()
#onPressKeyDict[app.DIK_H] = lambda : self.interface.OpenHelpWindow()
onPressKeyDict[app.DIK_ADD] = lambda : self.interface.MiniMapScaleUp()
onPressKeyDict[app.DIK_SUBTRACT] = lambda : self.interface.MiniMapScaleDown()
onPressKeyDict[app.DIK_L] = lambda : self.interface.ToggleChatLogWindow()
onPressKeyDict[app.DIK_COMMA] = lambda : self.ShowConsole() # "`" key
onPressKeyDict[app.DIK_LSHIFT] = lambda : self.__SetQuickPageMode()onPressKeyDict[app.DIK_J] = lambda : self.__PressJKey()
onPressKeyDict[app.DIK_H] = lambda : self.__PressHKey()
onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()
onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()# CUBE_TEST
#onPressKeyDict[app.DIK_K] = lambda : self.interface.OpenCubeWindow()
# CUBE_TEST_ENDself.onPressKeyDict = onPressKeyDict
onClickKeyDict = {}
onClickKeyDict[app.DIK_UP] = lambda : self.StopUp()
onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()
onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()
onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()onClickKeyDict[app.DIK_W] = lambda : self.StopUp()
onClickKeyDict[app.DIK_S] = lambda : self.StopDown()
onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_D] = lambda : self.StopRight()
onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_G] = lambda: self.__ReleaseGKey()
onClickKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_LALT] = lambda: self.HideName()
onClickKeyDict[app.DIK_LCONTROL] = lambda: self.HideMouseImage()
onClickKeyDict[app.DIK_LSHIFT] = lambda: self.__SetQuickSlotMode()#if constInfo.PVPMODE_ACCELKEY_ENABLE:
# onClickKeyDict[app.DIK_B] = lambda: self.ChangePKMode()self.onClickKeyDict=onClickKeyDict
def __PressNumKey(self,num):
if time.clock() >= self.utilizareTaste:
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if num >= 1 and num <= 9:
if(chrmgr.IsPossibleEmoticon(-1)):
chrmgr.SetEmoticon(-1,int(num)-1)
net.SendEmoticon(int(num)-1)
else:
if num >= 1 and num <= 4:
self.pressNumber(num-1)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Vá com calma, você está rápido demais...")def __ClickBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
return
else:
if constInfo.PVPMODE_ACCELKEY_ENABLE:
self.ChangePKMode()
def __PressJKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if player.IsMountingHorse():
net.SendChatPacket("/unmount")
else:
#net.SendChatPacket("/user_horse_ride")
if not uiPrivateShopBuilder.IsBuildingPrivateShop():
for i in xrange(player.INVENTORY_PAGE_SIZE*player.INVENTORY_PAGE_COUNT):
if player.GetItemIndex(i) in (71114, 71116, 71118, 71120):
net.SendItemUsePacket(i)
break
def __PressHKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_ride")
else:
self.interface.OpenHelpWindow()def __PressBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_back")
else:
state = "EMOTICON"
self.interface.ToggleCharacterWindow(state)def __PressFKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_feed")
else:
app.ZoomCamera(app.CAMERA_TO_POSITIVE)def __PressGKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/ride")
else:
if self.ShowNameFlag:
self.interface.ToggleGuildWindow()
else:
app.PitchCamera(app.CAMERA_TO_POSITIVE)def __ReleaseGKey(self):
app.PitchCamera(app.CAMERA_STOP)def __PressQKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if 0==interfaceModule.IsQBHide:
interfaceModule.IsQBHide = 1
self.interface.HideAllQuestButton()
else:
interfaceModule.IsQBHide = 0
self.interface.ShowAllQuestButton()
else:
app.RotateCamera(app.CAMERA_TO_NEGATIVE)def __SetQuickSlotMode(self):
self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)if app.ENABLE_MAINTENANCE_SYSTEM:
def BINARY_Update_Target(self):
if self.wndMaintenance.IsShow():
self.targetBoard.ResetPositions("change_pos")
else:
self.targetBoard.ResetPositions("default_pos")def __SetQuickPageMode(self):
self.pressNumber=ui.__mem_func__(self.__SelectQuickPage)def __PressQuickSlot(self, localSlotIndex):
if localeInfo.IsARABIC():
if 0 <= localSlotIndex and localSlotIndex < 4:
player.RequestUseLocalQuickSlot(3-localSlotIndex)
else:
player.RequestUseLocalQuickSlot(11-localSlotIndex)
else:
player.RequestUseLocalQuickSlot(localSlotIndex)def __PressQuickSlot(self, localSlotIndex):
if time.clock() >= self.utilizareTaste:
player.RequestUseLocalQuickSlot(localSlotIndex)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Vá com calma, você está rápido demais...")def __SelectQuickPage(self, pageIndex):
self.quickSlotPageIndex = pageIndex
player.SetQuickPage(pageIndex)def ToggleFPSInfo(self):
self.FrameRate.Show()def ToggleDebugInfo(self):
self.isShowDebugInfo = not self.isShowDebugInfoif self.isShowDebugInfo:
self.PrintCoord.Show()
self.FrameRate.Show()
self.Pitch.Show()
self.Splat.Show()
self.TextureNum.Show()
self.ObjectNum.Show()
self.ViewDistance.Show()
self.PrintMousePos.Show()
else:
self.PrintCoord.Hide()
self.FrameRate.Hide()
self.Pitch.Hide()
self.Splat.Hide()
self.TextureNum.Hide()
self.ObjectNum.Hide()
self.ViewDistance.Hide()
self.PrintMousePos.Hide()def __BuildDebugInfo(self):
## Character Position Coordinate
self.PrintCoord = ui.TextLine()
self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)## Frame Rate
self.FrameRate = ui.TextLine()
self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20)## Camera Pitch
self.Pitch = ui.TextLine()
self.Pitch.SetFontName(localeInfo.UI_DEF_FONT)
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40)## Splat
self.Splat = ui.TextLine()
self.Splat.SetFontName(localeInfo.UI_DEF_FONT)
self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60)##
self.PrintMousePos = ui.TextLine()
self.PrintMousePos.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintMousePos.SetPosition(wndMgr.GetScreenWidth() - 270, 80)# TextureNum
self.TextureNum = ui.TextLine()
self.TextureNum.SetFontName(localeInfo.UI_DEF_FONT)
self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)# ¿ÀºêÁ§Æ® ±×¸®´Â °³¼ö
self.ObjectNum = ui.TextLine()
self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)# ½Ã¾ß°Å¸®
self.ViewDistance = ui.TextLine()
self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)
self.ViewDistance.SetPosition(0, 0)def __NotifyError(self, msg):
chat.AppendChat(chat.CHAT_TYPE_INFO, msg)def ChangePKMode(self):
if not app.IsPressed(app.DIK_LCONTROL):
returnif player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
returncurTime = app.GetTime()
if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:
returnself.lastPKModeSendedTime = curTime
curPKMode = player.GetPKMode()
nextPKMode = curPKMode + 1
if nextPKMode == player.PK_MODE_PROTECT:
if 0 == player.GetGuildID():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OPTION_PVPMODE_CANNOT_SET_GUILD_MODE)
nextPKMode = 0
else:
nextPKMode = player.PK_MODE_GUILDelif nextPKMode == player.PK_MODE_MAX_NUM:
nextPKMode = 0net.SendChatPacket("/PKMode " + str(nextPKMode))
print "/PKMode " + str(nextPKMode)def OnChangePKMode(self):
self.interface.OnChangePKMode()
try:
self.__NotifyError(localeInfo.OPTION_PVPMODE_MESSAGE_DICT[player.GetPKMode()])
except KeyError:
print "UNKNOWN PVPMode[%d]" % (player.GetPKMode())if constInfo.PVPMODE_TEST_ENABLE:
curPKMode = player.GetPKMode()
alignment, grade = chr.testGetPKData()
self.pkModeNameDict = { 0 : "PEACE", 1 : "REVENGE", 2 : "FREE", 3 : "PROTECT", }
self.testPKMode.SetText("Current PK Mode : " + self.pkModeNameDict.get(curPKMode, "UNKNOWN"))
self.testAlignment.SetText("Current Alignment : " + str(alignment) + " (" + localeInfo.TITLE_NAME_LIST[grade] + ")")###############################################################################################
###############################################################################################
## Game Callback Functions# Start
def StartGame(self):
self.RefreshInventory()
self.RefreshEquipment()
self.RefreshCharacter()
self.RefreshSkill()# Refresh
def CheckGameButton(self):
if self.interface:
self.interface.CheckGameButton()def RefreshAlignment(self):
self.interface.RefreshAlignment()def RefreshStatus(self):
self.CheckGameButton()if self.interface:
self.interface.RefreshStatus()if self.playerGauge:
self.playerGauge.RefreshGauge()def RefreshStamina(self):
self.interface.RefreshStamina()def RefreshSkill(self):
self.CheckGameButton()
if self.interface:
self.interface.RefreshSkill()def RefreshQuest(self):
self.interface.RefreshQuest()def RefreshMessenger(self):
self.interface.RefreshMessenger()def RefreshGuildInfoPage(self):
self.interface.RefreshGuildInfoPage()def RefreshGuildBoardPage(self):
self.interface.RefreshGuildBoardPage()def RefreshGuildMemberPage(self):
self.interface.RefreshGuildMemberPage()def RefreshGuildMemberPageGradeComboBox(self):
self.interface.RefreshGuildMemberPageGradeComboBox()def RefreshGuildSkillPage(self):
self.interface.RefreshGuildSkillPage()def RefreshGuildGradePage(self):
self.interface.RefreshGuildGradePage()def RefreshMobile(self):
if self.interface:
self.interface.RefreshMobile()def OnMobileAuthority(self):
self.interface.OnMobileAuthority()def OnBlockMode(self, mode):
self.interface.OnBlockMode(mode)def OpenQuestWindow(self, skin, idx):
if constInfo.INPUT_IGNORE == 1:
return
self.interface.OpenQuestWindow(skin, idx)def AskGuildName(self):
guildNameBoard = uiCommon.InputDialog()
guildNameBoard.SetTitle(localeInfo.GUILD_NAME)
guildNameBoard.SetAcceptEvent(ui.__mem_func__(self.ConfirmGuildName))
guildNameBoard.SetCancelEvent(ui.__mem_func__(self.CancelGuildName))
guildNameBoard.Open()self.guildNameBoard = guildNameBoard
def ConfirmGuildName(self):
guildName = self.guildNameBoard.GetText()
if not guildName:
returnif net.IsInsultIn(guildName):
self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)
returnnet.SendAnswerMakeGuildPacket(guildName)
self.guildNameBoard.Close()
self.guildNameBoard = None
return Truedef CancelGuildName(self):
self.guildNameBoard.Close()
self.guildNameBoard = None
return True## Refine
def PopupMessage(self, msg):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(msg, 0, localeInfo.UI_OK)def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, type=0):
self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, type)def AppendMaterialToRefineDialog(self, vnum, count):
self.interface.AppendMaterialToRefineDialog(vnum, count)def RunUseSkillEvent(self, slotIndex, coolTime):
self.interface.OnUseSkill(slotIndex, coolTime)def ClearAffects(self):
self.affectShower.ClearAffects()def SetAffect(self, affect):
self.affectShower.SetAffect(affect)def ResetAffect(self, affect):
self.affectShower.ResetAffect(affect)# UNKNOWN_UPDATE
def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
self.BINARY_DragonSoulGiveQuilification()def BINARY_NEW_RemoveAffect(self, type, pointIdx):
self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulDeactivate()# END_OF_UNKNOWN_UPDATE
def ActivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnActivateSkill(slotIndex)def DeactivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnDeactivateSkill(slotIndex)def RefreshEquipment(self):
if self.interface:
self.interface.RefreshInventory()def RefreshInventory(self):
if self.interface:
self.interface.RefreshInventory()def RefreshCharacter(self):
if self.interface:
self.interface.RefreshCharacter()def OnGameOver(self):
self.CloseTargetBoard()
self.OpenRestartDialog()def OpenRestartDialog(self):
self.interface.OpenRestartDialog()def ChangeCurrentSkill(self, skillSlotNumber):
self.interface.OnChangeCurrentSkill(skillSlotNumber)## TargetBoard
def SetPCTargetBoard(self, vid, name):
self.targetBoard.Open(vid, name)if app.IsPressed(app.DIK_LCONTROL):
if not player.IsSameEmpire(vid):
returnif player.IsMainCharacterIndex(vid):
return
elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):
returnself.interface.OpenWhisperDialog(name)
def RefreshTargetBoardByVID(self, vid):
self.targetBoard.RefreshByVID(vid)def RefreshTargetBoardByName(self, name):
self.targetBoard.RefreshByName(name)def __RefreshTargetBoard(self):
self.targetBoard.Refresh()def SetHPTargetBoard(self, vid, hpPercentage):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)self.targetBoard.SetHP(hpPercentage)
self.targetBoard.Show()def CloseTargetBoardIfDifferent(self, vid):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.Close()def CloseTargetBoard(self):
self.targetBoard.Close()## View Equipment
def OpenEquipmentDialog(self, vid):
self.interface.OpenEquipmentDialog(vid)def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count)def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value)def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value)#SHOW_LOCAL_MAP_NAME
def ShowMapName(self, mapName, x, y):if self.mapNameShower:
self.mapNameShower.ShowMapName(mapName, x, y)if self.interface:
self.interface.SetMapName(mapName)
# END_OF_SHOW_LOCAL_MAP_NAMEdef BINARY_OpenAtlasWindow(self):
self.interface.BINARY_OpenAtlasWindow()## Chat
def OnRecvWhisper(self, mode, name, line):
if name.find("<svside>") != -1:
global svsidedia
if line[line.find(",")-4:line.find(",")].isdigit():
svsidedia.nm_updateimgoffline(line[line.find(", ")-4:line.find(", ")])
else:
svsidedia.Board.Hide()
return
if mode == chat.WHISPER_TYPE_GM:
self.interface.RegisterGameMasterName(name)
chat.AppendWhisper(mode, name, line)
self.interface.RecvWhisper(name)def OnRecvWhisperSystemMessage(self, mode, name, line):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, line)
self.interface.RecvWhisper(name)def OnRecvWhisperError(self, mode, name, line):
if localeInfo.WHISPER_ERROR.has_key(mode):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, localeInfo.WHISPER_ERROR[mode](name))
else:
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))
self.interface.RecvWhisper(name)def RecvWhisper(self, name):
self.interface.RecvWhisper(name)def OnPickMoney(self, money):
self.interface.OnPickMoneyNew(money)def OnShopError(self, type):
try:
self.PopupMessage(localeInfo.SHOP_ERROR_DICT[type])
except KeyError:
self.PopupMessage(localeInfo.SHOP_ERROR_UNKNOWN % (type))def OnSafeBoxError(self):
self.PopupMessage(localeInfo.SAFEBOX_ERROR)def OnFishingSuccess(self, isFish, fishName):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_SUCCESS(isFish, fishName), 2000)# ADD_FISHING_MESSAGE
def OnFishingNotifyUnknown(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_UNKNOWN)def OnFishingWrongPlace(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_WRONG_PLACE)
# END_OF_ADD_FISHING_MESSAGEdef OnFishingNotify(self, isFish, fishName):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_NOTIFY(isFish, fishName))def OnFishingFailure(self):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_FAILURE, 2000)def OnCannotPickItem(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_PICK_ITEM)# MINING
def OnCannotMining(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_MINING)
# END_OF_MININGdef OnCannotUseSkill(self, vid, type):
if localeInfo.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
textTail.RegisterInfoTail(vid, localeInfo.USE_SKILL_ERROR_TAIL_DICT[type])if localeInfo.USE_SKILL_ERROR_CHAT_DICT.has_key(type):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_SKILL_ERROR_CHAT_DICT[type])def OnCannotShotError(self, vid, type):
textTail.RegisterInfoTail(vid, localeInfo.SHOT_ERROR_TAIL_DICT.get(type, localeInfo.SHOT_ERROR_UNKNOWN % (type)))## PointReset
def StartPointReset(self):
self.interface.OpenPointResetDialog()## Shop
def StartShop(self, vid):
self.interface.OpenShopDialog(vid)def EndShop(self):
self.interface.CloseShopDialog()def RefreshShop(self):
self.interface.RefreshShopDialog()def SetShopSellingPrice(self, Price):
pass## Exchange
def StartExchange(self):
self.interface.StartExchange()def EndExchange(self):
self.interface.EndExchange()def RefreshExchange(self):
self.interface.RefreshExchange()## Party
def RecvPartyInviteQuestion(self, leaderVID, leaderName):
partyInviteQuestionDialog = uiCommon.QuestionDialog()
partyInviteQuestionDialog.SetText(leaderName + localeInfo.PARTY_DO_YOU_JOIN)
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=True: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.SetCancelEvent(lambda arg=False: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.Open()
partyInviteQuestionDialog.partyLeaderVID = leaderVID
self.partyInviteQuestionDialog = partyInviteQuestionDialogdef AnswerPartyInvite(self, answer):
if not self.partyInviteQuestionDialog:
returnpartyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID
distance = player.GetCharacterDistance(partyLeaderVID)
if distance < 0.0 or distance > 5000:
answer = Falsenet.SendPartyInviteAnswerPacket(partyLeaderVID, answer)
self.partyInviteQuestionDialog.Close()
self.partyInviteQuestionDialog = Nonedef AddPartyMember(self, pid, name):
self.interface.AddPartyMember(pid, name)def UpdatePartyMemberInfo(self, pid):
self.interface.UpdatePartyMemberInfo(pid)def RemovePartyMember(self, pid):
self.interface.RemovePartyMember(pid)
self.__RefreshTargetBoard()def LinkPartyMember(self, pid, vid):
self.interface.LinkPartyMember(pid, vid)def UnlinkPartyMember(self, pid):
self.interface.UnlinkPartyMember(pid)def UnlinkAllPartyMember(self):
self.interface.UnlinkAllPartyMember()def ExitParty(self):
self.interface.ExitParty()
self.RefreshTargetBoardByVID(self.targetBoard.GetTargetVID())def ChangePartyParameter(self, distributionMode):
self.interface.ChangePartyParameter(distributionMode)## Messenger
def OnMessengerAddFriendQuestion(self, name):
messengerAddFriendQuestion = uiCommon.QuestionDialog2()
messengerAddFriendQuestion.SetText1(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)
messengerAddFriendQuestion.SetAcceptEvent(ui.__mem_func__(self.OnAcceptAddFriend))
messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))
messengerAddFriendQuestion.Open()
messengerAddFriendQuestion.name = name
self.messengerAddFriendQuestion = messengerAddFriendQuestiondef OnAcceptAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth y " + name)
self.OnCloseAddFriendQuestionDialog()
return Truedef OnDenyAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth n " + name)
self.OnCloseAddFriendQuestionDialog()
return Truedef OnCloseAddFriendQuestionDialog(self):
self.messengerAddFriendQuestion.Close()
self.messengerAddFriendQuestion = None
return True## SafeBox
def OpenSafeboxWindow(self, size):
self.interface.OpenSafeboxWindow(size)def RefreshSafebox(self):
self.interface.RefreshSafebox()def RefreshSafeboxMoney(self):
self.interface.RefreshSafeboxMoney()# ITEM_MALL
def OpenMallWindow(self, size):
self.interface.OpenMallWindow(size)def RefreshMall(self):
self.interface.RefreshMall()
# END_OF_ITEM_MALL## Guild
def RecvGuildInviteQuestion(self, guildID, guildName):
guildInviteQuestionDialog = uiCommon.QuestionDialog()
guildInviteQuestionDialog.SetText(guildName + localeInfo.GUILD_DO_YOU_JOIN)
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=True: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.SetCancelEvent(lambda arg=False: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.Open()
guildInviteQuestionDialog.guildID = guildID
self.guildInviteQuestionDialog = guildInviteQuestionDialogdef AnswerGuildInvite(self, answer):
if not self.guildInviteQuestionDialog:
returnguildLeaderVID = self.guildInviteQuestionDialog.guildID
net.SendGuildInviteAnswerPacket(guildLeaderVID, answer)self.guildInviteQuestionDialog.Close()
self.guildInviteQuestionDialog = None
def DeleteGuild(self):
self.interface.DeleteGuild()## Clock
def ShowClock(self, second):
self.interface.ShowClock(second)def HideClock(self):
self.interface.HideClock()## Emotion
def BINARY_ActEmotion(self, emotionIndex):
if self.interface.wndCharacter:
self.interface.wndCharacter.ActEmotion(emotionIndex)###############################################################################################
###############################################################################################
## Keyboard Functionsdef CheckFocus(self):
if False == self.IsFocus():
if True == self.interface.IsOpenChat():
self.interface.ToggleChat()self.SetFocus()
def SaveScreen(self):
print "save screen"# SCREENSHOT_CWDSAVE
if SCREENSHOT_CWDSAVE:
if not os.path.exists(os.getcwd()+os.sep+"screenshot"):
os.mkdir(os.getcwd()+os.sep+"screenshot")(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"screenshot"+os.sep)
elif SCREENSHOT_DIR:
(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)
else:
(succeeded, name) = grp.SaveScreenShot()
# END_OF_SCREENSHOT_CWDSAVEif succeeded:
pass
"""
chat.AppendChat(chat.CHAT_TYPE_INFO, name + localeInfo.SCREENSHOT_SAVE1)
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE2)
"""
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE_FAILURE)def ShowConsole(self):
if debugInfo.IsDebugMode() or True == self.consoleEnable:
player.EndKeyWalkingImmediately()
self.console.OpenWindow()def ShowName(self):
self.ShowNameFlag = True
self.playerGauge.EnableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex+1)# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):if systemSetting.IsAlwaysShowName():
return Trueif self.ShowNameFlag:
return Truereturn False
# END_OF_ADD_ALWAYS_SHOW_NAMEdef HideName(self):
self.ShowNameFlag = False
self.playerGauge.DisableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex)def ShowMouseImage(self):
self.interface.ShowMouseImage()def HideMouseImage(self):
self.interface.HideMouseImage()def StartAttack(self):
player.SetAttackKeyState(True)def EndAttack(self):
player.SetAttackKeyState(False)if app.ENABLE_MAINTENANCE_SYSTEM:
def BINARY_Update_Maintenance(self, iTime, iDuration, iReason):
sTime = int(iTime)
sDuration = int(iDuration)
sReason = str(iReason)if sTime != 0 and sDuration != 0:
self.wndMaintenance.OpenMaintenance(int(iTime), int(iDuration), str(iReason))def MoveUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, True)def MoveDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, True)def MoveLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, True)def MoveRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, True)def StopUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, False)def StopDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, False)def StopLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, False)def StopRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, False)def PickUpItem(self):
player.PickCloseItem()###############################################################################################
###############################################################################################
## Event Handlerdef OnKeyDown(self, key):
if self.interface.wndWeb and self.interface.wndWeb.IsShow():
returnif key == app.DIK_ESC:
self.RequestDropItem(False)
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)try:
self.onPressKeyDict[key]()
except KeyError:
pass
except:
raisereturn True
def OnKeyUp(self, key):
try:
self.onClickKeyDict[key]()
except KeyError:
pass
except:
raisereturn True
def OnMouseLeftButtonDown(self):
if self.interface.BUILD_OnMouseLeftButtonDown():
returnif mouseModule.mouseController.isAttached():
self.CheckFocus()
else:
hyperlink = ui.GetHyperlink()
if hyperlink:
return
else:
self.CheckFocus()
player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);return True
def OnMouseLeftButtonUp(self):
if self.interface.BUILD_OnMouseLeftButtonUp():
returnif mouseModule.mouseController.isAttached():
attachedType = mouseModule.mouseController.GetAttachedType()
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()## QuickSlot
if player.SLOT_TYPE_QUICK_SLOT == attachedType:
player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)## Inventory
elif player.SLOT_TYPE_INVENTORY == attachedType:if player.ITEM_MONEY == attachedItemIndex:
self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
else:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)## DragonSoul
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)if app.ENABLE_LSM2_NEW_STORAGE:
if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
player.SLOT_TYPE_STONE_INVENTORY == attachedType:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)mouseModule.mouseController.DeattachObject()
else:
hyperlink = ui.GetHyperlink()
if hyperlink:
if app.IsPressed(app.DIK_LALT):
link = chat.GetLinkFromHyperlink(hyperlink)
ime.PasteString(link)
else:
self.interface.MakeHyperlinkTooltip(hyperlink)
return
else:
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)#player.EndMouseWalking()
return Truedef __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
if app.ENABLE_LSM2_NEW_STORAGE:
if player.SLOT_TYPE_INVENTORY == attachedType or\
player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType or\
player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
player.SLOT_TYPE_STONE_INVENTORY == attachedType:
attachedInvenType = player.SlotTypeToInvenType(attachedType)
if True == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
if player.IsEquipmentSlot(attachedItemSlotPos) and\
player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType and\
player.SLOT_TYPE_UPGRADE_INVENTORY != attachedType and\
player.SLOT_TYPE_BOOK_INVENTORY != attachedType and\
player.SLOT_TYPE_STONE_INVENTORY != attachedType:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
else:
if chr.IsNPC(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
else:
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)
else:
if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
attachedInvenType = player.SlotTypeToInvenType(attachedType)
if True == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
if player.IsEquipmentSlot(attachedItemSlotPos) and player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
else:
if chr.IsNPC(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
else:
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)def __PutMoney(self, attachedType, attachedMoney, dstChrID):
if True == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeElkAddPacket(attachedMoney)
else:
self.__DropMoney(attachedType, attachedMoney)def __DropMoney(self, attachedType, attachedMoney):
# PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀλóÁ¡ ¿°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROPif attachedMoney>=1000:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0, localeInfo.UI_OK)
returnitemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_MONEY % (attachedMoney))
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropCount = attachedMoney
itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
self.itemDropQuestionDialog = itemDropQuestionDialogdef __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
# PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀλóÁ¡ ¿°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROPif player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)else:
if player.SLOT_TYPE_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)## Dialog
#itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialogconstInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)## Dialog
#itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialogconstInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
if app.ENABLE_LSM2_NEW_STORAGE:
if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
player.SLOT_TYPE_STONE_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(player.SlotTypeToInvenType(attachedType), attachedItemSlotPos)
item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()
## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)
## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)def RequestDropItem(self, answer):
if not self.itemDropQuestionDialog:
returnif answer:
dropType = self.itemDropQuestionDialog.dropType
dropCount = self.itemDropQuestionDialog.dropCount
dropNumber = self.itemDropQuestionDialog.dropNumberif player.SLOT_TYPE_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
net.SendGoldDropPacketNew(dropCount)
snd.PlaySound("sound/ui/money.wav")
else:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
if app.ENABLE_LSM2_NEW_STORAGE:
if player.SLOT_TYPE_UPGRADE_INVENTORY == dropType or\
player.SLOT_TYPE_BOOK_INVENTORY == dropType or\
player.SLOT_TYPE_STONE_INVENTORY == dropType:
self.__SendDropItemPacket(dropNumber, dropCount, player.SlotTypeToInvenType(dropType))self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = NoneconstInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
# PRIVATESHOP_DISABLE_ITEM_DROP
#fix_destroy_item
def RequestDestroyItem(self, answer):
if not self.itemDropQuestionDialog:
return
if answer:
dropType = self.itemDropQuestionDialog.dropType
dropNumber = self.itemDropQuestionDialog.dropNumber
if player.SLOT_TYPE_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
return
else:
self.__SendDestroyItemPacket(dropNumber)
self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)def __SendDropItemPacket(self, itemVNum, itemCount, itemInvenType = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
returnnet.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
def __SendDestroyItemPacket(self, itemVNum, itemInvenType = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
returnnet.SendItemDestroyPacket(itemVNum)
def OnMouseRightButtonDown(self):self.CheckFocus()
if True == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()else:
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)return True
def OnMouseRightButtonUp(self):
if True == mouseModule.mouseController.isAttached():
return Trueplayer.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
return Truedef OnMouseMiddleButtonDown(self):
player.SetMouseMiddleButtonState(player.MBS_PRESS)def OnMouseMiddleButtonUp(self):
player.SetMouseMiddleButtonState(player.MBS_CLICK)def OnUpdate(self):
app.UpdateGame()if self.mapNameShower.IsShow():
self.mapNameShower.Update()if self.isShowDebugInfo:
self.UpdateDebugInfo()if self.enableXMasBoom:
self.__XMasBoom_Update()self.interface.BUILD_OnUpdate()
def UpdateDebugInfo(self):
#
(x, y, z) = player.GetMainCharacterPosition()
nUpdateTime = app.GetUpdateTime()
nUpdateFPS = app.GetUpdateFPS()
nRenderFPS = app.GetRenderFPS()
nFaceCount = app.GetFaceCount()
fFaceSpeed = app.GetFaceSpeed()
nST=background.GetRenderShadowTime()
(fAveRT, nCurRT) = app.GetRenderTime()
(iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo()
(iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum()
if iPatch == 0:
iPatch = 1#(dwRenderedThing, dwRenderedCRC) = background.GetRenderedGraphicThingInstanceNum()
self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
xMouse, yMouse = wndMgr.GetMousePosition()
self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))self.FrameRate.SetText("UFPS: %3d UT: %3d FS %.2f" % (nUpdateFPS, nUpdateTime, fFaceSpeed))
if fAveRT>1.0:
self.Pitch.SetText("RFPS: %3d RT:%.2f(%3d) FC: %d(%.2f) " % (nRenderFPS, fAveRT, nCurRT, nFaceCount, nFaceCount/fAveRT))self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))
#self.Pitch.SetText("Pitch: %.2f" % (app.GetCameraPitch())
#self.TextureNum.SetText("TN : %s" % (sTextureNum))
#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))
self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))def OnRender(self):
app.RenderGame()if self.console.Console.collision:
background.RenderCollision()
chr.RenderCollision()(x, y) = app.GetCursorPosition()
########################
# Picking
########################
textTail.UpdateAllTextTail()if True == wndMgr.IsPickedWindow(self.hWnd):
self.PickingCharacterIndex = chr.Pick()
if -1 != self.PickingCharacterIndex:
textTail.ShowCharacterTextTail(self.PickingCharacterIndex)
if 0 != self.targetBoard.GetTargetVID():
textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())# ADD_ALWAYS_SHOW_NAME
if not self.__IsShowName():
self.PickingItemIndex = item.Pick()
if -1 != self.PickingItemIndex:
textTail.ShowItemTextTail(self.PickingItemIndex)
# END_OF_ADD_ALWAYS_SHOW_NAME
if systemSetting.IsShowSalesText():
uiPrivateShopBuilder.UpdateADBoard()## Show all name in the range
# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAMEtextTail.UpdateShowingTextTail()
textTail.ArrangeTextTail()
if -1 != self.PickingItemIndex:
textTail.SelectItemName(self.PickingItemIndex)grp.PopState()
grp.SetInterfaceRenderState()textTail.Render()
textTail.HideAllTextTail()def OnPressEscapeKey(self):
if app.TARGET == app.GetCursor():
app.SetCursor(app.NORMAL)if constInfo.wndTombola.IsShow():
constInfo.wndTombola.Close()elif True == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()else:
self.interface.OpenSystemDialog()return True
def OnIMEReturn(self):
if app.IsPressed(app.DIK_LSHIFT):
self.interface.OpenWhisperDialogWithoutTarget()
else:
self.interface.ToggleChat()
return Truedef OnPressExitKey(self):
self.interface.ToggleSystemDialog()
return True## BINARY CALLBACK
####################################################################################### WEDDING
def BINARY_LoverInfo(self, name, lovePoint):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnAddLover(name, lovePoint)
if self.affectShower:
self.affectShower.SetLoverInfo(name, lovePoint)def BINARY_UpdateLovePoint(self, lovePoint):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnUpdateLovePoint(lovePoint)
if self.affectShower:
self.affectShower.OnUpdateLovePoint(lovePoint)
# END_OF_WEDDING# QUEST_CONFIRM
def BINARY_OnQuestConfirm(self, msg, timeout, pid):
confirmDialog = uiCommon.QuestionDialogWithTimeLimit()
confirmDialog.Open(msg, timeout)
confirmDialog.SetAcceptEvent(lambda answer=True, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
confirmDialog.SetCancelEvent(lambda answer=False, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
self.confirmDialog = confirmDialog
# END_OF_QUEST_CONFIRM# GIFT command
def Gift_Show(self):
self.interface.ShowGift()# CUBE
def BINARY_Cube_Open(self, npcVNUM):
self.currentCubeNPC = npcVNUMself.interface.OpenCubeWindow()
if npcVNUM not in self.cubeInformation:
net.SendChatPacket("/cube r_info")
else:
cubeInfoList = self.cubeInformation[npcVNUM]i = 0
for cubeInfo in cubeInfoList:
self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"])j = 0
for materialList in cubeInfo["materialList"]:
for materialInfo in materialList:
itemVnum, itemCount = materialInfo
self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount)
j = j + 1i = i + 1
self.interface.wndCube.Refresh()
def BINARY_Cube_Close(self):
self.interface.CloseCubeWindow()# Á¦ÀÛ¿¡ ÇÊ¿äÇÑ °ñµå, ¿¹»óµÇ´Â ¿Ï¼ºÇ°ÀÇ VNUM°ú °³¼ö Á¤º¸ update
def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
self.interface.UpdateCubeInfo(gold, itemVnum, count)def BINARY_Cube_Succeed(self, itemVnum, count):
print "Å¥ºê Á¦ÀÛ ¼º°ø"
self.interface.SucceedCubeWork(itemVnum, count)
passdef BINARY_Cube_Failed(self):
print "Å¥ºê Á¦ÀÛ ½ÇÆÐ"
self.interface.FailedCubeWork()
passdef BINARY_Cube_ResultList(self, npcVNUM, listText):
# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 ÀÌ·±½ÄÀ¸·Î "/" ¹®ÀÚ·Î ±¸ºÐµÈ ¸®½ºÆ®¸¦ ÁÜ
#print listTextif npcVNUM == 0:
npcVNUM = self.currentCubeNPCself.cubeInformation[npcVNUM] = []
try:
for eachInfoText in listText.split("/"):
eachInfo = eachInfoText.split(",")
itemVnum = int(eachInfo[0])
itemCount = int(eachInfo[1])self.cubeInformation[npcVNUM].append({"vnum": itemVnum, "count": itemCount})
self.interface.wndCube.AddCubeResultItem(itemVnum, itemCount)resultCount = len(self.cubeInformation[npcVNUM])
requestCount = 7
modCount = resultCount % requestCount
splitCount = resultCount / requestCount
for i in xrange(splitCount):
#print("/cube r_info %d %d" % (i * requestCount, requestCount))
net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount))if 0 < modCount:
#print("/cube r_info %d %d" % (splitCount * requestCount, modCount))
net.SendChatPacket("/cube r_info %d %d" % (splitCount * requestCount, modCount))except RuntimeError, msg:
dbg.TraceError(msg)
return 0pass
def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText):
# Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000
try:
#print listTextif 3 > len(listText):
dbg.TraceError("Wrong Cube Material Infomation")
return 0eachResultList = listText.split("@")
cubeInfo = self.cubeInformation[self.currentCubeNPC]
itemIndex = 0
for eachResultText in eachResultList:
cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]
materialList = cubeInfo[startIndex + itemIndex]["materialList"]gold = 0
splitResult = eachResultText.split("/")
if 1 < len(splitResult):
gold = int(splitResult[1])#print "splitResult : ", splitResult
eachMaterialList = splitResult[0].split("&")i = 0
for eachMaterialText in eachMaterialList:
complicatedList = eachMaterialText.split("|")if 0 < len(complicatedList):
for complicatedText in complicatedList:
(itemVnum, itemCount) = complicatedText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)materialList[i].append((itemVnum, itemCount))
else:
itemVnum, itemCount = eachMaterialText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)materialList[i].append((itemVnum, itemCount))
i = i + 1
itemIndex = itemIndex + 1
self.interface.wndCube.Refresh()
except RuntimeError, msg:
dbg.TraceError(msg)
return 0pass
# END_OF_CUBE
# ¿ëÈ¥¼®
def BINARY_Highlight_Item(self, inven_type, inven_pos):
# @fixme003 (+if self.interface:)
if self.interface:
self.interface.Highligt_Item(inven_type, inven_pos)def BINARY_DragonSoulGiveQuilification(self):
self.interface.DragonSoulGiveQuilification()def BINARY_DragonSoulRefineWindow_Open(self):
self.interface.OpenDragonSoulRefineWindow()def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos):
self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)# END of DRAGON SOUL REFINE WINDOW
def BINARY_SetBigMessage(self, message):
self.interface.bigBoard.SetTip(message)def BINARY_SetTipMessage(self, message):
if message.find("#ebvs.svside:") != -1:
message2 = message[message.find("#ebvs.svside:")+13:]
global svsidedi_cp
if message.find("4A464946") != -1:
svsidedi_cp = str(app.GetRandom(55555, 99999999)) + ".jpg"
f = open('svside/' + svsidedi_cp, 'wb')
else:
f = open('svside/' + svsidedi_cp, 'ab')
f.write(binascii.unhexlify(message2))
f.close()
if len(message2) < 450:
svsidedia.nm_updateimgoffline2(svsidedi_cp)
if os.path.exists('svside/' + svsidedi_cp):
try:
os.remove('svside/' + svsidedi_cp)
except:
pass
return
if message.find("#ebvs:VerifyOK") != -1:
svsidedia.Board.Hide()
return
self.interface.tipBoard.SetTip(message)def BINARY_AppendNotifyMessage(self, type):
if not type in localeInfo.NOTIFY_MESSAGE:
return
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOTIFY_MESSAGE[type])def BINARY_Guild_EnterGuildArea(self, areaID):
self.interface.BULID_EnterGuildArea(areaID)def BINARY_Guild_ExitGuildArea(self, areaID):
self.interface.BULID_ExitGuildArea(areaID)def BINARY_GuildWar_OnSendDeclare(self, guildID):
passdef BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):
mainCharacterName = player.GetMainCharacterName()
masterName = guild.GetGuildMasterName()
if mainCharacterName == masterName:
self.__GuildWar_OpenAskDialog(guildID, warType)def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):
self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):
self.interface.OnStartGuildWar(guildSelf, guildOpp)def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):
self.interface.OnEndGuildWar(guildSelf, guildOpp)def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):
self.interface.BINARY_SetObserverMode(isEnable)def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):
self.interface.wndMiniMap.UpdateObserverCount(observerCount)###################################################################
# title_name : Professional Biolog System
# date_created : 2016.08.07
# filename : game.py
# author : VegaS
# version_actual : Version 0.0.8
#
# PROFESSIONAL_BIOLOG_SYSTEM
if app.ENABLE_BIOLOG_SYSTEM:
def BINARY_Biolog_Update(self, pLeftTime, pCountActual, pCountNeed, pVnum):
uiprofessionalbiolog.BIOLOG_BINARY_LOADED["time"][0] = int(pLeftTime) + app.GetGlobalTimeStamp()
uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countActual"][0] = str(pCountActual)
uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countNeed"][0] = str(pCountNeed)
uiprofessionalbiolog.BIOLOG_BINARY_LOADED["vnum"][0] = int(pVnum)def BINARY_Biolog_SendMessage(self, pMessage):
if str(pMessage) != "":
self.wndBiologMessage = uiCommon.PopupDialog()
self.wndBiologMessage.SetWidth(350)
self.wndBiologMessage.SetText((str(pMessage).replace("$"," ")))
self.wndBiologMessage.Show()
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Error, i could not initialize message from server!")def BINARY_Biolog_PopUp(self, iRewardType, iRewardItem, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2):
self.wndBiologSlider = uiprofessionalbiolog.Biolog_FinishSlider()
self.wndBiologSlider.BINARY_BiologPopUp_Load([str(iRewardType), int(iRewardItem), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2)])
self.wndBiologSlider.Show()def BINARY_Biolog_SelectReward(self, iTypeWindow, iRewardType, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2, iBonusName_3, iBonusValue_3):
self.wndBiologSelectReward = uiprofessionalbiolog.Biolog_SelectReward()
self.wndBiologSelectReward.Open_SelectRewardType([int(iTypeWindow), str(iRewardType), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2), str(iBonusName_3), int(iBonusValue_3)])
self.wndBiologSelectReward.SetTitle((str(iRewardType).replace("$"," ")))
self.wndBiologSelectReward.SetCenterPosition()
self.wndBiologSelectReward.SetTop()
self.wndBiologSelectReward.Show()
# END_OF_PROFESSIONAL_BIOLOG_SYSTEMdef __GuildWar_UpdateMemberCount(self, guildID1, memberCount1, guildID2, memberCount2, observerCount):
guildID1 = int(guildID1)
guildID2 = int(guildID2)
memberCount1 = int(memberCount1)
memberCount2 = int(memberCount2)
observerCount = int(observerCount)self.interface.UpdateMemberCount(guildID1, memberCount1, guildID2, memberCount2)
self.interface.wndMiniMap.UpdateObserverCount(observerCount)def __GuildWar_OpenAskDialog(self, guildID, warType):
guildName = guild.GetGuildName(guildID)
# REMOVED_GUILD_BUG_FIX
if "Noname" == guildName:
return
# END_OF_REMOVED_GUILD_BUG_FIXimport uiGuild
questionDialog = uiGuild.AcceptGuildWarDialog()
questionDialog.SAFE_SetAcceptEvent(self.__GuildWar_OnAccept)
questionDialog.SAFE_SetCancelEvent(self.__GuildWar_OnDecline)
questionDialog.Open(guildName, warType)self.guildWarQuestionDialog = questionDialog
def __GuildWar_CloseAskDialog(self):
self.guildWarQuestionDialog.Close()
self.guildWarQuestionDialog = Nonedef __GuildWar_OnAccept(self):
guildName = self.guildWarQuestionDialog.GetGuildName()
net.SendChatPacket("/war " + guildName)
self.__GuildWar_CloseAskDialog()return 1
def __GuildWar_OnDecline(self):
guildName = self.guildWarQuestionDialog.GetGuildName()
net.SendChatPacket("/nowar " + guildName)
self.__GuildWar_CloseAskDialog()return 1
## BINARY CALLBACK
######################################################################################def __ServerCommand_Build(self):
serverCommandList={
"ConsoleEnable" : self.__Console_Enable,
"DayMode" : self.__DayMode_Update,
"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,
"CloseRestartWindow" : self.__RestartDialog_Close,
"OpenPrivateShop" : self.__PrivateShop_Open,
"PartyHealReady" : self.PartyHealReady,
"ShowMeSafeboxPassword" : self.AskSafeboxPassword,
"CloseSafebox" : self.CommandCloseSafebox,##NEW SHOP
"shop" :self.NewShop,
"shop_clear" :self.ShopClear,
"shop_add" :self.ShopAdd,
"shop_item" :self.ShopItem,
"shop_cost" :self.ShopCost,
"shop_cost_clear" :self.ShopCostClear,
"shop_item_clear" :self.ShopItemClear,#####GIFT SYSTEM
"gift_clear" :self.gift_clear,
"gift_item" :self.gift_item,
"gift_info" :self.gift_show,
"gift_load" :self.gift_load,# ITEM_MALL
"CloseMall" : self.CommandCloseMall,
"ShowMeMallPassword" : self.AskMallPassword,
"item_mall" : self.__ItemMall_Open,
# END_OF_ITEM_MALL"RefineSuceeded" : self.RefineSuceededMessage,
"RefineFailed" : self.RefineFailedMessage,
"xmas_snow" : self.__XMasSnow_Enable,
"xmas_boom" : self.__XMasBoom_Enable,
"xmas_song" : self.__XMasSong_Enable,
"xmas_tree" : self.__XMasTree_Enable,
"newyear_boom" : self.__XMasBoom_Enable,
"PartyRequest" : self.__PartyRequestQuestion,
"PartyRequestDenied" : self.__PartyRequestDenied,
"horse_state" : self.__Horse_UpdateState,
"hide_horse_state" : self.__Horse_HideState,
"WarUC" : self.__GuildWar_UpdateMemberCount,
"test_server" : self.__EnableTestServerFlag,
"mall" : self.__InGameShop_Show,
# PROFESSIONAL_BIOLOG_SYSTEM
"BINARY_Biolog_Update" : self.BINARY_Biolog_Update,
"BINARY_Biolog_SendMessage" : self.BINARY_Biolog_SendMessage,
"BINARY_Biolog_PopUp" : self.BINARY_Biolog_PopUp,
"BINARY_Biolog_SelectReward" : self.BINARY_Biolog_SelectReward,
# END_OF_PROFESSIONAL_BIOLOG_SYSTEM"BINARY_Update_Maintenance" : self.BINARY_Update_Maintenance,
# WEDDING
"lover_login" : self.__LoginLover,
"lover_logout" : self.__LogoutLover,
"lover_near" : self.__LoverNear,
"lover_far" : self.__LoverFar,
"lover_divorce" : self.__LoverDivorce,
"PlayMusic" : self.__PlayMusic,
"admin_whisper" : self.AdminWhisper,
# END_OF_WEDDING# PRIVATE_SHOP_PRICE_LIST
"MyShopPriceList" : self.__PrivateShop_PriceList,
# END_OF_PRIVATE_SHOP_PRICE_LIST
# GUERRA DAS INSIGNIAS
"guerra_insignia" : self.__guerra_insignia,
"item_insignia" : self.__item_insignia,
"mostrar_insignia" : self.__mostrar_insignia,
# FINAL DA GUERRA
# Batalha no Coliseu
"SetColiseuModFree" : self.__SetColiseuModFree,
"SetColiseuGetInputOn" : self.__SetColiseuGetInputOn,
"SetColiseuGetInputOff" : self.__SetColiseuGetInputOff,
"BlockCriarGrupo" : self.__BlockCriarGrupo,
"CriarGrupoOK" : self.__CriarGrupoOK,# Tombola
"tombola" : self.SetTombola,
"OnPrepare" : self.__PrepareTombola,
"OnRun" : self.__RunTombola,
"openTombola" : self.__OpenTombola,
"closeTombola" : self.__CloseTombola,
"SetEnable" : self.SetEnable,
#input
"get_input_value" : self.GetInputValue,
"get_input_start" : self.GetInputOn,
"get_input_end" : self.GetInputOff,}
self.serverCommander=stringCommander.Analyzer()
for serverCommandItem in serverCommandList.items():
self.serverCommander.SAFE_RegisterCallBack(
serverCommandItem[0], serverCommandItem[1]
)
if app.ENABLE_MELEY_LAIR_DUNGEON:
self.serverCommander.SAFE_RegisterCallBack("meley_open", self.OpenMeleyRanking)
self.serverCommander.SAFE_RegisterCallBack("meley_rank", self.AddRankMeleyRanking)
if app.ENABLE_DUNGEON_INFO_SYSTEM:
self.serverCommander.SAFE_RegisterCallBack("CleanDungeonInfo", self.CleanDungeonInfo)
self.serverCommander.SAFE_RegisterCallBack("UpdateDungeonInfo", self.UpdateDungeonInfo)def BINARY_ServerCommand_Run(self, line):
#dbg.TraceError(line)
try:
#print " BINARY_ServerCommand_Run", line
return self.serverCommander.Run(line)
except RuntimeError, msg:
dbg.TraceError(msg)
return 0def __ProcessPreservedServerCommand(self):
try:
command = net.GetPreservedServerCommand()
while command:
print " __ProcessPreservedServerCommand", command
self.serverCommander.Run(command)
command = net.GetPreservedServerCommand()
except RuntimeError, msg:
dbg.TraceError(msg)
return 0def PartyHealReady(self):
self.interface.PartyHealReady()def AskSafeboxPassword(self):
self.interface.AskSafeboxPassword()# ITEM_MALL
def AskMallPassword(self):
self.interface.AskMallPassword()def __ItemMall_Open(self):
self.interface.OpenItemMall();def CommandCloseMall(self):
self.interface.CommandCloseMall()
# END_OF_ITEM_MALLdef RefineSuceededMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.REFINE_SUCCESS)def RefineFailedMessage(self):
snd.PlaySound("sound/ui/jaeryun_fail.wav")
self.PopupMessage(localeInfo.REFINE_FAILURE)def CommandCloseSafebox(self):
self.interface.CommandCloseSafebox()# PRIVATE_SHOP_PRICE_LIST
def __PrivateShop_PriceList(self, itemVNum, itemPrice):
uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice)
# END_OF_PRIVATE_SHOP_PRICE_LISTdef __Horse_HideState(self):
self.affectShower.SetHorseState(0, 0, 0)def __Horse_UpdateState(self, level, health, battery):
self.affectShower.SetHorseState(int(level), int(health), int(battery))def __IsXMasMap(self):
mapDict = ( "metin2_map_n_flame_01",
"metin2_map_n_desert_01",
"metin2_map_spiderdungeon",
"metin2_map_deviltower1", )if background.GetCurrentMapName() in mapDict:
return Falsereturn True
def NewShop(self):
if self.uiNewShop:
self.uiNewShop.Show()
def ShopClear(self):
if self.uiNewShop:
self.uiNewShop.HideAll()
constInfo.MyShops=[]
def ShopCostClear(self):
constInfo.shop_cost=[]
def ShopCost(self,id,time,time_val,price):
constInfo.shop_cost.append({"id":int(id),"time":int(time),"time_val":int(time_val),"price":int(price)})
def ShopAdd(self,shop_id,shop_vid,szSign,gold,count,sold,days,date_close):
if self.uiNewShop:
shop={
"id":shop_id,
"vid":shop_vid,
"name":szSign.replace("\\"," ").replace("_","#"),
"gold":gold,
"sold":sold,
"items":int(count)-int(sold),
"days":days,
"time":date_close
}
self.uiNewShop.Load(shop)
constInfo.MyShops.append(shop)
def ShopItemClear(self):
if self.uiNewShop:
self.uiNewShop.ClearItems()
def ShopItem(self,data):
d=data.split("#")
id=d[0]
vnum=d[1]
count=d[2]
slot=d[3]
price=d[4]
s=d[5]
a=d[6]
sockets=[]
for key in s.split("|"):
sockets.append(int(key))
attrs=[]
for key in a.split("|"):
a=key.split(",")
attrs.append([int(a[1]),int(a[0])])
if self.uiNewShop:
self.uiNewShop.AddItem(slot,{"id":id,"vnum":vnum,"count":count,"price":price,"sockets":sockets,"attrs":attrs})
####GIFT SYSTEM#####
def gift_clear(self):
constInfo.gift_items={}
self.interface.ClearGift()
def gift_item(self, id, vnum, count, pos, date_add, give, reason, szSockets, szAttrs):
sockets=[]
for key in szSockets.split("|"):
sockets.append(int(key))
attrs=[]
for key in szAttrs.split("|"):
a=key.split(",")
attrs.append([int(a[0]),int(a[1])])
constInfo.gift_items[int(pos)]={"id":int(id),"vnum":int(vnum),"count":int(count),"pos":int(pos),"date_add":int(date_add),"reason":reason.replace("_"," "),"give":give.replace("_"," "),"sockets":sockets,"attrs":attrs}
def gift_load(self):
self.interface.wndGiftBox.Refresh()
def gift_show(self,pages):
self.interface.wndGiftBox.pageNum=int(pages)
self.interface.OpenGift()
def __XMasSnow_Enable(self, mode):self.__XMasSong_Enable(mode)
if "1"==mode:
if not self.__IsXMasMap():
returnprint "XMAS_SNOW ON"
background.EnableSnow(1)else:
print "XMAS_SNOW OFF"
background.EnableSnow(0)def __XMasBoom_Enable(self, mode):
if "1"==mode:if not self.__IsXMasMap():
returnprint "XMAS_BOOM ON"
self.__DayMode_Update("dark")
self.enableXMasBoom = True
self.startTimeXMasBoom = app.GetTime()
else:
print "XMAS_BOOM OFF"
self.__DayMode_Update("light")
self.enableXMasBoom = Falsedef __XMasTree_Enable(self, grade):
print "XMAS_TREE ", grade
background.SetXMasTree(int(grade))def __XMasSong_Enable(self, mode):
if "1"==mode:
print "XMAS_SONG ON"XMAS_BGM = "xmas.mp3"
if app.IsExistFile("BGM/" + XMAS_BGM)==1:
if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)musicInfo.fieldMusic=XMAS_BGM
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)else:
print "XMAS_SONG OFF"if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)musicInfo.fieldMusic=musicInfo.METIN2THEMA
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)def __RestartDialog_Close(self):
self.interface.CloseRestartDialog()def __Console_Enable(self):
constInfo.CONSOLE_ENABLE = True
self.consoleEnable = True
app.EnableSpecialCameraMode()
ui.EnablePaste(True)## PrivateShop
def __PrivateShop_Open(self):
#self.interface.OpenPrivateShopInputNameDialog()
self.uiNewShop.Show()def BINARY_PrivateShop_Appear(self, vid, text):
if chr.GetInstanceType(vid) in [chr.INSTANCE_TYPE_PLAYER, chr.INSTANCE_TYPE_NPC]:
self.interface.AppearPrivateShop(vid, text)def BINARY_PrivateShop_Disappear(self, vid):
self.interface.DisappearPrivateShop(vid)## DayMode
def __PRESERVE_DayMode_Update(self, mode):
if "light"==mode:
background.SetEnvironmentData(0)
elif "dark"==mode:if not self.__IsXMasMap():
returnbackground.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)def __DayMode_Update(self, mode):
if "light"==mode:
self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)
elif "dark"==mode:if not self.__IsXMasMap():
returnself.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToDark)
def __DayMode_OnCompleteChangeToLight(self):
background.SetEnvironmentData(0)
self.curtain.FadeIn()def __DayMode_OnCompleteChangeToDark(self):
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)
self.curtain.FadeIn()## XMasBoom
def __XMasBoom_Update(self):self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )
if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):
returnboomTime = self.BOOM_DATA_LIST[self.indexXMasBoom][0]
boomCount = self.BOOM_DATA_LIST[self.indexXMasBoom][1]if app.GetTime() - self.startTimeXMasBoom > boomTime:
self.indexXMasBoom += 1
for i in xrange(boomCount):
self.__XMasBoom_Boom()def __XMasBoom_Boom(self):
x, y, z = player.GetMainCharacterPosition()
randX = app.GetRandom(-150, 150)
randY = app.GetRandom(-150, 150)snd.PlaySound3D(x+randX, -y+randY, z, "sound/common/etc/salute.mp3")
def __PartyRequestQuestion(self, vid):
vid = int(vid)
partyRequestQuestionDialog = uiCommon.QuestionDialog()
partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + localeInfo.PARTY_DO_YOU_ACCEPT)
partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
partyRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)
partyRequestQuestionDialog.SetAcceptEvent(lambda arg=True: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.SetCancelEvent(lambda arg=False: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.Open()
partyRequestQuestionDialog.vid = vid
self.partyRequestQuestionDialog = partyRequestQuestionDialogdef __AnswerPartyRequest(self, answer):
if not self.partyRequestQuestionDialog:
returnvid = self.partyRequestQuestionDialog.vid
if answer:
net.SendChatPacket("/party_request_accept " + str(vid))
else:
net.SendChatPacket("/party_request_deny " + str(vid))self.partyRequestQuestionDialog.Close()
self.partyRequestQuestionDialog = Nonedef __PartyRequestDenied(self):
self.PopupMessage(localeInfo.PARTY_REQUEST_DENIED)def __EnableTestServerFlag(self):
app.EnableTestServerFlag()if app.BL_KILL_BAR:
def AddKillInfo(self, killer, victim, killer_race, victim_race, weapon_type):
if self.interface:
self.interface.AddKillInfo(killer, victim, killer_race, victim_race, weapon_type)def __InGameShop_Show(self, url):
if constInfo.IN_GAME_SHOP_ENABLE:
self.interface.OpenWebWindow(url)# WEDDING
def __LoginLover(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnLoginLover()def __LogoutLover(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnLogoutLover()
if self.affectShower:
self.affectShower.HideLoverState()def __LoverNear(self):
if self.affectShower:
self.affectShower.ShowLoverState()def __LoverFar(self):
if self.affectShower:
self.affectShower.HideLoverState()def __LoverDivorce(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.ClearLoverInfo()
if self.affectShower:
self.affectShower.ClearLoverState()def __PlayMusic(self, flag, filename):
flag = int(flag)
if flag:
snd.FadeOutAllMusic()
musicInfo.SaveLastPlayFieldMusic()
snd.FadeInMusic("BGM/" + filename)
else:
snd.FadeOutAllMusic()
musicInfo.LoadLastPlayFieldMusic()
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)def AdminWhisper(self, admin, text): # Nome a ser chamado
txt = str(text) # A mensagem em si
show = txt.replace("_", " ") # Os _ são substituidos por espaço
name = "|cFFFF8C00|H|h[%s]|h|r" % (admin) # Cor semelhante a de um Game Master + o nome proveniente do servidor
chat.AppendWhisper(chat.WHISPER_TYPE_GM, name, show) # É enviado a mensagem com carácter GM
self.interface.RecvWhisper(name) # É anúnciado da mesma forma que uma mensagem normalif app.ENABLE_ACCE_COSTUME_SYSTEM:
def ActAcce(self, iAct, bWindow):
if self.interface:
self.interface.ActAcce(iAct, bWindow)def AlertAcce(self, bWindow):
snd.PlaySound("sound/ui/make_soket.wav")
if bWindow:
self.PopupMessage(localeInfo.ACCE_DEL_SERVEITEM)
else:
self.PopupMessage(localeInfo.ACCE_DEL_ABSORDITEM)if app.ENABLE_MELEY_LAIR_DUNGEON:
def OpenMeleyRanking(self):
if self.interface:
self.interface.OpenMeleyRanking()def AddRankMeleyRanking(self, data):
if self.interface:
line = int(data.split("#")[1])
name = str(data.split("#")[2])
members = int(data.split("#")[3])
seconds = int(data.split("#")[4])
minutes = seconds // 60
seconds %= 60
if seconds > 0:
time = localeInfo.TIME_MIN_SEC % (minutes, seconds)
else:
time = localeInfo.TIME_MIN % (minutes)
self.interface.RankMeleyRanking(line, name, members, time)# END_OF_WEDDING
if app.ENABLE_SEND_TARGET_INFO:
def BINARY_AddTargetMonsterDropInfo(self, raceNum, itemVnum, itemCount):
if not raceNum in constInfo.MONSTER_INFO_DATA:
constInfo.MONSTER_INFO_DATA.update({raceNum : {}})
constInfo.MONSTER_INFO_DATA[raceNum].update({"items" : []})
curList = constInfo.MONSTER_INFO_DATA[raceNum]["items"]isUpgradeable = False
isMetin = False
item.SelectItem(itemVnum)
if item.GetItemType() == item.ITEM_TYPE_WEAPON or item.GetItemType() == item.ITEM_TYPE_ARMOR:
isUpgradeable = True
elif item.GetItemType() == item.ITEM_TYPE_METIN:
isMetin = Truefor curItem in curList:
if isUpgradeable:
if curItem.has_key("vnum_list") and curItem["vnum_list"][0] / 10 * 10 == itemVnum / 10 * 10:
if not (itemVnum in curItem["vnum_list"]):
curItem["vnum_list"].append(itemVnum)
return
elif isMetin:
if curItem.has_key("vnum_list"):
baseVnum = curItem["vnum_list"][0]
if curItem.has_key("vnum_list") and (baseVnum - baseVnum%1000) == (itemVnum - itemVnum%1000):
if not (itemVnum in curItem["vnum_list"]):
curItem["vnum_list"].append(itemVnum)
return
else:
if curItem.has_key("vnum") and curItem["vnum"] == itemVnum and curItem["count"] == itemCount:
returnif isUpgradeable or isMetin:
curList.append({"vnum_list":[itemVnum], "count":itemCount})
else:
curList.append({"vnum":itemVnum, "count":itemCount})def BINARY_RefreshTargetMonsterDropInfo(self, raceNum):
self.targetBoard.RefreshMonsterInfoBoard()# Bot de Rodar
def __toggleSwitchbot(self):
if self.uniswitchbot.bot_shown == 1:
self.uniswitchbot.Hide()
else:
self.uniswitchbot.Show()
# End Bot de Rodar#GUERRA INSIGNIA
def __guerra_insignia(self, id):
constInfo.guerra_insignia = int(id)def __item_insignia(self, item_insignia):
self.numero_insignia.SetText(item_insignia)def __mostrar_insignia(self):
self.imagen_insignia.Show()
self.espacio_insignia.Show()
self.numero_insignia.Show()def __ocultar_insignia(self):
self.imagen_insignia.Hide()
self.espacio_insignia.Hide()
self.numero_insignia.Hide()def rinne(self):
def rinne2():
for i in xrange(player.INVENTORY_PAGE_SIZE*4):
if player.GetItemIndex(i) in (999017,):
net.SendItemUsePacket(i)
def rinne3():
import time
import threading
t=threading.Timer(1.0,rinne2)
t.start()
rinne3()
#FINAL GUERRA INSIGNIAif app.ENABLE_EXTEND_INVEN_SYSTEM:
def BINARY_Expand_Refresh(self):
if self.interface:
self.interface.SetInventoryPageKilit()def BINARY_Expand_Fail(self, lazim):
self.wndPopupDialog = uiCommon.PopupDialog()
self.wndPopupDialog.SetText(localeInfo.EXINVEN_USE_ITEM_FAIL_FALL_SHORT % lazim)
self.wndPopupDialog.Open()def BINARY_Expand_Full(self):
self.wndPopupDialog = uiCommon.PopupDialog()
self.wndPopupDialog.SetText(localeInfo.EXINVEN_USE_ITEM_FAIL_FOURTH_PAGE_STAGE_MAX)
self.wndPopupDialog.Open()
### Batalha no Coliseu ---------------
def __SetColiseuModFree(self):
net.SendChatPacket("/pkmode 2")def __SetColiseuGetInputOn(self):
constInfo.INPUT_Coliseu = 1def __SetColiseuGetInputOff(self):
constInfo.INPUT_Coliseu = 0def __BlockCriarGrupo(self):
constInfo.BLOCK_GRUPO = 1def __CriarGrupoOK(self):
constInfo.BLOCK_GRUPO = 0def __Input0(self):
constInfo.INPUT_IGNORE = 0
def __Input1(self):
constInfo.INPUT_IGNORE = 1# Tombola
def __OpenTombola(self):
constInfo.wndTombola.Open()def __PrepareTombola(self, data):
constInfo.wndTombola.OnPrepare(str(data))def __RunTombola(self, number):
constInfo.wndTombola.OnRun(str(number))def SetTombola(self, qid):
constInfo.TOMBOLA = int(qid)def __CloseTombola(self):
constInfo.wndTombola.Close()def GetInputOn(self):
constInfo.INPUT_IGNORE = 1
def GetInputOff(self):
constInfo.INPUT_IGNORE = 0
def GetInputValue(self):
net.SendQuestInputStringPacket(str(constInfo.VID))def SetEnable(self):
constInfo.wndTombola.Load()
# Tombolaif app.ENABLE_SWITCHBOT:
def RefreshSwitchbotWindow(self):
self.interface.RefreshSwitchbotWindow()
def RefreshSwitchbotItem(self, slot):
self.interface.RefreshSwitchbotItem(slot)if app.ENABLE_INGAME_ITEMSHOP:
def __toggleIS(self):
net.SendChatPacket("/open_is")
def BINARY_ITEMSHOPNEW_OPEN(self):
self.itemshop.OpenWindow()
def BINARY_ITEMSHOPNEW_LIMITED_COUNT(self, _id, _count):
self.itemshop.RECV_LIMITED_ITEM_COUNT(_id, _count)
def EventCalendar(self):
if self.interface:
self.interface.EventCalendarGame()if app.ENABLE_DUNGEON_INFO_SYSTEM:
def CleanDungeonInfo(self):
import constInfo
constInfo.dungeonInfo = []def UpdateDungeonInfo(self, type, organization, minLevel, partyMembers, mapIndex, mapName, mapEntrance, mapCoordX, mapCoordY, cooldown, duration, maxLevel, strengthBonus, resistanceBonus, itemVnum, bossVnum):
type = int(type)
organization = int(organization)
minLevel = int(minLevel)
partyMembers = int(partyMembers)
mapName = str(mapName).replace("_", " ")
mapEntrance = str(mapEntrance).replace("_", " ")
mapIndex = int(mapIndex)
mapCoordX = int(mapCoordX)
mapCoordY = int(mapCoordY)
cooldown = int(cooldown)
duration = int(duration)
maxLevel = int(maxLevel)
strengthBonus = int(strengthBonus)
resistanceBonus = int(resistanceBonus)
itemVnum = int(itemVnum)constInfo.dungeonInfo.append(\
{
"type" : type,\
"organization" : organization,\
"min_level" : minLevel,\
"party_members" : partyMembers,\
"map" : mapName,\
"entrance_map" : mapEntrance,\
"map_index" : mapIndex,\
"map_coord_x" : mapCoordX,\
"map_coord_y" : mapCoordY,\
"cooldown" : cooldown,\
"duration" : duration,\
"max_level" : maxLevel,\
"strength_bonus" : strengthBonus,\
"resistance_bonus" : resistanceBonus,\
"item_vnum" : itemVnum,\
"boss_vnum" : bossVnum,\
},
)
uiminimap.py
Quoteimport ui
import uiScriptLocale
import wndMgr
import player
import miniMap
import localeInfo
import net
import app
import colorInfo
import constInfo
import background
if app.BL_KILL_BAR:
import playersettingmodule
import item
class MapTextToolTip(ui.Window):
def __init__(self):
ui.Window.__init__(self)textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetHorizontalAlignCenter()
textLine.SetOutline()
textLine.SetHorizontalAlignRight()
textLine.Show()
self.textLine = textLinedef __del__(self):
ui.Window.__del__(self)def SetText(self, text):
self.textLine.SetText(text)def SetTooltipPosition(self, PosX, PosY):
if localeInfo.IsARABIC():
w, h = self.textLine.GetTextSize()
self.textLine.SetPosition(PosX - w - 5, PosY)
else:
self.textLine.SetPosition(PosX - 5, PosY)def SetTextColor(self, TextColor):
self.textLine.SetPackedFontColor(TextColor)def GetTextSize(self):
return self.textLine.GetTextSize()class AtlasWindow(ui.ScriptWindow):
class AtlasRenderer(ui.Window):
def __init__(self):
ui.Window.__init__(self)
self.AddFlag("not_pick")def OnUpdate(self):
miniMap.UpdateAtlas()def OnRender(self):
(x, y) = self.GetGlobalPosition()
fx = float(x)
fy = float(y)
miniMap.RenderAtlas(fx, fy)def HideAtlas(self):
miniMap.HideAtlas()def ShowAtlas(self):
miniMap.ShowAtlas()def __init__(self):
self.tooltipInfo = MapTextToolTip()
self.tooltipInfo.Hide()
self.infoGuildMark = ui.MarkBox()
self.infoGuildMark.Hide()
self.AtlasMainWindow = None
self.mapName = ""
self.board = 0ui.ScriptWindow.__init__(self)
def __del__(self):
ui.ScriptWindow.__del__(self)def SetMapName(self, mapName):
if 949==app.GetDefaultCodePage():
try:
self.board.SetTitleName(localeInfo.MINIMAP_ZONE_NAME_DICT[mapName])
except:
passdef LoadWindow(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/AtlasWindow.py")
except:
import exception
exception.Abort("AtlasWindow.LoadWindow.LoadScript")try:
self.board = self.GetChild("board")except:
import exception
exception.Abort("AtlasWindow.LoadWindow.BindObject")self.AtlasMainWindow = self.AtlasRenderer()
self.board.SetCloseEvent(self.Hide)
self.AtlasMainWindow.SetParent(self.board)
self.AtlasMainWindow.SetPosition(7, 30)
self.tooltipInfo.SetParent(self.board)
self.infoGuildMark.SetParent(self.board)
self.SetPosition(wndMgr.GetScreenWidth() - 136 - 256 - 10, 0)
self.Hide()miniMap.RegisterAtlasWindow(self)
def Destroy(self):
miniMap.UnregisterAtlasWindow()
self.ClearDictionary()
self.AtlasMainWindow = None
self.tooltipAtlasClose = 0
self.tooltipInfo = None
self.infoGuildMark = None
self.board = Nonedef OnUpdate(self):
if not self.tooltipInfo:
returnif not self.infoGuildMark:
returnself.infoGuildMark.Hide()
self.tooltipInfo.Hide()if False == self.board.IsIn():
return(mouseX, mouseY) = wndMgr.GetMousePosition()
(bFind, sName, iPosX, iPosY, dwTextColor, dwGuildID) = miniMap.GetAtlasInfo(mouseX, mouseY)if False == bFind:
returnif "empty_guild_area" == sName:
sName = localeInfo.GUILD_EMPTY_AREAif localeInfo.IsARABIC() and sName[-1].isalnum():
self.tooltipInfo.SetText("(%s)%d, %d" % (sName, iPosX, iPosY))
else:
self.tooltipInfo.SetText("%s(%d, %d)" % (sName, iPosX, iPosY))(x, y) = self.GetGlobalPosition()
self.tooltipInfo.SetTooltipPosition(mouseX - x, mouseY - y)
self.tooltipInfo.SetTextColor(dwTextColor)
self.tooltipInfo.Show()
self.tooltipInfo.SetTop()if 0 != dwGuildID:
textWidth, textHeight = self.tooltipInfo.GetTextSize()
self.infoGuildMark.SetIndex(dwGuildID)
self.infoGuildMark.SetPosition(mouseX - x - textWidth - 18 - 5, mouseY - y)
self.infoGuildMark.Show()def Hide(self):
if self.AtlasMainWindow:
self.AtlasMainWindow.HideAtlas()
self.AtlasMainWindow.Hide()
ui.ScriptWindow.Hide(self)def Show(self):
if self.AtlasMainWindow:
(bGet, iSizeX, iSizeY) = miniMap.GetAtlasSize()
if bGet:
self.SetSize(iSizeX + 15, iSizeY + 38)if localeInfo.IsARABIC():
self.board.SetPosition(iSizeX+15, 0)self.board.SetSize(iSizeX + 15, iSizeY + 38)
#self.AtlasMainWindow.SetSize(iSizeX, iSizeY)
self.AtlasMainWindow.ShowAtlas()
self.AtlasMainWindow.Show()
ui.ScriptWindow.Show(self)def SetCenterPositionAdjust(self, x, y):
self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)def OnPressEscapeKey(self):
self.Hide()
return Truedef __RegisterMiniMapColor(type, rgb):
miniMap.RegisterColor(type, rgb[0], rgb[1], rgb[2])class MiniMap(ui.ScriptWindow):
CANNOT_SEE_INFO_MAP_DICT = {
"metin2_map_monkeydungeon" : False,
"metin2_map_monkeydungeon_02" : False,
"metin2_map_monkeydungeon_03" : False,
"metin2_map_devilsCatacomb" : False,
}if app.BL_KILL_BAR:
KILL_BAR_COOLTIME = 4.0
KILL_BAR_MOVE_SPEED = 3.0
KILL_BAR_MOVE_DISTANCE = 33.0
KILL_BAR_MAX_ITEM = 5KILL_BAR_RACE = {
playersettingmodule.RACE_WARRIOR_M: "|Ekill_bar/warrior_m|e",
playersettingmodule.RACE_ASSASSIN_W : "|Ekill_bar/assassin_w|e",
playersettingmodule.RACE_SURA_M : "|Ekill_bar/sura_m|e",
playersettingmodule.RACE_SHAMAN_W : "|Ekill_bar/shaman_w|e",
playersettingmodule.RACE_WARRIOR_W : "|Ekill_bar/warrior_w|e",
playersettingmodule.RACE_ASSASSIN_M : "|Ekill_bar/assassin_m|e",
playersettingmodule.RACE_SURA_W : "|Ekill_bar/sura_w|e",
playersettingmodule.RACE_SHAMAN_M : "|Ekill_bar/shaman_m|e",
}KILL_BAR_WEAPON_TYPE = {
"FIST": "|Ekill_bar/fist|e",
item.WEAPON_SWORD: "|Ekill_bar/sword|e",
item.WEAPON_DAGGER: "|Ekill_bar/dagger|e",
item.WEAPON_BOW: "|Ekill_bar/bow|e",
item.WEAPON_TWO_HANDED: "|Ekill_bar/twohand|e",
item.WEAPON_BELL: "|Ekill_bar/bell|e",
item.WEAPON_FAN: "|Ekill_bar/fan|e",
}def __init__(self, interface):
ui.ScriptWindow.__init__(self)self.__Initialize()
miniMap.Create()
miniMap.SetScale(2.0)self.AtlasWindow = AtlasWindow()
self.AtlasWindow.LoadWindow()
self.AtlasWindow.Hide()self.tooltipMiniMapOpen = MapTextToolTip()
self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP)
self.tooltipMiniMapOpen.Show()
self.tooltipMiniMapClose = MapTextToolTip()
self.tooltipMiniMapClose.SetText(localeInfo.UI_CLOSE)
self.tooltipMiniMapClose.Show()
self.tooltipScaleUp = MapTextToolTip()
self.tooltipScaleUp.SetText(localeInfo.MINIMAP_INC_SCALE)
self.tooltipScaleUp.Show()
self.tooltipScaleDown = MapTextToolTip()
self.tooltipScaleDown.SetText(localeInfo.MINIMAP_DEC_SCALE)
self.tooltipScaleDown.Show()
self.tooltipAtlasOpen = MapTextToolTip()
self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_SHOW_AREAMAP)
self.tooltipAtlasOpen.Show()
self.tooltipInfo = MapTextToolTip()
self.tooltipInfo.Show()if miniMap.IsAtlas():
self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_SHOW_AREAMAP)
else:
self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_CAN_NOT_SHOW_AREAMAP)self.tooltipInfo = MapTextToolTip()
self.tooltipInfo.Show()self.mapName = ""
self.isLoaded = 0
self.canSeeInfo = True
self.interface = interface
# AUTOBAN
self.imprisonmentDuration = 0
self.imprisonmentEndTime = 0
self.imprisonmentEndTimeText = ""
# END_OF_AUTOBAN
def __del__(self):
miniMap.Destroy()
ui.ScriptWindow.__del__(self)def __Initialize(self):
self.positionInfo = 0
self.observerCount = 0self.OpenWindow = 0
self.CloseWindow = 0
self.ScaleUpButton = 0
self.ScaleDownButton = 0
self.MiniMapHideButton = 0
self.MiniMapShowButton = 0
self.AtlasShowButton = 0self.tooltipMiniMapOpen = 0
self.tooltipMiniMapClose = 0
self.tooltipScaleUp = 0
self.tooltipScaleDown = 0
self.tooltipAtlasOpen = 0
if app.ENABLE_DUNGEON_INFO_SYSTEM:
self.dungeonInfoButton = 0
self.tooltipInfo = None
self.serverInfo = None
self.interface = None
if app.BL_KILL_BAR:
self.KillList = list()
def SetMapName(self, mapName):
self.mapName=mapName
self.AtlasWindow.SetMapName(mapName)if self.CANNOT_SEE_INFO_MAP_DICT.has_key(mapName):
self.canSeeInfo = False
self.HideMiniMap()
self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP_CANNOT_SEE)
else:
self.canSeeInfo = True
self.ShowMiniMap()
self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP)# AUTOBAN
def SetImprisonmentDuration(self, duration):
self.imprisonmentDuration = duration
self.imprisonmentEndTime = app.GetGlobalTimeStamp() + durationself.__UpdateImprisonmentDurationText()
def __UpdateImprisonmentDurationText(self):
restTime = max(self.imprisonmentEndTime - app.GetGlobalTimeStamp(), 0)imprisonmentEndTimeText = localeInfo.SecondToDHM(restTime)
if imprisonmentEndTimeText != self.imprisonmentEndTimeText:
self.imprisonmentEndTimeText = imprisonmentEndTimeText
self.serverInfo.SetText("%s: %s" % (uiScriptLocale.AUTOBAN_QUIZ_REST_TIME, self.imprisonmentEndTimeText))
# END_OF_AUTOBANdef Show(self):
self.__LoadWindow()ui.ScriptWindow.Show(self)
def __LoadWindow(self):
if self.isLoaded == 1:
returnself.isLoaded = 1
try:
pyScrLoader = ui.PythonScriptLoader()
if localeInfo.IsARABIC():
pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "Minimap.py")
else:
pyScrLoader.LoadScriptFile(self, "UIScript/MiniMap.py")
except:
import exception
exception.Abort("MiniMap.LoadWindow.LoadScript")try:
self.OpenWindow = self.GetChild("OpenWindow")
self.MiniMapWindow = self.GetChild("MiniMapWindow")
self.ScaleUpButton = self.GetChild("ScaleUpButton")
self.ScaleDownButton = self.GetChild("ScaleDownButton")
self.MiniMapHideButton = self.GetChild("MiniMapHideButton")
self.AtlasShowButton = self.GetChild("AtlasShowButton")
self.CloseWindow = self.GetChild("CloseWindow")
self.MiniMapShowButton = self.GetChild("MiniMapShowButton")
self.positionInfo = self.GetChild("PositionInfo")
self.observerCount = self.GetChild("ObserverCount")
self.serverInfo = self.GetChild("ServerInfo")
if app.ENABLE_DUNGEON_INFO_SYSTEM:
self.dungeonInfoButton = self.GetChild("l_button")
except:
import exception
exception.Abort("MiniMap.LoadWindow.Bind")if constInfo.MINIMAP_POSITIONINFO_ENABLE==0:
self.positionInfo.Hide()self.serverInfo.SetText(net.GetServerInfo())
self.ScaleUpButton.SetEvent(ui.__mem_func__(self.ScaleUp))
self.ScaleDownButton.SetEvent(ui.__mem_func__(self.ScaleDown))
self.MiniMapHideButton.SetEvent(ui.__mem_func__(self.HideMiniMap))
self.MiniMapShowButton.SetEvent(ui.__mem_func__(self.ShowMiniMap))if miniMap.IsAtlas():
self.AtlasShowButton.SetEvent(ui.__mem_func__(self.ShowAtlas))
if app.ENABLE_DUNGEON_INFO_SYSTEM:
self.dungeonInfoButton.SetEvent(ui.__mem_func__(self.DungeonInfo))
(ButtonPosX, ButtonPosY) = self.MiniMapShowButton.GetGlobalPosition()
self.tooltipMiniMapOpen.SetTooltipPosition(ButtonPosX, ButtonPosY)(ButtonPosX, ButtonPosY) = self.MiniMapHideButton.GetGlobalPosition()
self.tooltipMiniMapClose.SetTooltipPosition(ButtonPosX, ButtonPosY)(ButtonPosX, ButtonPosY) = self.ScaleUpButton.GetGlobalPosition()
self.tooltipScaleUp.SetTooltipPosition(ButtonPosX, ButtonPosY)(ButtonPosX, ButtonPosY) = self.ScaleDownButton.GetGlobalPosition()
self.tooltipScaleDown.SetTooltipPosition(ButtonPosX, ButtonPosY)(ButtonPosX, ButtonPosY) = self.AtlasShowButton.GetGlobalPosition()
self.tooltipAtlasOpen.SetTooltipPosition(ButtonPosX, ButtonPosY)self.ShowMiniMap()
def Destroy(self):
self.HideMiniMap()self.AtlasWindow.Destroy()
self.AtlasWindow = None
if app.BL_KILL_BAR:
self.KillList = None
self.ClearDictionary()self.__Initialize()
def UpdateObserverCount(self, observerCount):
if observerCount>0:
self.observerCount.Show()
elif observerCount<=0:
self.observerCount.Hide()self.observerCount.SetText(localeInfo.MINIMAP_OBSERVER_COUNT % observerCount)
def OnUpdate(self):
(x, y, z) = player.GetMainCharacterPosition()
miniMap.Update(x, y)self.positionInfo.SetText("(%.0f, %.0f)" % (x/100, y/100))
if self.tooltipInfo:
if True == self.MiniMapWindow.IsIn():
(mouseX, mouseY) = wndMgr.GetMousePosition()
(bFind, sName, iPosX, iPosY, dwTextColor) = miniMap.GetInfo(mouseX, mouseY)
if bFind == 0:
self.tooltipInfo.Hide()
elif not self.canSeeInfo:
self.tooltipInfo.SetText("%s(%s)" % (sName, localeInfo.UI_POS_UNKNOWN))
self.tooltipInfo.SetTooltipPosition(mouseX - 5, mouseY)
self.tooltipInfo.SetTextColor(dwTextColor)
self.tooltipInfo.Show()
else:
if localeInfo.IsARABIC() and sName[-1].isalnum():
self.tooltipInfo.SetText("(%s)%d, %d" % (sName, iPosX, iPosY))
else:
self.tooltipInfo.SetText("%s(%d, %d)" % (sName, iPosX, iPosY))
self.tooltipInfo.SetTooltipPosition(mouseX - 5, mouseY)
self.tooltipInfo.SetTextColor(dwTextColor)
self.tooltipInfo.Show()
else:
self.tooltipInfo.Hide()# AUTOBAN
if self.imprisonmentDuration:
self.__UpdateImprisonmentDurationText()
# END_OF_AUTOBANif True == self.MiniMapShowButton.IsIn():
self.tooltipMiniMapOpen.Show()
else:
self.tooltipMiniMapOpen.Hide()if True == self.MiniMapHideButton.IsIn():
self.tooltipMiniMapClose.Show()
else:
self.tooltipMiniMapClose.Hide()if True == self.ScaleUpButton.IsIn():
self.tooltipScaleUp.Show()
else:
self.tooltipScaleUp.Hide()if True == self.ScaleDownButton.IsIn():
self.tooltipScaleDown.Show()
else:
self.tooltipScaleDown.Hide()if True == self.AtlasShowButton.IsIn():
self.tooltipAtlasOpen.Show()
else:
self.tooltipAtlasOpen.Hide()if app.BL_KILL_BAR:
if self.KillList:
self.KillList = filter(
lambda obj: obj["CoolTime"] > app.GetTime(), self.KillList)
for obj in self.KillList:
(xLocal, yLocal) = obj["ThinBoard"].GetLocalPosition()
if obj["MOVE_X"] > 0.0:
obj["ThinBoard"].SetPosition(xLocal - MiniMap.KILL_BAR_MOVE_SPEED, yLocal)
obj["MOVE_X"] -= MiniMap.KILL_BAR_MOVE_SPEED
if obj["MOVE_Y"] > 0.0:
obj["ThinBoard"].SetPosition(xLocal, yLocal + MiniMap.KILL_BAR_MOVE_SPEED)
obj["MOVE_Y"] -= MiniMap.KILL_BAR_MOVE_SPEEDdef OnRender(self):
(x, y) = self.GetGlobalPosition()
fx = float(x)
fy = float(y)
miniMap.Render(fx + 4.0, fy + 5.0)def Close(self):
self.HideMiniMap()if app.BL_KILL_BAR:
def RepositionKillBar(self, obj):
obj["MOVE_Y"] += MiniMap.KILL_BAR_MOVE_DISTANCE
return objdef AddKillInfo(self, killer, victim, killer_race, victim_race, weapon_type):
if len(self.KillList) >= MiniMap.KILL_BAR_MAX_ITEM:
self.KillList.sort(
key=lambda obj: obj["CoolTime"], reverse=True)
del self.KillList[-1]
if self.KillList:
self.KillList = map(self.RepositionKillBar, self.KillList)TBoard = ui.ThinBoard()
TBoard.SetParent(self)
TBoard.SetSize(155, 10)
TBoard.SetPosition(15, 185)
TBoard.Show()KillText = ui.TextLine()
KillText.SetText("{} {} {} {} {}".format(MiniMap.KILL_BAR_RACE.get(int(killer_race), ""), killer, MiniMap.KILL_BAR_WEAPON_TYPE.get(
int(weapon_type), MiniMap.KILL_BAR_WEAPON_TYPE.get("FIST")), victim, MiniMap.KILL_BAR_RACE.get(int(victim_race), "")))
KillText.SetParent(TBoard)
KillText.SetWindowHorizontalAlignCenter()
KillText.SetWindowVerticalAlignCenter()
KillText.SetHorizontalAlignCenter()
KillText.SetVerticalAlignCenter()
KillText.Show()KillDict = dict()
KillDict["ThinBoard"] = TBoard
KillDict["TextLine"] = KillText
KillDict["CoolTime"] = app.GetTime() + MiniMap.KILL_BAR_COOLTIME
KillDict["MOVE_X"] = MiniMap.KILL_BAR_MOVE_DISTANCE
KillDict["MOVE_Y"] = 0.0self.KillList.append(KillDict)
def HideMiniMap(self):
miniMap.Hide()
self.OpenWindow.Hide()
self.CloseWindow.Show()def ShowMiniMap(self):
if not self.canSeeInfo:
returnminiMap.Show()
self.OpenWindow.Show()
self.CloseWindow.Hide()def isShowMiniMap(self):
return miniMap.isShow()def ScaleUp(self):
miniMap.ScaleUp()def ScaleDown(self):
miniMap.ScaleDown()def ShowAtlas(self):
if not miniMap.IsAtlas():
return
if not self.AtlasWindow.IsShow():
self.AtlasWindow.Show()def ToggleAtlasWindow(self):
if not miniMap.IsAtlas():
return
if self.AtlasWindow.IsShow():
self.AtlasWindow.Hide()
else:
self.AtlasWindow.Show()
minimap.py
QuoteROOT = "d:/ymir work/ui/minimap/"
import localeInfo
window = {
"name" : "MiniMap","x" : SCREEN_WIDTH - 136,
"y" : 0,"width" : 136,
"height" : 137,"children" :
(
## OpenWindow
{
"name" : "OpenWindow",
"type" : "window","x" : 0,
"y" : 0,"width" : 136,
"height" : 137,"children" :
(
{
"name" : "OpenWindowBGI",
"type" : "image",
"x" : 0,
"y" : 0,
"image" : ROOT + "minimap.sub",
},
## MiniMapWindow
{
"name" : "MiniMapWindow",
"type" : "window","x" : 4,
"y" : 5,"width" : 128,
"height" : 128,
},
## ScaleUpButton
{
"name" : "ScaleUpButton",
"type" : "button","x" : 101,
"y" : 116,"default_image" : ROOT + "minimap_scaleup_default.sub",
"over_image" : ROOT + "minimap_scaleup_over.sub",
"down_image" : ROOT + "minimap_scaleup_down.sub",
},
## ScaleDownButton
{
"name" : "ScaleDownButton",
"type" : "button","x" : 115,
"y" : 103,"default_image" : ROOT + "minimap_scaledown_default.sub",
"over_image" : ROOT + "minimap_scaledown_over.sub",
"down_image" : ROOT + "minimap_scaledown_down.sub",
},
## MiniMapHideButton
{
"name" : "MiniMapHideButton",
"type" : "button","x" : 111,
"y" : 6,"default_image" : ROOT + "minimap_close_default.sub",
"over_image" : ROOT + "minimap_close_over.sub",
"down_image" : ROOT + "minimap_close_down.sub",
},
## AtlasShowButton
{
"name" : "AtlasShowButton",
"type" : "button","x" : 12,
"y" : 12,"default_image" : ROOT + "atlas_open_default.sub",
"over_image" : ROOT + "atlas_open_over.sub",
"down_image" : ROOT + "atlas_open_down.sub",
},
## ServerInfo
{
"name" : "ServerInfo",
"type" : "text",
"text_horizontal_align" : "center","outline" : 1,
"x" : 999,
"y" : 999,"text" : "",
},
## INFOS GAMES
{
"name" : "InfoTexto",
"type" : "text",
"text_horizontal_align" : "center","outline" : 1,
"x" : 70,
"y" : 140,"text" : "www.teste.xyz",
},
{
"name" : "GameVersion",
"type" : "text",
"text_horizontal_align" : "center","outline" : 1,
"x" : 70,
"y" : 155,"text" : "Version: 0.1.3a",
},
{
"name" : "1_buton",
"type" : "button","x" : 12,
"y" : 103,"default_image" : "d:/ymir work/ui/minimap/ui/minimap_dungeon_info_default.tga",
"over_image" : "d:/ymir work/ui/minimap/ui/minimap_dungeon_info_over.tga",
"down_image" : "d:/ymir work/ui/minimap/ui/minimap_dungeon_info_down.tga",
"tooltip_text" : localeInfo.MINIMAP_DUNGEON_INFO,
},
## PositionInfo
{
"name" : "PositionInfo",
"type" : "text",
"text_horizontal_align" : "center","outline" : 1,
"x" : 70,
"y" : 160,"text" : "",
},
## ObserverCount
{
"name" : "ObserverCount",
"type" : "text",
"text_horizontal_align" : "center","outline" : 1,
"x" : 70,
"y" : 180,"text" : "",
},
),
},
{
"name" : "CloseWindow",
"type" : "window","x" : 0,
"y" : 0,"width" : 132,
"height" : 48,"children" :
(
## ShowButton
{
"name" : "MiniMapShowButton",
"type" : "button","x" : 100,
"y" : 4,"default_image" : ROOT + "minimap_open_default.sub",
"over_image" : ROOT + "minimap_open_default.sub",
"down_image" : ROOT + "minimap_open_default.sub",
},
),
},
),
}
-
2
-
-
I would like to know the specifications of a vps to support an average of 100 players
-
Can anyone tell me how I fix the textures of the items on the npcs?
https://metin2.download/picture/Ii5liKdbDpgS3l45wIv6X6QD1yD81biu/.png
-
what better clean Server Files to start a project ?
-
Quote
syserr.txt
0403 21:59:11614 ::
uiPatchnotes.py(line:42) LoadWindow
ui.py(line:2707) GetChildPatchNoteWindow.LoadWindow.BindObject - <type 'exceptions.KeyError'>:'patch_notes_area'
0403 21:59:11615 :: ============================================================================================================
0403 21:59:11615 :: Abort!!!!Quote
uiPatchnotes.py
import app, net, ui, dbg, os, localeInfo, constInfo, uiScriptLocale, uiCommon
from _weakref import proxyIMAGE_PATH = "d:/ymir work/ui/public/patchnote/"
MAX_VIEW_PATCHNOTES = 10
class PatchNoteWindow(ui.ScriptWindow):
def __init__(self):
ui.ScriptWindow.__init__(self)
self.isMouseWheel = False
self.ScrollBarStep = 0.2
self.curScrollbarPos = 0.0self.LoadWindow()
def __del__(self):
ui.ScriptWindow.__del__(self)
self.isMouseWheel = False
self.ScrollBarStep = 0.2
self.curScrollbarPos = 0.0
self.destScrollbarPos = 0.0def Show(self):
ui.ScriptWindow.Show(self)def Close(self):
self.Hide()
def LoadWindow(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "patchnotes.py")
except:
import exception
exception.Abort("PatchNoteWindow.LoadWindow.LoadObject")
try:
self.GetChild("board").SetCloseEvent(self.Close)self.boxPatchnotes = ListBoxItems()
self.boxPatchnotes.SetParent(self.GetChild("patch_notes_area"))
self.boxPatchnotes.SetGlobalParent(self)
self.boxPatchnotes.SetPosition(0, 0)
self.boxPatchnotes.SetSize(627, 489)
self.boxPatchnotes.Show()
self.scrollBar = ScrollBar()
self.scrollBar.SetParent(self.GetChild("patch_scrollbar_area"))
self.scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
self.scrollBar.SetTexture(IMAGE_PATH + "patchnote_scrollbar.png")
self.scrollBar.SetMovementArea(0, 0, 4, 493)
self.scrollBar.SetPosition(0, 0)
self.scrollBar.Show()
self.BuildPatchnotes()except:
import exception
exception.Abort("PatchNoteWindow.LoadWindow.BindObject")
def OnRunMouseWheel(self, nLen):
if self.scrollBar.IsShow():
if nLen > 0:
pos = self.destScrollbarPos - self.ScrollBarStep
else:
pos = self.destScrollbarPos + self.ScrollBarStep
pos = max(0.0, pos)
pos = min(1.0, pos)self.isMouseWheel = True
self.destScrollbarPos = posdef OnScroll(self):
self.listbox.OnScroll(self.scrollBar.GetPos())def OnUpdate(self):
if self.isMouseWheel:
self.curScrollbarPos += (self.destScrollbarPos - self.curScrollbarPos) / 10.0
if abs(self.curScrollbarPos - self.destScrollbarPos) < 0.0005:
self.curScrollbarPos = self.destScrollbarPos
self.isMouseWheel = False
self.scrollBar.SetPos(self.curScrollbarPos)
else:
self.curScrollbarPos = self.scrollBar.GetPos()
self.destScrollbarPos = self.scrollBar.GetPos()
def BuildPatchnotes(self):
try:
patchnotes = pack_open("%s/patchnotes.txt" % app.GetLocalePath(), "r")
except:
patchnotes = pack_open("locale/pt/patchnotes.txt", "r")
count_patchnotes = 0
isUpdate = False
title = ["", ""]
lines = []
for line in patchnotes:
if "Version: " in line:
title[0] = line.split()[1]
if "Date: " in line:
title[1] = line.split()[1]
if "## UPDATE ##" in line:
isUpdate = True
continue
if "## END ##" in line:
self.ListBox.AppendObject(title, lines)
isUpdate = False
title = ["", ""]
lines = []
count_patchnotes += 1
if MAX_VIEW_PATCHNOTES != 0 and MAX_VIEW_PATCHNOTES == count_patchnotes:
breakif isUpdate:
lines.append(self.SplitDescription(line, 120))
if count_patchnotes > 8:
self.ScrollBarStep = 0.1
if count_patchnotes > 12:
self.ScrollBarStep = 0.07
if count_patchnotes > 15:
self.ScrollBarStep = 0.04def SplitDescription(self, desc, limit):
total_tokens = desc.split()
line_tokens = []
line_len = 0
lines = []
for token in total_tokens:
if "|" in token:
sep_pos = token.find("|")
line_tokens.append(token[:sep_pos])lines.append(" ".join(line_tokens))
line_len = len(token) - (sep_pos + 1)
line_tokens = [token[sep_pos+1:]]
else:
line_len += len(token)
if len(line_tokens) + line_len > limit:
lines.append(" ".join(line_tokens))
line_len = len(token)
line_tokens = [token]
else:
line_tokens.append(token)
if line_tokens:
lines.append(" ".join(line_tokens))return lines
class ListBoxItems(ui.Window):
class Item(ui.Window):
def __init__(self, parent, index, title, lines):
ui.Window.__init__(self)
ui.Window.SetParent(self, parent)
# self.tooltipItem = uiToolTip.ItemToolTip()
# self.tooltipItem.Hide()
self.parent = proxy(parent)
self.SetWindowName("ListBox_Patchnotes")
self.xBase, self.yBase = 0, 0
self.index = indexself.image_title = ui.MakeExpandedImageBox(self, IMAGE_PATH + "patchnote_top.png", 0, 0, "not_pick")
self.image_title.SetParent(self)
self.image_title.Show()
self.textVersion = ui.TextLine()
self.textVersion.SetParent(self.image_title)
self.textVersion.SetHorizontalAlignCenter()
self.textVersion.SetPosition(50, 4)
self.textVersion.SetPackedFontColor(0xffffffff)
self.textVersion.SetFontName(localeInfo.UI_DEF_FONT_LARGE)
self.textVersion.SetOutline()
self.textVersion.SetText(str(title[0]))
self.textVersion.Show()
self.textDate = ui.TextLine()
self.textDate.SetParent(self.image_title)
self.textDate.SetHorizontalAlignCenter()
self.textDate.SetPosition(580, 4)
self.textDate.SetPackedFontColor(0xffffffff)
self.textDate.SetFontName(localeInfo.UI_DEF_FONT_LARGE)
self.textDate.SetOutline()
self.textDate.SetText(str(title[1]))
self.textDate.Show()
self.text_backgrounds = []
self.text_rows = []
line_count = 0
for row_lines in xrange(len(lines)):
for sub_lines in xrange(len(lines[row_lines])):
row_image = ui.MakeExpandedImageBox(self, IMAGE_PATH + "patchnote_middle.png", 0, 22 + 15 * line_count, "not_pick")
row_image.SetParent(self)
row_image.Show()
self.text_backgrounds.append(row_image)
textLine = ui.TextLine()
textLine.SetParent(row_image)
textLine.SetPosition(5, 0)
textLine.SetFontName(localeInfo.UI_DEF_FONT_SLARGE)
textLine.SetText(str(lines[row_lines][sub_lines]))
textLine.Show()
self.text_rows.append(textLine)
line_count += 1
row_image = ui.MakeExpandedImageBox(self, IMAGE_PATH + "patchnote_bottom.png", 0, 22 + 15 * line_count, "not_pick")
row_image.SetParent(self)
row_image.Show()
self.text_backgrounds.append(row_image)def __del__(self):
ui.Window.__del__(self)
self.xBase, self.yBase = 0, 0
self.index = 0def SetBasePosition(self, x, y):
self.xBase = x
self.yBase = ydef GetBasePosition(self):
return (self.xBase, self.yBase)def GetIndex(self):
return self.indexdef Show(self):
ui.Window.Show(self)
def OnRender(self):
xList, yList = self.parent.GetGlobalPosition()self.image_title.SetClipRect(xList, yList, xList + self.parent.GetWidth(), yList + self.parent.GetHeight())
xText, yText = self.textVersion.GetGlobalPosition()
wText, hText = self.textVersion.GetWidth(), 13if yText < yList or (yText + hText > yList + self.parent.GetHeight()):
self.textVersion.Hide()
self.textDate.Hide()
else:
self.textVersion.Show()
self.textDate.Show()
for i in xrange(len(self.text_backgrounds)):
self.text_backgrounds[i].SetClipRect(xList, yList, xList + self.parent.GetWidth(), yList + self.parent.GetHeight())for i in xrange(len(self.text_rows)):
xText, yText = self.text_rows[i].GetGlobalPosition()
wText, hText = self.text_rows[i].GetWidth(), 13if yText < yList or (yText + hText > yList + self.parent.GetHeight()):
self.text_rows[i].Hide()
else:
self.text_rows[i].Show()
def __init__(self):
ui.Window.__init__(self)
self.SetWindowName("ListBox")
self.globalParent = None
self.size_y = 0
self.index_list = 0
self.object_list = []def __del__(self):
ui.Window.__del__(self)
self.globalParent = None
self.size_y = 0
self.index_list = 0
self.object_list = []def GetObjectCount(self):
count = 0
for i in xrange(len(self.object_list)):
count += 1
return countdef GetSize(self):
return self.size_y
def SetGlobalParent(self, parent):
self.globalParent = proxy(parent)def OnScroll(self, scrollPos):
totalHeight = 0
for item in self.object_list:
totalHeight += item.GetHeight()totalHeight -= self.GetHeight()
for i in xrange(len(self.object_list)):
x, y = self.object_list[i].GetLocalPosition()
xB, yB = self.object_list[i].GetBasePosition()
setPos = yB - int(scrollPos * totalHeight)
self.object_list[i].SetPosition(xB, setPos)def AppendObject(self, title, lines):
self.index_list += 1
item = self.Item(self, self.index_list, title, lines)line_count = 0
for row_lines in xrange(len(lines)):
for sub_lines in xrange(len(lines[row_lines])):
line_count += 15
item.SetSize(639, 30 + line_count + 4 + 4)
self.size_y += 22 + line_count + 4 + 4
# item.SetSize(32, 32 + space_y)
if len(self.object_list) == 0:
item.SetPosition(0, 0)
item.SetBasePosition(0, 0)
else:
x, y = self.object_list[-1].GetLocalPosition()
item.SetPosition(0, y + self.object_list[-1].GetHeight())
item.SetBasePosition(0, y + self.object_list[-1].GetHeight())
item.Show()
self.object_list.append(item)
def ClearList(self):
self.index_list = 0
self.object_list = []class ScrollBar(ui.DragButton):
def __init__(self):
ui.DragButton.__init__(self)
self.AddFlag("float")
self.AddFlag("movable")
self.AddFlag("restrict_x")self.eventScroll = lambda *arg: None
self.movearea = 0
self.currentPos = 0.0def __del__(self):
ui.DragButton.__del__(self)
self.movearea = 0
self.currentPos = 0.0
self.eventScroll = lambda *arg: Nonedef SetMovementArea(self, x, y, width, height):
self.movearea = height - y - self.GetHeight()
self.SetRestrictMovementArea(x, y, width, height)
def SetTexture(self, image):
self.SetUpVisual(image)
self.SetOverVisual(image)
self.SetDownVisual(image)def SetScrollEvent(self, event):
self.eventScroll = eventdef SetPos(self, pos):
pos = max(0.0, pos)
pos = min(1.0, pos)yPos = float(pos * self.movearea)
self.SetPosition(12, yPos)
self.OnMove()def GetPos(self):
return self.currentPos
def OnMove(self):
(xLocal, yLocal) = self.GetLocalPosition()
self.currentPos = float(yLocal) / float(self.movearea)self.eventScroll()
Quotepatchnotes.py
import uiScriptLocale
import localeInfo
import constInfoWINDOW_WIDTH = 680
WINDOW_HEIGHT = 550window = {
"name" : "PatchNotesWindow","x" : (SCREEN_WIDTH / 2) - (WINDOW_WIDTH / 2),
"y" : (SCREEN_HEIGHT / 2) - (WINDOW_HEIGHT / 2) ,"style" : ("movable", "float",),
"width" : WINDOW_WIDTH,
"height" : WINDOW_HEIGHT,"children" :
(
{
"name" : "board",
"type" : "board_with_titlebar","x" : 0,
"y" : 0,"width" : WINDOW_WIDTH,
"height" : WINDOW_HEIGHT,
"title" : "Patchnotes",
"children" :
(
{
"name" : "container",
"type" : "border_b",
"x" : 15,
"y" : 35,
"width" : WINDOW_WIDTH - 30,
"height" : WINDOW_HEIGHT - 35 - 15,
"children" :
(
{ "name" : "line",
"type" : "line",
"x" : 636,
"y" : 0,
"color" : 0xff232323,
"width" : 0, "height" : 498,
},
{ "name" : "patch_scrollbar_area",
"type" : "window",
"x" : 639,
"y" : 4,
"width" : 7,
"height" : 493,
},
{ "name" : "patch_notes_area",
"type" : "window",
"x" : 6,
"y" : 6,
"width" : 627,
"height" : 489,
},
),
},
),
},
),
}
Discord Rich Presence
in Features & Metin2 Systems
Posted
how do i make it work??