Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- import os
- import app
- import dbg
- import grp
- import item
- import background
- import chr
- import chrmgr
- import player
- import snd
- import chat
- import event
- import textTail
- 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 constInfo2
- import ui
- import uiAchievement
- import uiCommon
- import uiPhaseCurtain
- import uiMapNameShower
- import uiAffectShower
- import uiPlayerGauge
- import uiCharacter
- import time
- import uiTarget
- import uiTaskbar
- import uiteleport
- import uiTarget
- # PRIVATE_SHOP_PRICE_LIST
- import uiPrivateShopBuilder
- # END_OF_PRIVATE_SHOP_PRICE_LIST
- import mouseModule
- import consoleModule
- import localeInfo
- import playerSettingModule
- import interfaceModule
- import uibansystem
- import musicInfo
- import debugInfo
- import uipetsystem
- import stringCommander
- import uiSearchShop
- import uiScriptLocale
- import uisupportsystem
- from _weakref import proxy
- # TEXTTAIL_LIVINGTIME_CONTROL
- #if localeInfo.IsJAPAN():
- # app.SetTextTailLivingTime(8.0)
- # END_OF_TEXTTAIL_LIVINGTIME_CONTROL
- # SCREENSHOT_CWDSAVE
- SCREENSHOT_CWDSAVE = FALSE
- SCREENSHOT_DIR = None
- if localeInfo.IsEUROPE():
- SCREENSHOT_CWDSAVE = TRUE
- if localeInfo.IsCIBN10():
- SCREENSHOT_CWDSAVE = FALSE
- SCREENSHOT_DIR = "YT2W"
- cameraDistance = 1550.0
- cameraPitch = 27.0
- cameraRotation = 0.0
- cameraHeight = 100.0
- testAlignment = 0
- pet_gui_activado = 0
- class 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.quickSlotPageIndex = 0
- self.lastPKModeSendedTime = 0
- self.LastBoniSwitcherId = 0
- self.pressNumber = None
- self.uiSearchShopBtn = ui.Button()
- self.uiSearchShopBtn.SetUpVisual("search.tga")
- self.uiSearchShopBtn.SetOverVisual("search.tga")
- self.uiSearchShopBtn.SetDownVisual("search.tga")
- self.uiSearchShopBtn.SetText("")
- self.uiSearchShopBtn.SetToolTipText(uiScriptLocale.SHOP_SEARCH_TITLE)
- self.uiSearchShopBtn.SetPosition(int(wndMgr.GetScreenWidth()/2), 0)
- self.uiSearchShopBtn.SetEvent(self.OnClickSearch)
- self.uiSearchShopBtn.Show()
- self.uiSearchShop=uiSearchShop.ShopSearch()
- self.uiSearchShop.SetPosition(100,100)
- self.uiSearchShop.AddFlag('movable')
- self.uiSearchShop.AddFlag('float')
- self.uiSearchShop.Close()
- self.guildWarQuestionDialog = None
- self.interface = None
- self.targetBoard = None
- self.console = None
- self.mapNameShower = None
- self.affectShower = None
- self.playerGauge = None
- self.petInventoryWnd = None
- self.boniSwitcherWnd = []
- constInfo.BONI_SWITCHER_LOAD = FALSE
- self.itemShopWnd = None
- #import uiBoniSwitcher
- #for i in xrange(constInfo.SWITCHER_COUNT):
- #self.boniSwitcherWnd.append(uiBoniSwitcher.BoniSwitcherDialog(i))
- #self.boniSwitcherWnd[i].SetChangeBonusSwitcherEvent(self.__BoniSwitcherShow)
- #self.boniSwitcherWnd[i].GAMESetBoniSwitcherCheckEvent(self.__BoniSwitcherCheckEvent)
- self.stream=stream
- self.interface = interfaceModule.Interface()
- self.interface.MakeInterface()
- self.interface.SetOpenBoniSwitcherEvent(self.__BoniSwitcherShow)
- self.interface.wndTaskBar.SetMallShowEvent(self.__ItemShopShow)
- 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.petmain = uipetsystem.PetSystemMain()
- self.petmini = uipetsystem.PetSystemMini()
- self.console = consoleModule.ConsoleWindow()
- self.console.BindGameClass(self)
- self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200)
- self.console.Hide()
- self.bansystem = uibansystem.bansystemwindow()
- self.supportpg = uisupportsystem.SupportMainGui()
- self.mapNameShower = uiMapNameShower.MapNameShower()
- self.affectShower = uiAffectShower.AffectShower()
- if app.ENABLE_TITLE_SYSTEM:
- import title_system
- self.wndTitleSystem = title_system.Title_System()
- self.playerGauge = uiPlayerGauge.PlayerGauge(self)
- self.playerGauge.Hide()
- self.__SetQuickSlotMode()
- self.__ServerCommand_Build()
- self.__ProcessPreservedServerCommand()
- self.teleport = uiteleport.TeleportWindow()
- self.uiNewShopCreate = None
- self.uiNewShop = None
- def OnClickSearch(self):
- if not self.uiSearchShop.IsShow():
- self.uiSearchShop.Show()
- self.uiSearchShop.SetCenterPosition()
- else:
- self.uiSearchShop.Hide()
- def Close(self):
- if self.uiSearchShop:
- self.uiSearchShop.Close()
- self.uiSearchShop=0
- 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())
- Espacio = ui.AniImageBox()
- Espacio.SetWindowHorizontalAlignLeft()
- Espacio.SetWindowVerticalAlignTop()
- Espacio.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")
- self.Espacio = Espacio
- self.Espacio.SetPosition(10, 80)
- self.contador_usuarios_guerra = ui.TextLine()
- self.contador_usuarios_guerra.SetWindowHorizontalAlignLeft()
- self.contador_usuarios_guerra.SetWindowVerticalAlignTop()
- self.contador_usuarios_guerra.SetDefaultFontName()
- self.contador_usuarios_guerra.SetPosition(24+8, 37+2 +40)
- self.contador_usuarios_guerra.SetText("0")
- self.contador_usuarios_guerra.SetOutline()
- self.muertos_guerra = ui.TextLine()
- self.muertos_guerra.SetWindowHorizontalAlignLeft()
- self.muertos_guerra.SetWindowVerticalAlignTop()
- self.muertos_guerra.SetDefaultFontName()
- self.muertos_guerra.SetPosition(24+8, 47+2+40)
- self.muertos_guerra.SetText("0")
- self.muertos_guerra.SetOutline()
- self.caido_guerra = ui.TextLine()
- self.caido_guerra.SetWindowHorizontalAlignLeft()
- self.caido_guerra.SetWindowVerticalAlignTop()
- self.caido_guerra.SetDefaultFontName()
- self.caido_guerra.SetPosition(24+8, 57+2+40)
- self.caido_guerra.SetText("0")
- self.caido_guerra.SetOutline()
- self.usuarios_guerra = ui.TextLine()
- self.usuarios_guerra.SetWindowHorizontalAlignLeft()
- self.usuarios_guerra.SetWindowVerticalAlignTop()
- self.usuarios_guerra.SetDefaultFontName()
- self.usuarios_guerra.SetPosition(10+8, 37+2+40)
- self.usuarios_guerra.SetText("U:")
- self.usuarios_guerra.SetOutline()
- self.ranking_guerra = ui.TextLine()
- self.ranking_guerra.SetWindowHorizontalAlignLeft()
- self.ranking_guerra.SetWindowVerticalAlignTop()
- self.ranking_guerra.SetDefaultFontName()
- self.ranking_guerra.SetPosition(10+8, 47+2+40)
- self.ranking_guerra.SetText("R:")
- self.ranking_guerra.SetOutline()
- self.ranking_caido = ui.TextLine()
- self.ranking_caido.SetWindowHorizontalAlignLeft()
- self.ranking_caido.SetWindowVerticalAlignTop()
- self.ranking_caido.SetDefaultFontName()
- self.ranking_caido.SetPosition(10 +8, 57 +2+40)
- self.ranking_caido.SetText("M:")
- self.ranking_caido.SetOutline()
- Medallas_gui = ui.AniImageBox()
- Medallas_gui.SetWindowHorizontalAlignLeft()
- Medallas_gui.SetWindowVerticalAlignTop()
- Medallas_gui.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")
- self.Medallas_gui = Medallas_gui
- self.Medallas_gui.SetPosition(10, 40)
- self.muertes = ui.TextLine()
- self.muertes.SetWindowHorizontalAlignLeft()
- self.muertes.SetWindowVerticalAlignTop()
- self.muertes.SetDefaultFontName()
- self.muertes.SetPosition(24, 51)
- self.muertes.SetText("0")
- self.muertes.SetOutline()
- self.primera_muerte = ui.AniImageBox()
- self.primera_muerte.SetWindowHorizontalAlignLeft()
- self.primera_muerte.SetWindowVerticalAlignTop()
- self.primera_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/1.dds")
- self.primera_muerte.SetPosition(43, 40)
- self.doble_muerte = ui.AniImageBox()
- self.doble_muerte.SetWindowHorizontalAlignLeft()
- self.doble_muerte.SetWindowVerticalAlignTop()
- self.doble_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/2.dds")
- self.doble_muerte.SetPosition(43 + 33, 40)
- self.triple_muerte = ui.AniImageBox()
- self.triple_muerte.SetWindowHorizontalAlignLeft()
- self.triple_muerte.SetWindowVerticalAlignTop()
- self.triple_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/3.dds")
- self.triple_muerte.SetPosition(43 + 33 + 33, 40)
- self.exterminio = ui.AniImageBox()
- self.exterminio.SetWindowHorizontalAlignLeft()
- self.exterminio.SetWindowVerticalAlignTop()
- self.exterminio.AppendImage("d:/ymir work/ui/pattern/medallas/4.dds")
- self.exterminio.SetPosition(43+ 33+ 33 + 33, 40)
- self.muertacular = ui.AniImageBox()
- self.muertacular.SetWindowHorizontalAlignLeft()
- self.muertacular.SetWindowVerticalAlignTop()
- self.muertacular.AppendImage("d:/ymir work/ui/pattern/medallas/5.dds")
- self.muertacular.SetPosition(43+ 33+ 33+ 33 + 33, 40)
- self.bestialidad = ui.AniImageBox()
- self.bestialidad.SetWindowHorizontalAlignLeft()
- self.bestialidad.SetWindowVerticalAlignTop()
- self.bestialidad.AppendImage("d:/ymir work/ui/pattern/medallas/6.dds")
- self.bestialidad.SetPosition(43+ 33+ 33+ 33+ 33 + 33, 40)
- self.salvajada = ui.AniImageBox()
- self.salvajada.SetWindowHorizontalAlignLeft()
- self.salvajada.SetWindowVerticalAlignTop()
- self.salvajada.AppendImage("d:/ymir work/ui/pattern/medallas/7.dds")
- self.salvajada.SetPosition(43+ 33+ 33+ 33+ 33+ 33 + 33, 40)
- self.catastrofe = ui.AniImageBox()
- self.catastrofe.SetWindowHorizontalAlignLeft()
- self.catastrofe.SetWindowVerticalAlignTop()
- self.catastrofe.AppendImage("d:/ymir work/ui/pattern/medallas/8.dds")
- self.catastrofe.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)
- self.apocalipsis = ui.AniImageBox()
- self.apocalipsis.SetWindowHorizontalAlignLeft()
- self.apocalipsis.SetWindowVerticalAlignTop()
- self.apocalipsis.AppendImage("d:/ymir work/ui/pattern/medallas/9.dds")
- self.apocalipsis.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)
- self.lluvia_muertos = ui.AniImageBox()
- self.lluvia_muertos.SetWindowHorizontalAlignLeft()
- self.lluvia_muertos.SetWindowVerticalAlignTop()
- self.lluvia_muertos.AppendImage("d:/ymir work/ui/pattern/medallas/10.dds")
- self.lluvia_muertos.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)
- self.super_increible = ui.AniImageBox()
- self.super_increible.SetWindowHorizontalAlignLeft()
- self.super_increible.SetWindowVerticalAlignTop()
- self.super_increible.AppendImage("d:/ymir work/ui/pattern/medallas/11.dds")
- self.super_increible.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)
- #Fin menu
- self.quickSlotPageIndex = 0
- self.PickingCharacterIndex = -1
- self.PickingItemIndex = -1
- self.consoleEnable = FALSE
- self.isShowDebugInfo = FALSE
- self.ShowNameFlag = FALSE
- self.enableXMasBoom = FALSE
- self.startTimeXMasBoom = 0.0
- self.indexXMasBoom = 0
- global 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 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_UPDATE
- ## 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가 큐브시스템으로 만들 수 있는 아이템들의 목록을 캐싱
- # ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
- self.cubeInformation = {}
- self.currentCubeNPC = 0
- if systemSetting.IsShowOfflineShop() == 0:
- net.SendChatPacket("/show_hide_shops 0")
- else:
- net.SendChatPacket("/show_hide_shops 1")
- import uiNewShop
- self.uiNewShop = uiNewShop.ShopDialog()
- self.uiNewShop.Close()
- self.uiNewShopCreate = uiNewShop.ShopDialogCreate()
- self.uiNewShopCreate.Hide()
- def Close(self):
- self.Hide()
- global cameraDistance, cameraPitch, cameraRotation, cameraHeight
- (cameraDistance, cameraPitch, cameraRotation, cameraHeight) = app.GetCamera()
- if musicInfo.fieldMusic != "":
- snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)
- self.onPressKeyDict = None
- self.onClickKeyDict = None
- chat.Close()
- snd.StopAllSound()
- grp.InitScreenEffect()
- chr.Destroy()
- textTail.Clear()
- quest.Clear()
- background.Destroy()
- guild.Destroy()
- messenger.Destroy()
- skill.ClearSkillData()
- wndMgr.Unlock()
- mouseModule.mouseController.DeattachObject()
- 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_CONFIRM
- self.PrintCoord = None
- self.FrameRate = None
- self.Pitch = None
- self.Splat = None
- self.TextureNum = None
- self.ObjectNum = None
- self.ViewDistance = None
- self.PrintMousePos = None
- self.ClearDictionary()
- self.supportpg.Close()
- self.petmain.Close()
- self.petmini.Close()
- self.playerGauge = None
- self.bansystem.Close()
- self.mapNameShower = None
- self.affectShower = None
- if self.console:
- self.console.BindGameClass(0)
- self.console.Close()
- self.console=None
- if self.targetBoard:
- self.targetBoard.Destroy()
- self.targetBoard = None
- if app.ENABLE_TITLE_SYSTEM:
- self.wndTitleSystem.Close()
- if self.itemShopWnd:
- self.itemShopWnd.Destroy()
- self.itemShopWnd = None
- if self.interface:
- self.interface.HideAllWindows()
- self.interface.Close()
- self.interface=None
- for i in xrange(len(self.boniSwitcherWnd)):
- if self.boniSwitcherWnd[i]:
- self.boniSwitcherWnd[i].Destroy()
- self.boniSwitcherWnd[i] = None
- if self.petInventoryWnd:
- self.petInventoryWnd.Destroy()
- self.petInventoryWnd = None
- player.ClearSkillDict()
- player.ResetCameraRotation()
- self.KillFocus()
- app.HideCursor()
- self.uiNewShop.Hide()
- self.uiNewShopCreate.Hide()
- uiPrivateShopBuilder.Clear()
- print "---------------------------------------------------------------------------- CLOSE GAME WINDOW"
- def __BuildKeyDict(self):
- onPressKeyDict = {}
- ##PressKey 는 누르고 있는 동안 계속 적용되는 키이다.
- ## 숫자 단축키 퀵슬롯에 이용된다.(이후 숫자들도 퀵 슬롯용 예약)
- ## F12 는 클라 디버그용 키이므로 쓰지 않는 게 좋다.
- 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)
- if app.ENABLE_TITLE_SYSTEM:
- onPressKeyDict[app.DIK_F5] = lambda : self.OpenTitleSystem()
- onPressKeyDict[app.DIK_F6] = lambda : self.EnablePickUp()
- 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.__PressQKey
- onPressKeyDict[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_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()
- onPressKeyDict[app.DIK_X] = lambda : self.__PressXKey()
- # CUBE_TEST
- #onPressKeyDict[app.DIK_K] = lambda : self.interface.OpenCubeWindow()
- # CUBE_TEST_END
- self.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()
- onClickKeyDict[app.DIK_X] = lambda: self.OpenSupportGui()
- onClickKeyDict[app.DIK_P] = lambda: self.OpenPetMainGui()
- #if constInfo.PVPMODE_ACCELKEY_ENABLE:
- # onClickKeyDict[app.DIK_B] = lambda: self.ChangePKMode()
- self.onClickKeyDict=onClickKeyDict
- def __PressNumKey(self,num):
- 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)
- 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:
- if not uiPrivateShopBuilder.IsBuildingPrivateShop() or not uiOfflineShopBuilder.IsBuildingOfflineShop():
- if app.ENABLE_MOUNT_SYSTEM:
- for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
- index = player.GetItemIndex(i)
- if index:
- item.SelectItem(index)
- subType = item.GetItemSubType()
- if subType == item.USE_MOUNT:
- allow = 0
- net.SendItemUsePacket(i)
- break
- else:
- for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
- if player.GetItemIndex(i) in (52043, 52044, 52045, 71164, 71165, 71166, 71167, 71168, 52091, 52092, 52093, 52094, 52095, 52096, 52097, 52098, 71161, 71131, 52033, 52005, 52019, 71176, 71177):
- 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):
- if player.IsMountingHorse():
- net.SendChatPacket("/unmount")
- else:
- if not uiPrivateShopBuilder.IsBuildingPrivateShop() or not uiOfflineShopBuilder.IsBuildingOfflineShop():
- if app.ENABLE_MOUNT_SYSTEM:
- for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
- index = player.GetItemIndex(i)
- if index:
- item.SelectItem(index)
- subType = item.GetItemSubType()
- if subType == item.USE_MOUNT:
- allow = 0
- net.SendItemUsePacket(i)
- break
- else:
- for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
- if player.GetItemIndex(i) in (52043, 52044, 52045, 71164, 71165, 71166, 71167, 71168, 52091, 52092, 52093, 52094, 52095, 52096, 52097, 52098, 71161, 71131, 52033, 52005, 52019, 71176, 71177):
- net.SendItemUsePacket(i)
- break
- else:
- app.PitchCamera(app.CAMERA_TO_POSITIVE)
- def __ReleaseGKey(self):
- app.PitchCamera(app.CAMERA_STOP)
- if app.ENABLE_TITLE_SYSTEM:
- def OpenTitleSystem(self):
- self.wndTitleSystem.OpenWindow()
- 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 __PressJKey(self):
- if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
- if player.IsmountingHorse():
- net.SendChatPacket("/unmount")
- else:
- self.teleport.Open()
- def __SetQuickSlotMode(self):
- self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)
- 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 __SelectQuickPage(self, pageIndex):
- self.quickSlotPageIndex = pageIndex
- player.SetQuickPage(pageIndex)
- def ToggleDebugInfo(self):
- self.isShowDebugInfo = not self.isShowDebugInfo
- if 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):
- return
- if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
- self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
- return
- curTime = app.GetTime()
- if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:
- return
- self.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_GUILD
- elif nextPKMode == player.PK_MODE_MAX_NUM:
- nextPKMode = 0
- net.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.CApiSetHide == 1:
- net.SendQuestInputStringPacket(str(constInfo.SendString))
- constInfo.CApiSetHide = 0
- return
- if constInfo.INPUT_IGNORE == 1:
- return
- self.interface.OpenQuestWindow(skin, idx)
- def HideAllQuestWindow(self):
- self.interface.HideAllQuestWindow()
- 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:
- return
- if net.IsInsultIn(guildName):
- self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)
- return
- net.SendAnswerMakeGuildPacket(guildName)
- self.guildNameBoard.Close()
- self.guildNameBoard = None
- return TRUE
- def 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):
- return
- if player.IsMainCharacterIndex(vid):
- return
- elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):
- return
- self.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()
- if app.ENABLE_VIEW_TARGET_DECIMAL_HP:
- def SetHPTargetBoard(self, vid, hpPercentage, iMinHP, iMaxHP):
- if vid != self.targetBoard.GetTargetVID():
- self.targetBoard.ResetTargetBoard()
- self.targetBoard.SetEnemyVID(vid)
- self.targetBoard.SetHP(hpPercentage, iMinHP, iMaxHP)
- self.targetBoard.Show()
- else:
- 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_NAME
- def BINARY_OpenAtlasWindow(self):
- self.interface.BINARY_OpenAtlasWindow()
- ## Chat
- def OnRecvWhisper(self, mode, name, line):
- 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):
- chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (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_MESSAGE
- def 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_MINING
- def 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 = partyInviteQuestionDialog
- def AnswerPartyInvite(self, answer):
- if not self.partyInviteQuestionDialog:
- return
- partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID
- distance = player.GetCharacterDistance(partyLeaderVID)
- if distance < 0.0 or distance > 5000:
- answer = FALSE
- net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)
- self.partyInviteQuestionDialog.Close()
- self.partyInviteQuestionDialog = None
- def 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 = messengerAddFriendQuestion
- def OnAcceptAddFriend(self):
- name = self.messengerAddFriendQuestion.name
- net.SendChatPacket("/messenger_auth y " + name)
- self.OnCloseAddFriendQuestionDialog()
- return TRUE
- def OnDenyAddFriend(self):
- name = self.messengerAddFriendQuestion.name
- net.SendChatPacket("/messenger_auth n " + name)
- self.OnCloseAddFriendQuestionDialog()
- return TRUE
- def 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 = guildInviteQuestionDialog
- def AnswerGuildInvite(self, answer):
- if not self.guildInviteQuestionDialog:
- return
- guildLeaderVID = 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 Functions
- def 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_CWDSAVE
- if 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):
- pass
- 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 TRUE
- if self.ShowNameFlag:
- return TRUE
- return FALSE
- # END_OF_ADD_ALWAYS_SHOW_NAME
- def 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)
- 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 Handler
- def OnKeyDown(self, key):
- if self.interface.wndWeb and self.interface.wndWeb.IsShow():
- return
- constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)
- try:
- self.onPressKeyDict[key]()
- except KeyError:
- pass
- except:
- raise
- return TRUE
- def OnKeyUp(self, key):
- try:
- self.onClickKeyDict[key]()
- except KeyError:
- pass
- except:
- raise
- return TRUE
- def OnMouseLeftButtonDown(self):
- if self.interface.BUILD_OnMouseLeftButtonDown():
- return
- if 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():
- return
- if 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)
- 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 TRUE
- def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
- 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):
- 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:
- if app.ENABLE_MELEY_LAIR_DUNGEON:
- if chr.IsStone(dstChrID):
- net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
- else:
- net.SendExchangeStartPacket(dstChrID)
- net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
- 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_DROP
- if attachedMoney>=1000:
- self.stream.popupWindow.Close()
- self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0, localeInfo.UI_OK)
- return
- itemDropQuestionDialog = uiCommon.QuestionDialog()
- itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_MONEY % (attachedMoney))
- itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
- itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
- itemDropQuestionDialog.Open()
- itemDropQuestionDialog.dropType = attachedType
- itemDropQuestionDialog.dropCount = attachedMoney
- itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
- self.itemDropQuestionDialog = itemDropQuestionDialog
- def __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_DROP
- if 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.SetText(questionText)
- itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(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_DROP_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.SetText(questionText)
- itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(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_DROP_QUESTION_DIALOG_STATUS(1)
- def RequestDropItem(self, answer):
- if not self.itemDropQuestionDialog:
- return
- if answer:
- dropType = self.itemDropQuestionDialog.dropType
- dropCount = self.itemDropQuestionDialog.dropCount
- dropNumber = self.itemDropQuestionDialog.dropNumber
- if 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
- self.itemDropQuestionDialog.Close()
- self.itemDropQuestionDialog = None
- constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)
- # PRIVATESHOP_DISABLE_ITEM_DROP
- def __SendDropItemPacket(self, itemVNum, itemCount, itemInvenType = player.INVENTORY):
- if uiPrivateShopBuilder.IsBuildingPrivateShop():
- chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
- return
- net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
- # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
- 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 TRUE
- player.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
- return TRUE
- def OnMouseMiddleButtonDown(self):
- player.SetMouseMiddleButtonState(player.MBS_PRESS)
- def OnMouseMiddleButtonUp(self):
- player.SetMouseMiddleButtonState(player.MBS_CLICK)
- def OnUpdate(self):
- app.UpdateGame()
- if app.ENABLE_TITLE_SYSTEM:
- self.wndTitleSystem.OnUpdate()
- if self.IsEnableAutoPickUp():
- self.PickUpItem()
- if self.mapNameShower.IsShow():
- self.mapNameShower.Update()
- if self.isShowDebugInfo:
- self.UpdateDebugInfo()
- if self.enableXMasBoom:
- self.__XMasBoom_Update()
- self.interface.BUILD_OnUpdate()
- #for i in xrange(4+1):
- #if self.boniSwitcherWnd[i]:
- #if not self.boniSwitcherWnd[i].IsShow():
- #self.boniSwitcherWnd[i].OnUpdate()
- def UpdateDebugInfo(self):
- #
- # 캐릭터 좌표 및 FPS 출력
- (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
- ## 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_NAME
- if systemSetting.IsShowSalesText():
- uiPrivateShopBuilder.UpdateADBoard()
- textTail.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)
- 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 TRUE
- def 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
- 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 = True
- for 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:
- return
- if 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()
- # 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 = npcVNUM
- self.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 + 1
- i = 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)
- pass
- def BINARY_Cube_Failed(self):
- print "큐브 제작 실패"
- self.interface.FailedCubeWork()
- pass
- def BINARY_Cube_ResultList(self, npcVNUM, listText):
- # ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 이런식으로 "/" 문자로 구분된 리스트를 줌
- #print listText
- if npcVNUM == 0:
- npcVNUM = self.currentCubeNPC
- self.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 0
- pass
- 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 listText
- if 3 > len(listText):
- dbg.TraceError("Wrong Cube Material Infomation")
- return 0
- eachResultList = 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 0
- pass
- # END_OF_CUBE
- # 용혼석
- def BINARY_Highlight_Item(self, inven_type, inven_pos):
- 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):
- 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):
- pass
- def 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)
- def __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_FIX
- import 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 = None
- def __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={
- "SetTeamOnline" : self.__TeamLogin,
- "SetTeamOffline" : self.__TeamLogout,
- "dopes_index" :self.__bonus_questindex,
- "evento_ultimo_superviviente" : self.__evento_ultimo_superviviente,
- "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,
- "Teleport" : self.Teleport,
- ##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,
- "SupportLv" : self.SetSupportLevel,
- "SupportName" : self.SetSupportName,
- "SupportLeave" : self.SupportLeave,
- "SupporInt" : self.SupportInt,
- "SupportExp" : self.SetSupportExp,
- "SupportIcon" : self.SetSupportIcon,
- "SupportSpeciality" : self.SetSupportSpeciality,
- #####GIFT SYSTEM
- "gift_clear" :self.gift_clear,
- "gift_item" :self.gift_item,
- "gift_info" :self.gift_show,
- "gift_load" :self.gift_load,
- ### Achievement System START
- "achievement" : self.__AchievementTest,
- "achievementpoints" : self.__ShowAchievementPoints,
- # Achievement System END
- # Fix input quest Start
- "GetInputStringStart" : self.GetInputStringStart,
- "GetInputStringEnd" : self.GetInputStringEnd,
- # Fix input quest End
- # PET_SYSTEM
- "PetIsMine" : self.__PetIsMineByVid,
- "ActivarGui" : self.__ActivarGui,
- "SetPetClearItemSlotButtonIndex" : self.__PetSetClearItemSlotButtonIndex,
- "SetPetIncreaseBoniButtonIndex" : self.__PetSetIncreaseBoniButtonIndex,
- "SetPetSendAwayButtonIndex" : self.__PetSetSendAwayButtonIndex,
- "ShowPet" : self.__PetShow,
- "HidePet" : self.__PetHide,
- "GetPetClearSlot" : self.__PetGetClearSlot,
- "GetPetIncreaseBoni" : self.__PetGetIncreaseBoni,
- "SetPet" : self.__PetSet,
- "SetPetHead" : self.__PetSetHead,
- "SetPetNeck" : self.__PetSetNeck,
- "SetPetFoot" : self.__PetSetFoot,
- "SetPetAttackValue" : self.__PetSetAttackValue,
- "SetPetMagicAttackValue" : self.__PetSetMagicAttackValue,
- "SetPetArmorValue" : self.__PetSetArmorValue,
- "SetPetName" : self.__PetSetName,
- "SetPetLevel" : self.__PetSetLevel,
- "SetPetExp" : self.__PetSetExp,
- "SetPetMaxExp" : self.__PetSetMaxExp,
- "SetPetSkillPoints" : self.__PetSetSkillPoints,
- # END_OF_PET_SYSTEM
- # ITEM_MALL
- "CloseMall" : self.CommandCloseMall,
- "ShowMeMallPassword" : self.AskMallPassword,
- "item_mall" : self.__ItemMall_Open,
- #Telep
- "Telep" : self.__MakeTelep,
- # 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,
- "PetEvolution" : self.SetPetEvolution,
- "PetName" : self.SetPetName,
- "PetLevel" : self.SetPetLevel,
- "PetDuration" : self.SetPetDuration,
- "PetBonus" : self.SetPetBonus,
- "PetSkill" : self.SetPetskill,
- "PetIcon" : self.SetPetIcon,
- "PetExp" : self.SetPetExp,
- "PetUnsummon" : self.PetUnsummon,
- "OpenPetIncubator" : self.OpenPetIncubator,
- # ITEM_SHOP
- #guerra
- "mostrar_usuarios" : self.__mostrar_usuarios,
- "ocultar_usuarios" : self.__ocultar_usuarios,
- "muerto_guerras" : self.__muerto_guerras,
- "alubias" : self.__alubias,
- "proteccion_guerra" : self.__proteccion_guerra,
- "contador_usuarios_guerra" : self.__contador_usuarios_guerra,
- "muertos_guerra" : self.__muertos_guerra,
- "caido_guerra" : self.__caido_guerra,
- "ataque_guerra" : self.__ataque_guerra,
- "ataque_guerra1" : self.__ataque_guerra1,
- "activar_libre" : self.__activar_libre,
- "cerrar_grupo" : self.__grupobug,
- "spirit2" : self.__spirit2,
- #guerra
- "SetISLoadButtonIndex" : self.__ISSetLoadButtonIndex,
- "SetISBuyButtonIndex" : self.__ISSetBuyButtonIndex,
- "GetISBuyID" : self.__ISGetBuyID,
- "GetISBuyID2" : self.__ISGetBuyID2,
- "AddISCategory" : self.__ISAddCategory,
- "SelectISCategory" : self.__ISSelectCategory,
- "ClearISItems" : self.__ISClearItems,
- "AddISItem" : self.__ISAddItem,
- "AddISItemDesc" : self.__ISAddItemDesc,
- "SetISLoadSuccess" : self.__ISSetLoadSuccess,
- "SetISLoadFail" : self.__ISSetLoadFail,
- "SetISBuySuccess" : self.__ISSetBuySuccess,
- "SetISBuyFail" : self.__ISSetBuyFail,
- "SetISCoins" : self.__ISSetCoins,
- "SetISMarks" : self.__ISSetMarks,
- "input0" : self.__Input0,
- "input1" : self.__Input1,
- "OpenGuiGaya" : self.OpenGuiGaya,
- "GayaCheck" : self.GayaCheck,
- "OpenGuiGayaMarket" :self.OpenGuiGayaMarket,
- "GayaMarketSlotsDesblock" : self.GayaMarketSlotsDesblock,
- "GayaMarketItems" : self.GayaMarketItems,
- "GayaMarketClear" : self.GayaMarketClear,
- # END_OF_ITEM_SHOP
- # WEDDING
- "lover_login" : self.__LoginLover,
- "lover_logout" : self.__LogoutLover,
- "lover_near" : self.__LoverNear,
- "lover_far" : self.__LoverFar,
- "lover_divorce" : self.__LoverDivorce,
- "PlayMusic" : self.__PlayMusic,
- # END_OF_WEDDING
- "ban_system_open" : self.__BanStart,
- ########Anti Exp Button by Sanii##########
- "anti_exp" : self.AntiExp,
- "anti_exp_state" : self.AntiExpState,
- # PRIVATE_SHOP_PRICE_LIST
- "MyShopPriceList" : self.__PrivateShop_PriceList,
- # END_OF_PRIVATE_SHOP_PRICE_LIST
- "channel" : self.ChangeCH,
- "MakeVisibleOX" : self.__SetAllPlayersVisible,
- "RemoveTitleOX" : self.__ClearPlayersTitle,
- # BONI_SWITCHER
- #"ResetBoniFromSwitcher" : self.__ResetBoniFromSwitcher,
- #"AddBoniToSwitcher" : self.__AddBoniToSwitcher,
- #"AddMaxValueToBoni" : self.__AddMaxValueToBoni,
- #"SetBoniSwitcherLoad" : self.__SetBoniSwitcherLoad,
- # END_OF_BONI_SWITCHER
- }
- 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)
- def __MakeTelep(self, qid):
- constInfo.Telepqin= int(qid)
- 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 0
- def __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 0
- def 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_MALL
- def 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_LIST
- def SetPetEvolution(self, evo):
- petname = ["Cucciolo", "Selvaggio", "Coraggioso", "Eroico"]
- self.petmain.SetEvolveName(petname[int(evo)])
- def SetPetName(self, name):
- if len(name) > 1 and name != "":
- self.petmini.Show()
- self.petmain.SetName(name)
- def SetPetLevel(self, level):
- self.petmain.SetLevel(level)
- def SetPetDuration(self, dur, durt):
- if int(durt) > 0:
- self.petmini.SetDuration(dur, durt)
- self.petmain.SetDuration(dur, durt)
- def SetPetBonus(self, hp, dif, sp):
- self.petmain.SetHp(hp)
- self.petmain.SetDef(dif)
- self.petmain.SetSp(sp)
- def SetPetskill(self, slot, idx, lv):
- if int(lv) > 0:
- self.petmini.SetSkill(slot, idx, lv)
- self.petmain.SetSkill(slot, idx, lv)
- self.affectShower.BINARY_NEW_AddAffect(5400+int(idx),int(constInfo.LASTAFFECT_POINT)+1,int(constInfo.LASTAFFECT_VALUE)+1, 0)
- if int(slot)==0:
- constInfo.SKILL_PET1=5400+int(idx)
- if int(slot)==1:
- constInfo.SKILL_PET2=5400+int(idx)
- if int(slot)==2:
- constInfo.SKILL_PET3=5400+int(idx)
- def SetPetIcon(self, vnum):
- if int(vnum) > 0:
- self.petmini.SetImageSlot(vnum)
- self.petmain.SetImageSlot(vnum)
- def SetPetExp(self, exp, expi, exptot):
- if int(exptot) > 0:
- self.petmini.SetExperience(exp, expi, exptot)
- self.petmain.SetExperience(exp, expi, exptot)
- def PetUnsummon(self):
- self.petmini.SetDefaultInfo()
- self.petmini.Close()
- self.petmain.SetDefaultInfo()
- self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET1),0)
- self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET2),0)
- self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET3),0)
- constInfo.SKILL_PET1 = 0
- constInfo.SKILL_PET2 = 0
- constInfo.SKILL_PET3 = 0
- def OpenPetMainGui(self):
- self.petmain.Show()
- self.petmain.SetTop()
- def OpenPetIncubator(self, pet_new = 0):
- import uipetincubatrice
- self.petinc = uipetincubatrice.PetSystemIncubator(pet_new)
- self.petinc.Show()
- self.petinc.SetTop()
- def OpenPetMini(self):
- self.petmini.Show()
- self.petmini.SetTop()
- def OpenPetFeed(self):
- self.feedwind = uipetfeed.PetFeedWindow()
- self.feedwind.Show()
- self.feedwind.SetTop()
- def Gift_Show(self):
- if constInfo.PET_MAIN == 0:
- self.petmain.Show()
- constInfo.PET_MAIN =1
- self.petmain.SetTop()
- else:
- self.petmain.Hide()
- constInfo.PET_MAIN =0
- def ChangeCH(self, CH):
- import serverInfo
- rgID = 0
- chID = int(CH)
- if not chID:
- return
- for svID in serverInfo.REGION_DICT[rgID].keys():
- if serverInfo.REGION_DICT[rgID][svID]["name"] == net.GetServerInfo().split(",")[0]:
- try:
- svName = serverInfo.REGION_DICT[rgID][svID]["name"]
- chName = serverInfo.REGION_DICT[rgID][svID]["channel"][chID]["name"]
- markKey = rgID * 1000 + svID * 10
- markAddrValue = serverInfo.MARKADDR_DICT[markKey]
- net.SetMarkServer(markAddrValue["ip"], markAddrValue["tcp_port"])
- app.SetGuildMarkPath(markAddrValue["mark"])
- app.SetGuildSymbolPath(markAddrValue["symbol_path"])
- net.SetServerInfo("%s, %s" % (svName, chName))
- except KeyError, TypeError:
- pass
- def __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 FALSE
- return TRUE
- def __XMasSnow_Enable(self, mode):
- self.__XMasSong_Enable(mode)
- if "1"==mode:
- if not self.__IsXMasMap():
- return
- print "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():
- return
- print "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 = FALSE
- def __XMasTree_Enable(self, grade):
- print "XMAS_TREE ", grade
- background.SetXMasTree(int(grade))
- # PET_INVENTORY
- def __PetIsMineByVid(self, vid):
- targetName = chr.GetNameByVID(int(vid))
- charName = player.GetName() or chr.GetMainCharacterName()
- if targetName[0:len(charName)] == charName:
- localeInfo.SEND_BACK = "true"
- else:
- localeInfo.SEND_BACK = "false"
- self.__SendTextPacketToQuest()
- localeInfo.SEND_BACK = ""
- def __SendTextPacketToQuest(self):
- net.SendQuestInputStringPacket(localeInfo.SEND_BACK)
- def __PressXKey(self):
- import event
- #self.__DeactivarGui()
- self.__PetHide()
- event.QuestButtonClick(constInfo2.PET_SEND_AWAY_BUTTON_INDEX)
- def GetInputStringStart(self):
- constInfo.INPUT_IGNORE = 1
- def GetInputStringEnd(self):
- constInfo.INPUT_IGNORE = 0
- def __PetSetClearItemSlotButtonIndex(self, index):
- constInfo2.PET_CLEAR_ITEM_SLOT_BUTTON_INDEX = int(index)
- def __PetSetIncreaseBoniButtonIndex(self, index):
- constInfo2.PET_INCREASE_BONI_BUTTON_INDEX = int(index)
- def __PetSetSendAwayButtonIndex(self, index):
- constInfo2.PET_SEND_AWAY_BUTTON_INDEX = int(index)
- def __ActivarGui(self):
- global pet_gui_activado
- pet_gui_activado = 1
- def __DeactivarGui(self):
- global pet_gui_activado
- pet_gui_activado = 0
- def __PetShow(self):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.Show()
- def __PetHide(self):
- if self.petInventoryWnd:
- self.petInventoryWnd.Hide()
- def __PetGetClearSlot(self):
- net.SendQuestInputStringPacket(str(self.petInventoryWnd.GetClearSlot()))
- def __PetGetIncreaseBoni(self):
- net.SendQuestInputStringPacket(str(self.petInventoryWnd.GetIncreaseBoni()))
- def __PetSet(self, itemVnum):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetPet(itemVnum)
- def __PetSetHead(self, itemVnum):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- if int(itemVnum) > 0:
- self.petInventoryWnd.SetHeadItem(itemVnum)
- else:
- self.petInventoryWnd.ClearHeadItem()
- def __PetSetNeck(self, itemVnum):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- if int(itemVnum) > 0:
- self.petInventoryWnd.SetNeckItem(itemVnum)
- else:
- self.petInventoryWnd.ClearNeckItem()
- def __PetSetFoot(self, itemVnum):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- if int(itemVnum) > 0:
- self.petInventoryWnd.SetFootItem(itemVnum)
- else:
- self.petInventoryWnd.ClearFootItem()
- def __PetSetAttackValue(self, value):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetAttackValue(value)
- def __PetSetMagicAttackValue(self, value):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetMagicAttackValue(value)
- def __PetSetArmorValue(self, value):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetArmorValue(value)
- def __PetSetName(self, name):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetName(name.replace("[_]", " "))
- def __PetSetLevel(self, level):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetLevel(level)
- def __PetSetExp(self, exp):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetExp(exp)
- self.petInventoryWnd.UpdateExpBar()
- def __PetSetMaxExp(self, maxexp):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetMaxExp(maxexp)
- self.petInventoryWnd.UpdateExpBar()
- def __PetSetSkillPoints(self, points):
- if not self.petInventoryWnd:
- import uiPet
- self.petInventoryWnd = uiPet.PetInventoryDialog()
- self.petInventoryWnd.SetSkillPoints(points)
- # END_PET_INVENTORY
- 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)
- def __muerto_guerras(self, id):
- constInfo.muerto_guerras = int(id)
- def __alubias(self):
- for i in xrange(player.INVENTORY_PAGE_SIZE*2):
- if player.GetItemIndex(i) in (70102,):
- net.SendItemUsePacket(i)
- net.SendItemUsePacket(i)
- net.SendItemUsePacket(i)
- net.SendItemUsePacket(i)
- net.SendItemUsePacket(i)
- net.SendItemUsePacket(i)
- break
- def __spirit2(self):
- net.SendChatPacket("(spirit2)")
- def __proteccion_guerra(self):
- net.SendChatPacket("(proteccion_guerra)")
- def __contador_usuarios_guerra(self, contador_usuarios_guerra):
- self.contador_usuarios_guerra.SetText(contador_usuarios_guerra)
- def __muertos_guerra(self, muertos_guerra):
- self.muertos_guerra.SetText(muertos_guerra)
- def __caido_guerra(self, caido_guerra):
- self.caido_guerra.SetText(caido_guerra)
- def __mostrar_usuarios(self):
- self.Espacio.Show()
- self.contador_usuarios_guerra.Show()
- self.muertos_guerra.Show()
- self.caido_guerra.Show()
- self.usuarios_guerra.Show()
- self.ranking_guerra.Show()
- self.ranking_caido.Show()
- def __ocultar_usuarios(self):
- self.Espacio.Hide()
- self.contador_usuarios_guerra.Hide()
- self.muertos_guerra.Hide()
- self.caido_guerra.Hide()
- self.usuarios_guerra.Hide()
- self.ranking_guerra.Hide()
- self.ranking_caido.Hide()
- def __ataque_guerra(self):
- constInfo.ataque_guerra = 1
- def __ataque_guerra1(self):
- constInfo.ataque_guerra = 0
- def __activar_libre(self):
- net.SendChatPacket("/pkmode 2")
- def __grupobug(self):
- net.SendPartyExitPacket()
- ## 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():
- return
- background.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():
- return
- self.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):
- return
- boomTime = 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 = partyRequestQuestionDialog
- def __AnswerPartyRequest(self, answer):
- if not self.partyRequestQuestionDialog:
- return
- vid = 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 = None
- def __PartyRequestDenied(self):
- self.PopupMessage(localeInfo.PARTY_REQUEST_DENIED)
- def __EnableTestServerFlag(self):
- app.EnableTestServerFlag()
- def __InGameShop_Show(self, url):
- if constInfo.IN_GAME_SHOP_ENABLE:
- self.interface.OpenWebWindow(url)
- def __SetAllPlayersVisible(self):
- chrmgr.ShowAllPlayers()
- def __ClearPlayersTitle(self):
- chrmgr.RemoveAllPlayersTitle()
- # 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)
- 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)
- if app.ENABLE_SASH_SYSTEM:
- def ActSash(self, iAct, bWindow):
- if self.interface:
- self.interface.ActSash(iAct, bWindow)
- def AlertSash(self, bWindow):
- snd.PlaySound("sound/ui/make_soket.wav")
- if bWindow:
- self.PopupMessage(localeInfo.SASH_DEL_SERVEITEM)
- else:
- self.PopupMessage(localeInfo.SASH_DEL_ABSORDITEM)
- if app.ENABLE_CHANGELOOK_SYSTEM:
- def ActChangeLook(self, iAct):
- if self.interface:
- self.interface.ActChangeLook(iAct)
- def AlertChangeLook(self):
- self.PopupMessage(localeInfo.CHANGE_LOOK_DEL_ITEM)
- # END_OF_WEDDING
- ########Anti Exp Button by Sanii##########
- def AntiExp(self, qid):
- constInfo.ANTI_EXP = int(qid)
- def AntiExpState(self, state):
- constInfo.ANTI_EXP_STATE = int(state)
- ##########################################
- # BONI_SWITCHER
- def __BoniSwitcherChangeVisible(self):
- if not self.boniSwitcherWnd[self.LastBoniSwitcherId].IsShow():
- self.__HideAllBoniSwitcher()
- self.boniSwitcherWnd[self.LastBoniSwitcherId].Show(FALSE)
- else:
- self.__HideAllBoniSwitcher()
- def __BoniSwitcherShow(self, id):
- lastId = self.LastBoniSwitcherId
- self.LastBoniSwitcherId = id
- if not self.boniSwitcherWnd[id].IsShow():
- self.__HideAllBoniSwitcher()
- (x, y) = self.boniSwitcherWnd[lastId].GetGlobalPosition()
- self.boniSwitcherWnd[id].SetPosition(x, y)
- self.boniSwitcherWnd[id].Show(FALSE)
- def __BoniSwitcherHide(self, id):
- if self.boniSwitcherWnd[id]:
- self.boniSwitcherWnd[id].Hide()
- def __HideAllBoniSwitcher(self):
- for i in xrange(len(self.boniSwitcherWnd)):
- self.__BoniSwitcherHide(i)
- def __ResetBoniFromSwitcher(self):
- constInfo.BONI_LIST_WEAPON = []
- constInfo.BONI_LIST_WEAPON_ADDON = []
- constInfo.BONI_LIST_ARMOR = []
- constInfo.BONI_LIST_BRACELET = []
- constInfo.BONI_LIST_BOOTS = []
- constInfo.BONI_LIST_NECKLACE = []
- constInfo.BONI_LIST_HELMET = []
- constInfo.BONI_LIST_SHIELD = []
- constInfo.BONI_LIST_EARRINGS = []
- # ITEM_SHOP
- def __ItemShopShow(self):
- if not self.itemShopWnd:
- import uiItemShop
- self.itemShopWnd = uiItemShop.ItemShopBoard()
- self.itemShopWnd.Show()
- def __ISSetLoadButtonIndex(self, index):
- constInfo.ITEM_SHOP_LOAD_BUTTON_INDEX = int(index)
- def __ISSetBuyButtonIndex(self, index):
- constInfo.ITEM_SHOP_BUY_BUTTON_INDEX = int(index)
- def __ISGetBuyID(self):
- if self.itemShopWnd:
- net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString())
- else:
- net.SendQuestInputStringPacket("ERROR")
- def __ISGetBuyID2(self):
- if self.itemShopWnd:
- net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString2())
- else:
- net.SendQuestInputStringPacket("ERROR")
- def __Input0(self):
- constInfo.INPUT_IGNORE = 0
- def __Input1(self):
- constInfo.INPUT_IGNORE = 1
- def __ISAddCategory(self, catId, catName):
- self.itemShopWnd.AddCategory(catId, catName.replace("[_]", " "))
- def __ISSelectCategory(self, catId):
- self.itemShopWnd.SelectCategory(catId)
- def __ISClearItems(self):
- self.itemShopWnd.Clear()
- def __ISAddItem(self, catId, itemId, itemVnum, itemCount, itemCost, itemCostType, attr1, val1, attr2, val2, attr3, val3, attr4, val4, attr5, val5, attr6, val6, attr7, val7, sock1, sock2, sock3):
- itemAttr = [[attr1, val1], [attr2, val2], [attr3, val3], [attr4, val4], [attr5, val5], [attr6, val6], [attr7, val7]]
- for attr in itemAttr:
- attr[0] = int(attr[0])
- attr[1] = int(attr[1])
- itemSocket = [int(sock1), int(sock2), int(sock3)]
- self.curIsItem = {
- "cat" : catId,
- "id" : itemId,
- "vnum" : itemVnum,
- "count" : itemCount,
- "desc" : "",
- "cost" : itemCost,
- "cost_type" : itemCostType,
- "attr" : itemAttr,
- "socket" : itemSocket,
- }
- def __ISAddItemDesc(self, itemDesc):
- obj = self.curIsItem
- if not obj:
- return
- obj["desc"] += itemDesc.replace("[_]", " ")
- self.itemShopWnd.AddItem(obj["cat"], obj["id"], obj["vnum"], obj["count"], obj["desc"], obj["cost"], obj["cost_type"], obj["attr"], obj["socket"])
- self.curIsItem = None
- def __ISSetLoadSuccess(self):
- self.itemShopWnd.SetLoadSuccess()
- def __ISSetLoadFail(self):
- self.itemShopWnd.SetLoadFail()
- def __ISSetBuySuccess(self):
- self.itemShopWnd.SetItemBuySuccess()
- def __ISSetBuyFail(self):
- self.itemShopWnd.SetItemBuyFail()
- def __ISSetCoins(self, coins):
- self.itemShopWnd.SetCoins(coins)
- def __ISSetMarks(self, marks):
- self.itemShopWnd.SetMarks(marks)
- # END_ITEM_SHOP
- def __AddBoniToSwitcher(self, EquipType, boniType):
- EquipType = int(EquipType)
- if EquipType == 1:
- constInfo.BONI_LIST_WEAPON.append(int(boniType))
- constInfo.BONI_LIST_WEAPON_ADDON.append(int(boniType))
- elif EquipType == 2:
- constInfo.BONI_LIST_ARMOR.append(int(boniType))
- elif EquipType == 3:
- constInfo.BONI_LIST_BRACELET.append(int(boniType))
- elif EquipType == 4:
- constInfo.BONI_LIST_BOOTS.append(int(boniType))
- elif EquipType == 5:
- constInfo.BONI_LIST_NECKLACE.append(int(boniType))
- elif EquipType == 6:
- constInfo.BONI_LIST_HELMET.append(int(boniType))
- elif EquipType == 7:
- constInfo.BONI_LIST_SHIELD.append(int(boniType))
- elif EquipType == 8:
- constInfo.BONI_LIST_EARRINGS.append(int(boniType))
- elif EquipType == 9:
- constInfo.BONI_LIST_WEAPON_ADDON.append(int(boniType))
- def __AddMaxValueToBoni(self, boniType, maxValue):
- constInfo.BONI_LIST_MAX_VALUE[int(boniType)] = int(maxValue)
- def __SetBoniSwitcherLoad(self):
- constInfo.BONI_SWITCHER_LOAD = TRUE
- def __BoniSwitcherCheckEvent(self, slotPos):
- for boniSwitcher in self.boniSwitcherWnd:
- if boniSwitcher.aktItemPos == int(slotPos):
- return TRUE
- return FALSE
- # END_BONI_SWITCHER
- # Achievement System START
- def __ShowAchievementPoints(self, points):
- self.uiAchievement = uiAchievement.AchievementDialog()
- uiAchievement.AchievementPoints = int(points)
- def __AchievementTest(self, archivement):
- self.uiAchievement = uiAchievement.AchievementDialog()
- self.uiAchievement.Show(1, str(archivement))
- self.uiAchievement.SetTop()
- # Achievement System END
- def Teleport(self, getString):
- if getString.find("index") != -1:
- self.teleport.UpdateIndex(int(getString.split("x")[1]))
- else:
- constInfo.SendString = str(self.teleport.SendToServer)
- constInfo.CApiSetHide = 1
- def __evento_ultimo_superviviente(self):
- import net
- net.SendChatPacket("/pkmode 2", chat.CHAT_TYPE_TALKING)
- def __Switcher(self):
- import uiswitch
- self.wndSwitch = uiswitch.Switcher()
- self.wndSwitch.Show()
- def __BonusPage(self):
- import uiswitch
- self.wndSwitch = uiswitch.Switcher()
- self.wndSwitch.Show()
- def __bonus_questindex(self, value3):
- constInfo.BONUS_QUESTINDEX = int(value3)
- def __activare_bonus(self):
- activare_bonus = constInfo.BONUS_QUESTINDEX
- event.QuestButtonClick(activare_bonus)
- def __depozit_questindex(self, value):
- constInfo.DEPOZIT_QUESTINDEX = int(value)
- def __activare_depozit(self):
- activare_depozit = constInfo.DEPOZIT_QUESTINDEX
- event.QuestButtonClick(activare_depozit)
- def __antiexp_questindex(self, value1):
- constInfo.ANTIEXP_QUESTINDEX = int(value1)
- def __activare_antiexp(self):
- activare_antiexp = constInfo.ANTIEXP_QUESTINDEX
- event.QuestButtonClick(activare_antiexp)
- def __teleporter_questindex(self, value2):
- constInfo.TELEPORTER_QUESTINDEX = int(value2)
- def __activare_teleporter(self):
- activare_teleporter = constInfo.TELEPORTER_QUESTINDEX
- event.QuestButtonClick(activare_teleporter)
- 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]
- if app.ENABLE_CHANGELOOK_SYSTEM:
- transmutation=d[5]
- s=d[6]
- a=d[7]
- else:
- 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:
- if app.ENABLE_CHANGELOOK_SYSTEM:
- self.uiNewShop.AddItem(slot,{"id":id,"vnum":vnum,"count":count,"price":price,"sockets":sockets,"attrs":attrs,"transmutation":transmutation})
- else:
- 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()
- if app.ENABLE_INVENTORY_PROTECT_SYSTEM:
- def BINARY_Inventory_State(self, case):
- self.interface.AskInventoryPassword(case)
- def BINARY_Inventory_Lock(self):
- self.interface.InventoryLock()
- def BINARY_Inventory_Unlock(self):
- self.interface.InventoryUnlock()
- def __TeamLogin(self, name):
- if self.interface.wndMessenger:
- self.interface.wndMessenger.OnLogin(2, name)
- def __TeamLogout(self, name):
- if self.interface.wndMessenger:
- self.interface.wndMessenger.OnLogout(2, name)
- def IsEnableAutoPickUp(self):
- return constInfo.M2_USER["cfg"]["pickup"]
- def EnablePickUp(self):
- def SetStatus(val):
- constInfo.M2_USER["cfg"]["pickup"] = val
- chat.AppendChat(chat.CHAT_TYPE_INFO, (localeInfo.M2_USER_INFO_PICKUP % (val)))
- if not self.IsEnableAutoPickUp():
- SetStatus(1)
- else:
- SetStatus(0)
- def OpenSupportGui(self):
- if constInfo.SUPPORTGUI == 0:
- self.supportpg.Show()
- self.supportpg.SetTop()
- constInfo.SUPPORTGUI = 1
- else:
- self.supportpg.Close()
- constInfo.SUPPORTGUI = 0
- def SetSupportLevel(self, level):
- self.supportpg.SetLevel(level)
- constInfo.SUPPORTLEVEL = int(level)
- def SetSupportName(self, name, name2):
- self.supportpg.SetName(name, name2)
- def SupportLeave(self):
- self.supportpg.SetDefaultInfo()
- self.supportpg.Close()
- def SupportInt(self , ints):
- self.supportpg.SetInt(ints)
- def SetSupportExp(self, exp, exptot):
- if int(exptot) > 0:
- self.supportpg.SetExperience(exp, exptot)
- self.supportpg.SetExperience(exp, exptot)
- def SetSupportIcon(self, vnum):
- if int(vnum) > 0:
- self.supportpg.SetImageSlot(vnum)
- self.supportpg.SetImageSlot(vnum)
- def SetSupportSpeciality(self,speciality):
- self.supportpg.SetSpeciality(speciality)
- def OpenGuiGaya(self):
- self.interface.OpenGuiGaya()
- def GayaCheck(self):
- self.interface.GayaCheck()
- def OpenGuiGayaMarket(self):
- self.interface.OpenGuiGayaMarket()
- def GayaMarketItems(self,vnums,gaya,count):
- self.interface.GayaMarketItems(vnums,gaya,count)
- def GayaMarketSlotsDesblock(self,slot0,slot1,slot2,slot3,slot4,slot5):
- self.interface.GayaMarketSlotsDesblock(slot0,slot1,slot2,slot3,slot4,slot5)
- def GayaMarketClear(self):
- self.interface.GayaMarketClear()
- def __BanStart(self):
- self.bansystem.Show()
- if app.ENABLE_MAINTENANCE_SYSTEM:
- def BINARY_Maintenance(self, sec, dur):
- sec = int(sec)
- dur = int(dur)
- self.interface.StartMaintenance(sec,dur)
- # chat.AppendChat(1, "%i - %s" % (sec,dur))
- if app.ENABLE_SHOW_CHEST_DROP:
- def BINARY_AddChestDropInfo(self, chestVnum, pageIndex, slotIndex, itemVnum, itemCount):
- if self.interface:
- self.interface.AddChestDropInfo(chestVnum, pageIndex, slotIndex, itemVnum, itemCount)
- def BINARY_RefreshChestDropInfo(self, chestVnum):
- if self.interface:
- self.interface.RefreshChestDropInfo(chestVnum)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement