Register for your free account! | Forgot your password?

You last visited: Today at 05:07

  • Please register to post and access all features, it's quick, easy and FREE!

 

Switchbot

Reply
 
Old   #1
 
elite*gold: 0
Join Date: Mar 2012
Posts: 980
Received Thanks: 12
Question Switchbot

Der Switcher öffnet sich nicht habe den hotkey auf F7 gesetzt
aber es öffnet sich nicht
[R] Switchbot Collection

Game.py:
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
afk 
0

class GameWindow(ui.ScriptWindow):
    
def __init__(selfstream):
        
ui.ScriptWindow.__init__(self"GAME")
        
self.SetWindowName("game")
        
net.SetPhaseWindow(net.PHASE_WINDOW_GAMEself)
        
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()

    
def __del__(self):
        
player.SetGameWindow(0)
        
net.ClearPhaseWindow(net.PHASE_WINDOW_GAMEself)
        
ui.ScriptWindow.__del__(self)

    
def Open(self):
        
app.SetFrameSkip(1)

        
self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())

        
##START_KILLGUI
        
KillGuiBg ui.AniImageBox()
        
KillGuiBg.AppendImage("d:/ymir work/ui/blue_killgui_interface.dds")
        
self.KillGuiBg KillGuiBg
        
        self
.KillGuiBg.SetPosition(wndMgr.GetScreenWidth()-465,0)
        
        
self.KillBlauReich ui.TextLine()
        
self.KillBlauReich.SetDefaultFontName()
        
self.KillBlauReich.SetPosition((wndMgr.GetScreenWidth()-465)+12035)
        
self.KillBlauReich.SetText("Blaues Reich:      ")
        
self.KillBlauReich.SetOutline()
        
        
self.KillGelbReich ui.TextLine()
        
self.KillGelbReich.SetDefaultFontName()
        
self.KillGelbReich.SetPosition((wndMgr.GetScreenWidth()-465)+12055)
        
self.KillGelbReich.SetText("Gelbes Reich:       ")
        
self.KillGelbReich.SetOutline()

        
self.KillRotReich ui.TextLine()
        
self.KillRotReich.SetDefaultFontName()
        
self.KillRotReich.SetPosition((wndMgr.GetScreenWidth()-465)+12075)
        
self.KillRotReich.SetText("Rotes Reich:       ")
        
self.KillRotReich.SetOutline()

        
self.KillMob ui.TextLine()
        
self.KillMob.SetDefaultFontName()
        
self.KillMob.SetPosition((wndMgr.GetScreenWidth()-465)+12095)
        
self.KillMob.SetText("Monster:       ")
        
self.KillMob.SetOutline()
        
##END_KILLGUI

        
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 cameraDistancecameraPitchcameraRotationcameraHeight

        app
.SetCamera(cameraDistancecameraPitchcameraRotationcameraHeight)

        
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(015)
            
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(035)
            
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 
cameraDistancecameraPitchcameraRotationcameraHeight
        
(cameraDistancecameraPitchcameraRotationcameraHeight) = 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.__afk()
        
onPressKeyDict[app.DIK_F5]    = lambda self.__showkillgui()
        
onPressKeyDict[app.DIK_F7]    = 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]            = lambdaapp.RotateCamera(app.CAMERA_TO_POSITIVE)
        
onPressKeyDict[app.DIK_R]            = lambdaapp.ZoomCamera(app.CAMERA_TO_NEGATIVE)
        
#onPressKeyDict[app.DIK_F]            = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)
        
onPressKeyDict[app.DIK_T]            = lambdaapp.PitchCamera(app.CAMERA_TO_NEGATIVE)
        
onPressKeyDict[app.DIK_G]            = self.__PressGKey
        onPressKeyDict
[app.DIK_Q]            = self.__PressQKey

        onPressKeyDict
[app.DIK_NUMPAD9]        = lambdaapp.MovieResetCamera()
        
onPressKeyDict[app.DIK_NUMPAD4]        = lambdaapp.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
        
onPressKeyDict[app.DIK_NUMPAD6]        = lambdaapp.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
        
onPressKeyDict[app.DIK_PGUP]        = lambdaapp.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
        
onPressKeyDict[app.DIK_PGDN]        = lambdaapp.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
        
onPressKeyDict[app.DIK_NUMPAD8]        = lambdaapp.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
        
onPressKeyDict[app.DIK_NUMPAD2]        = lambdaapp.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] = lambdaapp.RotateCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_E] = lambdaapp.RotateCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_R] = lambdaapp.ZoomCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_F] = lambdaapp.ZoomCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_T] = lambdaapp.PitchCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_G] = lambdaself.__ReleaseGKey()
        
onClickKeyDict[app.DIK_NUMPAD4] = lambdaapp.MovieRotateCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_NUMPAD6] = lambdaapp.MovieRotateCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_PGUP] = lambdaapp.MovieZoomCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_PGDN] = lambdaapp.MovieZoomCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_NUMPAD8] = lambdaapp.MoviePitchCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_NUMPAD2] = lambdaapp.MoviePitchCamera(app.CAMERA_STOP)
        
onClickKeyDict[app.DIK_LALT] = lambdaself.HideName()
        
onClickKeyDict[app.DIK_LCONTROL] = lambdaself.HideMouseImage()
        
