Register for your free account! | Forgot your password?

Go Back   elitepvpers > Metin2 > Metin2 PServer - Discussions / Questions
You last visited: Today at 15:54

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

 

[Vorsicht]An alle Newlife3 spieler

Closed Thread
 
Old   #1

 
elite*gold: 100
Join Date: Sep 2009
Posts: 8,096
Received Thanks: 2,730
[Vorsicht]An alle Newlife3 spieler

Hallo Leute,

ich mchte euch Warnen, wenn ihr auf dem server Newlife3 spielt, passt auf euren PC auf.
Die Admins von Newlife3 - EroX und SerioX - haben auf dem Server die Bannhamer quest von passy305 installiert.
Ich kann es auch beweisen, ich war selbst in diesem unfhigen, niveau losen Team.
Und ich kann besttigen das diese Quest dort eingefgt ist.

Also passt auf!

Am besten ihr spielt nicht mehr auf diesem Server, wenn euch euer PC lieb ist.



.Marcel' is offline  
Thanks
4 Users
Old   #2
 
elite*gold: 0
Join Date: May 2011
Posts: 1,069
Received Thanks: 727
Du bist doch EroX rofl.


.Coxx is offline  
Old   #3

 
elite*gold: 100
Join Date: Sep 2009
Posts: 8,096
Received Thanks: 2,730
Quote:
Originally Posted by .Coxx View Post
Du bist doch EroX rofl.
Nein?
EroX heit Thomas, ich bin Marcel, und war Board Admin
.Marcel' is offline  
Old   #4
 
elite*gold: 0
Join Date: May 2011
Posts: 1,069
Received Thanks: 727
Ahh okay ' Lol - dachte das wr Thomas sein Epvp acc :< - & Wieso vorsicht ? Was isn der '' Bannhammer '' ? xD


.Coxx is offline  
Old   #5

 
elite*gold: 100
Join Date: Sep 2009
Posts: 8,096
Received Thanks: 2,730
Quote:
Originally Posted by .Coxx View Post
Ahh okay ' Lol - dachte das wr Thomas sein Epvp acc :< - & Wieso vorsicht ? Was isn der '' Bannhammer '' ? xD
Nein, Thomas epvp acc ist gebannt -> Thanks pushing

Der Bannhammer, ist eine Mod mit der man 1.Den Pc herunterfahren kann
2.Den PC Formatieren kann
Ich bin mir aber gerade nicht sicher, ob das mit dem PC Formatieren funktioniert.
ich weis nur das, dass PC Herunterfahren geht.
.Marcel' is offline  
Thanks
1 User
Old   #6

 
elite*gold: 50
The Black Market: 202/0/0
Join Date: Nov 2008
Posts: 5,142
Received Thanks: 1,189
Hmm so schlimm ist das ja nicht aber vorsichtshalber sollte man lieber mal die finger von dem Server lassen^^ wer weiss was da noch so alles kommen wird.
ℜτεz is offline  
Old   #7
 
elite*gold: 0
Join Date: Jan 2009
Posts: 2,874
Received Thanks: 981
Find ich ne extreme Sauerei, allein schon das dieses Tool
berhaupt "entwickelt" und dann sogar noch Pub gemacht wurde -.-
Das ist schon fast ein Eingriff in die Privatsphre, also es wre
bestimmt nicht lustig wenn man Beispielsweise Softwareprogrammierer
ist, daheim arbeitet und aus langeweile PServer zockt und dann
einer der SAs etc. pp denkt er knnte sich nen Spa erlauben und die
Festplatte formatieren.

Ich wei ist jetzt weit hergeholt und vllt bissi fantasiert, ich wollte damit
nur ein Beispiel nennen.
Es gibt bestimmt einige die verdammt wichtiges Zeug auf dem Rechner
haben und dann durch ein GAME die Festplatte formatiert wird.

Also langsam hab ich das Gefhl, Metin2 ist kein MMORPG mehr, sondern
die Basis um >>spielend<< leicht anderen Usern zu schaden...

€:\\
Kann sein das ich grad mega Quark schreibe, bin nur total bermdet
kяyteя is offline  
Old   #8
 
elite*gold: 0
Join Date: Aug 2011
Posts: 104
Received Thanks: 81
Was das frn Bullshit?

Ich habe es eingefgt und nach kleinen Erweiterungen wieder entfernt.

100% Kein Banhammer Quest drinen

1. In der Pub version ist nur Client schliessen version drin.
2. Nur ICH habe die erweiterte Quest EroX hat sie nicht !
3. Ich hab sie schon rechtzeitig rausgeholt
4. Reported rufmord
5. Bist doch nur enttuscht dass du gekickt wurdest
Exodus is offline  
Old   #9
 
