[R] Switchbot Collection

~~JeyMaker~~ · 12/17/2015, 22:43

Quote:

Originally Posted by Mijago

JeyMaker, Das ist keine produktive Antwort, aber das ist in dieser Sektion leider normal.

Bastüh: schau mal die letzten 28 Seiten durch, irgendwo gibt es dafür bestimmt schon eine Lösung. Das kommt ganz auf deinen Client an.
Ansonsten alle relevanten Zeilen auskommentieren.

Ich habe keine Zeit mehr für so etwas, sorry, nur mein Tapatalk hat mich auf den Thread hingewiesen

Stimmt, beim nächsten Mal schick ich gleich paar fertige Serverfiles zur Auswahl mit

theskulls · 12/20/2015, 14:20

Jungs wie behebe ich? Ich sehe, wenn ich zum schwarzen Bildschirm, den Client-Spiel.

Spoiler

sniperxace · 12/25/2015, 20:58

fehler?

game.py

Spoiler

PHP Code:



import os 
import app 
import dbg 
import grp 
import item 
import background 
import chr 
import chrmgr 
import player 
import snd 
import chat 
import textTail 
import snd 
import net 
import effect 
import wndMgr 
import fly 
import systemSetting 
import quest 
import guild 
import skill 
import messenger 
import locale 
import constInfo 
import exchange 
import ime 
 
import ui 
import uiCommon 
import uiPhaseCurtain 
import uiMapNameShower 
import uiAffectShower 
import uiPlayerGauge 
import uiCharacter 
import uiTarget 
 
# PRIVATE_SHOP_PRICE_LIST 
import uiPrivateShopBuilder 
# END_OF_PRIVATE_SHOP_PRICE_LIST 
 
import mouseModule 
import consoleModule 
import locale 
 
import playerSettingModule 
import interfaceModule 
 
import musicInfo 
import debugInfo 
import stringCommander 
 
from switchbot import Bot 
from _weakref import proxy 
 
# TEXTTAIL_LIVINGTIME_CONTROL 
#if locale.IsJAPAN(): 
#    app.SetTextTailLivingTime(8.0) 
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL 
 
# SCREENSHOT_CWDSAVE 
SCREENSHOT_CWDSAVE = FALSE 
SCREENSHOT_DIR = None 
 
if locale.IsEUROPE(): 
    SCREENSHOT_CWDSAVE = TRUE 
 
if locale.IsCIBN10(): 
    SCREENSHOT_CWDSAVE = FALSE 
        SCREENSHOT_DIR = "YT2W" 
 
cameraDistance = 1550.0 
cameraPitch = 27.0 
cameraRotation = 0.0 
cameraHeight = 100.0 
 
testAlignment = 0 
 