onClickKeyDict[app.DIK_LSHIFT] = lambdaself.__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 >= and num <= 9:
                if(
chrmgr.IsPossibleEmoticon(-1)):                
                    
chrmgr.SetEmoticon(-1,int(num)-1)
                    
net.SendEmoticon(int(num)-1)
        else:
            if 
num >= 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(iin (71114711167111871120):
                            
net.SendItemUsePacket(i)
                            break
    
def    __PressHKey(self):
        if 
app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
            
net.SendChatPacket("/user_horse_ride")
        else:
            
self.interface.OpenHelpWindow()

    
def    __PressBKey(self):
        if 
app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
            
net.SendChatPacket("/user_horse_back")
        else:
            
state "EMOTICON"
            
self.interface.ToggleCharacterWindow(state)

    
def    __PressFKey(self):
        if 
app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
            
net.SendChatPacket("/user_horse_feed")    
        else:
            
app.ZoomCamera(app.CAMERA_TO_POSITIVE)

    
def __PressGKey(self):
        if 
app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
            
net.SendChatPacket("/ride")    
        else:
            if 
self.ShowNameFlag:
                
self.interface.ToggleGuildWindow()
            else:
                
app.PitchCamera(app.CAMERA_TO_POSITIVE)

    
def    __ReleaseGKey(self):
        
app.PitchCamera(app.CAMERA_STOP)

    
def __PressQKey(self):
        if 
app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
            if 
0==interfaceModule.IsQBHide:
                
interfaceModule.IsQBHide 1
                self
.interface.HideAllQuestButton()
            else:
                
interfaceModule.IsQBHide 0
                self
.interface.ShowAllQuestButton()
        else:
            
app.RotateCamera(app.CAMERA_TO_NEGATIVE)

    
def __SetQuickSlotMode(self):
        
self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)

    
def __SetQuickPageMode(self):
        
self.pressNumber=ui.__mem_func__(self.__SelectQuickPage)

    
def __PressQuickSlot(selflocalSlotIndex):
        
player.RequestUseLocalQuickSlot(localSlotIndex)

    
def __SelectQuickPage(selfpageIndex):
        
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() - 2700)

        
## Frame Rate
        
self.FrameRate ui.TextLine()
        
self.FrameRate.SetFontName(locale.UI_DEF_FONT)
        
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 27020)

        
## Camera Pitch
        
self.Pitch ui.TextLine()
        
self.Pitch.SetFontName(locale.UI_DEF_FONT)
        
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 27040)

        
## Splat
        
self.Splat ui.TextLine()
        
self.Splat.SetFontName(locale.UI_DEF_FONT)
        
self.Splat.SetPosition(wndMgr.GetScreenWidth() - 27060)

        
# TextureNum
        
self.TextureNum ui.TextLine()
        
self.TextureNum.SetFontName(locale.UI_DEF_FONT)
        
self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 27080)

        
# 오브젝트 그리는 개수
        
self.ObjectNum ui.TextLine()
        
self.ObjectNum.SetFontName(locale.UI_DEF_FONT)
        
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270100)

        
# 시야거리
        
self.ViewDistance ui.TextLine()
        
self.ViewDistance.SetFontName(locale.UI_DEF_FONT)
        
self.ViewDistance.SetPosition(00)

    
def __NotifyError(selfmsg):
        
chat.AppendChat(chat.CHAT_TYPE_INFOmsg)

    
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 
== player.GetGuildID():
                
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.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()
            
alignmentgrade chr.testGetPKData()
            
self.pkModeNameDict = { "PEACE""REVENGE""FREE""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(selfmode):
        
self.interface.OnBlockMode(mode)

    
def OpenQuestWindow(selfskinidx):
        
self.interface.OpenQuestWindow(skinidx)

    
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(selfmsg):
        
self.stream.popupWindow.Close()
        
self.stream.popupWindow.Open(msg0locale.UI_OK)

    
def OpenRefineDialog(selftargetItemPosnextGradeItemVnumcostprobtype=0):
        
self.interface.OpenRefineDialog(targetItemPosnextGradeItemVnumcostprobtype)

    
def AppendMaterialToRefineDialog(selfvnumcount):
        
self.interface.AppendMaterialToRefineDialog(vnumcount)

    
def RunUseSkillEvent(selfslotIndexcoolTime):
        
self.interface.OnUseSkill(slotIndexcoolTime)

    
def ClearAffects(self):
        
self.affectShower.ClearAffects()

    
def SetAffect(selfaffect):
        
self.affectShower.SetAffect(affect)

    
def ResetAffect(selfaffect):
        
self.affectShower.ResetAffect(affect)

    
# UNKNOWN_UPDATE
    
def BINARY_NEW_AddAffect(selftypepointIdxvalueduration):
        
self.affectShower.BINARY_NEW_AddAffect(typepointIdxvalueduration)

    
def BINARY_NEW_RemoveAffect(selftypepointIdx):
        
self.affectShower.BINARY_NEW_RemoveAffect(typepointIdx)
    
# END_OF_UNKNOWN_UPDATE

    
def ActivateSkillSlot(selfslotIndex):
        if 
self.interface:
            
self.interface.OnActivateSkill(slotIndex)

    
def DeactivateSkillSlot(selfslotIndex):
        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(selfskillSlotNumber):
        
self.interface.OnChangeCurrentSkill(skillSlotNumber)

    
## TargetBoard
    
def SetPCTargetBoard(selfvidname):
        
self.targetBoard.Open(vidname)
        
        if 
app.IsPressed(app.DIK_LCONTROL):
            
            if 
not player.IsSameEmpire(vid):
                return

            if 
player.IsMainCharacterIndex(vid):
                return        
            
elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):
                return

            
