[How To]Fischkiller scripten

LuckyTabak · 09/10/2010, 11:19

Hi,
Ich will euch hier zeigen wie ihr einen Fischkiller scriptet.

Schritt 1. Root entpacken[Epk,Eix]
Schritt 2. game.py öffnen
Schritt 3. Hotkey festlegen->

Quote:

onPressKeyDict[app.DIK_X] = lambda : self.Fischkiller()

Schritt 4. Die Funktion dazu:

PHP Code:



def Fischkiller(self): 
        SLOT_COUNT = 90 
        for eachSlot in xrange(SLOT_COUNT): 
        itemVNum = player.GetItemIndex(eachSlot) 
        if itemVNum == 27803: 
        net.SendItemUsePacket(eachSlot)

Die 27803 ist jetzt ein Zander wenn ihr mehr Fische killen wollt müsst ihr immer ein

PHP Code:



or itemVnum == 00000

mach der Value eintragen
Natürlich die 000000 durch eure Fischvalue ersetzen.

PHP Code:



if itemVNum >= 27803 and itemVNum <= 27823:

Von 27803 bis Value also könnt ihr es durch eure Value ersetzen dann killt er alle Fische von 27803 bis zu eurer Value[Thx an Renozeros
Speichert es ab und ihr könnt Ingame mit der taste L die Fische killen

@DaRkFoRgE™®

Quote:

Was du immer mit deiner Game.py hast ö.Ö

Dort wird eigentlich fast alles festgelegt was im Game passiert.
Man kann aber auch ne Extra Py Datei dafür machen und in fischkiller.py z.b import game schreiben

DaaRkk · 09/10/2010, 11:21

Was du immer mit deiner Game.py hast ö.Ö

BrokenSoul :3 · 09/10/2010, 11:21

Hilft bestimmt vielen weiter.

Hermes2012 · 09/10/2010, 11:34

hab schon ein fishbuyer und killer kann ich ja pub machen

.xeonBSD · 09/10/2010, 11:54

very nice . weiter so!

Hermes2012 · 09/10/2010, 12:16

jo lol kannst wie ich j aversuchen einen fischbuyer zu scripten

~~'Haseo~~ · 09/10/2010, 13:59

ist doch voll leicht zu scripten aber naja so viele die sich mit python auskennen scheint es hier nicht zu geben weil das dann schon viel mehr gemacht hätten!

Hermes2012 · 09/10/2010, 15:38

Naja das scripten geht weil ich mein es könne leicht fehler enstehen p.s bin grade dabei ein ingame gm-tool zu machen

~~Perfection-~~ · 09/10/2010, 15:58

gutes tut kann man in manchen situationen gebrauchen

~~Prσfizσcker94~~ · 09/10/2010, 20:03

Quote:

Originally Posted by ℓσℓ

Hi,
Ich will euch hier zeigen wie ihr einen Fischkiller scriptet.

Schritt 1. Root entpacken[Epk,Eix]
Schritt 2. game.py öffnen
Schritt 3. Hotkey festlegen->
Schritt 4. Die Funktion dazu:

PHP Code:

def Fischkiller(self): SLOT_COUNT = 90 for eachSlot in xrange(SLOT_COUNT): itemVNum = player.GetItemIndex(eachSlot) if itemVNum == 27803: net.SendItemUsePacket(eachSlot)

Die 27803 ist jetzt ein Zander wenn ihr mehr Fische killen wollt müsst ihr immer ein

PHP Code:

or itemVnum == 00000

mach der Value eintragen
Natürlich die 000000 durch eure Fischvalue ersetzen.
Speichert es ab und ihr könnt Ingame mit der taste L die Fische killen

@DaRkFoRgE™®

Dort wird eigentlich fast alles festgelegt was im Game passiert.
Man kann aber auch ne Extra Py Datei dafür machen und in fischkiller.py z.b import game schreiben

Sehr geil was du in letzter Zeit so pub machst, weiter so

Hermes2012 · 09/10/2010, 22:04

@Edit

Bei mir geht der nicht in der syserr wird folgender fehler angezeigt

Quote:

0910 22:41:19819 ::
0910 22:41:19819 :: itemVNum = shop.GetItemID(eachSlot)

0910 22:41:19819 ::
0910 22:41:19819 ::
0910 22:41:19819 ::
0910 22:41:19819 ::
0910 22:41:19819 ::
0910 22:41:19819 ::
0910 22:41:19819 ::
0910 22:41:19820 ::
0910 22:41:19820 :: ^

0910 22:41:19820 :: IndentationError
0910 22:41:19820 :: :
0910 22:41:19820 :: expected an indented block
0910 22:41:19820 ::

Habe kamer meine Game.py geschickt er wusste auch nicht wo der fehler lag

dfish · 09/10/2010, 23:45

laut fehlermeldung scheint die einrückung nicht zu stimmen. ggf. hast du leerzeichen anstatt tabs benutzt?

Hermes2012 · 09/10/2010, 23:59

was meinste mit tabs?

Renozerus · 09/11/2010, 02:32

anstatt -->
if itemVNum == 27803 or itemVNum == 00000 or itemVNum == 00000:
usw....
kann man auch bei den Fischen das ganze so schreiben-->
if itemVNum >= 27803 and itemVNum <= 27823:
größer oder gleich als/wie vnum 27803 und kleiner oder gleich als/wie vnum 27823
nun sind alle VNum von 27803 bis 27823 mit einbezogen.

so sollte das dann aussehen:

Code:

def Fischkiller(self):
     SLOT_COUNT = 90
     for eachSlot in xrange(SLOT_COUNT):
             itemVNum = player.GetItemIndex(eachSlot)
             if itemVNum >= 27803 and itemVNum <= 27823:
                   net.SendItemUsePacket(eachSlot)

allgemein kann man mit dieser Funktion viel anstellen. KaMeR war es mal wieder von dem der Baustein stammt.

sitze nun an v1.1 und v1.2 bekommt dann ganz andere Optionen

Spoiler

hier noch ein Tipp macht euch noch einen weiteren Hotkey und dann könnt Ihr hiermit den ganzen Müll rauswerfen-->

Code:

def Rauswerfen(self):
      SLOT_COUNT = 90
      for eachSlot in xrange(SLOT_COUNT):
              itemVNum = player.GetItemIndex(eachSlot)
              if itemVNum == 27990 or itemVNum == 27799 or itemVNum == 27802 or itemVNum >= 27833 and itemVNum <= 27853:
                    net.SendItemDropPacket(eachSlot)

wirft Steinstücke, Gräten, tote Fische und kleine Fische raus wer möchte kann sich noch Würmer hinzufügen aber die kommen sehr selten. Das Inventar ist vorher voll und man hat nichtmal 50 Würmer. Der Platz ist dann ganz hilfreich für ein Bündel zum Beispiel.

Das ganze wäre auch brauchbar für die Eventhelferin aber das habe ich nicht gesagt...

Hermes2012 · 09/11/2010, 08:22

hammer danke die gui dazu ist einfach habe schon meine eigene Ingame GM-Tool Gui aber die befehle klappen nciht so

@Edit man das ganze klappt überhaupt nicht

Hier meine Game.py Habs rot Makiert

Spoiler

Quote:

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 game

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

from _weakref import proxy

# TEXTTAIL_LIVINGTIME_CONTROL
if locale.IsJAPAN():
app.SetTextTailLivingTime(8.0)
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL
app.SetTextTailLivingTime(0.5)
# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = FALSE

if locale.IsEUROPE():
SCREENSHOT_CWDSAVE = TRUE
# END_OF_SCREENSHOT_CWDSAVE

cameraDistance = 1550.0
cameraPitch = 27.0
cameraRotation = 0.0
cameraHeight = 100.0

testAlignment = 0

class GameWindow(ui.ScriptWindow):
canQuestLettersShow = 1
def __init__(self, stream):
ui.ScriptWindow.__init__(self, "GAME")
self.SetWindowName("game")
net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
player.SetGameWindow(self)

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

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

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

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

self.targetBoard = uiTarget.TargetBoard()
self.targetBoard.SetWhisperEvent(ui.__mem_func__(s elf.interface.OpenWhisperDialog))
self.targetBoard.Hide()

self.console = consoleModule.ConsoleWindow()
self.console.BindGameClass(self)
self.console.SetConsoleSize(wndMgr.GetScreenWidth( ), 200)
self.console.Hide()

self.mapNameShower = uiMapNameShower.MapNameShower()
self.affectShower = uiAffectShower.AffectShower()

self.playerGauge = uiPlayerGauge.PlayerGauge(self)
self.playerGauge.Hide()

self.__SetQuickSlotMode()

self.__ServerCommand_Build()
self.__ProcessPreservedServerCommand()

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

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

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

self.quickSlotPageIndex = 0
self.PickingCharacterIndex = -1
self.PickingItemIndex = -1
self.consoleEnable = FALSE
self.isShowDebugInfo = FALSE
self.ShowNameFlag = FALSE

self.enableXMasBoom = FALSE
self.startTimeXMasBoom = 0.0
self.indexXMasBoom = 0

global cameraDistance, cameraPitch, cameraRotation, cameraHeight

app.SetCamera(cameraDistance, cameraPitch, cameraRotation, cameraHeight)

constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()
constInfo.SET_DEFAULT_CHRNAME_COLOR()
constInfo.SET_DEFAULT_FOG_LEVEL()
constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENAB LE()
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)