class GameWindow(ui.ScriptWindow): 
    canQuestLettersShow = 1 
    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.pressNumber = None 
 
        self.guildWarQuestionDialog = None 
        self.interface = None 
        self.targetBoard = None 
        self.console = None 
        self.mapNameShower = None 
        self.affectShower = None 
        self.playerGauge = None 
 
        self.stream=stream 
        self.interface = interfaceModule.Interface() 
        self.interface.MakeInterface() 
        self.interface.ShowDefaultWindows() 
 
        self.curtain = uiPhaseCurtain.PhaseCurtain() 
        self.curtain.speed = 0.03 
        self.curtain.Hide() 
         
        self.switchbot = Bot() 
        self.switchbot.Hide() 
 
        self.targetBoard = uiTarget.TargetBoard() 
        self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog)) 
        self.targetBoard.Hide() 
 
        self.console = consoleModule.ConsoleWindow() 
        self.console.BindGameClass(self) 
        self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200) 
        self.console.Hide() 
 
        self.mapNameShower = uiMapNameShower.MapNameShower() 
        self.affectShower = uiAffectShower.AffectShower() 
 
        self.playerGauge = uiPlayerGauge.PlayerGauge(self) 
        self.playerGauge.Hide() 
 
        self.__SetQuickSlotMode() 
 
        self.__ServerCommand_Build() 
        self.__ProcessPreservedServerCommand() 
 
    def __del__(self): 
        player.SetGameWindow(0) 
        net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self) 
        ui.ScriptWindow.__del__(self) 
 
    def Open(self): 
        app.SetFrameSkip(1) 
 
        self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight()) 
 
        self.quickSlotPageIndex = 0 
        self.PickingCharacterIndex = -1 
        self.PickingItemIndex = -1 
        self.consoleEnable = FALSE 
        self.isShowDebugInfo = FALSE 
        self.ShowNameFlag = 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(locale.UI_LEFT_TIME) 
 
        textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE) 
 
        if constInfo.PVPMODE_TEST_ENABLE: 
            self.testPKMode = ui.TextLine() 
            self.testPKMode.SetFontName(locale.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(locale.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 
 
        if debugInfo.IsDebugMode(): 
            self.ToggleDebugInfo() 
 
        ## 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 
 
    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.ClearDictionary() 
 
        self.playerGauge = None 
        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 self.interface: 
            self.interface.HideAllWindows() 
            self.interface.Close() 
            self.interface=None 
 
        player.ClearSkillDict() 
        player.ResetCameraRotation() 
 
        self.KillFocus() 
        app.HideCursor() 
 
        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) 
        onPressKeyDict[app.DIK_F5]    = lambda : self.__toggleSwitchbot() 
 
        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_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() 
 
        # 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() 
 
        #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: 
                #net.SendChatPacket("/user_horse_ride") 
                if not uiPrivateShopBuilder.IsBuildingPrivateShop(): 
                    for i in xrange(player.INVENTORY_PAGE_SIZE): 
                        if player.GetItemIndex(i) in (71114, 71116, 71118, 71120): 
                            net.SendItemUsePacket(i) 
                            break 
    def    __PressHKey(self): 
        if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL): 
            net.SendChatPacket("/user_horse_ride") 
        else: 
            self.interface.OpenHelpWindow() 
 
    def    __PressBKey(self): 
        if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL): 
            net.SendChatPacket("/user_horse_back") 
        else: 
            state = "EMOTICON" 
            self.interface.ToggleCharacterWindow(state) 
 
    def    __PressFKey(self): 
        if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL): 
            net.SendChatPacket("/user_horse_feed")     
        else: 
            app.ZoomCamera(app.CAMERA_TO_POSITIVE) 
 
    def __PressGKey(self): 
        if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL): 
            net.SendChatPacket("/ride")     
        else: 
            if self.ShowNameFlag: 
                self.interface.ToggleGuildWindow() 
            else: 
                app.PitchCamera(app.CAMERA_TO_POSITIVE) 
 
    def    __ReleaseGKey(self): 
        app.PitchCamera(app.CAMERA_STOP) 
 
    def __PressQKey(self): 
        if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL): 
            if 0!=self.canQuestLettersShow: 
                self.interface.HideAllQuestButton() 
                self.canQuestLettersShow = 0 
            else: 
                self.interface.ShowAllQuestButton() 
                self.canQuestLettersShow = 1 
        else: 
            app.RotateCamera(app.CAMERA_TO_NEGATIVE) 
 
    def __SetQuickSlotMode(self): 
        self.pressNumber=ui.__mem_func__(self.__PressQuickSlot) 
 
    def __SetQuickPageMode(self): 
        self.pressNumber=ui.__mem_func__(self.__SelectQuickPage) 
 
    def __PressQuickSlot(self, localSlotIndex): 
        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() 
        else: 
            self.PrintCoord.Hide() 
            self.FrameRate.Hide() 
            self.Pitch.Hide() 
            self.Splat.Hide() 
            self.TextureNum.Hide() 
            self.ObjectNum.Hide() 
            self.ViewDistance.Hide() 
 
    def __BuildDebugInfo(self): 
        ## Character Position Coordinate 
        self.PrintCoord = ui.TextLine() 
        self.PrintCoord.SetFontName(locale.UI_DEF_FONT) 
        self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0) 
 
        ## Frame Rate 
        self.FrameRate = ui.TextLine() 
        self.FrameRate.SetFontName(locale.UI_DEF_FONT) 
        self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20) 
 
        ## Camera Pitch 
        self.Pitch = ui.TextLine() 
        self.Pitch.SetFontName(locale.UI_DEF_FONT) 
        self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40) 
 
        ## Splat 
        self.Splat = ui.TextLine() 
        self.Splat.SetFontName(locale.UI_DEF_FONT) 
        self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60) 
 
        # TextureNum 
        self.TextureNum = ui.TextLine() 
        self.TextureNum.SetFontName(locale.UI_DEF_FONT) 
        self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 80) 
 
        # 오브젝트 그리는 개수 
        self.ObjectNum = ui.TextLine() 
        self.ObjectNum.SetFontName(locale.UI_DEF_FONT) 
        self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100) 
 
        # 시야거리 
        self.ViewDistance = ui.TextLine() 
        self.ViewDistance.SetFontName(locale.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(locale.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, locale.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(locale.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) + " (" + locale.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): 
        self.interface.OpenQuestWindow(skin, idx) 
 
    def AskGuildName(self): 
 
        guildNameBoard = uiCommon.InputDialog() 
        guildNameBoard.SetTitle(locale.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(locale.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, locale.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) 
 
    def BINARY_NEW_RemoveAffect(self, type, pointIdx): 
        self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx) 
    # 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) 
 
    def RefreshTargetBoardByVID(self, vid): 
        self.targetBoard.RefreshByVID(vid) 
 
    def RefreshTargetBoardByName(self, name): 
        self.targetBoard.RefreshByName(name) 
         
    def __RefreshTargetBoard(self): 
        self.targetBoard.Refresh() 
         
    def SetHPTargetBoard(self, vid, hpPercentage): 
        if vid != self.targetBoard.GetTargetVID(): 
            self.targetBoard.ResetTargetBoard() 
            self.targetBoard.SetEnemyVID(vid) 
 
        self.targetBoard.SetHP(hpPercentage) 
        self.targetBoard.Show() 
 
    def CloseTargetBoardIfDifferent(self, vid): 
        if vid != self.targetBoard.GetTargetVID(): 
            self.targetBoard.Close() 
 
    def CloseTargetBoard(self): 
        self.targetBoard.Close() 
 
    ## View Equipment 
    def OpenEquipmentDialog(self, vid): 
        self.interface.OpenEquipmentDialog(vid) 
 
    def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count): 
        self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count) 
 
    def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value): 
        self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value) 
 
    def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value): 
        self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value) 
 
    # SHOW_LOCAL_MAP_NAME 
    def ShowMapName(self, mapName, x, y): 
 
        if self.mapNameShower: 
            self.mapNameShower.ShowMapName(mapName, x, y) 
 
        if self.interface: 
            self.interface.SetMapName(mapName) 
    # END_OF_SHOW_LOCAL_MAP_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 locale.WHISPER_ERROR.has_key(mode): 
            chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, locale.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, locale.GAME_PICK_MONEY % (money)) 
 
    def OnShopError(self, type): 
        try: 
            self.PopupMessage(locale.SHOP_ERROR_DICT[type]) 
        except KeyError: 
            self.PopupMessage(locale.SHOP_ERROR_UNKNOWN % (type)) 
 
    def OnSafeBoxError(self): 
        self.PopupMessage(locale.SAFEBOX_ERROR) 
 
    def OnFishingSuccess(self, isFish, fishName): 
        chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, locale.FISHING_SUCCESS(isFish, fishName), 2000) 
 
    # ADD_FISHING_MESSAGE 
    def OnFishingNotifyUnknown(self): 
        chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_UNKNOWN) 
 
    def OnFishingWrongPlace(self): 
        chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_WRONG_PLACE) 
    # END_OF_ADD_FISHING_MESSAGE 
 
    def OnFishingNotify(self, isFish, fishName): 
        chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_NOTIFY(isFish, fishName)) 
 
    def OnFishingFailure(self): 
        chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, locale.FISHING_FAILURE, 2000) 
 
    def OnCannotPickItem(self): 
        chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GAME_CANNOT_PICK_ITEM) 
 
    # MINING 
    def OnCannotMining(self): 
        chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GAME_CANNOT_MINING) 
    # END_OF_MINING 
 
    def OnCannotUseSkill(self, vid, type): 
        if locale.USE_SKILL_ERROR_TAIL_DICT.has_key(type): 
            textTail.RegisterInfoTail(vid, locale.USE_SKILL_ERROR_TAIL_DICT[type]) 
 
        if locale.USE_SKILL_ERROR_CHAT_DICT.has_key(type): 
            chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_SKILL_ERROR_CHAT_DICT[type]) 
 
    def    OnCannotShotError(self, vid, type): 
        textTail.RegisterInfoTail(vid, locale.SHOT_ERROR_TAIL_DICT.get(type, locale.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 + locale.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(locale.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name)) 
        messengerAddFriendQuestion.SetText2(locale.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 + locale.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 + locale.SCREENSHOT_SAVE1) 
            chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SCREENSHOT_SAVE2) 
            """ 
        else: 
            chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SCREENSHOT_SAVE_FAILURE) 
 
    def ShowConsole(self): 
        if debugInfo.IsDebugMode() or TRUE == self.consoleEnable: 
            player.EndKeyWalkingImmediately() 
            self.console.OpenWindow() 
 
    def ShowName(self): 
        self.ShowNameFlag = TRUE 
        self.playerGauge.EnableShowAlways() 
        player.SetQuickPage(self.quickSlotPageIndex+1) 
 
    # ADD_ALWAYS_SHOW_NAME 
    def __IsShowName(self): 
 
        if systemSetting.IsAlwaysShowName(): 
            return 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) 
 
            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 TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID: 
            if player.IsEquipmentSlot(attachedItemSlotPos): 
                self.stream.popupWindow.Close() 
                self.stream.popupWindow.Open(locale.EXCHANGE_FAILURE_EQUIP_ITEM, 0, locale.UI_OK) 
            else: 
                if chr.IsNPC(dstChrID): 
                    net.SendGiveItemPacket(dstChrID, attachedItemSlotPos, attachedItemCount) 
                else: 
                    net.SendExchangeStartPacket(dstChrID) 
                    net.SendExchangeItemAddPacket(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, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP) 
            return 
        # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP 
         
        if attachedMoney>=1000: 
            self.stream.popupWindow.Close() 
            self.stream.popupWindow.Open(locale.DROP_MONEY_FAILURE_1000_OVER, 0, locale.UI_OK) 
            return 
 
        itemDropQuestionDialog = uiCommon.QuestionDialog() 
        itemDropQuestionDialog.SetText(locale.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, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP) 
            return 
        # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP 
         
        if player.IsEquipmentSlot(attachedItemSlotPos): 
            self.stream.popupWindow.Close() 
            self.stream.popupWindow.Open(locale.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, locale.UI_OK) 
 
        else: 
            dropItemIndex = player.GetItemIndex(attachedItemSlotPos) 
 
            item.SelectItem(dropItemIndex) 
            dropItemName = item.GetItemName() 
 
            ## Question Text 
            questionText = locale.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 
 
        self.itemDropQuestionDialog.Close() 
        self.itemDropQuestionDialog = None 
 
        constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0) 
 
    # PRIVATESHOP_DISABLE_ITEM_DROP 
    def __SendDropItemPacket(self, itemVNum, itemCount): 
        if uiPrivateShopBuilder.IsBuildingPrivateShop(): 
            chat.AppendChat(chat.CHAT_TYPE_INFO, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP) 
            return 
 
        net.SendItemDropPacketNew(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 self.mapNameShower.IsShow(): 
            self.mapNameShower.Update() 
 
        if self.isShowDebugInfo: 
            self.UpdateDebugInfo() 
 
        if self.enableXMasBoom: 
            self.__XMasBoom_Update() 
 
        self.interface.BUILD_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)))             
 
        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 
 
        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 
     
    # 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 
 
    # CUBE 
    def BINARY_Cube_Open(self): 
        self.interface.OpenCubeWindow() 
 
    def BINARY_Cube_Close(self): 
        self.interface.CloseCubeWindow() 
 
    def BINARY_Cube_Succeed(self, itemVnum, count): 
        print "큐브 제작 성공" 
        self.interface.SucceedCubeWork(itemVnum, count) 
        pass 
 
    def BINARY_Cube_Failed(self): 
        print "큐브 제작 실패" 
        #self.PopupMessage(locale.CUBE_FAILURE) 
        pass 
 
    # END_OF_CUBE 
     
    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 locale.NOTIFY_MESSAGE: 
            return 
        chat.AppendChat(chat.CHAT_TYPE_INFO, locale.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={ 
            "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, 
 
            # ITEM_MALL 
            "CloseMall"                : self.CommandCloseMall, 
            "ShowMeMallPassword"    : self.AskMallPassword, 
            "item_mall"                : self.__ItemMall_Open, 
            # END_OF_ITEM_MALL 
 
            "RefineSuceeded"        : self.RefineSuceededMessage, 
            "RefineFailed"            : self.RefineFailedMessage, 
            "xmas_snow"                : self.__XMasSnow_Enable, 
            "xmas_boom"                : self.__XMasBoom_Enable, 
            "xmas_song"                : self.__XMasSong_Enable, 
            "xmas_tree"                : self.__XMasTree_Enable, 
            "newyear_boom"            : self.__XMasBoom_Enable, 
            "PartyRequest"            : self.__PartyRequestQuestion, 
            "PartyRequestDenied"    : self.__PartyRequestDenied, 
            "horse_state"            : self.__Horse_UpdateState, 
            "hide_horse_state"        : self.__Horse_HideState, 
            "WarUC"                    : self.__GuildWar_UpdateMemberCount, 
            "test_server"            : self.__EnableTestServerFlag, 
            "mall"            : self.__InGameShop_Show, 
 
            # 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 
 
            # PRIVATE_SHOP_PRICE_LIST 
            "MyShopPriceList"        : self.__PrivateShop_PriceList, 
            # END_OF_PRIVATE_SHOP_PRICE_LIST 
        } 
 
        self.serverCommander=stringCommander.Analyzer() 
        for serverCommandItem in serverCommandList.items(): 
            self.serverCommander.SAFE_RegisterCallBack( 
                serverCommandItem[0], serverCommandItem[1] 
            ) 
 
    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(locale.REFINE_SUCCESS) 
 
    def RefineFailedMessage(self): 
        snd.PlaySound("sound/ui/jaeryun_fail.wav") 
        self.PopupMessage(locale.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 __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)) 
 
    def __XMasSong_Enable(self, mode): 
        if "1"==mode: 
            print "XMAS_SONG ON" 
 
            XMAS_BGM = "xmas.mp3" 
 
            if app.IsExistFile("BGM/" + XMAS_BGM)==1: 
                if musicInfo.fieldMusic != "": 
                    snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic) 
 
                musicInfo.fieldMusic=XMAS_BGM 
                snd.FadeInMusic("BGM/" + musicInfo.fieldMusic) 
 
        else: 
            print "XMAS_SONG OFF" 
 
            if musicInfo.fieldMusic != "": 
                snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic) 
 
            musicInfo.fieldMusic=musicInfo.METIN2THEMA 
            snd.FadeInMusic("BGM/" + musicInfo.fieldMusic) 
 
    def __RestartDialog_Close(self): 
        self.interface.CloseRestartDialog() 
 
    def __Console_Enable(self): 
        constInfo.CONSOLE_ENABLE = TRUE 
        self.consoleEnable = TRUE 
        app.EnableSpecialCameraMode() 
        ui.EnablePaste(TRUE) 
 
    ## PrivateShop 
    def __PrivateShop_Open(self): 
        self.interface.OpenPrivateShopInputNameDialog() 
 
    def BINARY_PrivateShop_Appear(self, vid, text): 
        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) + locale.PARTY_DO_YOU_ACCEPT) 
        partyRequestQuestionDialog.SetAcceptText(locale.UI_ACCEPT) 
        partyRequestQuestionDialog.SetCancelText(locale.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(locale.PARTY_REQUEST_DENIED) 
 
    def __EnableTestServerFlag(self): 
        app.EnableTestServerFlag() 
 
    def __InGameShop_Show(self, url): 
        if constInfo.IN_GAME_SHOP_ENABLE: 
            self.interface.OpenWebWindow(url) 
 
    # WEDDING 
    def __LoginLover(self): 
        if self.interface.wndMessenger: 
            self.interface.wndMessenger.OnLoginLover() 
 
    def __LogoutLover(self): 
        if self.interface.wndMessenger: 
            self.interface.wndMessenger.OnLogoutLover() 
        if self.affectShower: 
            self.affectShower.HideLoverState() 
 
    def __LoverNear(self): 
        if self.affectShower: 
            self.affectShower.ShowLoverState() 
 
    def __LoverFar(self): 
        if self.affectShower: 
            self.affectShower.HideLoverState() 
 
    def __LoverDivorce(self): 
        if self.interface.wndMessenger: 
            self.interface.wndMessenger.ClearLoverInfo() 
        if self.affectShower: 
            self.affectShower.ClearLoverState() 
             
    def __toggleSwitchbot(self): 
        if self.switchbot.bot_shown == 1: 
            self.switchbot.Hide() 
        else: 
            self.switchbot.Show() 
 
    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) 
 
    # END_OF_WEDDING

sniperxace · 12/27/2015, 17:16

hilfe währe sehr nett im tema oben drüber

mRxR34L · 01/23/2016, 08:53

Liebe Community ich versuche den Switchbot von Mijago einzubauen aber schaffe es leider nicht...
Problem ist er öffnet sich zwar aber ich kann nichts Switchen er lässt es einfach nicht zu und finde auch leider den Fehler nicht.

Sysrr

0122 20:48:49400 :: Traceback (most recent call last):

0122 20:48:49401 :: File "ui.py", line 1069, in OnToggleDown

0122 20:48:49402 :: File "switchbot.py", line 63, in Activate

0122 20:48:49402 :: AttributeError
0122 20:48:49402 :: :
0122 20:48:49402 :: 'int' object has no attribute 'gameWindow'
0122 20:48:49402 ::

game.py

.Ayaz' · 02/08/2016, 19:54

Guten Abend,

also der Switchbot switcht, habe keine Fehler damit, außer dieses eine Problem (2.0):

Wenn ich den Switchbot beim switchen minimiere, verschwindet das Item im Switchbot und es wird nicht mehr geswitcht.

Könnte mir bitte jemand helfen?

LG

usaewa96 · 03/13/2016, 03:45

Hallo Jungs,
habe den Bot genau so eingefügt, wie vorgegeben.
Und das Game startet aber nach der Charauswahl bleibt es bei einem vollem Ladebalken stehen.
Hier einmal mein Syserr:

Spoiler

Und noch meine Game Datei :

Spoiler

Danke im vorraus !

WeisNicht777 · 04/26/2016, 12:06

Hey wo find ich denn in injector ?^^

~~Leibauer~~ · 04/27/2016, 17:38

Sehr gut gemacht

troll1981 · 07/05/2016, 09:50

Bei all deinem Switcher der rumgeht die ich gesehen habe fehlt der Bonus

"Angriffsgeschwindigkeit"

war das Absicht ?

N1nJa2011 · 07/26/2016, 10:25

0726 10:23:23617 :: File "networkModule.py", line 245, in SetGamePhase

0726 10:23:23617 :: File "system.py", line 130, in __pack_import

0726 10:23:23617 :: File "system.py", line 110, in _process_result

0726 10:23:23617 :: File "game.py", line 59, in ?

0726 10:23:23617 :: File "system.py", line 130, in __pack_import

0726 10:23:23618 :: File "system.py", line 110, in _process_result

0726 10:23:23618 :: File "switchbot.py", line 6, in ?

0726 10:23:23618 :: File "system.py", line 137, in __pack_import

0726 10:23:23618 :: ImportError
0726 10:23:23618 :: :
0726 10:23:23618 :: No module named locale
0726 10:23:23618 ::

krosa69 · 10/27/2016, 22:19

I tried to use it by inject, so I deleted the comment Bot.Show on the last line.
I Enjected it and the loader says Successfull. When I write Load bonusswitcher 2.3.py it says successfull but nothing happen... why?

DeZy. · 10/27/2016, 22:48

Quote:

Originally Posted by krosa69

I tried to use it by inject, so I deleted the comment Bot.Show on the last line.
I Enjected it and the loader says Successfull. When I write Load bonusswitcher 2.3.py it says successfull but nothing happen... why?

You must rename the bonusswitcher2.3.py in switchbot.py

krosa69 · 10/27/2016, 23:21

What's wrong? Still nothing happen

I need to delete the Selected line right?

Isoo65 · 05/01/2017, 18:47

hallo ich habe immer Probleme wenn ich alles einfüge vorallem das Erste From schwitchbord imput bot dauert der client beim laden und dreht verrückt diese f6 bsw. f5 taste funkitionier und das andere mit der def aber die anderen 3 sachen oder 2 bringen mein client zum durchdrehen!

Spoiler

bis zum Charackter wahl komme ich rein aber danach ladet es einfach nur diese rad und komme nicht ins spiel rein was ist der fehler !!!

from switchbot import Bot

self.switchbot = Bot()
self.switchbot.Hide()

wenn ich die beiden Coods einfüge der rest funkitioniert bei mir aber bei den beidne Hängt mein Client bei dem 2011 client und wenn ich die 3 coods lösche funktioniert es wieder bitte um hilfe !!