self.interface.OpenWhisperDialog(name)
            

    
def RefreshTargetBoardByVID(selfvid):
        
self.targetBoard.RefreshByVID(vid)

    
def RefreshTargetBoardByName(selfname):
        
self.targetBoard.RefreshByName(name)
        
    
def __RefreshTargetBoard(self):
        
self.targetBoard.Refresh()
        
    
def SetHPTargetBoard(selfvidhpPercentage):
        if 
vid != self.targetBoard.GetTargetVID():
            
self.targetBoard.ResetTargetBoard()
            
self.targetBoard.SetEnemyVID(vid)

        
self.targetBoard.SetHP(hpPercentage)
        
self.targetBoard.Show()

    
def CloseTargetBoardIfDifferent(selfvid):
        if 
vid != self.targetBoard.GetTargetVID():
            
self.targetBoard.Close()

    
def CloseTargetBoard(self):
        
self.targetBoard.Close()

    
## View Equipment
    
def OpenEquipmentDialog(selfvid):
        
self.interface.OpenEquipmentDialog(vid)

    
def SetEquipmentDialogItem(selfvidslotIndexvnumcount):
        
self.interface.SetEquipmentDialogItem(vidslotIndexvnumcount)

    
def SetEquipmentDialogSocket(selfvidslotIndexsocketIndexvalue):
        
self.interface.SetEquipmentDialogSocket(vidslotIndexsocketIndexvalue)

    
def SetEquipmentDialogAttr(selfvidslotIndexattrIndextypevalue):
        
self.interface.SetEquipmentDialogAttr(vidslotIndexattrIndextypevalue)

    
# SHOW_LOCAL_MAP_NAME
    
def ShowMapName(selfmapNamexy):

        if 
self.mapNameShower:
            
self.mapNameShower.ShowMapName(mapNamexy)

        if 
self.interface:
            
self.interface.SetMapName(mapName)
    
# END_OF_SHOW_LOCAL_MAP_NAME    

    
def BINARY_OpenAtlasWindow(self):
        
self.interface.BINARY_OpenAtlasWindow()

    
def OnRecvWhisper(selfmodenameline):
        global 
afk
        afk 
time.strftime("%H:%M")
        if 
mode == chat.WHISPER_TYPE_GM:
            
self.interface.RegisterGameMasterName(name)
        if 
line[-25:] == "Tut mir leid, ich bin AFK":
                
net.SendWhisperPacket(nameafk)
                
chat.AppendWhisper(modenameline)
                
self.interface.RecvWhisper(name)
                return
        if 
constInfo.AFK == and line[-5:] != afk:
                
net.SendWhisperPacket(name"Tut mir leid, ich bin AFK")
                
chat.AppendWhisper(modenameline)
                
self.interface.RecvWhisper(name)
        else:    
            
chat.AppendWhisper(modenameline)
            
self.interface.RecvWhisper(name)

    
def OnRecvWhisperSystemMessage(selfmodenameline):
        
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEMnameline)
        
self.interface.RecvWhisper(name)

    
def OnRecvWhisperError(selfmodenameline):
        if 
locale.WHISPER_ERROR.has_key(mode):
            
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEMnamelocale.WHISPER_ERROR[mode](name))
        else:
            
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEMname"Whisper Unknown Error(mode=%d, name=%s)" % (modename))
        
self.interface.RecvWhisper(name)

    
def RecvWhisper(selfname):
        
self.interface.RecvWhisper(name)

    
def OnPickMoney(selfmoney):
        
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.GAME_PICK_MONEY % (money))

    
def OnShopError(selftype):
        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(selfisFishfishName):
        
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFOlocale.FISHING_SUCCESS(isFishfishName), 2000)

    
# ADD_FISHING_MESSAGE
    
def OnFishingNotifyUnknown(self):
        
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.FISHING_UNKNOWN)

    
def OnFishingWrongPlace(self):
        
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.FISHING_WRONG_PLACE)
    
# END_OF_ADD_FISHING_MESSAGE

    
def OnFishingNotify(selfisFishfishName):
        
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.FISHING_NOTIFY(isFishfishName))

    
def OnFishingFailure(self):
        
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFOlocale.FISHING_FAILURE2000)

    
def OnCannotPickItem(self):
        
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.GAME_CANNOT_PICK_ITEM)

    
# MINING
    
def OnCannotMining(self):
        
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.GAME_CANNOT_MINING)
    
# END_OF_MINING

    
def OnCannotUseSkill(selfvidtype):
        if 
locale.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
            
textTail.RegisterInfoTail(vidlocale.USE_SKILL_ERROR_TAIL_DICT[type])

        if 
locale.USE_SKILL_ERROR_CHAT_DICT.has_key(type):
            
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.USE_SKILL_ERROR_CHAT_DICT[type])

    
def    OnCannotShotError(selfvidtype):
        
textTail.RegisterInfoTail(vidlocale.SHOT_ERROR_TAIL_DICT.get(typelocale.SHOT_ERROR_UNKNOWN % (type)))

    
## PointReset
    