ui.EnablePaste(TRUE)

if constInfo.PVPMODE_TEST_ENABLE:
self.testPKMode = ui.TextLine()
self.testPKMode.SetFontName(locale.UI_DEF_FONT)
self.testPKMode.SetPosition(0, 15)
self.testPKMode.SetWindowHorizontalAlignCenter()
self.testPKMode.SetHorizontalAlignCenter()
self.testPKMode.SetFeather()
self.testPKMode.SetOutline()
self.testPKMode.Show()

self.testAlignment = ui.TextLine()
self.testAlignment.SetFontName(locale.UI_DEF_FONT)
self.testAlignment.SetPosition(0, 35)
self.testAlignment.SetWindowHorizontalAlignCenter( )
self.testAlignment.SetHorizontalAlignCenter()
self.testAlignment.SetFeather()
self.testAlignment.SetOutline()
self.testAlignment.Show()

self.__BuildKeyDict()
self.__BuildDebugInfo()

# PRIVATE_SHOP_PRICE_LIST
uiPrivateShopBuilder.Clear()
# END_OF_PRIVATE_SHOP_PRICE_LIST

# UNKNOWN_UPDATE
exchange.InitTrading()
# END_OF_UNKNOWN_UPDATE

if debugInfo.IsDebugMode():
self.ToggleDebugInfo()

## Sound
snd.SetMusicVolumef(systemSetting.GetMusicVolume() *net.GetFieldMusicVolume())
snd.SetSoundVolume(systemSetting.GetSoundVolume())

netFieldMusicFileName = net.GetFieldMusicFileName()
if netFieldMusicFileName:
snd.FadeInMusic("BGM/" + netFieldMusicFileName)
elif musicInfo.fieldMusic != "":
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)

self.__SetQuickSlotMode()
self.__SelectQuickPage(self.quickSlotPageIndex)

self.SetFocus()
self.Show()
app.ShowCursor()

net.SendEnterGamePacket()

# START_GAME_ERROR_EXIT
try:
self.StartGame()
except:
import exception
exception.Abort("GameWindow.Open")
# END_OF_START_GAME_ERROR_EXIT

def Close(self):
self.Hide()

global cameraDistance, cameraPitch, cameraRotation, cameraHeight
(cameraDistance, cameraPitch, cameraRotation, cameraHeight) = app.GetCamera()

if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)

self.onPressKeyDict = None
self.onClickKeyDict = None

chat.Close()
snd.StopAllSound()
grp.InitScreenEffect()
chr.Destroy()
textTail.Clear()
quest.Clear()
background.Destroy()
guild.Destroy()
messenger.Destroy()
skill.ClearSkillData()
wndMgr.Unlock()
mouseModule.mouseController.DeattachObject()

if self.guildWarQuestionDialog:
self.guildWarQuestionDialog.Close()

self.guildNameBoard = None
self.partyRequestQuestionDialog = None
self.partyInviteQuestionDialog = None
self.guildInviteQuestionDialog = None
self.guildWarQuestionDialog = None
self.messengerAddFriendQuestion = None

# UNKNOWN_UPDATE
self.itemDropQuestionDialog = None
# END_OF_UNKNOWN_UPDATE

# QUEST_CONFIRM
self.confirmDialog = None
# END_OF_QUEST_CONFIRM

self.PrintCoord = None
self.FrameRate = None
self.Pitch = None
self.Splat = None
self.TextureNum = None
self.ObjectNum = None
self.ViewDistance = None

self.ClearDictionary()

self.playerGauge = None
self.mapNameShower = None
self.affectShower = None

if self.console:
self.console.BindGameClass(0)
self.console.Close()
self.console=None

if self.targetBoard:
self.targetBoard.Destroy()
self.targetBoard = None

if self.interface:
self.interface.HideAllWindows()
self.interface.Close()
self.interface=None

player.ClearSkillDict()
player.ResetCameraRotation()

self.KillFocus()
app.HideCursor()

print "---------------------------------------------------------------------------- CLOSE GAME WINDOW"

def __BuildKeyDict(self):
import linecache
onPressKeyDict = {}

##PressKey ´Â ´©¸£°í ÀÖ´Â µ¿¾È °è¼Ó Àû¿ëµÇ´Â Å°ÀÌ´Ù.