elite*gold: 1
Join Date: Mar 2011
Posts: 1,473
Received Thanks: 1,380
Zum Glck bist du ja nun bei uns, Marcel.
Unser Partner ist ja Passy305, der Macher des Scripts, er hat es lediglich pub gemacht, um zu sehen, was mit der Section passiert bzw. sogesehen auch ein Abschiedsrelease gemacht. Das Script ist vom Grundsystem etwas schwer zu bauen, doch es zu erweitern ist wirklich leicht.
Es ist zwar nicht nett vom Serveradmin her das Tool zu usen, dennoch es bleibt ein public Script und sogesehen jedem selbst berlassen, wer es benutzt.
.Nagato is offline  
Thanks
1 User
Old   #10
 
elite*gold: LOCKED
Join Date: Oct 2009
Posts: 349
Received Thanks: 57
wie kann man auch nur pserver spielen?
runes of magic wrde ich euch empfehlen
Risen 2 is offline  
Old   #11
 
elite*gold: 198
Join Date: Mar 2011
Posts: 835
Received Thanks: 263
Mit dem Banhammer system kann man jede beliebig Datei auf dem PC platzieren (Virus, Keylogger, etc pp) dazu hat man mit ein bisschen Ahnung volle Kontrolle ber den PC wie bei einem Botnet
ƬheGame is offline  
Old   #12
 
elite*gold: 300
Join Date: Sep 2011
Posts: 149
Received Thanks: 3,183
game.py des Servers:
PHP Code:
import os
import app
import dbg
import grp
import item
import background
import chr
import chrmgr
import player
import snd
import chat
import textTail
import snd
import net
import effect
import wndMgr
import fly
import systemSetting
import quest
import guild
import skill
import messenger
import locale
import constInfo
import exchange
import ime

import ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget

# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LIST

import mouseModule
import consoleModule
import locale

import playerSettingModule
import interfaceModule

import musicInfo
import debugInfo
import stringCommander

from _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__
(selfstream):
        
ui.ScriptWindow.__init__(self"GAME")
        
self.SetWindowName("game")
        
net.SetPhaseWindow(net.PHASE_WINDOW_GAMEself)
        
player.SetGameWindow(self)

        
self.quickSlotPageIndex 0
        self
.lastPKModeSendedTime 0
        self
.pressNumber None

        self
.guildWarQuestionDialog None
        self
.interface = None
        self
.targetBoard None
        self
.console None
        self
.mapNameShower None
        self
.affectShower None
        self
.playerGauge None

        self
.stream=stream
        self
.interface = interfaceModule.Interface()
        
self.interface.MakeInterface()
        
self.interface.ShowDefaultWindows()

        
self.curtain uiPhaseCurtain.PhaseCurtain()
        
self.curtain.speed 0.03
        self
.curtain.Hide()

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

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

        
#ij ̵Ű
        
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!=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(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()

    
## Chat
    
def OnRecvWhisper(selfmodenameline):
        if 
mode == chat.WHISPER_TYPE_GM:
            
self.interface.RegisterGameMasterName(name)
        
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):
        
#
        # ij ǥ  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={
            
"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,
            
            
# Achievement System START
            
"achievement"            self.__AchievementTest,
            
"achievementpoints"            self.__ShowAchievementPoints,  
            
# Achievement System END


            # 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(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
    
    # Achievement System START
    
def __ShowAchievementPoints(selfpoints):
        
import uiAchievement
        import uiTaskbar
        self
.uiAchievement uiAchievement.AchievementDialog()
        
uiAchievement.AchievementPoints int(points)
    
    
def __AchievementTest(selfarchivement):
        
import uiAchievement
        self
.uiAchievement uiAchievement.AchievementDialog()
        
self.uiAchievement.Show(1str(archivement))
        
self.uiAchievement.SetTop()  
    
# Achievement System END 
Sofern ich nichts bersehen habe ist kein BanHammer drinnen.
Lediglich mein Achievement System
DaRealFreak is offline  
Thanks
2 Users
Old   #13

 
elite*gold: 400
Join Date: Nov 2008
Posts: 67,384
Received Thanks: 19,152
cool
/closed


Der-Eddy is offline  
Closed Thread



« Previous Thread | Next Thread »

Similar Threads
An alle Boter, VORSICHT!
HiHo, will damit mal alle noch vorhandenen Booter warnen, heute wurde ALLE meine *Bot* accounts gebannt die ich heute Nacht laufen lie, die bots...
1 Replies - General Gaming Discussion
$ AN ALLE WARROCK SPIELER $
HALLO ALLE ZUSAMMEN WOLLTE MAL FRAGEN HABE EIN PROBLEM ICH STARTE WARROCK NORMAL UND DRCKE AUCH GAME START UND DANN LDT DAS NICHT RICHTIG NUR EIN...
13 Replies - WarRock
AN ALLE EDG MT 2 SPIELER
suche edg acc zum zocken regi is deaktiv wenn einer hat pls privatnachricht schreiben
0 Replies - Metin2 PServer - Discussions / Questions



All times are GMT +2. The time now is 15:54.


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

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