def StartPointReset(self):
        
self.interface.OpenPointResetDialog()

    
## Shop
    
def StartShop(selfvid):
        
self.interface.OpenShopDialog(vid)

    
def EndShop(self):
        
self.interface.CloseShopDialog()

    
def RefreshShop(self):
        
self.interface.RefreshShopDialog()

    
def SetShopSellingPrice(selfPrice):
        
pass

    
## Exchange
    
def StartExchange(self):
        
self.interface.StartExchange()

    
def EndExchange(self):
        
self.interface.EndExchange()

    
def RefreshExchange(self):
        
self.interface.RefreshExchange()

    
## Party
    
def RecvPartyInviteQuestion(selfleaderVIDleaderName):
        
partyInviteQuestionDialog uiCommon.QuestionDialog()
        
partyInviteQuestionDialog.SetText(leaderName locale.PARTY_DO_YOU_JOIN)
        
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUEself.AnswerPartyInvite(arg))
        
partyInviteQuestionDialog.SetCancelEvent(lambda arg=FALSEself.AnswerPartyInvite(arg))
        
partyInviteQuestionDialog.Open()
        
partyInviteQuestionDialog.partyLeaderVID leaderVID
        self
.partyInviteQuestionDialog partyInviteQuestionDialog

    def AnswerPartyInvite
(selfanswer):

        if 
not self.partyInviteQuestionDialog:
            return

        
partyLeaderVID self.partyInviteQuestionDialog.partyLeaderVID

        distance 
player.GetCharacterDistance(partyLeaderVID)
        if 
distance 0.0 or distance 5000:
            
answer FALSE

        net
.SendPartyInviteAnswerPacket(partyLeaderVIDanswer)

        
self.partyInviteQuestionDialog.Close()
        
self.partyInviteQuestionDialog None

    def AddPartyMember
(selfpidname):
        
self.interface.AddPartyMember(pidname)

    
def UpdatePartyMemberInfo(selfpid):
        
self.interface.UpdatePartyMemberInfo(pid)

    
def RemovePartyMember(selfpid):
        
self.interface.RemovePartyMember(pid)
        
self.__RefreshTargetBoard()

    
def LinkPartyMember(selfpidvid):
        
self.interface.LinkPartyMember(pidvid)

    
def UnlinkPartyMember(selfpid):
        
self.interface.UnlinkPartyMember(pid)

    
def UnlinkAllPartyMember(self):
        
self.interface.UnlinkAllPartyMember()

    
def ExitParty(self):
        
self.interface.ExitParty()
        
self.RefreshTargetBoardByVID(self.targetBoard.GetTargetVID())

    
def ChangePartyParameter(selfdistributionMode):
        
self.interface.ChangePartyParameter(distributionMode)

    
## Messenger
    
def OnMessengerAddFriendQuestion(selfname):
        
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(selfsize):
        
self.interface.OpenSafeboxWindow(size)

    
def RefreshSafebox(self):
        
self.interface.RefreshSafebox()

    
def RefreshSafeboxMoney(self):
        
self.interface.RefreshSafeboxMoney()

    
# ITEM_MALL
    
def OpenMallWindow(selfsize):
        
self.interface.OpenMallWindow(size)

    
def RefreshMall(self):
        
self.interface.RefreshMall()
    
# END_OF_ITEM_MALL

    ## Guild
    
def RecvGuildInviteQuestion(selfguildIDguildName):
        
guildInviteQuestionDialog uiCommon.QuestionDialog()
        
guildInviteQuestionDialog.SetText(guildName locale.GUILD_DO_YOU_JOIN)
        
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUEself.AnswerGuildInvite(arg))
        
guildInviteQuestionDialog.SetCancelEvent(lambda arg=FALSEself.AnswerGuildInvite(arg))
        
guildInviteQuestionDialog.Open()
        
guildInviteQuestionDialog.guildID guildID
        self
.guildInviteQuestionDialog guildInviteQuestionDialog

    def AnswerGuildInvite
(selfanswer):

        if 
not self.guildInviteQuestionDialog:
            return

        
guildLeaderVID self.guildInviteQuestionDialog.guildID
        net
.SendGuildInviteAnswerPacket(guildLeaderVIDanswer)

        
self.guildInviteQuestionDialog.Close()
        
self.guildInviteQuestionDialog None

    
    def DeleteGuild
(self):
        
self.interface.DeleteGuild()

    
## Clock
    
def ShowClock(selfsecond):
        
self.interface.ShowClock(second)

    
def HideClock(self):
        
self.interface.HideClock()

    
## Emotion
    
def BINARY_ActEmotion(selfemotionIndex):
        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")

            (
succeededname) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"screenshot"+os.sep)
        
elif SCREENSHOT_DIR:
            (
succeededname) = grp.SaveScreenShot(SCREENSHOT_DIR)
        else:
            (
succeededname) = 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_INFOlocale.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_UPTRUE)

    
def MoveDown(self):
        
player.SetSingleDIKKeyState(app.DIK_DOWNTRUE)

    
def MoveLeft(self):
        
player.SetSingleDIKKeyState(app.DIK_LEFTTRUE)

    
def MoveRight(self):
        
player.SetSingleDIKKeyState(app.DIK_RIGHTTRUE)

    
def StopUp(self):
        