## ¼ýÀÚ ´ÜÃàÅ° Äü½½·Ô¿¡ ÀÌ¿ëµÈ´Ù.(ÀÌÈÄ ¼ýÀÚµéµµ Äü ½½·Ô¿ë ¿¹¾à)
## F12 ´Â Å¬¶ó µð¹ö±×¿ë Å°ÀÌ¹Ç·Î ¾²Áö ¾Ê´Â °Ô ÁÁ´Ù.
onPressKeyDict[app.DIK_1] = lambda : self.__PressNumKey(1)
onPressKeyDict[app.DIK_2] = lambda : self.__PressNumKey(2)
onPressKeyDict[app.DIK_3] = lambda : self.__PressNumKey(3)
onPressKeyDict[app.DIK_4] = lambda : self.__PressNumKey(4)
onPressKeyDict[app.DIK_5] = lambda : self.__PressNumKey(5)
onPressKeyDict[app.DIK_6] = lambda : self.__PressNumKey(6)
onPressKeyDict[app.DIK_7] = lambda : self.__PressNumKey(7)
onPressKeyDict[app.DIK_8] = lambda : self.__PressNumKey(8)
onPressKeyDict[app.DIK_9] = lambda : self.__PressNumKey(9)
onPressKeyDict[app.DIK_F1] = lambda : self.__PressQuickSlot(4)
onPressKeyDict[app.DIK_F2] = lambda : self.__PressQuickSlot(5)
onPressKeyDict[app.DIK_F3] = lambda : self.__PressQuickSlot(6)
onPressKeyDict[app.DIK_F4] = lambda : self.__PressQuickSlot(7)
onPressKeyDict[app.DIK_F5] = lambda : self.__PressF5Key()
onPressKeyDict[app.DIK_F9] = lambda : self.Rauswerfen()
onPressKeyDict[app.DIK_F8] = lambda : self.Fischkiller()
onPressKeyDict[app.DIK_F7] = lambda : self.Fishbuyer()

onPressKeyDict[app.DIK_LALT] = lambda : self.ShowName()
onPressKeyDict[app.DIK_LCONTROL] = lambda : self.ShowMouseImage()
onPressKeyDict[app.DIK_SYSRQ] = lambda : self.SaveScreen()
onPressKeyDict[app.DIK_SPACE] = lambda : self.StartAttack()

#Ä³¸¯ÅÍ ÀÌµ¿Å°
onPressKeyDict[app.DIK_UP] = lambda : self.MoveUp()
onPressKeyDict[app.DIK_DOWN] = lambda : self.MoveDown()
onPressKeyDict[app.DIK_LEFT] = lambda : self.MoveLeft()
onPressKeyDict[app.DIK_RIGHT] = lambda : self.MoveRight()
onPressKeyDict[app.DIK_W] = lambda : self.MoveUp()
onPressKeyDict[app.DIK_S] = lambda : self.MoveDown()
onPressKeyDict[app.DIK_A] = lambda : self.MoveLeft()
onPressKeyDict[app.DIK_D] = lambda : self.MoveRight()

onPressKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_TO_NEGATIVE)
#onPressKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_G] = self.__PressGKey
onPressKeyDict[app.DIK_Q] = self.__PressQKey

onPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()
onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()
onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()
onPressKeyDict[app.DIK_C] = lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_V] = lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)
#onPressKeyDict[app.DIK_B] = lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_N] = lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()
onPressKeyDict[app.DIK_M] = lambda : self.interface.PressMKey()
#onPressKeyDict[app.DIK_H] = lambda : self.interface.OpenHelpWindow()
onPressKeyDict[app.DIK_ADD] = lambda : self.interface.MiniMapScaleUp()
onPressKeyDict[app.DIK_SUBTRACT] = lambda : self.interface.MiniMapScaleDown()
#onPressKeyDict[app.DIK_O] = lambda : self.ToggleDebugInfo()
onPressKeyDict[app.DIK_P] = lambda : self.ShowClock()
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_H] = lambda : self.__PressHKey()
onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()
onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()

# CUBE_TEST
#onPressKeyDict[app.DIK_K] = lambda : self.interface.OpenCubeWindow()
# CUBE_TEST_END

self.onPressKeyDict = onPressKeyDict

onClickKeyDict = {}
onClickKeyDict[app.DIK_UP] = lambda : self.StopUp()
onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()
onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()
onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()

onClickKeyDict[app.DIK_W] = lambda : self.StopUp()
onClickKeyDict[app.DIK_S] = lambda : self.StopDown()
onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_D] = lambda : self.StopRight()
onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_G] = lambda: app.PitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_LALT] = lambda: self.HideName()
onClickKeyDict[app.DIK_LCONTROL] = lambda: self.HideMouseImage()
onClickKeyDict[app.DIK_LSHIFT] = lambda: self.__SetQuickSlotMode()

#if constInfo.PVPMODE_ACCELKEY_ENABLE:
# onClickKeyDict[app.DIK_B] = lambda: self.ChangePKMode()

self.onClickKeyDict=onClickKeyDict

def __PressNumKey(self,num):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):

if num >= 1 and num <= 9:
if(chrmgr.IsPossibleEmoticon(-1)):
chrmgr.SetEmoticon(-1,int(num)-1)
net.SendEmoticon(int(num)-1)
else:
if num >= 1 and num <= 4:
self.pressNumber(num-1)

def __ClickBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
return
else:
if constInfo.PVPMODE_ACCELKEY_ENABLE:
self.ChangePKMode()

def __PressHKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_ride")

def __PressPKey(self):
if app.IsPressed(app.DIK_P):
self.minimap.Show()

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 __PressF5Key(self):
self.console.OpenWindow()

def __PressGKey(self):
if self.ShowNameFlag:
self.interface.ToggleGuildWindow()
else:
app.PitchCamera(app.CAMERA_TO_POSITIVE)

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.__PressQuick Slot)

def __SetQuickPageMode(self):
self.pressNumber=ui.__mem_func__(self.__SelectQuic kPage)

def __PressQuickSlot(self, localSlotIndex):
player.RequestUseLocalQuickSlot(localSlotIndex)

def __SelectQuickPage(self, pageIndex):
self.quickSlotPageIndex = pageIndex
player.SetQuickPage(pageIndex)

def ToggleDebugInfo(self):
self.isShowDebugInfo = not self.isShowDebugInfo

if self.isShowDebugInfo:
self.PrintCoord.Show()
self.FrameRate.Show()
self.Pitch.Show()
self.Splat.Show()
self.TextureNum.Show()
self.ObjectNum.Show()
self.ViewDistance.Show()
else:
self.PrintCoord.Hide()
self.FrameRate.Hide()
self.Pitch.Hide()
self.Splat.Hide()
self.TextureNum.Hide()
self.ObjectNum.Hide()
self.ViewDistance.Hide()

def __BuildDebugInfo(self):
## Character Position Coordinate
self.PrintCoord = ui.TextLine()
self.PrintCoord.SetFontName(locale.UI_DEF_FONT)
self.PrintCoord.SetPosition(wndMgr.GetScreenWidth( ) - 270, 0)

## Frame Rate
self.FrameRate = ui.TextLine()
self.FrameRate.SetFontName(locale.UI_DEF_FONT)
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20)

## Camera Pitch
self.Pitch = ui.TextLine()
self.Pitch.SetFontName(locale.UI_DEF_FONT)
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40)

## Splat
self.Splat = ui.TextLine()
self.Splat.SetFontName(locale.UI_DEF_FONT)
self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60)

# TextureNum
self.TextureNum = ui.TextLine()
self.TextureNum.SetFontName(locale.UI_DEF_FONT)
self.TextureNum.SetPosition(wndMgr.GetScreenWidth( ) - 270, 80)

# ¿ÀºêÁ§Æ® ±×¸®´Â °³¼ö
self.ObjectNum = ui.TextLine()
self.ObjectNum.SetFontName(locale.UI_DEF_FONT)
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)

