Porblem mit Switchbot

Hallo ich habe eben den das hier [Only registered and activated users can see links. Click Here To Register...] eingef�gt
und seit dem komme ich nicht mehr ingame rein.Der ladebalken ist fertig geladen
aber ich komme nicht ingame rein.

sysser

Spoiler

PHP Code:


			
0202 17:07:04412 :: CEffectManager::RegisterEffect - LoadScript(d:/ymir work/effect/hit/percent_damage1.mse) Error

0202 17:07:04412 :: CInstanceBase::RegisterEffect(eEftType=264, c_szEftAttachBone=, c_szEftName=d:/ymir work/effect/hit/percent_damage1.mse, isCache=1) - Error

0202 17:07:04432 :: CEffectManager::RegisterEffect - LoadScript(d:/ymir work/effect/hit/percent_damage2.mse) Error

0202 17:07:04432 :: CInstanceBase::RegisterEffect(eEftType=265, c_szEftAttachBone=, c_szEftName=d:/ymir work/effect/hit/percent_damage2.mse, isCache=1) - Error

0202 17:07:04452 :: CEffectManager::RegisterEffect - LoadScript(d:/ymir work/effect/hit/percent_damage3.mse) Error

0202 17:07:04452 :: CInstanceBase::RegisterEffect(eEftType=266, c_szEftAttachBone=, c_szEftName=d:/ymir work/effect/hit/percent_damage3.mse, isCache=1) - Error

0202 17:07:04938 :: invalid idx 0

0202 17:07:10355 :: CMapOutdoor::Load - LoadMonsterAreaInfo ERROR

0202 17:07:16940 :: GRANNY: r:/granny/rt/granny_file_info.cpp(145): File has run-time type tag of 0x8000000f, which doesn't match this version of Granny (0x80000010).  Automatic conversion will be attempted.

0202 17:07:24126 :: CEffectManager::RegisterEffect - LoadScript(D:/ymir work/pc/common/effect/armor/armor-4-2-1.mse) Error

0202 17:07:24126 :: CInstanceBase::RegisterEffect(eEftType=248, c_szEftAttachBone=Bip01, c_szEftName=D:/ymir work/pc/common/effect/armor/armor-4-2-1.mse, isCache=0) - Error

0202 17:07:24146 :: CEffectManager::RegisterEffect - LoadScript(D:/ymir work/pc/common/effect/armor/armor-4-2-2.mse) Error

0202 17:07:24146 :: CInstanceBase::RegisterEffect(eEftType=249, c_szEftAttachBone=Bip01, c_szEftName=D:/ymir work/pc/common/effect/armor/armor-4-2-2.mse, isCache=0) - Error

0202 17:07:27193 :: Traceback (most recent call last):



0202 17:07:27193 ::   File "networkModule.py", line 231, in SetGamePhase



0202 17:07:27193 ::   File "system.py", line 130, in __pack_import



0202 17:07:27193 ::   File "

0202 17:07:27193 :: <string>

0202 17:07:27193 :: ", line 

0202 17:07:27193 :: 1974

0202 17:07:27193 :: 



0202 17:07:27193 ::     

0202 17:07:27193 :: if self.switchbot.bot_shown == 1:



0202 17:07:27193 ::     

0202 17:07:27193 ::  

0202 17:07:27193 :: ^



0202 17:07:27193 :: IndentationError

0202 17:07:27193 :: : 

0202 17:07:27193 :: expected an indented block

0202 17:07:27193 ::

meine 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 time

from switchbot import Bot



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 _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.switchbot = Bot()

        self.switchbot.Hide()



        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.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()

        self.timeLine = ui.TextLine()

        self.timeLine.SetFontName(locale.UI_DEF_FONT_LARGE)

        self.timeLine.SetFontColor(  255,64,   64)

        self.timeLine.SetPosition((wndMgr.GetScreenWidth() - 130) / 2, 175)



    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_F6]    = 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)

        self.timeLine.SetWindowHorizontalAlignCenter()

        self.timeLine.SetHorizontalAlignCenter()

        self.timeLine.SetFeather()

        self.timeLine.SetOutline()

        self.timeLine.Show()



        ## 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()

            localtime = localtime = time.strftime("[%H:%M:%S]")

            self.timeLine.SetText(localtime)

            self.timeLine.Show()



        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 __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



    #Switchbot



    def __toggleSwitchbot(self):

    if self.switchbot.bot_shown == 1:

    self.switchbot.Hide()

    else:

    self.switchbot.Show()



#Switchbot END