player.SetSingleDIKKeyState(app.DIK_UPFALSE)

    
def StopDown(self):
        
player.SetSingleDIKKeyState(app.DIK_DOWNFALSE)

    
def StopLeft(self):
        
player.SetSingleDIKKeyState(app.DIK_LEFTFALSE)

    
def StopRight(self):
        
player.SetSingleDIKKeyState(app.DIK_RIGHTFALSE)

    
def PickUpItem(self):
        
player.PickCloseItem()

    
###############################################################################################
    ###############################################################################################
    ## Event Handler

    
def OnKeyDown(selfkey):
        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
(selfkey):
        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_LEFTplayer.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(attachedTypeattachedItemCountself.PickingCharacterIndex)
                else:
                    
self.__PutItem(attachedTypeattachedItemIndexattachedItemSlotPosattachedItemCountself.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_LEFTplayer.MBS_CLICK)

        
#player.EndMouseWalking()
        
return TRUE

    def __PutItem
(selfattachedTypeattachedItemIndexattachedItemSlotPosattachedItemCountdstChrID):
        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_ITEM0locale.UI_OK)
            else:
                if 
chr.IsNPC(dstChrID):
                    
net.SendGiveItemPacket(dstChrIDattachedItemSlotPosattachedItemCount)
                else:
                    
net.SendExchangeStartPacket(dstChrID)
                    
net.SendExchangeItemAddPacket(attachedItemSlotPos0)
        else:
            
self.__DropItem(attachedTypeattachedItemIndexattachedItemSlotPosattachedItemCount)

    
def __PutMoney(selfattachedTypeattachedMoneydstChrID):
        if 
TRUE == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:
            
net.SendExchangeStartPacket(dstChrID)
            
net.SendExchangeElkAddPacket(attachedMoney)
        else:
            
self.__DropMoney(attachedTypeattachedMoney)

    
def __DropMoney(selfattachedTypeattachedMoney):
        
# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
        
if uiPrivateShopBuilder.IsBuildingPrivateShop():            
            
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.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_OVER0locale.UI_OK)
            return

        
itemDropQuestionDialog uiCommon.QuestionDialog()
        
itemDropQuestionDialog.SetText(locale.DO_YOU_DROP_MONEY % (attachedMoney))
        
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUEself.RequestDropItem(arg))
        
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSEself.RequestDropItem(arg))
        
itemDropQuestionDialog.Open()
        
itemDropQuestionDialog.dropType attachedType
        itemDropQuestionDialog
.dropCount attachedMoney
        itemDropQuestionDialog
.dropNumber player.ITEM_MONEY
        self
.itemDropQuestionDialog itemDropQuestionDialog

    def __DropItem
(selfattachedTypeattachedItemIndexattachedItemSlotPosattachedItemCount):
        
# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
        
if uiPrivateShopBuilder.IsBuildingPrivateShop():            
            
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.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_ITEM0locale.UI_OK)

        else:
            
dropItemIndex player.GetItemIndex(attachedItemSlotPos)

            
item.SelectItem(dropItemIndex)
            
dropItemName item.GetItemName()

            
## Question Text
            
questionText locale.HOW_MANY_ITEM_DO_YOU_DROP(dropItemNameattachedItemCount)

            
## Dialog
            
itemDropQuestionDialog uiCommon.QuestionDialog()
            
itemDropQuestionDialog.SetText(questionText)
            
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUEself.RequestDropItem(arg))
            
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSEself.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(selfanswer):
        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(dropNumberdropCount)
                    
# 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(selfitemVNumitemCount):
        if 
uiPrivateShopBuilder.IsBuildingPrivateShop():
            
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.DROP_ITEM_FAILURE_PRIVATE_SHOP)
            return

        
net.SendItemDropPacketNew(itemVNumitemCount)
    
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

    
def OnMouseRightButtonDown(self):

        
self.CheckFocus()

        if 
TRUE == mouseModule.mouseController.isAttached():
            
mouseModule.mouseController.DeattachObject()

        else:
            
player.SetMouseState(player.MBT_RIGHTplayer.MBS_PRESS)

        return 
TRUE

    def OnMouseRightButtonUp
(self):
        if 
TRUE == mouseModule.mouseController.isAttached():
            return 
TRUE

        player
.SetMouseState(player.MBT_RIGHTplayer.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 출력
        
(xyz) = player.GetMainCharacterPosition()
        
nUpdateTime app.GetUpdateTime()
        
nUpdateFPS app.GetUpdateFPS()
        
nRenderFPS app.GetRenderFPS()
        
nFaceCount app.GetFaceCount()
        
fFaceSpeed app.GetFaceSpeed()
        
nST=background.GetRenderShadowTime()
        (
fAveRTnCurRT) =  app.GetRenderTime()
        (
iNumfFogStartfFogEndfFarCilp) = background.GetDistanceSetInfo()
        (
iPatchiSplatfSplatRatiosTextureNum) = background.GetRenderedSplatNum()
        if 
iPatch == 0:
            
iPatch 1

        
#(dwRenderedThing, dwRenderedCRC) = background.GetRenderedGraphicThingInstanceNum()

        
self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (xyzapp.GetAvailableTextureMemory()/(1024*1024)))            

        
self.FrameRate.SetText("UFPS: %3d UT: %3d FS %.2f" % (nUpdateFPSnUpdateTimefFaceSpeed))

        if 