# ½Ã¾ß°Å¸®
self.ViewDistance = ui.TextLine()
self.ViewDistance.SetFontName(locale.UI_DEF_FONT)
self.ViewDistance.SetPosition(0, 0)

def __NotifyError(self, msg):
chat.AppendChat(chat.CHAT_TYPE_INFO, msg)

def ChangePKMode(self):

if not app.IsPressed(app.DIK_LCONTROL):
return

if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_P ROTECTED_LEVEL:
self.__NotifyError(locale.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
return

curTime = app.GetTime()
if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:
return

self.lastPKModeSendedTime = curTime

curPKMode = player.GetPKMode()
nextPKMode = curPKMode + 1
if nextPKMode == player.PK_MODE_PROTECT:
if 0 == player.GetGuildID():
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.OPTION_PVPMODE_CANNOT_SET_GUILD_MODE)
nextPKMode = 0
else:
nextPKMode = player.PK_MODE_GUILD

elif nextPKMode == player.PK_MODE_MAX_NUM:
nextPKMode = 0

net.SendChatPacket("/PKMode " + str(nextPKMode))
print "/PKMode " + str(nextPKMode)

def OnChangePKMode(self):

self.interface.OnChangePKMode()

try:
self.__NotifyError(locale.OPTION_PVPMODE_MESSAGE_D ICT[player.GetPKMode()])
except KeyError:
print "UNKNOWN PVPMode[%d]" % (player.GetPKMode())

if constInfo.PVPMODE_TEST_ENABLE:
curPKMode = player.GetPKMode()
alignment, grade = chr.testGetPKData()
self.pkModeNameDict = { 0 : "PEACE", 1 : "REVENGE", 2 : "FREE", 3 : "PROTECT", }
self.testPKMode.SetText("Current PK Mode : " + self.pkModeNameDict.get(curPKMode, "UNKNOWN"))
self.testAlignment.SetText("Current Alignment : " + str(alignment) + " (" + locale.TITLE_NAME_LIST[grade] + ")")

################################################## #############################################
################################################## #############################################
## Game Callback Functions

# Start
def StartGame(self):
self.RefreshInventory()
self.RefreshEquipment()
self.RefreshCharacter()
self.RefreshSkill()

# Refresh
def CheckGameButton(self):
if self.interface:
self.interface.CheckGameButton()

def RefreshAlignment(self):
self.interface.RefreshAlignment()

def RefreshStatus(self):
self.CheckGameButton()

if self.interface:
self.interface.RefreshStatus()

if self.playerGauge:
self.playerGauge.RefreshGauge()

def RefreshStamina(self):
self.interface.RefreshStamina()

def RefreshSkill(self):
self.CheckGameButton()
if self.interface:
self.interface.RefreshSkill()

def RefreshQuest(self):
self.interface.RefreshQuest()

def RefreshMessenger(self):
self.interface.RefreshMessenger()

def RefreshGuildInfoPage(self):
self.interface.RefreshGuildInfoPage()

def RefreshGuildBoardPage(self):
self.interface.RefreshGuildBoardPage()

def RefreshGuildMemberPage(self):
self.interface.RefreshGuildMemberPage()

def RefreshGuildMemberPageGradeComboBox(self):
self.interface.RefreshGuildMemberPageGradeComboBox ()

def RefreshGuildSkillPage(self):
self.interface.RefreshGuildSkillPage()

def RefreshGuildGradePage(self):
self.interface.RefreshGuildGradePage()

def RefreshMobile(self):
if self.interface:
self.interface.RefreshMobile()

def OnMobileAuthority(self):
self.interface.OnMobileAuthority()

def OnBlockMode(self, mode):
self.interface.OnBlockMode(mode)

def OpenQuestWindow(self, skin, idx):
self.interface.OpenQuestWindow(skin, idx)

def AskGuildName(self):

guildNameBoard = uiCommon.InputDialog()
guildNameBoard.SetTitle(locale.GUILD_NAME)
guildNameBoard.SetAcceptEvent(ui.__mem_func__(self .ConfirmGuildName))
guildNameBoard.SetCancelEvent(ui.__mem_func__(self .CancelGuildName))
guildNameBoard.Open()

self.guildNameBoard = guildNameBoard

def ConfirmGuildName(self):
guildName = self.guildNameBoard.GetText()
if not guildName:
return

if net.IsInsultIn(guildName):
self.PopupMessage(locale.GUILD_CREATE_ERROR_INSULT _NAME)
return

net.SendAnswerMakeGuildPacket(guildName)
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE

def CancelGuildName(self):
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE

## Refine
def PopupMessage(self, msg):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(msg, 0, locale.UI_OK)

def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, type=0):
self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, type)

def AppendMaterialToRefineDialog(self, vnum, count):
self.interface.AppendMaterialToRefineDialog(vnum, count)

def RunUseSkillEvent(self, slotIndex, coolTime):
self.interface.OnUseSkill(slotIndex, coolTime)

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

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

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

# UNKNOWN_UPDATE
def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)

def BINARY_NEW_RemoveAffect(self, type, pointIdx):
self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)
# END_OF_UNKNOWN_UPDATE

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

def DeactivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnDeactivateSkill(slotIndex)

def RefreshEquipment(self):
if self.interface:
self.interface.RefreshInventory()

def RefreshInventory(self):
if self.interface:
self.interface.RefreshInventory()

def RefreshCharacter(self):
if self.interface:
self.interface.RefreshCharacter()

def OnGameOver(self):
self.CloseTargetBoard()
self.OpenRestartDialog()

def OpenRestartDialog(self):
self.interface.OpenRestartDialog()

def ChangeCurrentSkill(self, skillSlotNumber):
self.interface.OnChangeCurrentSkill(skillSlotNumbe r)

## TargetBoard
def SetPCTargetBoard(self, vid, name):
self.targetBoard.Open(vid, name)

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

def RefreshTargetBoardByName(self, name):
self.targetBoard.RefreshByName(name)

def __RefreshTargetBoard(self):
self.targetBoard.Refresh()

def SetHPTargetBoard(self, vid, hpPercentage):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)

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

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

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

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

def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count)

def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value)

def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value)

# SHOW_LOCAL_MAP_NAME
def ShowMapName(self, mapName, x, y):

if self.mapNameShower:
self.mapNameShower.ShowMapName(mapName, x, y)

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

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

## Chat
def OnRecvWhisper(self, name, line):
chat.AppendWhisper(chat.WHISPER_TYPE_CHAT, name, line)
self.interface.RecvWhisper(name)

def OnRecvWhisperSystemMessage(self, name, line):
chat.AppendWhisper(chat.WHISPER_TYPE_INFO, name, line)
self.interface.RecvWhisper(name)

def OnRecvWhisperError(self, mode, name):
if locale.WHISPER_ERROR.has_key(mode):
chat.AppendWhisper(chat.WHISPER_TYPE_INFO, name, locale.WHISPER_ERROR[mode](name))
else:
chat.AppendWhisper(chat.WHISPER_TYPE_INFO, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))

self.interface.RecvWhisper(name)

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

def OnPickMoney(self, money):
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GAME_PICK_MONEY % (money))