fAveRT>1.0:
            
self.Pitch.SetText("RFPS: %3d RT:%.2f(%3d) FC: %d(%.2f) " % (nRenderFPSfAveRTnCurRTnFaceCountnFaceCount/fAveRT))

        
self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatchiSplatfSplatRatio))
        
#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" % (iNumfFogStartfFogEndfFarCilp))

    
def OnRender(self):
        
app.RenderGame()
        
        if 
self.console.Console.collision:
            
background.RenderCollision()
            
chr.RenderCollision()

        (
xy) = app.GetCursorPosition()

        
########################
        # Picking
        ########################
        
textTail.UpdateAllTextTail()

        if 
TRUE == wndMgr.IsPickedWindow(self.hWnd):

            
self.PickingCharacterIndex chr.Pick()

            if -
!= self.PickingCharacterIndex:
                
textTail.ShowCharacterTextTail(self.PickingCharacterIndex)
            if 
!= self.targetBoard.GetTargetVID():
                
textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())

            
# ADD_ALWAYS_SHOW_NAME
            
if not self.__IsShowName():
                
self.PickingItemIndex item.Pick()
                if -
!= 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(xy)
        
# END_OF_ADD_ALWAYS_SHOW_NAME

        
textTail.UpdateShowingTextTail()
        
textTail.ArrangeTextTail()
        if -
!= 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(selfnamelovePoint):
        if 
self.interface.wndMessenger:
            
self.interface.wndMessenger.OnAddLover(namelovePoint)
        if 
self.affectShower:
            
self.affectShower.SetLoverInfo(namelovePoint)

    
def BINARY_UpdateLovePoint(selflovePoint):
        if 
self.interface.wndMessenger:
            
self.interface.wndMessenger.OnUpdateLovePoint(lovePoint)
        if 
self.affectShower:
            
self.affectShower.OnUpdateLovePoint(lovePoint)
    
# END_OF_WEDDING
    
    # QUEST_CONFIRM
    
def BINARY_OnQuestConfirm(selfmsgtimeoutpid):
        
confirmDialog uiCommon.QuestionDialogWithTimeLimit()
        
confirmDialog.Open(msgtimeout)
        
confirmDialog.SetAcceptEvent(lambda answer=TRUEpid=pidnet.SendQuestConfirmPacket(answerpid) or self.confirmDialog.Hide())
        
confirmDialog.SetCancelEvent(lambda answer=FALSEpid=pidnet.SendQuestConfirmPacket(answerpid) 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(selfitemVnumcount):
        print 
"큐브 제작 성공"
        
self.interface.SucceedCubeWork(itemVnumcount)
        
pass

    def BINARY_Cube_Failed
(self):
        print 
"큐브 제작 실패"
        
#self.PopupMessage(locale.CUBE_FAILURE)
        
pass

    
# END_OF_CUBE
    
    
def BINARY_SetBigMessage(selfmessage):
        
self.interface.bigBoard.SetTip(message)

    
def BINARY_SetTipMessage(selfmessage):
        
self.interface.tipBoard.SetTip(message)        

    
def BINARY_AppendNotifyMessage(selftype):
        if 
not type in locale.NOTIFY_MESSAGE:
            return
        
chat.AppendChat(chat.CHAT_TYPE_INFOlocale.NOTIFY_MESSAGE[type])

    
def BINARY_Guild_EnterGuildArea(selfareaID):
        
self.interface.BULID_EnterGuildArea(areaID)

    
def BINARY_Guild_ExitGuildArea(selfareaID):
        
self.interface.BULID_ExitGuildArea(areaID)

    
def BINARY_GuildWar_OnSendDeclare(selfguildID):
        
pass

    def BINARY_GuildWar_OnRecvDeclare
(selfguildIDwarType):
        
mainCharacterName player.GetMainCharacterName()
        
masterName guild.GetGuildMasterName()
        if 
mainCharacterName == masterName:
            
self.__GuildWar_OpenAskDialog(guildIDwarType)

    
def BINARY_GuildWar_OnRecvPoint(selfgainGuildIDopponentGuildIDpoint):
        
self.interface.OnRecvGuildWarPoint(gainGuildIDopponentGuildIDpoint)    

    
def BINARY_GuildWar_OnStart(selfguildSelfguildOpp):
        
self.interface.OnStartGuildWar(guildSelfguildOpp)

    
def BINARY_GuildWar_OnEnd(selfguildSelfguildOpp):
        
self.interface.OnEndGuildWar(guildSelfguildOpp)

    
def BINARY_BettingGuildWar_SetObserverMode(selfisEnable):
        
self.interface.BINARY_SetObserverMode(isEnable)

    
def BINARY_BettingGuildWar_UpdateObserverCount(selfobserverCount):
        
self.interface.wndMiniMap.UpdateObserverCount(observerCount)

    
def __GuildWar_UpdateMemberCount(selfguildID1memberCount1guildID2memberCount2observerCount):
        
guildID1 int(guildID1)
        
guildID2 int(guildID2)
        
memberCount1 int(memberCount1)
        
memberCount2 int(memberCount2)
        
observerCount int(observerCount)

        
self.interface.UpdateMemberCount(guildID1memberCount1guildID2memberCount2)
        
self.interface.wndMiniMap.UpdateObserverCount(observerCount)

    
def __GuildWar_OpenAskDialog(selfguildIDwarType):

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

        
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={
            
##KILLGUI
            
"ShowKillGui"            self.__showkillgui,
            
"HideKillGui"            self.__hidekillgui,
            
"KillBlauReich"            self.__KillBlauReich,
            
"KillGelbReich"            self.__KillGelbReich,
            
"KillRotReich"            self.__KillRotReich,
            
"KillMob"            self.__KillMob,
            
##END_KILLGUI
            
"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

            # NEW_EFFECTS
            
"buff1"                    self.__buff1,
            
"buff2"                    self.__buff2,
            
"buff3"                    self.__buff3,
            
"buff4"                    self.__buff4,
            
"pot1"                    self.__pot1,
            
"buff5"                    self.__buff5,
            
"buff6"                    self.__buff6,
            
# END_NEW_EFFECTS
        
}

        
self.serverCommander=stringCommander.Analyzer()
        for 
serverCommandItem in serverCommandList.items():
            
self.serverCommander.SAFE_RegisterCallBack(
                
serverCommandItem[0], serverCommandItem[1]
            )

    
def BINARY_ServerCommand_Run(selfline):
        
#dbg.TraceError(line)
        
try:
            
#print " BINARY_ServerCommand_Run", line
            
return self.serverCommander.Run(line)
        
except RuntimeErrormsg:
            
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 RuntimeErrormsg:
            
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(selfitemVNumitemPrice):
        
uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNumitemPrice)    
    
# END_OF_PRIVATE_SHOP_PRICE_LIST

    
def __Horse_HideState(self):
        
self.affectShower.SetHorseState(000)

    
def __Horse_UpdateState(selflevelhealthbattery):
        
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
(selfmode):

        
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(selfmode):
        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
(selfgrade):

        print 
"XMAS_TREE "grade
        background
.SetXMasTree(int(grade))

    
def __XMasSong_Enable(selfmode):
        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(selfvidtext):
        
self.interface.AppearPrivateShop(vidtext)

    
def BINARY_PrivateShop_Disappear(selfvid):
        
self.interface.DisappearPrivateShop(vid)

    
## DayMode
    
def __PRESERVE_DayMode_Update(selfmode):
        if 
"light"==mode:
            
background.SetEnvironmentData(0)
        
elif "dark"==mode:

            if 
not self.__IsXMasMap():
                return

            
background.RegisterEnvironmentData(1constInfo.ENVIRONMENT_NIGHT)
            
background.SetEnvironmentData(1)

    
def __DayMode_Update(selfmode):
        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(1constInfo.ENVIRONMENT_NIGHT)
        
background.SetEnvironmentData(1)
        
self.curtain.FadeIn()

    
## XMasBoom
    
def __XMasBoom_Update(self):

        
self.BOOM_DATA_LIST = ( (25), (52), (73), (103), (205) )
        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):
        
xyplayer.GetMainCharacterPosition()
        
randX app.GetRandom(-150150)
        
randY app.GetRandom(-150150)

        
snd.PlaySound3D(x+randX, -y+randYz"sound/common/etc/salute.mp3")

    
def __PartyRequestQuestion(selfvid):
        
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=TRUEself.__AnswerPartyRequest(arg))
        
partyRequestQuestionDialog.SetCancelEvent(lambda arg=FALSEself.__AnswerPartyRequest(arg))
        
partyRequestQuestionDialog.Open()
        
partyRequestQuestionDialog.vid vid
        self
.partyRequestQuestionDialog partyRequestQuestionDialog

    def __AnswerPartyRequest
(selfanswer):
        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(selfurl):
        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(selfflagfilename):
        
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

    # NEW_EFFECTS
    
def __buff1(self):
        
net.SendChatPacket("(buff1)")
    
def __buff2(self):
        
net.SendChatPacket("(buff2)")
    
def __buff3(self):
        
net.SendChatPacket("(buff3)")
    
def __buff4(self):
        
net.SendChatPacket("(buff4)")
    
def __pot1(self):
        
net.SendChatPacket("(pot1)")
    
def __buff5(self):
        
net.SendChatPacket("(buff5)")
    
def __buff6(self):
        
net.SendChatPacket("(buff6)")        
    
# END_NEW_EFFECTS

#Afk Mode
    
def __afk(self):
        if 
constInfo.AFK == 0:
            
constInfo.AFK 1
            self
.PopupMessage("Dein Status wurde auf Abwesend gesetzt")
        
elif constInfo.AFK == 1:
            
constInfo.AFK 0
            self
.PopupMessage("Du bist nichtmehr AFK")
#Afk Mode END

    
def __hidekillgui(self):
        
self.KillGuiBg.Hide()
        
self.KillBlauReich.Hide()
        
self.KillGelbReich.Hide()
        
self.KillRotReich.Hide()
        
self.KillMob.Hide()

    
def __showkillgui(self):
        if 
constInfo.killgui == 0:
            
constInfo.killgui 1
            self
.KillGuiBg.Show()
            
self.KillBlauReich.Show()
            
self.KillGelbReich.Show()
            
self.KillRotReich.Show()
            
self.KillMob.Show()
        
elif constInfo.killgui == 1:
            
constInfo.killgui 0
            self
.KillGuiBg.Hide()
            