def OnShopError(self, type):
try:
self.PopupMessage(locale.SHOP_ERROR_DICT[type])
except KeyError:
self.PopupMessage(locale.SHOP_ERROR_UNKNOWN % (type))

def OnSafeBoxError(self):
self.PopupMessage(locale.SAFEBOX_ERROR)

def OnFishingSuccess(self, isFish, fishName):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, locale.FISHING_SUCCESS(isFish, fishName), 2000)

# ADD_FISHING_MESSAGE
def OnFishingNotifyUnknown(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_UNKNOWN)

def OnFishingWrongPlace(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_WRONG_PLACE)
# END_OF_ADD_FISHING_MESSAGE

def OnFishingNotify(self, isFish, fishName):
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_NOTIFY(isFish, fishName))

def OnFishingFailure(self):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, locale.FISHING_FAILURE, 2000)

def OnCannotPickItem(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GAME_CANNOT_PICK_ITEM)

# MINING
def OnCannotMining(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GAME_CANNOT_MINING)
# END_OF_MINING

def OnCannotUseSkill(self, vid, type):
if locale.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
textTail.RegisterInfoTail(vid, locale.USE_SKILL_ERROR_TAIL_DICT[type])

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

def OnCannotShotError(self, vid, type):
textTail.RegisterInfoTail(vid, locale.SHOT_ERROR_TAIL_DICT.get(type, locale.SHOT_ERROR_UNKNOWN % (type)))

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

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

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

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

def SetShopSellingPrice(self, Price):
pass

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

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

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

## Party
def RecvPartyInviteQuestion(self, leaderVID, leaderName):
partyInviteQuestionDialog = uiCommon.QuestionDialog()
partyInviteQuestionDialog.SetText(leaderName + locale.PARTY_DO_YOU_JOIN)
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.Open()
partyInviteQuestionDialog.partyLeaderVID = leaderVID
self.partyInviteQuestionDialog = partyInviteQuestionDialog

def AnswerPartyInvite(self, answer):

if not self.partyInviteQuestionDialog:
return

partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

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

net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

self.partyInviteQuestionDialog.Close()
self.partyInviteQuestionDialog = None

def AddPartyMember(self, pid, name):
self.interface.AddPartyMember(pid, name)

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

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

def LinkPartyMember(self, pid, vid):
self.interface.LinkPartyMember(pid, vid)

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

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

def ExitParty(self):
self.interface.ExitParty()
self.RefreshTargetBoardByVID(self.targetBoard.GetT argetVID())

def ChangePartyParameter(self, distributionMode):
self.interface.ChangePartyParameter(distributionMo de)

## Messenger
def OnMessengerAddFriendQuestion(self, name):
messengerAddFriendQuestion = uiCommon.QuestionDialog2()
messengerAddFriendQuestion.SetText1(locale.MESSENG ER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
messengerAddFriendQuestion.SetText2(locale.MESSENG ER_DO_YOU_ACCEPT_ADD_FRIEND_2)
messengerAddFriendQuestion.SetAcceptEvent(ui.__mem _func__(self.OnAcceptAddFriend))
messengerAddFriendQuestion.SetCancelEvent(ui.__mem _func__(self.OnDenyAddFriend))
messengerAddFriendQuestion.Open()
messengerAddFriendQuestion.name = name
self.messengerAddFriendQuestion = messengerAddFriendQuestion

def OnAcceptAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth y " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUE

def OnDenyAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth n " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUE

def OnCloseAddFriendQuestionDialog(self):
self.messengerAddFriendQuestion.Close()
self.messengerAddFriendQuestion = None
return TRUE

## SafeBox
def OpenSafeboxWindow(self, size):
self.interface.OpenSafeboxWindow(size)

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

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

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

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

## Guild
def RecvGuildInviteQuestion(self, guildID, guildName):
guildInviteQuestionDialog = uiCommon.QuestionDialog()
guildInviteQuestionDialog.SetText(guildName + locale.GUILD_DO_YOU_JOIN)
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.Open()
guildInviteQuestionDialog.guildID = guildID
self.guildInviteQuestionDialog = guildInviteQuestionDialog

def AnswerGuildInvite(self, answer):

if not self.guildInviteQuestionDialog:
return

guildLeaderVID = self.guildInviteQuestionDialog.guildID
net.SendGuildInviteAnswerPacket(guildLeaderVID, answer)

self.guildInviteQuestionDialog.Close()
self.guildInviteQuestionDialog = None

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

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

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

## Emotion
def BINARY_ActEmotion(self, emotionIndex):
if self.interface.wndCharacter:
self.interface.wndCharacter.ActEmotion(emotionInde x)

################################################## #############################################
################################################## #############################################
## Keyboard Functions

def CheckFocus(self):
if FALSE == self.IsFocus():
if TRUE == self.interface.IsOpenChat():
self.interface.ToggleChat()

self.SetFocus()

def SaveScreen(self):
print "save screen"

# SCREENSHOT_CWDSAVE
if SCREENSHOT_CWDSAVE:
if not os.path.exists(os.getcwd()+os.sep+"screenshot"):
os.mkdir(os.getcwd()+os.sep+"screenshot")

(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"scree nshot"+os.sep)
else:
(succeeded, name) = grp.SaveScreenShot()
# END_OF_SCREENSHOT_CWDSAVE

if succeeded:
chat.AppendChat(chat.CHAT_TYPE_INFO, name + locale.SCREENSHOT_SAVE1)
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SCREENSHOT_SAVE2)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SCREENSHOT_SAVE_FAILURE)

def ShowConsole(self):
player.EndKeyWalkingImmediately()
self.console.OpenWindow()

def ShowName(self):
self.ShowNameFlag = TRUE
self.playerGauge.EnableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex+1)

# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):

if systemSetting.IsAlwaysShowName():
return TRUE

if self.ShowNameFlag:
return TRUE

return FALSE
# END_OF_ADD_ALWAYS_SHOW_NAME

def HideName(self):
self.ShowNameFlag = FALSE
self.playerGauge.DisableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex)

def ShowMouseImage(self):
self.interface.ShowMouseImage()

def HideMouseImage(self):
self.interface.HideMouseImage()

def StartAttack(self):
player.SetAttackKeyState(TRUE)

def EndAttack(self):
player.SetAttackKeyState(FALSE)

def MoveUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, TRUE)

def MoveDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, TRUE)

def MoveLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, TRUE)

def MoveRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, TRUE)

def StopUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, FALSE)

def StopDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, FALSE)

def StopLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, FALSE)

def StopRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, FALSE)

def PickUpItem(self):
player.PickCloseItem()

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

def OnKeyDown(self, key):
if self.interface.wndWeb and self.interface.wndWeb.IsShow():
return
try:
self.onPressKeyDict[key]()
except KeyError:
pass
except:
raise

return TRUE

def OnKeyUp(self, key):
try:
self.onClickKeyDict[key]()
except KeyError:
pass
except:
raise

return TRUE

def OnMouseLeftButtonDown(self):

if self.interface.BUILD_OnMouseLeftButtonDown():
return

self.CheckFocus()

if FALSE == mouseModule.mouseController.isAttached():
player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);

return TRUE

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():
return

if TRUE == 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(attachedItemSl otPos)

## Inventory
elif player.SLOT_TYPE_INVENTORY == attachedType:

if player.ITEM_MONEY == attachedItemIndex:
self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
else:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)

mouseModule.mouseController.DeattachObject()

else:
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)

#player.EndMouseWalking()
return TRUE

def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
if player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(locale.EXCHANGE_FAILU RE_EQUIP_ITEM, 0, locale.UI_OK)
else:
if chr.IsNPC(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedItemSlotPos, attachedItemCount)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedItemSlotPos, 0)
else:
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)

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

def __DropMoney(self, attachedType, attachedMoney):
# PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀÎ»óÁ¡ ¿*°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

if attachedMoney>=1000:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(locale.DROP_MONEY_FAI LURE_1000_OVER, 0, locale.UI_OK)
return

itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog.SetText(locale.DO_YOU_DROP_ MONEY % (attachedMoney))
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropCount = attachedMoney
itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
self.itemDropQuestionDialog = itemDropQuestionDialog

def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
# PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀÎ»óÁ¡ ¿*°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

if player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(locale.DROP_ITEM_FAIL URE_EQUIP_ITEM, 0, locale.UI_OK)

else:
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

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

## Question Text
questionText = locale.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog

def RequestDropItem(self, answer):

if not self.itemDropQuestionDialog:
return

if answer:
dropType = self.itemDropQuestionDialog.dropType
dropCount = self.itemDropQuestionDialog.dropCount
dropNumber = self.itemDropQuestionDialog.dropNumber

if player.SLOT_TYPE_INVENTORY == dropType:

if dropNumber == player.ITEM_MONEY:
net.SendGoldDropPacketNew(dropCount)
snd.PlaySound("sound/ui/money.wav")

else:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None

# PRIVATESHOP_DISABLE_ITEM_DROP
def __SendDropItemPacket(self, itemVNum, itemCount):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return

net.SendItemDropPacketNew(itemVNum, itemCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

def OnMouseRightButtonDown(self):

self.CheckFocus()

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

else:
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)

return TRUE

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

player.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
return TRUE

def OnMouseMiddleButtonDown(self):
player.SetMouseMiddleButtonState(player.MBS_PRESS)

def OnMouseMiddleButtonUp(self):
player.SetMouseMiddleButtonState(player.MBS_CLICK)

def Rauswerfen(self):
SLOT_COUNT = 90
for eachSlot in xrange(SLOT_COUNT):
itemVNum = player.GetItemIndex(eachSlot)
if itemVNum == 27990 or itemVNum == 27799 or itemVNum == 27802 or itemVNum >= 27833 and itemVNum <= 27853:
net.SendItemDropPacket(eachSlot)

def Fischkiller(self):
SLOT_COUNT = 90
for eachSlot in xrange(SLOT_COUNT):
itemVNum = player.GetItemIndex(eachSlot)
if itemVNum >= 27803 and itemVNum <= 27823:
net.SendItemUsePacket(eachSlot)

def Fishbuyer(self):
SLOT_COUNT = 90
for eachSlot in xrange(SLOT_COUNT):
getShopItemID = shop.GetItemID(eachSlot)
if getShopItemID == 27803:
net.SendShopBuyPacket(eachSlot)

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()
## speed hack
self.MultiHack()

def MultiHack(self):
## speed hack
file=open('mod_config.cfg','r')
file_lines=file.readlines()
AttackSpeed = file_lines[1].strip()
WalkSpeed = file_lines[2].strip()
AttackSpeed = AttackSpeed.replace('AttackSpeed=', '')
WalkSpeed = WalkSpeed.replace('WalkSpeed=', '')
AttackSpeedHack = file_lines[3].strip()
WalkSpeedHack = file_lines[4].strip()
AutoPickUp = file_lines[5].strip()
if AttackSpeedHack == "AttackSpeedHack=on":
chr.SetAttackSpeed(int(AttackSpeed))
if WalkSpeedHack == "WalkSpeedHack=on":
chr.SetMoveSpeed(int(WalkSpeed))
if AutoPickUp == "AutoPickUp=on":
player.PickCloseItem()

def UpdateDebugInfo(self):
#
# Ä³¸¯ÅÍ ÁÂÇ¥ ¹× FPS Ãâ·Â
(x, y, z) = player.GetMainCharacterPosition()
nUpdateTime = app.GetUpdateTime()
nUpdateFPS = app.GetUpdateFPS()
nRenderFPS = app.GetRenderFPS()
nFaceCount = app.GetFaceCount()
fFaceSpeed = app.GetFaceSpeed()
nST=background.GetRenderShadowTime()
(fAveRT, nCurRT) = app.GetRenderTime()
(iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo()
(iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum()
if iPatch == 0:
iPatch = 1

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

self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))

self.FrameRate.SetText("UFPS: %3d UT: %3d FS %.2f" % (nUpdateFPS, nUpdateTime, fFaceSpeed))

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

self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))
#self.Pitch.SetText("Pitch: %.2f" % (app.GetCameraPitch())
#self.TextureNum.SetText("TN : %s" % (sTextureNum))
#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))
self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))

def OnRender(self):
app.RenderGame()

if self.console.Console.collision:
background.RenderCollision()
chr.RenderCollision()

(x, y) = app.GetCursorPosition()

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

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

self.PickingCharacterIndex = chr.Pick()

if -1 != self.PickingCharacterIndex:
textTail.ShowCharacterTextTail(self.PickingCharact erIndex)
if 0 != self.targetBoard.GetTargetVID():
textTail.ShowCharacterTextTail(self.targetBoard.Ge tTargetVID())

# ADD_ALWAYS_SHOW_NAME
if not self.__IsShowName():
self.PickingItemIndex = item.Pick()
if -1 != self.PickingItemIndex:
textTail.ShowItemTextTail(self.PickingItemIndex)
# END_OF_ADD_ALWAYS_SHOW_NAME

## Show all name in the range

# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAME

textTail.UpdateShowingTextTail()
textTail.ArrangeTextTail()
if -1 != self.PickingItemIndex:
textTail.SelectItemName(self.PickingItemIndex)

grp.PopState()
grp.SetInterfaceRenderState()

textTail.Render()
textTail.HideAllTextTail()

def OnPressEscapeKey(self):
if app.TARGET == app.GetCursor():
app.SetCursor(app.NORMAL)

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

else:
self.interface.OpenSystemDialog()

return TRUE

def OnIMEReturn(self):
if app.IsPressed(app.DIK_LSHIFT):
self.interface.OpenWhisperDialogWithoutTarget()
else:
self.interface.ToggleChat()
return TRUE

def OnPressExitKey(self):
self.interface.ToggleSystemDialog()
return TRUE

## BINARY CALLBACK
################################################## ####################################

# WEDDING
def BINARY_LoverInfo(self, name, lovePoint):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnAddLover(name, lovePoint)
if self.affectShower:
self.affectShower.SetLoverInfo(name, lovePoint)

def BINARY_UpdateLovePoint(self, lovePoint):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnUpdateLovePoint(love Point)
if self.affectShower:
self.affectShower.OnUpdateLovePoint(lovePoint)
# END_OF_WEDDING