self.KillBlauReich.Hide()
            
self.KillGelbReich.Hide()
            
self.KillRotReich.Hide()
            
self.KillMob.Hide()

    
def __KillBlauReich(selfKillBlauReich):
        
self.KillBlauReich.SetText("Blaues Reich:    " KillBlauReich)
    
    
def __KillGelbReich(selfKillGelbReich):
        
self.KillGelbReich.SetText("Gelbes Reich:    " KillGelbReich)
    
    
def __KillRotReich(selfKillRotReich):
        
self.KillRotReich.SetText("Rotes Reich:    " KillRotReich)
        
    
def __KillMob(selfKillMob):
        
self.KillMob.SetText("Monster:    " KillMob)

    
def __toggleSwitchbot(self):
        if 
self.switchbot.bot_shown == 1:
        
self.switchbot.Hide()
    else:
        
self.switchbot.Show() 
syserr
PHP Code:
0104 16:13:11543 :: CMapOutdoor::Load LoadMonsterAreaInfo ERROR
0104 16
:13:11831 :: GRANNYr:/granny/rt/granny_file_info.cpp(145): File has run-time type tag of 0x8000000fwhich doesn't match this version of Granny (0x80000010).  Automatic conversion will be attempted.
0104 16:13:11919 :: CMapOutdoor::LoadTerrain AreaProperty Read Error

0104 16:13:11919 ::  CArea::Load File Load metin2_map_safemap\001000\AreaData.txt ERROR
0104 16:13:11919 ::  CArea::Load File Load metin2_map_safemap\001000\AreaAmbienceData.txt ERROR
0104 16:13:11919 :: CMapOutdoor::LoadTerrain AreaProperty Read Error

0104 16:13:11919 ::  CArea::Load File Load metin2_map_safemap\000001\AreaData.txt ERROR
0104 16:13:11919 ::  CArea::Load File Load metin2_map_safemap\000001\AreaAmbienceData.txt ERROR
0104 16:13:11919 :: CMapOutdoor::LoadTerrain AreaProperty Read Error

0104 16:13:11919 ::  CArea::Load File Load metin2_map_safemap\001001\AreaData.txt ERROR
0104 16:13:11919 ::  CArea::Load File Load metin2_map_safemap\001001\AreaAmbienceData.txt ERROR
0104 16:13:15245 :: CPythonPlayer::SetItemData(dwSlotIndex=54, itemIndex=910) - Failed to item data

0104 16:13:15245 :: CPythonPlayer::SetItemData(dwSlotIndex=14, itemIndex=409) - Failed to item data

0104 16:13:15246 :: CPythonPlayer::SetItemData(dwSlotIndex=62, itemIndex=919) - Failed to item data

0104 16:13:15246 :: CPythonPlayer::SetItemData(dwSlotIndex=21, itemIndex=409) - Failed to item data

0104 16:13:15246 :: CPythonPlayer::SetItemData(dwSlotIndex=49, itemIndex=919) - Failed to item data

0104 16:13:15246 :: CPythonPlayer::SetItemData(dwSlotIndex=79, itemIndex=919) - Failed to item data

0104 16:13:15246 :: CPythonPlayer::SetItemData(dwSlotIndex=61, itemIndex=919) - Failed to item data

0104 16:13:15246 :: CPythonPlayer::SetItemData(dwSlotIndex=0, itemIndex=439) - Failed to item data

0104 16:13:15246 :: CPythonPlayer::SetItemData(dwSlotIndex=20, itemIndex=409) - Failed to item data

0104 16:13:15246 :: CPythonPlayer::SetItemData(dwSlotIndex=78, itemIndex=919) - Failed to item data

0104 16:13:16067 :: GRANNY: r:/granny/rt/granny_file_info.cpp(145): File has run-time type tag of 0x80000015, which doesn'
t match this version of Granny (0x80000010).  Automatic conversion will be attempted



The2MrMetin2 is offline  
Reply



« Previous Thread | Next Thread »

Similar Threads
[Switchbot]English Python Switchbot
Guten Morgen liebe Com. Da mir gerade ein bischen Langweilig ist und ich dies noch nirgends gesehen habe, dachte ich mir ich Übersetze den Python...
49 Replies - Metin2 Hacks, Bots, Cheats, Exploits & Macros
[Switchbot] Padmak switchbot v2.0
Hallo liebe Com. ich brauche eure hilfe... ich habe ein problem mit dem Padmak boni switcher... ich versuche mich zu regestrieren im bot aber es geht...
19 Replies - Metin2 PServer - Discussions / Questions
switchbot
hi leute , suche einen kostenlosen und funktionierenden switchbot für p-server . danke im vorraus :D p.s: wäre net wen ihr den...
3 Replies - Metin2 Main - Discussions / Questions
[Switchbot] Padmak switchbot v2.0
Hey Leute, ich hab ich 2 probleme ersten befürchte ich das, dass die falsche section ist 2. der funzt bei mir nicht richtig der bot und zwar ist mein...
3 Replies - Metin2 PServer - Discussions / Questions



All times are GMT +1. The time now is 05:07.


Powered by vBulletin®
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
SEO by vBSEO ©2011, Crawlability, Inc.

Support | Contact Us | FAQ | Advertising | Privacy Policy | Abuse
Copyright ©2017 elitepvpers All Rights Reserved.