# QUEST_CONFIRM
def BINARY_OnQuestConfirm(self, msg, timeout, pid):
confirmDialog = uiCommon.QuestionDialogWithTimeLimit()
confirmDialog.Open(msg, timeout)
confirmDialog.SetAcceptEvent(lambda answer=TRUE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
confirmDialog.SetCancelEvent(lambda answer=FALSE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
self.confirmDialog = confirmDialog
# END_OF_QUEST_CONFIRM

# CUBE
def BINARY_Cube_Open(self):
self.interface.OpenCubeWindow()

def BINARY_Cube_Close(self):
self.interface.CloseCubeWindow()

def BINARY_Cube_Succeed(self, itemVnum, count):
print "Å¥ºê Á¦ÀÛ ¼º°ø"
self.interface.SucceedCubeWork(itemVnum, count)
pass

def BINARY_Cube_Failed(self):
print "Å¥ºê Á¦ÀÛ ½ÇÆÐ"
#self.PopupMessage(locale.CUBE_FAILURE)
pass

# END_OF_CUBE

def BINARY_SetBigMessage(self, message):
self.interface.bigBoard.SetTip(message)

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

def BINARY_AppendNotifyMessage(self, type):
if not type in locale.NOTIFY_MESSAGE:
return
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.NOTIFY_MESSAGE[type])

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

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

def BINARY_GuildWar_OnSendDeclare(self, guildID):
pass

def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):
mainCharacterName = player.GetMainCharacterName()
masterName = guild.GetGuildMasterName()
if mainCharacterName == masterName:
self.__GuildWar_OpenAskDialog(guildID, warType)

def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):
self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)

def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):
self.interface.OnStartGuildWar(guildSelf, guildOpp)

def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):
self.interface.OnEndGuildWar(guildSelf, guildOpp)

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

def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):
self.interface.wndMiniMap.UpdateObserverCount(obse rverCount)

def __GuildWar_UpdateMemberCount(self, guildID1, memberCount1, guildID2, memberCount2, observerCount):
guildID1 = int(guildID1)
guildID2 = int(guildID2)
memberCount1 = int(memberCount1)
memberCount2 = int(memberCount2)
observerCount = int(observerCount)

self.interface.UpdateMemberCount(guildID1, memberCount1, guildID2, memberCount2)
self.interface.wndMiniMap.UpdateObserverCount(obse rverCount)

def __GuildWar_OpenAskDialog(self, guildID, warType):

guildName = guild.GetGuildName(guildID)

# REMOVED_GUILD_BUG_FIX
if "Noname" == guildName:
return
# END_OF_REMOVED_GUILD_BUG_FIX

import uiGuild
questionDialog = uiGuild.AcceptGuildWarDialog()
questionDialog.SAFE_SetAcceptEvent(self.__GuildWar _OnAccept)
questionDialog.SAFE_SetCancelEvent(self.__GuildWar _OnDecline)
questionDialog.Open(guildName, warType)

self.guildWarQuestionDialog = questionDialog

def __GuildWar_CloseAskDialog(self):
self.guildWarQuestionDialog.Close()
self.guildWarQuestionDialog = None

def __GuildWar_OnAccept(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/war " + guildName)
self.__GuildWar_CloseAskDialog()

return 1

def __GuildWar_OnDecline(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/nowar " + guildName)
self.__GuildWar_CloseAskDialog()

return 1
## BINARY CALLBACK
################################################## ####################################

def __ServerCommand_Build(self):
serverCommandList={
"ConsoleEnable" : self.__Console_Enable,
"DayMode" : self.__DayMode_Update,
"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,
"CloseRestartWindow" : self.__RestartDialog_Close,
"OpenPrivateShop" : self.__PrivateShop_Open,
"PartyHealReady" : self.PartyHealReady,
"ShowMeSafeboxPassword" : self.AskSafeboxPassword,
"CloseSafebox" : self.CommandCloseSafebox,

# ITEM_MALL
"CloseMall" : self.CommandCloseMall,
"ShowMeMallPassword" : self.AskMallPassword,
"item_mall" : self.__ItemMall_Open,
# END_OF_ITEM_MALL

"RefineSuceeded" : self.RefineSuceededMessage,
"RefineFailed" : self.RefineFailedMessage,
"xmas_snow" : self.__XMasSnow_Enable,
"xmas_boom" : self.__XMasBoom_Enable,
"xmas_song" : self.__XMasSong_Enable,
"xmas_tree" : self.__XMasTree_Enable,
"newyear_boom" : self.__XMasBoom_Enable,
"PartyRequest" : self.__PartyRequestQuestion,
"PartyRequestDenied" : self.__PartyRequestDenied,
"horse_state" : self.__Horse_UpdateState,
"hide_horse_state" : self.__Horse_HideState,
"WarUC" : self.__GuildWar_UpdateMemberCount,
"test_server" : self.__EnableTestServerFlag,
"mall" : self.__InGameShop_Show,

# WEDDING
"lover_login" : self.__LoginLover,
"lover_logout" : self.__LogoutLover,
"lover_near" : self.__LoverNear,
"lover_far" : self.__LoverFar,
"lover_divorce" : self.__LoverDivorce,
"PlayMusic" : self.__PlayMusic,
# END_OF_WEDDING

# PRIVATE_SHOP_PRICE_LIST
"MyShopPriceList" : self.__PrivateShop_PriceList,
# END_OF_PRIVATE_SHOP_PRICE_LIST
}

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

def BINARY_ServerCommand_Run(self, line):
dbg.TraceError(line)
try:
#print " BINARY_ServerCommand_Run", line
return self.serverCommander.Run(line)
except RuntimeError, msg:
dbg.TraceError(msg)
return 0

def __ProcessPreservedServerCommand(self):
try:
command = net.GetPreservedServerCommand()
while command:
print " __ProcessPreservedServerCommand", command
self.serverCommander.Run(command)
command = net.GetPreservedServerCommand()
except RuntimeError, msg:
dbg.TraceError(msg)
return 0

def PartyHealReady(self):
self.interface.PartyHealReady()

def AskSafeboxPassword(self):
self.interface.AskSafeboxPassword()

# ITEM_MALL
def AskMallPassword(self):
self.interface.AskMallPassword()

def __ItemMall_Open(self):
self.interface.OpenItemMall();

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

def RefineSuceededMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(locale.REFINE_SUCCESS)

def RefineFailedMessage(self):
snd.PlaySound("sound/ui/jaeryun_fail.wav")
self.PopupMessage(locale.REFINE_FAILURE)

def CommandCloseSafebox(self):
self.interface.CommandCloseSafebox()

# PRIVATE_SHOP_PRICE_LIST
def __PrivateShop_PriceList(self, itemVNum, itemPrice):
uiPrivateShopBuilder.SetPrivateShopItemPrice(itemV Num, itemPrice)
# END_OF_PRIVATE_SHOP_PRICE_LIST

def __Horse_HideState(self):
self.affectShower.SetHorseState(0, 0, 0)

def __Horse_UpdateState(self, level, health, battery):
self.affectShower.SetHorseState(int(level), int(health), int(battery))

def __IsXMasMap(self):
mapDict = ( "metin2_map_n_flame_01",
"metin2_map_n_desert_01",
"metin2_map_spiderdungeon",
"metin2_map_deviltower1", )

if background.GetCurrentMapName() in mapDict:
return FALSE

return TRUE

def __XMasSnow_Enable(self, mode):

self.__XMasSong_Enable(mode)

if "1"==mode:

if not self.__IsXMasMap():
return

print "XMAS_SNOW ON"
background.EnableSnow(1)

else:
print "XMAS_SNOW OFF"
background.EnableSnow(0)

def __XMasBoom_Enable(self, mode):
if "1"==mode:

if not self.__IsXMasMap():
return

print "XMAS_BOOM ON"
self.__DayMode_Update("dark")
self.enableXMasBoom = TRUE
self.startTimeXMasBoom = app.GetTime()
else:
print "XMAS_BOOM OFF"
self.__DayMode_Update("light")
self.enableXMasBoom = FALSE

def __XMasTree_Enable(self, grade):

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

def __XMasSong_Enable(self, mode):
if "1"==mode:
print "XMAS_SONG ON"

XMAS_BGM = "xmas.mp3"

if app.IsExistFile("BGM/" + XMAS_BGM)==1:
if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)

musicInfo.fieldMusic=XMAS_BGM
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)

else:
print "XMAS_SONG OFF"

if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)

musicInfo.fieldMusic=musicInfo.METIN2THEMA
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)

def __RestartDialog_Close(self):
self.interface.CloseRestartDialog()

def __Console_Enable(self):
self.consoleEnable = TRUE
app.EnableSpecialCameraMode()
ui.EnablePaste(TRUE)

## PrivateShop
def __PrivateShop_Open(self):
self.interface.OpenPrivateShopInputNameDialog()

def BINARY_PrivateShop_Appear(self, vid, text):
self.interface.AppearPrivateShop(vid, text)

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

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

if not self.__IsXMasMap():
return

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

def __DayMode_Update(self, mode):
if "light"==mode:
self.curtain.SAFE_FadeOut(self.__DayMode_OnComplet eChangeToLight)
elif "dark"==mode:

if not self.__IsXMasMap():
return

self.curtain.SAFE_FadeOut(self.__DayMode_OnComplet eChangeToDark)

def __DayMode_OnCompleteChangeToLight(self):
background.SetEnvironmentData(0)
self.curtain.FadeIn()

def __DayMode_OnCompleteChangeToDark(self):
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)
self.curtain.FadeIn()

## XMasBoom
def __XMasBoom_Update(self):

self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )
if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):
return

boomTime = self.BOOM_DATA_LIST[self.indexXMasBoom][0]
boomCount = self.BOOM_DATA_LIST[self.indexXMasBoom][1]

if app.GetTime() - self.startTimeXMasBoom > boomTime:

self.indexXMasBoom += 1

for i in xrange(boomCount):
self.__XMasBoom_Boom()

def __XMasBoom_Boom(self):
x, y, z = player.GetMainCharacterPosition()
randX = app.GetRandom(-150, 150)
randY = app.GetRandom(-150, 150)

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

def __PartyRequestQuestion(self, vid):
vid = int(vid)
partyRequestQuestionDialog = uiCommon.QuestionDialog()
partyRequestQuestionDialog.SetText(chr.GetNameByVI D(vid) + locale.PARTY_DO_YOU_ACCEPT)
partyRequestQuestionDialog.SetAcceptText(locale.UI _ACCEPT)
partyRequestQuestionDialog.SetCancelText(locale.UI _DENY)
partyRequestQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.Open()
partyRequestQuestionDialog.vid = vid
self.partyRequestQuestionDialog = partyRequestQuestionDialog

def __AnswerPartyRequest(self, answer):
if not self.partyRequestQuestionDialog:
return

vid = self.partyRequestQuestionDialog.vid

if answer:
net.SendChatPacket("/party_request_accept " + str(vid))
else:
net.SendChatPacket("/party_request_deny " + str(vid))

self.partyRequestQuestionDialog.Close()
self.partyRequestQuestionDialog = None

def __PartyRequestDenied(self):
self.PopupMessage(locale.PARTY_REQUEST_DENIED)

def __EnableTestServerFlag(self):
app.EnableTestServerFlag()

def __InGameShop_Show(self, url):
if constInfo.IN_GAME_SHOP_ENABLE:
self.interface.OpenWebWindow(url)

# WEDDING
def __LoginLover(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnLoginLover()

def __LogoutLover(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnLogoutLover()
if self.affectShower:
self.affectShower.HideLoverState()

def __LoverNear(self):
if self.affectShower:
self.affectShower.ShowLoverState()

def __LoverFar(self):
if self.affectShower:
self.affectShower.HideLoverState()

def __LoverDivorce(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.ClearLoverInfo()
if self.affectShower:
self.affectShower.ClearLoverState()

def __PlayMusic(self, flag, filename):
flag = int(flag)
if flag:
snd.FadeOutAllMusic()
musicInfo.SaveLastPlayFieldMusic()
snd.FadeInMusic("BGM/" + filename)
else:
snd.FadeOutAllMusic()
musicInfo.LoadLastPlayFieldMusic()
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)

# END_OF_WEDDING

HIer meine Syserr.txt ausm Client

Spoiler

Quote:

0911 08:51:04669 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 2826

0911 08:51:04669 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 2836

0911 08:51:04669 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 2846

0911 08:51:04682 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 4437

0911 08:51:04682 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 4438

0911 08:51:04682 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 4439

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5264

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5265

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5266

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5267

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5268

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5269

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5270

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5271

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5272

0911 08:51:04689 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5273

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5294

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5295

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5296

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5297

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5298

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5299

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5300

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5301

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5302

0911 08:51:04690 :: CItemManager::LoadItemList(locale/de/item_list.txt) - StrangeLine in 5303

0911 08:51:12686 :: GRANNY: r:/granny/rt/granny_file_info.cpp(145): File has run-time type tag of 0x8000000f, which doesn't match this version of Granny (0x80000010). Automatic conversion will be attempted.
0911 08:52:14805 :: CRaceData::RegisterMotionData - LoadMotionData(c_szFileName=d:/ymir work/pc2/warrior/skill/musa_2.msa) ERROR
0911 08:52:14812 :: CRaceData::RegisterMotionData - LoadMotionData(c_szFileName=d:/ymir work/pc2/warrior/skill/musa_3.msa) ERROR
0911 08:52:14819 :: CRaceData::RegisterMotionData - LoadMotionData(c_szFileName=d:/ymir work/pc2/warrior/skill/musa_4.msa) ERROR
0911 08:52:18181 :: Traceback (most recent call last):

0911 08:52:18182 :: File "networkModule.py", line 231, in SetGamePhase

0911 08:52:18183 :: File "system.py", line 130, in __pack_import

0911 08:52:18183 :: File "
0911 08:52:18183 :: <string>
0911 08:52:18183 :: ", line
0911 08:52:18183 :: 1343
0911 08:52:18183 ::

0911 08:52:18183 ::
0911 08:52:18183 :: def Rauswerfen(self):

0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 ::
0911 08:52:18183 :: ^

0911 08:52:18183 :: IndentationError
0911 08:52:18183 :: :
0911 08:52:18183 :: unindent does not match any outer indentation level
0911 08:52:18183 ::