#########################################

# title_name : System Pack #

# filename : root #
# author : Bvural41 #
# version : Version 0.0.2 #
# date : 2015 04 11 #
# update : 2019 02 05 #
#########################################

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 localeInfo
import constInfo
import exchange
import ime
import translate
import uiruhtasi
import uibkoku
import uiWordGameSystem
import uifutboltopu
import uibiyolog
import uiminimap
import uicategorypick
import uiMiniGameFishEvent
import uiMiniGame
import uiminigameattendance
import systeminfo
import ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
import time
import savbec
import surabec
import ninjabec
import samanbec
import lycanbec
import uiPrivateShopBuilder
import uiOfflineShopBuilder
import uiOfflineShop
import mouseModule
import consoleModule
import localeInfo
import playerSettingModule
import interfaceModule
import musicInfo
import debugInfo
import uipetsystem
import stringCommander
import uibktrade
import event
import uicalendar
import uiguildranking
import uibosstracking
##SvSide Kurulum Start
#svsidedia = None
#svsidedi_cp = ""
#from svsideoi import SvsideDialog
#import binascii
##SvSide Kurulum End
if app.ENABLE_12ZI:
import ui12zi
if app.ENABLE_WHISPER_ADMIN_SYSTEM:
import uiwhisperadmin
if app.ENABLE_ADMIN_BAN_MANAGER:
import uiadmintool
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
import uikeyboardsettings
if app.ENABLE_MINI_GAME_CATCH_KING:
import uiminigamecatchking
if app.ENABLE_DUNGEON_INFO_SYSTEM:
import uiDungeonInfo
from _weakref import proxy

# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = None

if localeInfo.IsEUROPE():
SCREENSHOT_CWDSAVE = TRUE

if localeInfo.IsCIBN10():
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = "YT2W"

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

testAlignment = 0
BPisLodaded = 0

class GameWindow(ui.ScriptWindow):
MailBoxOpenT = 0
GuildRankingTime = 0
def __init__(self, stream):
ui.ScriptWindow.__init__(self, "GAME")
self.SetWindowName("game")
net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
player.SetGameWindow(self)
self.onQuest = 0
self.startGameTime = 0

##SvSide Kurulum Start

#global svsidedia
#if svsidedia == None:
#svsidedia = SvsideDialog()
#svsidedia.Board.Hide()
##SvSide Kurulum End

self.biyoekran = uibiyolog.BiyologEkran()
self.biyoekran.Hide()

self.ruhtasi = uiruhtasi.RuhTasi()
self.ruhtasi.Hide()

self.bkoku = uibkoku.BKOku()
self.bkoku.Hide()

self.categorypick = uicategorypick.CategoryPick()
self.categorypick.Hide()

self.wordgame = uiWordGameSystem.WordGameWindow()
self.wordgame.Close()

self.topver = uifutboltopu.TopEventi()
self.topver.Close()

self.calendar = uicalendar.CalendarSystem()
self.calendar.Close()

import uidailypass
self.wnddailypass = uidailypass.DailyPass()

self.quickSlotPageIndex = 0
self.lastPKModeSendedTime = 0
self.pressNumber = None
if (app.WJ_COMBAT_ZONE):
import uicombatzone
self.wndCombatZone = uicombatzone.CombatZoneWindow()

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

if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
self.dlgKeyboardSettings = None
 self.stream=stream
self.interface = interfaceModule.Interface()
self.interface.SetStream(self.stream)
self.interface.MakeInterface()
self.interface.ShowDefaultWindows()
self.stream.isAutoSelect = 0

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

self.BKTradeSys = uibktrade.BKTrade()
self.BKTradeSys.Close()

self.targetBoard = uiTarget.TargetBoard()

self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog))
self.targetBoard.Hide()

self.guildranking = uiguildranking.guildranking()

self.petmain = uipetsystem.PetSystemMain()
if (app.ENABLE_PET_ATTR_DETERMINE):
self.petmain.SetItemToolTip(self.interface.tooltipItem)
self.petmini = uipetsystem.PetSystemMini()

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

if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
self.dlgKeyboardSettings =
uikeyboardsettings.KeyChangeWindow(self)

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

if app.ENABLE_ADMIN_BAN_MANAGER:
self.wndAdminTool = uiadmintool.AdminTool()

if app.ENABLE_WHISPER_ADMIN_SYSTEM:
self.adminWhisperManager = uiwhisperadmin.WhisperManager()

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

self.bosstracking = uibosstracking.BossTrackingSystemWindow()
self.bosstracking.Hide()

self.itemDropQuestionDialog = None

self.titletimer = 0

self.__SetQuickSlotMode()

self.__ServerCommand_Build()
self.__ProcessPreservedServerCommand()
 def __del__(self):
player.SetGameWindow(0)
net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)
ui.ScriptWindow.__del__(self)
self.onQuest = 0
self.startGameTime = 0

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

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

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

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

global cameraDistance, cameraPitch, cameraRotation, cameraHeight

app.SetCamera(cameraDistance, cameraPitch, cameraRotation,

cameraHeight)

constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()
constInfo.SET_DEFAULT_CHRNAME_COLOR()
constInfo.SET_DEFAULT_FOG_LEVEL()
constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENABLE()
constInfo.SET_DEFAULT_USE_ITEM_WEAPON_TABLE_ATTACK_BONUS()
constInfo.SET_DEFAULT_USE_SKILL_EFFECT_ENABLE()

# TWO_HANDED_WEAPON_ATTACK_SPEED_UP
constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP

import event
event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)

textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)

if constInfo.PVPMODE_TEST_ENABLE:
self.testPKMode = ui.TextLine()
self.testPKMode.SetFontName(localeInfo.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(localeInfo.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()

if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
self.dlgKeyboardSettings.BuildKeyDict()

# PRIVATE_SHOP_PRICE_LIST
uiPrivateShopBuilder.Clear()
# END_OF_PRIVATE_SHOP_PRICE_LIST

uiOfflineShopBuilder.Clear()

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

if constInfo.Kar2 == 1:
background.RegisterEnvironmentData(1,
constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)

if app.PARTY_MATCH:
constInfo.KILITLE = 0

# START_GAME_ERROR_EXIT
try:
self.StartGame()
except:
import exception
exception.Abort("GameWindow.Open")
# END_OF_START_GAME_ERROR_EXIT
 self.cubeInformation = {}
self.currentCubeNPC = 0

for i in xrange(10):
if systemSetting.IsSnowTexturesMode():
if background.GetCurrentMapName():
snow_maps = [
"metin2_map_a1",
"metin2_map_b1",
"metin2_map_c1"
]
snow_maps_textures = {
"metin2_map_a1" :
"textureset\metin2_a1_snow.txt",
"metin2_map_b1" :
"textureset\metin2_b1_snow.txt",
"metin2_map_c1" :
"textureset\metin2_c1_snow.txt", }
if str(background.GetCurrentMapName()) in snow_maps:

background.TextureChange(snow_maps_textures[str(background.GetCurrentMapName())])

elif systemSetting.IsSnowTexturesMode():
if background.GetCurrentMapName():
snow_maps_karli = [
"metin2_map_a1",
"metin2_map_b1",
"metin2_map_c1"
]
snow_maps_textures_karli = {
"metin2_map_a1" :
"textureset\metin2_a1_snow2.txt",
"metin2_map_b1" :
"textureset\metin2_b1_snow2.txt",
"metin2_map_c1" :
"textureset\metin2_c1_snow2.txt", }
if str(background.GetCurrentMapName()) in
snow_maps_karli:

background.TextureChange(snow_maps_textures_karli[str(background.GetCurrentMapName(
))])

if app.ENABLE_FOG_FIX:
if systemSetting.IsFogMode():
background.SetEnvironmentFog(False)
else:
background.SetEnvironmentFog(True)

self.startGameTime = app.GetTime()

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.captchatest = None
self.guildInviteQuestionDialog = None
self.guildWarQuestionDialog = None
self.messengerAddFriendQuestion = None

# UNKNOWN_UPDATE
self.itemDropQuestionDialog = None
# END_OF_UNKNOWN_UPDATE

if self.guildranking.IsShow():
self.guildranking.Open()

# 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.PrintMousePos = None

self.ClearDictionary()
self.petmain.Close()
self.petmini.Close()

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

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

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

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

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

if self.wordgame:
self.wordgame.Close()
self.wordgame = None

if self.topver:
self.topver.Close()
self.topver = None

if self.calendar:
self.calendar.Close()
self.calendar = None

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

if self.guildranking.IsShow():
self.guildranking.Open()

if app.ENABLE_ADMIN_BAN_MANAGER:
if self.adminWhisperManager:
self.adminWhisperManager.Hide()

if app.ENABLE_WHISPER_ADMIN_SYSTEM:
if self.adminWhisperManager:
self.adminWhisperManager.Hide()

if (app.WJ_COMBAT_ZONE):
if self.wndCombatZone:
self.wndCombatZone.Close()

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 GetBossTrackingInformation(self, btcadi1, btcadi2, btcadi3, btcadi4,

btcadi5, btcadi6, btalevkral1, btalevkral2, btalevkral3, btalevkral4, btalevkral5,
btalevkral6, btkorumcek1, btkorumcek2, btkorumcek3, btkorumcek4, btkorumcek5,
btkorumcek6, btsarikaplan1, btsarikaplan2, btsarikaplan3, btsarikaplan4,
btsarikaplan5, btsarikaplan6, btbuzkralice1, btbuzkralice2, btbuzkralice3,
btbuzkralice4, btbuzkralice5, btbuzkralice6, btdokuzk1, btdokuzk2, btdokuzk3,
btdokuzk4, btdokuzk5, btdokuzk6, btcolejder1, btcolejder2, btcolejder3,
btcolejder4, btcolejder5, btcolejder6, btagac1, btagac2, btagac3, btagac4, btagac5,
btagac6, btkomutan1, btkomutan2, btkomutan3, btkomutan4, btkomutan5, btkomutan6,
btkaranlik1, btkaranlik2, btkaranlik3, btkaranlik4, btkaranlik5, btkaranlik6):
self.bosstracking.GetMobInformation(btcadi1, btcadi2, btcadi3, btcadi4,
btcadi5, btcadi6, btalevkral1, btalevkral2, btalevkral3, btalevkral4, btalevkral5,
btalevkral6, btkorumcek1, btkorumcek2, btkorumcek3, btkorumcek4, btkorumcek5,
btkorumcek6, btsarikaplan1, btsarikaplan2, btsarikaplan3, btsarikaplan4,
btsarikaplan5, btsarikaplan6, btbuzkralice1, btbuzkralice2, btbuzkralice3,
btbuzkralice4, btbuzkralice5, btbuzkralice6, btdokuzk1, btdokuzk2, btdokuzk3,
btdokuzk4, btdokuzk5, btdokuzk6, btcolejder1, btcolejder2, btcolejder3,
btcolejder4, btcolejder5, btcolejder6, btagac1, btagac2, btagac3, btagac4, btagac5,
btagac6, btkomutan1, btkomutan2, btkomutan3, btkomutan4, btkomutan5, btkomutan6,
btkaranlik1, btkaranlik2, btkaranlik3, btkaranlik4, btkaranlik5, btkaranlik6)

def BossTrackingUpdate(self):
net.SendChatPacket("/bosstrackingtest")

def BossTrackingSystemShow(self):
self.bosstracking.Show()
net.SendChatPacket("/bosstrackingtest")

def biyoodulac(self, gorev, af1, afv1, af2, afv2, af3, afv3):

self.biyoekran.Show()
self.biyoekran.SetBaslik(str(gorev))
self.biyoekran.SetOdul(af1,afv1,af2,afv2,af3,afv3)

def biyologekrankapa(self):
self.biyoekran.Close()

def biyolog(self, bioitem, verilen, toplam, kalansure):

self.interface.SetBiyolog(bioitem, verilen, toplam, kalansure)

def BINARY_ReceiveChannel(self, channel):

if self.interface:
if self.interface.wndMiniMap:
self.interface.wndMiniMap.UpdateChannelInfo(channel)
constInfo.channel_idx = channel

def ruhcac(self):
self.ruhtasi.Show()

def bkac(self):
self.bkoku.Show()
def AltTaskbarAc(self):
if self.interface:
self.interface.wndExpandedTaskBar.Hide()

def guildrankingopen(self):
self.guildranking.Open()

def __guildranking(self, info):

CMD = info.split("/")
if CMD[0]=="index":
constInfo.guildranking["index"] = int(CMD[1])
elif CMD[0]=="input":

net.SendQuestInputStringPacket(str(constInfo.guildranking["CMD"]))
elif CMD[0]=="yeniliste":
constInfo.guildranking["Liste"] = []
elif CMD[0]=="liste":
constInfo.guildranking["Liste"].append(CMD[1].split("|"))
elif CMD[0]=="blok":
self.guildranking.LoadPage(CMD[1])
elif CMD[0]=="sayfa":
self.guildranking.Setsayfa(CMD[1])

def uyariloncasira(self, msg):

if msg == "bilgiyok":
self.PopupMessage("Hen�z bilgi girilmemis!")
elif msg == "oyuncuyok":
self.PopupMessage("Oyuncu bulunamadi!")

def WordGameWindowShow(self):
self.wordgame.Show()

def FutbolTopuVer(self):
self.topver.Show()

def __BuildKeyDict(self):
onPressKeyDict = {}

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

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)

if app.WJ_SPLIT_INVENTORY_SYSTEM:
onPressKeyDict[app.DIK_K] = lambda :
self.__PressExtendedInventory()

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_P] = self.__PressPKey

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

if app.ENABLE_DRAGON_SOUL_SYSTEM:
onPressKeyDict[app.DIK_O] = lambda :
self.interface.ToggleDragonSoulWindowWithNoInfo()

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

self.onPressKeyDict = onPressKeyDict

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

onClickKeyDict[app.DIK_W] = lambda : self.StopUp()

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

self.onClickKeyDict=onClickKeyDict

def __PressExtendedInventory(self):
if self.interface:
self.interface.ToggleExtendedInventoryWindow()

def __PressNumKey(self,num):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
 if num >= 1 and num <= 9:
if(chrmgr.IsPossibleEmoticon(-1)):
chrmgr.SetEmoticon(-1,int(num)-1)
net.SendEmoticon(int(num)-1)
else:
if num >= 1 and num <= 4:
self.pressNumber(num-1)

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

def __PressJKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if player.IsMountingHorse():
net.SendChatPacket("/unmount")
else:
if not uiPrivateShopBuilder.IsBuildingPrivateShop() or not
uiOfflineShopBuilder.IsBuildingOfflineShop():
for i in xrange(player.INVENTORY_PAGE_SIZE):
if player.GetItemIndex(i) in (71114, 71116,
71118, 71120):
net.SendItemUsePacket(i)
break
def __PressHKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_ride")
else:
self.interface.OpenHelpWindow()

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

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

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

def __ReleaseGKey(self):
app.PitchCamera(app.CAMERA_STOP)
 if app.ENABLE_ADMIN_BAN_MANAGER:
def OpenAdminTool(self):
if self.wndAdminTool.IsShow():
self.wndAdminTool.Hide()
else:
self.wndAdminTool.Show()

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

def __PressPKey(self):
if (app.IsPressed(app.DIK_LCONTROL) or
app.IsPressed(app.DIK_RCONTROL)):
if (interfaceModule.IsWhisperHide == 0):
interfaceModule.IsWhisperHide = 1
self.interface.HideAllWhisperButton()
else:
interfaceModule.IsWhisperHide = 0
self.interface.ShowAllWhisperButton()

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

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

def __PressQuickSlot(self, localSlotIndex):

if localeInfo.IsARABIC():
if 0 <= localSlotIndex and localSlotIndex < 4:
player.RequestUseLocalQuickSlot(3-localSlotIndex)
else:
player.RequestUseLocalQuickSlot(11-localSlotIndex)
else:
player.RequestUseLocalQuickSlot(localSlotIndex)

def __PressTeleport(self):
if self.interface:
self.interface.ToggleTeleportWindow()

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()
self.PrintMousePos.Show()
else:
self.PrintCoord.Hide()
self.FrameRate.Hide()
self.Pitch.Hide()
self.Splat.Hide()
self.TextureNum.Hide()
self.ObjectNum.Hide()
self.ViewDistance.Hide()
self.PrintMousePos.Hide()

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

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

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

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

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

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

# ����Ʈ �‫���� ���׸‬

self.ObjectNum = ui.TextLine()
self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)

# �þ߰Ÿ�
self.ViewDistance = ui.TextLine()
self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)
self.ViewDistance.SetPosition(0, 0)

def __NotifyError(self, msg):

chat.AppendChat(chat.CHAT_TYPE_INFO, msg)
 if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
def PressNumberKey(self, key):
self.pressNumber(key)

def PressQuickSlot(self, key):

player.RequestUseLocalQuickSlot(key)

def SelectQuickPage(self, key):

if app.IsPressed(app.DIK_LSHIFT):
self.quickSlotPageIndex = key
player.SetQuickPage(key)

def SetEmoticon(self, key):

if app.IsPressed(app.DIK_LCONTROL) or
app.IsPressed(app.DIK_RCONTROL):
if (chrmgr.IsPossibleEmoticon(-1)):
chrmgr.SetEmoticon(-1, key)
net.SendEmoticon(key)

def ShowNameNew(self):
self.ShowNameFlag = True
self.playerGauge.EnableShowAlways()

def HideNameNew(self):
self.ShowNameFlag = False
self.playerGauge.DisableShowAlways()

def PressExtraKey(self, key):

if key == "RIDE_HORSE":
if app.IsPressed(app.DIK_LCONTROL) or
app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_ride")

elif key == "RIDE_PEED":

if app.IsPressed(app.DIK_LCONTROL) or
app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_feed")

elif key == "RIDE":

if app.IsPressed(app.DIK_LCONTROL) or
app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/ride")

elif key == "RIDE_J":

if app.IsPressed(app.DIK_LCONTROL) or
app.IsPressed(app.DIK_RCONTROL):
if player.IsMountingHorse():
net.SendChatPacket("/unmount")
else:
if not
uiPrivateShopBuilder.IsBuildingPrivateShop():
if app.ENABLE_MOUNT_SYSTEM:
for i in xrange(180):
index =
player.GetItemIndex(i)
if index:
item.SelectItem(index)
subType =
item.GetItemSubType()
 if subType ==
item.USE_MOUNT:

net.SendItemUsePacket(i)
break
else:
return

elif key == "RIDE_BYE":

net.SendChatPacket("/user_horse_back")

elif key == "QUEST_SCROLL_ONOFF":

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

elif key == "GUILD_WINDOW":

if app.IsPressed(app.DIK_LALT):
self.interface.ToggleGuildWindow()

elif key == "MESSENGER_WINDOW":

if app.IsPressed(app.DIK_LCONTROL):
self.interface.ToggleMessenger()

elif key == "SHOW_MINIMAP":

if app.IsPressed(app.DIK_LSHIFT):
if False ==
self.interface.wndMiniMap.isShowMiniMap():
self.interface.wndMiniMap.ShowMiniMap()
self.interface.wndMiniMap.SetTop()
else:
self.interface.wndMiniMap.HideMiniMap()

elif key == "HIDE_PM":

if 0 == interfaceModule.IsWisperHide:
interfaceModule.IsWisperHide = 1
self.interface.HideAllWhisperButton()
else:
interfaceModule.IsWisperHide = 0
self.interface.ShowAllWhisperButton()

elif key == "OPEN_WHISPER":

self.interface.OpenWhisperDialogWithoutTarget()

def ChangePKMode(self):

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

if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
self.__NotifyError(localeInfo.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,
localeInfo.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)

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

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

import constInfo
if constInfo.INPUT_IGNORE == 1:
return
if constInfo.GIFT_INPUT == 1:
return
self.interface.OpenQuestWindow(skin, idx)

def HideAllQuestWindow(self):
self.interface.HideAllQuestWindow()

def AskGuildName(self):

guildNameBoard = uiCommon.InputDialog()
guildNameBoard.SetTitle(localeInfo.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(localeInfo.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, localeInfo.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)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or
chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulActivate(type -
chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
self.BINARY_DragonSoulGiveQuilification()

def BINARY_NEW_RemoveAffect(self, type, pointIdx):

self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or
chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulDeactivate()
# END_OF_UNKNOWN_UPDATE

def ActivateSkillSlot(self, slotIndex):

if self.interface:
self.interface.OnActivateSkill(slotIndex)

def DeactivateSkillSlot(self, slotIndex):

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

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

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

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

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

def ChangeCurrentSkill(self, skillSlotNumber):

self.interface.OnChangeCurrentSkill(skillSlotNumber)

def ExInvenItemUseMsg(self, current_stage, need_left, need_count):

if app.ENABLE_EXTEND_INVEN_SYSTEM:
self.interface.ExInvenItemUseMsg(current_stage, need_left,
need_count)

if app.ENABLE_12ZI:
def OpenUI12zi(self, yellowmark, greenmark, yellowreward, greenreward,
goldreward):
self.interface.OpenUI12zi(yellowmark, greenmark, yellowreward,
greenreward, goldreward)

def Refresh12ziTimer(self, currentFloor, jumpCount, limitTime,

elapseTime):
self.interface.Refresh12ziTimer(currentFloor, jumpCount,
limitTime, elapseTime)

def Show12ziJumpButton(self):
self.interface.Show12ziJumpButton()

def Hide12ziTimer(self):
self.interface.Hide12ziTimer()

def OpenReviveDialog(self, vid, itemcount):

self.targetBoard.OpenReviveDialog(vid, itemcount);

def NotEnoughPrism(self, itemcount):

self.PopupMessage(localeInfo.NOT_ENOUGH_PRISM % (itemcount))

def RefreshShopItemToolTip(self):
self.interface.RefreshShopItemToolTip()

def __Refresh12ziTimer1(self):
net.SendChatPacket("/open_cz")

def __Refresh12ziTimer2(self, a, b, c, d, e):

self.OpenUI12zi(int(a), int(b), int(c), int(d), int(e))
 if app.WJ_SHOW_STROKE_INFO:
def RegisterStroke(self, targetVID, value):
self.targetBoard.RegisterStroke(targetVID, value)

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

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(self, vid):

self.targetBoard.RefreshByVID(vid)

def RefreshTargetBoardByName(self, name):

self.targetBoard.RefreshByName(name)

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

if app.ENABLE_VIEW_ELEMENT or app.ENABLE_VIEW_TARGET_DECIMAL_HP:
def SetHPTargetBoard(self, vid, hpPercentage, bElement, iMinHP,
iMaxHP):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)

self.targetBoard.SetHP(hpPercentage, iMinHP, iMaxHP)

self.targetBoard.SetElementImage(bElement)
self.targetBoard.Show()
else:
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):
 if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.interface.OpenEquipmentDialog(vid)

def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count, transmutation):

if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum,
count, transmutation)

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

if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.interface.SetEquipmentDialogSocket(vid, slotIndex,
socketIndex, value)

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

if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex,
type, value)

def ViewEquipRequest(self, vid):

if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
vid = int(vid)
eqRequestQuestionDialog = uiCommon.QuestionDialog()
eqRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + '
giydiklerini g�rmek istiyor?')
eqRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
eqRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)
eqRequestQuestionDialog.SetAcceptEvent(lambda arg = True:
self.AnswerViewEquipRequest(arg))
eqRequestQuestionDialog.SetCancelEvent(lambda arg = False:
self.AnswerViewEquipRequest(arg))
eqRequestQuestionDialog.Open()
eqRequestQuestionDialog.vid = vid
self.eqRequestQuestionDialog = eqRequestQuestionDialog

def AnswerViewEquipRequest(self, answer):

if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
if not self.eqRequestQuestionDialog:
return
else:
vid = self.eqRequestQuestionDialog.vid
if answer:
net.SendChatPacket('/view_equip_accept ' + str(vid))
else:
net.SendChatPacket('/view_equip_deny ' + str(vid))
self.eqRequestQuestionDialog.Close()
self.eqRequestQuestionDialog = None
return

def ViewEquipRequestDenied(self):
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.PopupMessage('Profil g�r�nt�leme iste�i reddedildi.')

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

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

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

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

## Chat
def OnRecvWhisper(self, mode, name, line):

##SvSide Kurulum Start

#if name.find("<svside>") != -1:
#global svsidedia
#if line[line.find(",")-4:line.find(",")].isdigit():
#svsidedia.nm_updateimgoffline(line[line.find(", ")-
4:line.find(", ")])
#else:
#svsidedia.Board.Hide()
#return
##SvSide Kurulum End

if mode == chat.WHISPER_TYPE_GM:
self.interface.RegisterGameMasterName(name)
else:
pass

chat.AppendWhisper(mode, name, line)

self.interface.RecvWhisper(name)

def OnRecvWhisperSystemMessage(self, mode, name, line):

chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, line)
self.interface.RecvWhisper(name)

def OnRecvWhisperError(self, mode, name, line):

if localeInfo.WHISPER_ERROR.has_key(mode):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name,
localeInfo.WHISPER_ERROR[mode](name))
else:
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper
Unknown Error(mode=%d, name=%s)" % (mode, name))
self.interface.RecvWhisper(name)

def RecvWhisper(self, name):

self.interface.RecvWhisper(name)

if app.ENABLE_WHISPER_ADMIN_SYSTEM:
def OnRecvWhisperAdminSystem(self, name, line, color):

def ExistCustomColor(val):
return (val > 0)

def GetColor(type):
WHISPER_COLOR_MESSAGE = {
0: "|cffffffff|H|h",
1: "|cffff796a|H|h",
2: "|cffb1ff80|H|h",
3: "|cff46deff|H|h"
}
return WHISPER_COLOR_MESSAGE[type]
 def ResizeTextWithColor(color, text):
return str("%s%s|h|r" % (GetColor(color), text))

import datetime
now = datetime.datetime.now()
ret = line.replace("#", " ")

if ExistCustomColor(int(color)):
ret = ResizeTextWithColor(int(color), ret)
else:
ret = ResizeTextWithColor(0, ret)

text = localeInfo.WHISPER_ADMIN_MESSAGE % (ret)

self.interface.RegisterGameMasterName(name)
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, text)
self.interface.RecvWhisper(name)

def OnPickMoney(self, money):

if constInfo.YangDrop == 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY %
(money))
else:
return

def OnPickCheque(self, cheque):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHEQUE_SYSTEM_PICK_WON
% (cheque))

if app.ENABLE_12ZI:
def SetBeadCount(self, value):
self.interface.SetBeadCount(value)

def NextBeadUpdateTime(self, value):

self.interface.NextBeadUpdateTime(value)

def OnShopError(self, type):

try:
self.PopupMessage(localeInfo.SHOP_ERROR_DICT[type])
except KeyError:
self.PopupMessage(localeInfo.SHOP_ERROR_UNKNOWN % (type))

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

def OnFishingSuccess(self, isFish, fishName):

chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO,
localeInfo.FISHING_SUCCESS(isFish, fishName), 2000)

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

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

def OnFishingNotify(self, isFish, fishName):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_NOTIFY(isFish,
fishName))

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

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

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

def OnCannotUseSkill(self, vid, type):

if localeInfo.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
textTail.RegisterInfoTail(vid,
localeInfo.USE_SKILL_ERROR_TAIL_DICT[type])

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

def OnCannotShotError(self, vid, type):

textTail.RegisterInfoTail(vid,
localeInfo.SHOT_ERROR_TAIL_DICT.get(type, localeInfo.SHOT_ERROR_UNKNOWN % (type)))

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

## Shop
if (app.WJ_COMBAT_ZONE):
def StartShop(self, vid, points, curLimit, maxLimit):
self.interface.OpenShopDialog(vid, points, curLimit, maxLimit)
else:
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

## OfflineShop
def StartOfflineShop(self, vid):
self.interface.OpenOfflineShopDialog(vid)

def EndOfflineShop(self):
self.interface.CloseOfflineShopDialog()

def RefreshOfflineShop(self):
self.interface.RefreshOfflineShopDialog()

## 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.QuestionDialogWithTimeLimit()
partyInviteQuestionDialog.SetText1(leaderName +
localeInfo.PARTY_DO_YOU_JOIN)

partyInviteQuestionDialog.SetTimeOverMsg(localeInfo.PARTY_ANSWER_TIMEOVER)
partyInviteQuestionDialog.SetTimeOverEvent(self.AnswerPartyInvite,
False)
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=True:
self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.SetCancelEvent(lambda arg=False:
self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.Open(10)
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

if app.ENABLE_PARTY_UPDATE:
def AddPartyMember(self, pid, name, mapIdx, channel):
self.interface.AddPartyMember(pid, name, mapIdx, channel)
else:
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()

if app.ENABLE_PARTY_UPDATE:
def LinkPartyMember(self, pid, vid, mapIdx, channel):
self.interface.LinkPartyMember(pid, vid, mapIdx, channel)
 else:
def LinkPartyMember(self, pid, vid):
self.interface.LinkPartyMember(pid, vid)

def UnlinkPartyMember(self, pid):

self.interface.UnlinkPartyMember(pid)

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

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

def ChangePartyParameter(self, distributionMode):

self.interface.ChangePartyParameter(distributionMode)

## Messenger
def OnMessengerAddFriendQuestion(self, name):
messengerAddFriendQuestion = uiCommon.QuestionDialogWithTimeLimit()

messengerAddFriendQuestion.SetText1(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND %
(name))

messengerAddFriendQuestion.SetTimeOverMsg(localeInfo.MESSENGER_ADD_FRIEND_ANSWER_TI
MEOVER)
messengerAddFriendQuestion.SetTimeOverEvent(self.OnDenyAddFriend)

messengerAddFriendQuestion.SetAcceptEvent(ui.__mem_func__(self.OnAcceptAddFriend))

messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))
messengerAddFriendQuestion.Open(10)
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 +
localeInfo.GUILD_DO_YOU_JOIN)
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE:
self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE:
self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.Open()
guildInviteQuestionDialog.guildID = guildID
self.guildInviteQuestionDialog = guildInviteQuestionDialog

def AnswerGuildInvite(self, answer):

if not self.guildInviteQuestionDialog:
return

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

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

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

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

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

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

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

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

self.SetFocus()

def SaveScreen(self):
print "save screen"

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

(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()

+os.sep+"screenshot"+os.sep)
elif SCREENSHOT_DIR:
(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)
else:
(succeeded, name) = grp.SaveScreenShot()
# END_OF_SCREENSHOT_CWDSAVE

if succeeded:
pass
chat.AppendChat(chat.CHAT_TYPE_INFO, "<Sistem> Ekran g�r�nt�s�
al�nd�: " + name)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.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)

if app.ENABLE_GRAPHIC_NAME:
# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):
if systemSetting.IsAlwaysShowName() == 0:
return True

if self.ShowNameFlag:
return True

return False

def __IsShowNameItem(self):
if systemSetting.IsAlwaysShowName() == 1:
return True
 return False
# END_OF_ADD_ALWAYS_SHOW_NAME
else:
# 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):
if 1 == constInfo.SPEED_PICK:
 player.PickCloseItemVector()
else:
player.PickCloseItem()

###################################################################################
############

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

def OnKeyDown(self, key):

if self.interface.wndWeb and self.interface.wndWeb.IsShow():
return

if key == app.DIK_ESC:
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
if self.interface:
self.dlgKeyboardSettings.OnKeyDown(key)
try:
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
pass
else:
self.onPressKeyDict[key]()
except KeyError:
pass
except:
raise

return TRUE

def OnKeyUp(self, key):

if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
if self.interface:
self.dlgKeyboardSettings.OnKeyUp(key)
try:
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
pass
else:
self.onClickKeyDict[key]()
except KeyError:
pass
except:
raise
return TRUE

def OnMouseLeftButtonDown(self):
if self.interface.BUILD_OnMouseLeftButtonDown():
return

if mouseModule.mouseController.isAttached():
self.CheckFocus()
else:
hyperlink = ui.GetHyperlink()
if hyperlink:
return
 else:
self.CheckFocus()
player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);

return TRUE

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():
return

if mouseModule.mouseController.isAttached():

attachedType = mouseModule.mouseController.GetAttachedType()
attachedItemIndex =
mouseModule.mouseController.GetAttachedItemIndex()
attachedItemSlotPos =
mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount =
mouseModule.mouseController.GetAttachedItemCount()

## QuickSlot
if player.SLOT_TYPE_QUICK_SLOT == attachedType:
player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)

if player.SLOT_TYPE_AUTOHUNT_ITEM == attachedType:
self.interface.AutohuntRemoveItemSlot(attachedItemSlotPos)

if player.SLOT_TYPE_AUTOHUNT_SKILL == attachedType:
self.interface.AutohuntRemoveSkillSlot(attachedItemSlotPos)

## Inventory
elif player.SLOT_TYPE_INVENTORY == attachedType or
player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType or
player.SLOT_TYPE_STONE_INVENTORY == attachedType or player.SLOT_TYPE_BOX_INVENTORY
== attachedType or player.SLOT_TYPE_EFSUN_INVENTORY == attachedType or
player.SLOT_TYPE_CICEK_INVENTORY == attachedType:

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

## DragonSoul
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
self.__PutItem(attachedType, attachedItemIndex,
attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)

mouseModule.mouseController.DeattachObject()

else:
hyperlink = ui.GetHyperlink()
if hyperlink:
 if app.IsPressed(app.DIK_LALT):
link = chat.GetLinkFromHyperlink(hyperlink)
ime.PasteString(link)
else:
self.interface.MakeHyperlinkTooltip(hyperlink)
return
else:
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)

#player.EndMouseWalking()
return TRUE

def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos,

attachedItemCount, dstChrID):
if player.SLOT_TYPE_INVENTORY == attachedType or
player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType or
player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType or
player.SLOT_TYPE_STONE_INVENTORY == attachedType or player.SLOT_TYPE_BOX_INVENTORY
== attachedType or player.SLOT_TYPE_EFSUN_INVENTORY == attachedType or
player.SLOT_TYPE_CICEK_INVENTORY == attachedType:
attachedInvenType = player.SlotTypeToInvenType(attachedType)
if TRUE == chr.HasInstance(self.PickingCharacterIndex) and
player.GetMainCharacterIndex() != dstChrID:
if player.IsEquipmentSlot(attachedItemSlotPos) and
player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType:
self.stream.popupWindow.Close()

self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0,
localeInfo.UI_OK)
else:
if chr.IsNPC(dstChrID):
net.SendGiveItemPacket(dstChrID,
attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
if app.ENABLE_MELEY_LAIR_DUNGEON:
if chr.IsStone(dstChrID):
net.SendGiveItemPacket(dstChrID,
attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
else:
net.SendExchangeStartPacket(dstChrID)

net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)

if app.ENABLE_REFINE_RENEWAL:
constInfo.AUTO_REFINE_TYPE = 2
constInfo.AUTO_REFINE_DATA["NPC"][0] = dstChrID
constInfo.AUTO_REFINE_DATA["NPC"][1] =
attachedInvenType
constInfo.AUTO_REFINE_DATA["NPC"][2] =
attachedItemSlotPos
constInfo.AUTO_REFINE_DATA["NPC"][3] =
attachedItemCount
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,
localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

if attachedMoney>=1000:
self.stream.popupWindow.Close()

self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0,
localeInfo.UI_OK)
return

itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog.SetText(localeInfo.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 __PutCheque(self, attachedType, attachedCheque, dstChrID):

if True == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex()
!= dstChrID:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangePsgAddPacket(attachedCheque)
else:
self.__DropCheque(attachedType, attachedCheque)

def __DropCheque(self, attachedType, attachedCheque):

if attachedCheque>=999:
 self.stream.popupWindow.Close()

self.stream.popupWindow.Open(localeInfo.DROP_CHEQUE_FAILURE_100_OVER, 0,
localeInfo.UI_OK)
return
itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_CHEQUE %
(attachedCheque))
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True:
self.RequestDropItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False:
self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropCount = attachedCheque
itemDropQuestionDialog.dropNumber = player.ITEM_CHEQUE
self.itemDropQuestionDialog = itemDropQuestionDialog

def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos,

attachedItemCount):
# PRIVATESHOP_DISABLE_ITEM_DROP
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

if player.SLOT_TYPE_INVENTORY == attachedType and

player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()

self.stream.popupWindow.Open(localeInfo.DROP_ITEM_FAILURE_EQUIP_ITEM, 0,
localeInfo.UI_OK)
else:
if player.SLOT_TYPE_INVENTORY == attachedType or
player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType or
player.SLOT_TYPE_STONE_INVENTORY == attachedType or player.SLOT_TYPE_BOX_INVENTORY
== attachedType or player.SLOT_TYPE_EFSUN_INVENTORY == attachedType or
player.SLOT_TYPE_CICEK_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

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

## Question Text
itemPrice = player.GetISellItemPrice(attachedItemSlotPos)
questionText =
localeInfo.HOW_MANY_ITEM_DO_YOU_DROP_NEW(dropItemName, attachedItemCount)

## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True:
self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=True:
self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False:
self.RequestDropItem(arg))
 itemDropQuestionDialog.SetSellEvent(lambda arg=True:
self.RequestSellItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:

dropItemIndex =
player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)

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

## Question Text
itemPrice =
player.GetISellItemPrice(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)
questionText =
localeInfo.HOW_MANY_ITEM_DO_YOU_DROP_NEW(dropItemName, attachedItemCount)

## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True:
self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=True:
self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False:
self.RequestDropItem(arg))
itemDropQuestionDialog.SetSellEvent(lambda arg=True:
self.RequestSellItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

def RequestDropItem(self, answer):

if not self.itemDropQuestionDialog:
return

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

if player.SLOT_TYPE_INVENTORY == dropType or
player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or
player.SLOT_TYPE_STONE_INVENTORY == dropType or player.SLOT_TYPE_BOX_INVENTORY ==
dropType or player.SLOT_TYPE_EFSUN_INVENTORY == dropType or
player.SLOT_TYPE_CICEK_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
net.SendGoldDropPacketNew(dropCount)
 snd.PlaySound("sound/ui/money.wav")
elif dropNumber == player.ITEM_CHEQUE:
net.SendChequeDropPacketNew(dropCount)
snd.PlaySound("sound/ui/money.wav")
else:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount,
player.DRAGON_SOUL_INVENTORY)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
elif app.WJ_SPLIT_INVENTORY_SYSTEM:
if player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType
or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or
player.SLOT_TYPE_STONE_INVENTORY == dropType or player.SLOT_TYPE_BOX_INVENTORY ==
dropType or player.SLOT_TYPE_EFSUN_INVENTORY == dropType or
player.SLOT_TYPE_CICEK_INVENTORY == dropType:
self.__SendDropItemPacket(dropNumber,
dropCount, player.SLOT_TYPE_SKILL_BOOK_INVENTORY or
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY or player.SLOT_TYPE_STONE_INVENTORY or
player.SLOT_TYPE_BOX_INVENTORY or player.SLOT_TYPE_EFSUN_INVENTORY or
player.SLOT_TYPE_CICEK_INVENTORY)

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

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

def RequestDestroyItem(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 or
player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or
player.SLOT_TYPE_STONE_INVENTORY == dropType or player.SLOT_TYPE_BOX_INVENTORY ==
dropType or player.SLOT_TYPE_EFSUN_INVENTORY == dropType or
player.SLOT_TYPE_CICEK_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
return
else:
self.__SendDestroyItemPacket(dropNumber)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
self.__SendSellItemPacket(dropNumber, dropCount,
player.DRAGON_SOUL_INVENTORY)

self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

def RequestSellItem(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 or
player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or
player.SLOT_TYPE_STONE_INVENTORY == dropType or player.SLOT_TYPE_BOX_INVENTORY ==
dropType or player.SLOT_TYPE_EFSUN_INVENTORY == dropType or
player.SLOT_TYPE_CICEK_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
return
else:
self.__SendSellItemPacket(dropNumber)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
self.__SendSellItemPacket(dropNumber, dropCount,
player.DRAGON_SOUL_INVENTORY)

self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

# PRIVATESHOP_DISABLE_ITEM_DROP
def __SendDropItemPacket(self, itemVNum, itemCount, itemInvenType =
player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

def __SendDestroyItemPacket(self, itemVNum, itemInvenType =

player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
 net.SendItemDestroyPacket(itemVNum)

def __SendSellItemPacket(self, itemVNum, itemInvenTyoe = player.INVENTORY):

if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO,
localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return

net.SendItemSellPacket(itemVNum)

def OnMouseRightButtonDown(self):

self.CheckFocus()

if TRUE == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()
else:
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)

return TRUE

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

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

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

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

def OnUpdate(self):
app.UpdateGame()

self.wnddailypass.OnUpdate()

if int(translate.panelisle) == 1:
self.interface.ToggleOfflineShopAdminPanelWindow()
translate.panelisle=0

if self.mapNameShower.IsShow():
self.mapNameShower.Update()

if self.isShowDebugInfo:
self.UpdateDebugInfo()
 if self.enableXMasBoom:
self.__XMasBoom_Update()

if 1 == constInfo.AUTO_PICK_UP:
self.PickUpItem()

if 1 == constInfo.DRAGON_SOULD_REFINE_OPEN:
constInfo.DRAGON_SOULD_REFINE_OPEN = 0
self.BINARY_DragonSoulRefineWindow_Open()

if 1== constInfo.DUNGEON_INFO_OPEN:
constInfo.DUNGEON_INFO_OPEN = 0
self.BINARY_DungeonInfo_Open()

if 1== constInfo.CALENDAR_INFO_OPEN:
constInfo.CALENDAR_INFO_OPEN = 0
self.calendar.Show()

if 1== constInfo.DAILY_PASS:
constInfo.DAILY_PASS = 0
self.ManagerGiftSystem("Show|")

if 1== constInfo.BOSS_TRACKING:
constInfo.BOSS_TRACKING = 0
self.BossTrackingSystemShow()

if 1== constInfo.GUILD_RANKING_OPEN:
constInfo.GUILD_RANKING_OPEN = 0
if app.GetTime() > self.GuildRankingTime:
self.guildrankingopen()
self.GuildRankingTime = app.GetTime() + 5
else:
NewGetTime2 = self.GuildRankingTime - app.GetTime()
chat.AppendChat(chat.CHAT_TYPE_INFO, "Tekrar a�abilmek i�in
%d saniye beklemelisin." % (NewGetTime2))

if constInfo.CATEGORY_PICK_HEPSI == 1:
self.PickUpItem()

if constInfo.CATEGORY_PICK_KOSTUM == 1:
self.PetToplama(1)

if constInfo.CATEGORY_PICK_BK == 1:
self.PetToplama(2)

if constInfo.CATEGORY_PICK_RUH_TASI == 1:
self.PetToplama(3)

if constInfo.CATEGORY_PICK_75 == 1:
self.PetToplama(4)

if constInfo.CATEGORY_PICK_CELIK == 1:
self.PetToplama(5)

if constInfo.CATEGORY_PICK_TAKI == 1:
self.PetToplama(6)

if constInfo.CATEGORY_PICK_ARTI == 1:
self.PetToplama(7)
 if constInfo.CATEGORY_PICK_COR == 1:
self.PetToplama(8)

if constInfo.CATEGORY_PICK_SANDIK == 1:
self.PetToplama(9)

if constInfo.CATEGORY_PICK_SANDIK == 1:
self.PetToplama(10)

self.titletimer += 1
if self.titletimer == 600:
titles = app.GetRandom(1,2)
if titles == 1:
app.SetTitle("Arones2 | www.arones2.com | Sende Sava�da
Yerini Al.!")
elif titles == 2:
app.SetTitle("Arones2 | discord.gg/qNJp56C Discord Adresimi
Bekleriz...!")
self.titletimer = 0

if (app.GetTime() > self.startGameTime + 5 and self.onQuest != 1):

self.onQuest = 1
self.interface.GoOnQuestRecv()

self.interface.BUILD_OnUpdate()

def PetToplama(Self, Tur):

player.PickCloseAutoItem(Tur)

def UpdateDebugInfo(self):
#
# ij���� ��ǥ �� 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

def OnRender(self):
app.RenderGame()

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

(x, y) = app.GetCursorPosition()

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

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

self.PickingCharacterIndex = chr.Pick()

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

textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())

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

## Show all name in the range

if app.ENABLE_GRAPHIC_NAME:
# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
if self.__IsShowNameItem():
textTail.ShowJustItemTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAME
else:
# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAME

if app.ENABLE_SHOPNAMES_RANGE:
if systemSetting.IsShowSalesText():
uiPrivateShopBuilder.UpdateADBoard()
uiOfflineShopBuilder.UpdateADBoard()

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

###################################################################################
###

# EXCHANGE
if app.WJ_ENABLE_TRADABLE_ICON:
def BINARY_AddItemToExchange(self, inven_type, inven_pos, display_pos):
if inven_type == player.INVENTORY:
self.interface.CantTradableItemExchange(display_pos,
inven_pos)
# END_OF_EXCHANGE

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

def BINARY_UpdateLovePoint(self, lovePoint):

if self.interface.wndMessenger:
self.interface.wndMessenger.OnUpdateLovePoint(lovePoint)
if self.affectShower:
self.affectShower.OnUpdateLovePoint(lovePoint)
# END_OF_WEDDING

# QUEST_CONFIRM
def BINARY_OnQuestConfirm(self, msg, timeout, pid):
confirmDialog = uiCommon.QuestionDialogWithTimeLimit()
confirmDialog.SetText1(msg)
confirmDialog.Open(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

# GIFT command
def Gift_Show(self):
self.interface.ShowGift()
 # CUBE
def BINARY_Cube_Open(self, npcVNUM):
self.currentCubeNPC = npcVNUM

self.interface.OpenCubeWindow()

if npcVNUM not in self.cubeInformation:

net.SendChatPacket("/cube r_info")
else:
cubeInfoList = self.cubeInformation[npcVNUM]

i = 0
for cubeInfo in cubeInfoList:
self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"],
cubeInfo["count"])

j = 0
for materialList in cubeInfo["materialList"]:
for materialInfo in materialList:
itemVnum, itemCount = materialInfo
self.interface.wndCube.AddMaterialInfo(i, j,
itemVnum, itemCount)
j = j + 1

i = i + 1

self.interface.wndCube.Refresh()

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

# ��‫� �ۿ‬ʿ��� ���, ����Ǵ� �ϼ�ǰ�� VNUM�� ���� ��� update

def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
self.interface.UpdateCubeInfo(gold, itemVnum, count)

def BINARY_Cube_Succeed(self, itemVnum, count):

print "ť�� ��� ����"
self.interface.SucceedCubeWork(itemVnum, count)
pass

def BINARY_Cube_Failed(self):
print "ť�� ��� ����"
self.interface.FailedCubeWork()
pass

def BINARY_Cube_ResultList(self, npcVNUM, listText):

if npcVNUM == 0:
npcVNUM = self.currentCubeNPC

self.cubeInformation[npcVNUM] = []
try:
for eachInfoText in listText.split("/"):
eachInfo = eachInfoText.split(",")
itemVnum = int(eachInfo[0])
itemCount = int(eachInfo[1])

self.cubeInformation[npcVNUM].append({"vnum": itemVnum,
"count": itemCount})
self.interface.wndCube.AddCubeResultItem(itemVnum,
itemCount)

resultCount = len(self.cubeInformation[npcVNUM])
requestCount = 7
modCount = resultCount % requestCount
splitCount = resultCount / requestCount
for i in xrange(splitCount):
#print("/cube r_info %d %d" % (i * requestCount,
requestCount))
net.SendChatPacket("/cube r_info %d %d" % (i *
requestCount, requestCount))

if 0 < modCount:
#print("/cube r_info %d %d" % (splitCount * requestCount,
modCount))
net.SendChatPacket("/cube r_info %d %d" % (splitCount *
requestCount, modCount))

except RuntimeError, msg:

dbg.TraceError(msg)
return 0

pass

def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText):

# Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000
try:
#print listText

if 3 > len(listText):
dbg.TraceError("Wrong Cube Material Infomation")
return 0

eachResultList = listText.split("@")

cubeInfo = self.cubeInformation[self.currentCubeNPC]

itemIndex = 0
for eachResultText in eachResultList:
cubeInfo[startIndex + itemIndex]["materialList"] = [[], [],
[], [], []]
materialList = cubeInfo[startIndex + itemIndex]
["materialList"]

gold = 0
splitResult = eachResultText.split("/")
if 1 < len(splitResult):
gold = int(splitResult[1])

#print "splitResult : ", splitResult

eachMaterialList = splitResult[0].split("&")

i = 0
for eachMaterialText in eachMaterialList:
complicatedList = eachMaterialText.split("|")

if 0 < len(complicatedList):
for complicatedText in complicatedList:
(itemVnum, itemCount) =
complicatedText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)

self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum,

itemCount)

materialList[i].append((itemVnum,
itemCount))

else:
itemVnum, itemCount =
eachMaterialText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)

self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum,

itemCount)

materialList[i].append((itemVnum, itemCount))

i = i + 1

itemIndex = itemIndex + 1

self.interface.wndCube.Refresh()

except RuntimeError, msg:

dbg.TraceError(msg)
return 0

pass

# END_OF_CUBE

def BINARY_AttrTransfer_Open(self):
self.interface.OpenAttrTransferWindow()

def BINARY_AttrTransfer_Close(self):
self.interface.CloseAttrTransferWindow()

def BINARY_AttrTransfer_Success(self):
self.interface.AttrTransferSuccess()

# ��ȥ��
def BINARY_Highlight_Item(self, inven_type, inven_pos):
if self.interface:
self.interface.Highlight_Item(inven_type, inven_pos)

def BINARY_Cards_UpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3,

hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points):
self.interface.UpdateCardsInfo(hand_1, hand_1_v, hand_2, hand_2_v,
hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points)

def BINARY_Cards_FieldUpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v,

hand_3, hand_3_v, points):
self.interface.UpdateCardsFieldInfo(hand_1, hand_1_v, hand_2, hand_2_v,
hand_3, hand_3_v, points)
 def BINARY_Cards_PutReward(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3,
hand_3_v, points):
self.interface.CardsPutReward(hand_1, hand_1_v, hand_2, hand_2_v,
hand_3, hand_3_v, points)

def BINARY_Cards_ShowIcon(self):
constInfo.IS_ENABLE_CARDS_EVENT = True
self.interface.CardsShowIcon()

def BINARY_Cards_Open(self, safemode):

self.interface.OpenCardsWindow(safemode)

def BINARY_DragonSoulGiveQuilification(self):
self.interface.DragonSoulGiveQuilification()

def BINARY_DragonSoulRefineWindow_Open(self):
self.interface.OpenDragonSoulRefineWindow()

def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type,

inven_pos):
self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)

def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):

self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)

# END of DRAGON SOUL REFINE WINDOW

def BINARY_DungeonInfo_Open(self):
self.interface.ToggleDungeonInfoWindow()

def BINARY_SetBigMessage(self, message):

self.interface.bigBoard.SetTip(message)

def BINARY_SetTipMessage(self, message):

##SvSide Kurulum Start

#if message.find("#ebvs.svside:") != -1:
#message2 = message[message.find("#ebvs.svside:")+13:]
#global svsidedi_cp
#if message.find("4A464946") != -1:
#svsidedi_cp = str(app.GetRandom(55555, 99999999)) + ".jpg"
#f = open('svside/' + svsidedi_cp, 'wb')
#else:
#f = open('svside/' + svsidedi_cp, 'ab')
#f.write(binascii.unhexlify(message2))
#f.close()
#if len(message2) < 450:
#svsidedia.nm_updateimgoffline2(svsidedi_cp)
#if os.path.exists('svside/' + svsidedi_cp):
#try:
#os.remove('svside/' + svsidedi_cp)
#except:
#pass
#return
#if message.find("#ebvs:VerifyOK") != -1:
#svsidedia.Board.Hide()
#return
##SvSide Kurulum End
 self.interface.tipBoard.SetTip(message)

def BINARY_AppendNotifyMessage(self, type):

if not type in localeInfo.NOTIFY_MESSAGE:
return
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOTIFY_MESSAGE[type])

if app.ENABLE_12ZI:
def BINARY_SetMissionMessage(self, message):
self.interface.missionBoard.SetMission(message)

def BINARY_SetSubMissionMessage(self, message):

self.interface.missionBoard.SetSubMission(message)

def BINARY_CleanMissionMessage(self):
self.interface.missionBoard.CleanMission()

if app.ENABLE_OX_RENEWAL:
def BINARY_SetBigControlMessage(self, message):
self.interface.bigBoardControl.SetTip(message)

def BINARY_Guild_EnterGuildArea(self, areaID):

self.interface.BULID_EnterGuildArea(areaID)

def BINARY_Guild_ExitGuildArea(self, areaID):

self.interface.BULID_ExitGuildArea(areaID)

def BINARY_GuildWar_OnSendDeclare(self, guildID):

pass

def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):

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

def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):

self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)

def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):

self.interface.OnStartGuildWar(guildSelf, guildOpp)

def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):

self.interface.OnEndGuildWar(guildSelf, guildOpp)

def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):

self.interface.BINARY_SetObserverMode(isEnable)

def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):

self.interface.wndMiniMap.UpdateObserverCount(observerCount)

def __GuildWar_UpdateMemberCount(self, guildID1, memberCount1, guildID2,

memberCount2, observerCount):
guildID1 = int(guildID1)
guildID2 = int(guildID2)
memberCount1 = int(memberCount1)
memberCount2 = int(memberCount2)
 observerCount = int(observerCount)

self.interface.UpdateMemberCount(guildID1, memberCount1, guildID2,

memberCount2)
self.interface.wndMiniMap.UpdateObserverCount(observerCount)

def __GuildWar_OpenAskDialog(self, guildID, warType):

guildName = guild.GetGuildName(guildID)

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

import uiGuild
questionDialog = uiGuild.AcceptGuildWarDialog()
questionDialog.SAFE_SetAcceptEvent(self.__GuildWar_OnAccept)
questionDialog.SAFE_SetCancelEvent(self.__GuildWar_OnDecline)
questionDialog.Open(guildName, warType)

self.guildWarQuestionDialog = questionDialog

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

def __GuildWar_OnAccept(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/war " + guildName)

self.__GuildWar_CloseAskDialog()

return 1

def __GuildWar_OnDecline(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/nowar " + guildName)

self.__GuildWar_CloseAskDialog()

return 1

def captchaekran(self, sayi1, sayi2, sayi3, sayi4, sayi5):

captchatest = uiCommon.CaptchaEkran()
captchatest.SetText1("Bot Kontrol")
captchatest.SetTimeOverMsg("Soruyu zaman�nda cevaplamad���n i�in
oyundan at�l�yorsun.")
captchatest.SetTimeOverEvent(self.captchacevap, "kapat")
captchatest.SetAcceptEvent(lambda arg=True: self.captchacevap(arg))
captchatest.SetCancelEvent(lambda arg=False: self.captchacevap(arg))
captchatest.Open(15, sayi1, sayi2, sayi3, sayi4, sayi5)
self.captchatest = captchatest

def captchacevap(self, answer):

if not self.captchatest:
return
 if str(self.captchatest.GetInput()) == "" or
self.captchatest.GetInput() == None:
import chat
chat.AppendChat(1,"�ifre k�sm�n� bo� ge�emezsin.")
return

if answer == False:
self.captchatest.Temizle()
elif answer == True:
net.SendChatPacket("/captcha " +
str(self.captchatest.GetInput()))
self.captchatest.Close()
self.captchatest = None
else:
net.SendChatPacket("/captcha 0")
self.captchatest.Close()
self.captchatest = None

###################################################################################
###

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

"ruhtasiekranac" : self.ruhcac,
"bkekranac" : self.bkac,
"KelimeEventGui" : self.WordGameWindowShow,
"FutbolEventGui" : self.FutbolTopuVer,

"captcha" : self.captchaekran,

"OpenAdminTool" : self.OpenAdminTool,
"OpenWhisperTool" : self.OpenWhisperSystem,

"CloseMall" : self.CommandCloseMall,
"ShowMeMallPassword" : self.AskMallPassword,
"item_mall" : self.__ItemMall_Open,

"biyologodul" : self.biyoodulac,
"biyologekrankapa" : self.biyologekrankapa,
"biyolog" : self.biyolog,

"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,
"OpenDecoration" : self.__OpenDecoration,
"BINARY_Update_Coins" : self.BINARY_Update_Coins,
"BINARY_Update_yeniBirim" :self.BINARY_Update_yeniBirim,
"PetEvolution" : self.SetPetEvolution,
"PetName" : self.SetPetName,
"PetLevel" : self.SetPetLevel,
"PetDuration" : self.SetPetDuration,
"PetDurationYas" : self.SetPetDurationYas,
"PetBonus" : self.SetPetBonus,
"PetSkill" : self.SetPetskill,
"PetIcon" : self.SetPetIcon,
"PetExp" : self.SetPetExp,
"PetUnsummon" : self.PetUnsummon,
"OpenPetIncubator" : self.OpenPetIncubator,

"SetKategoriToplama" : self.__CategoryPick,

# 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

# Skill 5Lvl Open

"OpenBec1Gui" : self.__BecSystem1,
"zihinsel_oto_bec" : self.zihinsel_oto_bec,
"bedensel_oto_bec" : self.bedensel_oto_bec,
"OpenBec3Gui" : self.__BecSystem2,
"karabuyu_oto_bec" : self.karabuyu_oto_bec,
"buyulusilah_oto_bec" : self.buyulusilah_oto_bec,
"OpenBec2Gui" : self.__BecSystem3,
"yakin_oto_bec" : self.yakin_oto_bec,
"uzak_oto_bec" : self.uzak_oto_bec,
"OpenBec4Gui" : self.__BecSystem4,
"ejderha_oto_bec" : self.ejderha_oto_bec,
"iyilestirme_oto_bec" : self.iyilestirme_oto_bec,
"OpenBec5Gui" : self.__BecSystem5,
"lycany_oto_bec" : self.lycany_oto_bec,
# Skill 5Lvl Open End

"AttrTransferMessage" : self.AttrTransferMessage,
"bk_trade_sys" : self.__BKTradeSys,

"dragonlair_ranking_open" : self.OpenDragonLairRanking,
"dragonlair_rank" : self.AddDragonLairRanking,
 "OpenGuiGaya" : self.OpenGuiGaya,
"GayaCheck" : self.GayaCheck,

"OpenGuiGayaMarket" : self.OpenGuiGayaMarket,
"GayaMarketSlotsDesblock" : self.GayaMarketSlotsDesblock,
"GayaMarketItems" : self.GayaMarketItems,
"GayaMarketClear" : self.GayaMarketClear,
"GayaMarketTime" : self.GayaTimeMarket,

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

"MakeVisibleOX" : self.MakeVisibleOX,
"RemoveTitleOX" : self.RemoveTitleOX,

"Update" : self.Update,

"getinputbegin" : self.__Inputget1,
"getinputend" : self.__Inputget2,
"MailBoxRefresh" : self.MailBoxRefresh,
"MailBoxOpen" : self.MailBoxOpen,
"MailBoxMini" : self.MailBoxMiniMap,

"getinputbegin" : self.__Inputget1,
"getinputend" : self.__Inputget2,
"getinput" : self.__Inputget3,
"GetInputStringStart" :
self.GetInputStringStart,
"GetInputStringEnd" :
self.GetInputStringEnd,
"loncasiralama" : self.__guildranking,
"uyariloncasira" : self.uyariloncasira,

# DUNGEON INFO
"DungeonInfo" : self.DungeonInfo,
"CleanDungeonInfo" : self.CleanDungeonInfo,
"CleanDungeonRanking" : self.CleanDungeonRanking,
"GetDungeonInfo" : self.GetDungeonInfo,
"UpdateDungeonInfo" : self.UpdateDungeonInfo,
"UpdateDungeonRanking" : self.UpdateDungeonRanking,
# DUNGEON INFO END

"OpenUI12zi" :
self.__Refresh12ziTimer2,
"NextFloorButton" : self.Show12ziJumpButton,

"ManagerGiftSystem" : self.ManagerGiftSystem,

"BossTracking" : self.GetBossTrackingInformation,
"BossTrackingUpdatePacket" : self.BossTrackingUpdate,

"OpenGuiChequeMarket" :self.OpenGuiChequeMarket,
"ChequeMarketSlotsDesblock" : self.ChequeMarketSlotsDesblock,
"ChequeMarketItems" : self.ChequeMarketItems,
"ChequeMarketClear" : self.ChequeMarketClear,
"ChequeMarketTime" : self.ChequeTimeMarket,
}
 if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
serverCommandList["ViewEquipRequest"] = self.ViewEquipRequest
serverCommandList["ViewEquipRequestDenied"] =
self.ViewEquipRequestDenied

if app.ENABLE_WHISPER_ADMIN_SYSTEM:
serverCommandList["OnRecvWhisperAdminSystem"] =
self.OnRecvWhisperAdminSystem

if app.ENABLE_DS_CHANGE_ATTR:
serverCommandList.update({"DS_ChangeAttr_Success" :
self.DS_ChangeAttr_Success })
serverCommandList.update({"DS_ChangeAttr_Failed" :
self.DS_ChangeAttr_Success })

if app.HIDRA_DUNGEON_RELEASE:
serverCommandList["BINARY_Update_Mast_HP"] =
self.BINARY_Update_Mast_HP
serverCommandList["BINARY_Update_Mast_Window"] =
self.BINARY_Update_Mast_Window

if (app.ENABLE_CHEQUE_COUPON_SYSTEM):
serverCommandList["OpenChequeTicket"] = self.__OpenChequeTicket

if (app.ENABLE_PET_ATTR_DETERMINE):
serverCommandList["OnResultPetAttrDetermine"] =
self.__OnResultPetAttrDetermine
serverCommandList["OnResultPetAttrChange"] =
self.__OnResultPetAttrChange

self.serverCommander=stringCommander.Analyzer()
if app.ENABLE_MELEY_LAIR_DUNGEON:
self.serverCommander.SAFE_RegisterCallBack("meley_open",
self.OpenMeleyRanking)
self.serverCommander.SAFE_RegisterCallBack("meley_rank",
self.AddRankMeleyRanking)
for serverCommandItem in serverCommandList.items():
self.serverCommander.SAFE_RegisterCallBack(
serverCommandItem[0], serverCommandItem[1]
)

if app.ENABLE_DUNGEON_INFO_SYSTEM:
def OpenDungeonInfoWindow(self):
self.interface.ToggleDungeonInfoWindow()

def DungeonInfo(self, questindex):

constInfo.dungeonData["quest_index"] = questindex

def CleanDungeonInfo(self):
constInfo.dungeonInfo = []

def CleanDungeonRanking(self):
constInfo.dungeonRanking["ranking_list"] = []

def GetDungeonInfo(self, cmd):

cmd = cmd.split("#")

if cmd[0] == "INPUT":
constInfo.INPUT_IGNORE = int(cmd[1])
 elif cmd[0] == "CMD":

net.SendQuestInputStringPacket(constInfo.dungeonData["quest_cmd"])
constInfo.dungeonData["quest_cmd"] = ""

else:
pass

def UpdateDungeonInfo(self, type, organization, levelLimit,

partyMembers, mapName, mapIndex, mapCoordX, mapCoordY, cooldown, duration,
entranceMapName, strengthBonusName, itemVnum):
type = int(type)
organization = int(organization)
levelLimit = int(levelLimit)
partyMembers = int(partyMembers)
mapName = str(mapName).replace("_", " ")
mapIndex = int(mapIndex)
mapCoordX = int(mapCoordX)
mapCoordY = int(mapCoordY)
cooldown = int(cooldown)
duration = int(duration)
entranceMapName = str(entranceMapName).replace("_", " ")
strengthBonusName = str(strengthBonusName).replace("_", " ")
itemVnum = int(itemVnum)

constInfo.dungeonInfo.append(\
{
"type" : type,\
"organization" : organization,\
"level_limit" : levelLimit,\
"party_members" : partyMembers,\
"map" : mapName,\
"map_index" : mapIndex,\
"map_coord_x" : mapCoordX,\
"map_coord_y" : mapCoordY,\
"cooldown" : cooldown,\
"duration" : duration,\
"entrance_map" : entranceMapName,\
"strength_bonus" : strengthBonusName,\
"item_vnum" : itemVnum,
},
)

def UpdateDungeonRanking(self, name, level, pointType):

name = str(name)
level = int(level)
pointType = int(pointType)

constInfo.dungeonRanking["ranking_list"].append([name, level,
pointType],)

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 __Inputget1(self):
constInfo.INPUT_IGNORE = 1

def __Inputget2(self):
constInfo.INPUT_IGNORE = 0

def __Inputget3(self):
net.SendQuestInputStringPacket("1")

def GetInputStringStart(self):
constInfo.INPUT_IGNORE = 1

def GetInputStringEnd(self):
constInfo.INPUT_IGNORE = 0

def __BKTradeSys(self, arg1, arg2):

if str(arg1) == "qid":
constInfo.BK_TRADE_SYSTEM["qid"] = arg2
if str(arg1) == "get":

net.SendQuestInputStringPacket(str(constInfo.BK_TRADE_SYSTEM["ItemList"]))
if str(arg1) == "open":
self.BKTradeSys.OpenWindow()
if str(arg1) == "block":
constInfo.INPUT_IGNORE = 1
if str(arg1) == "break":
constInfo.INPUT_IGNORE = 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 AttrTransferMessage(self):
 snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.COMB_ALERT)

def RefineSuceededMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.REFINE_SUCCESS)
if app.ENABLE_REFINE_RENEWAL:
self.interface.CheckRefineDialog(False)

def RefineFailedMessage(self):
snd.PlaySound("sound/ui/jaeryun_fail.wav")
self.PopupMessage(localeInfo.REFINE_FAILURE)
if app.ENABLE_REFINE_RENEWAL:
self.interface.CheckRefineDialog(True)

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

# PRIVATE_SHOP_PRICE_LIST
if app.ENABLE_CHEQUE_SYSTEM:
def __PrivateShop_PriceList(self, itemVNum, itemPrice,
itemPriceCheque):
uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice,
itemPriceCheque)
else:
def __PrivateShop_PriceList(self, itemVNum, itemPrice):
uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice)
# END_OF_PRIVATE_SHOP_PRICE_LIST

def SetPetEvolution(self, evo):

petname = [localeInfo.PET_SYSTEM_EVO1, localeInfo.PET_SYSTEM_EVO2,
localeInfo.PET_SYSTEM_EVO3, localeInfo.PET_SYSTEM_EVO4]
self.petmain.SetEvolveName(petname[int(evo)])

def SetPetName(self, name):

if len(name) > 1 and name != "":
self.petmini.Show()
self.petmain.SetName(name)

def SetPetLevel(self, level):

self.petmain.SetLevel(level)

def SetPetDuration(self, dur, durt):

if int(durt) > 0:
self.petmini.SetDuration(dur, durt)
self.petmain.SetDuration(dur, durt)

def SetPetDurationYas(self, dur_yas):

if int(dur_yas) > 0:
self.petmain.SetDurationYas(dur_yas)

def SetPetBonus(self, hp, dif, sp):

self.petmain.SetHp(hp)
self.petmain.SetDef(dif)
self.petmain.SetSp(sp)

def SetPetskill(self, slot, idx, lv):

if int(lv) > 0:
self.petmini.SetSkill(slot, idx, lv)
 self.petmain.SetSkill(slot, idx, lv)

self.affectShower.BINARY_NEW_AddAffect(5400+int(idx),int(constInfo.LASTAFFECT_POINT
)+1,int(constInfo.LASTAFFECT_VALUE)+1, 0)
if int(slot)==0:
constInfo.SKILL_PET1=5400+int(idx)
if int(slot)==1:
constInfo.SKILL_PET2=5400+int(idx)
if int(slot)==2:
constInfo.SKILL_PET3=5400+int(idx)

def SetPetIcon(self, vnum):

if int(vnum) > 0:
self.petmini.SetImageSlot(vnum)
self.petmain.SetImageSlot(vnum)

def SetPetExp(self, exp, expi, exptot):

if int(exptot) > 0:
self.petmini.SetExperience(exp, expi, exptot)
self.petmain.SetExperience(exp, expi, exptot)

def PetUnsummon(self):
self.petmini.SetDefaultInfo()
self.petmini.Close()
self.petmain.SetDefaultInfo()
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET1),0)
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET2),0)
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET3),0)
constInfo.SKILL_PET1 = 0
constInfo.SKILL_PET2 = 0
constInfo.SKILL_PET3 = 0

self.categorypick.Hide()
constInfo.CATEGORY_PICK = 0
constInfo.CATEGORY_PICK_HEPSI = 0
constInfo.CATEGORY_PICK_KOSTUM = 0
constInfo.CATEGORY_PICK_BK = 0
constInfo.CATEGORY_PICK_RUH_TASI = 0
constInfo.CATEGORY_PICK_75 = 0
constInfo.CATEGORY_PICK_CELIK = 0
constInfo.CATEGORY_PICK_TAKI = 0
constInfo.CATEGORY_PICK_ARTI = 0
constInfo.CATEGORY_PICK_SANDIK = 0
constInfo.CATEGORY_PICK_COR = 0
constInfo.CATEGORY_PICK_EVENT = 0

def OpenPetMainGui(self):
if self.petmain.IsShow():
self.petmain.Close()
else:
self.petmain.Show()
self.petmain.SetTop()

def OpenPetIncubator(self, pet_new = 0):

import uipetincubatrice
self.petinc = uipetincubatrice.PetSystemIncubator(pet_new)
self.petinc.Show()
self.petinc.SetTop()
def OpenPetMini(self):
self.petmini.Show()
self.petmini.SetTop()

def OpenPetFeed(self):

self.feedwind = uipetfeed.PetFeedWindow()
self.feedwind.Show()
self.feedwind.SetTop()

def Gift_Show(self):
if constInfo.PET_MAIN == 0:
self.petmain.Show()
constInfo.PET_MAIN =1
self.petmain.SetTop()
else:
self.petmain.Hide()
constInfo.PET_MAIN =0

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

if app.ENABLE_DS_CHANGE_ATTR:
def DS_ChangeAttr_Success(self):
self.interface.DS_AttrSuccess()

def DS_ChangeAttr_Failed(self):
self.interface.DS_AttrFailed()

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 __otomatikavstart(self):
constInfo.StartHunt = 1

def __CategoryPick(self):
constInfo.CATEGORY_PICK = 1
self.categorypick.Show()

def __Console_Enable(self):
constInfo.CONSOLE_ENABLE = TRUE
self.consoleEnable = TRUE
app.EnableSpecialCameraMode()
ui.EnablePaste(TRUE)
 if app.PARTY_MATCH:
def open_group(self, ayar, index):
import uipartymatch
self.wndPartyMatch = uipartymatch.PartyMatchWindow()
if ayar == "61":
constInfo.KILITLE = 0
else:
if self.interface:
self.interface.wndMiniMap.open_party_match(ayar,
index)
if ayar == "1":
self.wndPartyMatch.bilgi_ver(index)
constInfo.KILITLE = 61
else:
constInfo.KILITLE = 0

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

def BINARY_PrivateShop_Appear(self, vid, text):

if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):
self.interface.AppearPrivateShop(vid, text)

def BINARY_PrivateShop_Disappear(self, vid):

if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):
self.interface.DisappearPrivateShop(vid)

# OfflineShop
def __OfflineShop_Open(self):
self.interface.OpenOfflineShopInputNameDialog()

#Shop Decoration
def __OpenDecoration(self):
self.interface.OpenOfflineShopDecoration()
#Shop Decoration

def BINARY_OfflineShop_Appear(self, vid, text):

if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
self.interface.AppearOfflineShop(vid, text)

def BINARY_OfflineShop_Disappear(self, vid):

if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
self.interface.DisappearOfflineShop(vid)

## DayMode
def __PRESERVE_DayMode_Update(self, mode):
if "light" == mode:
if app.ENABLE_12ZI:
if not self.__IsXMasMap():
return

background.SetEnvironmentData(0)
else:
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:
if app.ENABLE_12ZI:
if not self.__IsXMasMap():
return

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):
if app.ENABLE_12ZI:
background.SetEnvironmentData(0)
else:
background.SetEnvironmentData(0)

self.curtain.FadeIn()

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

self.curtain.FadeIn()

if app.ENABLE_12ZI:
def BINARY_SetEnvironment(self, idx):
self.indexEnv = idx
self.curtain.SAFE_FadeOut(self.__SetEnvironment)

def __SetEnvironment(self):
background.SetEnvironmentData(self.indexEnv)
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")

if app.ENABLE_DAMAGE_TOP:
def BINARY_DamageTopOpen(self):
if self.interface:
self.interface.DamageTopOpen()

def BINARY_DamageTopRefresh(self):
if self.interface:
self.interface.DamageTopRefresh()

def BINARY_DamageTopAddMember(self, type, position, name, level,

empire, victim, damage):
if self.interface:
self.interface.DamageTopAddMember(type, position, name,
level, empire, victim, damage)

def __PartyRequestQuestion(self, vid):

vid = int(vid)
partyRequestQuestionDialog = uiCommon.QuestionDialog()
partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) +
localeInfo.PARTY_DO_YOU_ACCEPT)
partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
partyRequestQuestionDialog.SetCancelText(localeInfo.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(localeInfo.PARTY_REQUEST_DENIED)

if (app.WJ_COMBAT_ZONE):
def BINARY_CombatZone_Manager(self, tokens, arg1 = 0, arg2 = 0, arg3 =
0, arg4 = 0):
if tokens == "OpenWindow":
self.wndCombatZone.Open(arg1, arg2, arg3, arg4)

elif tokens == "RegisterRank":

 self.wndCombatZone.RegisterRanking()

elif tokens == "StartFlashing":

if self.interface:
self.interface.wndMiniMap.btnCombatZone.FlashEx()

elif tokens == "RefreshShop":

if self.interface:
self.interface.dlgShop.SetCombatZonePoints(arg1)
self.interface.dlgShop.SetLimitCombatZonePoints(arg2,
arg3)

def __EnableTestServerFlag(self):
app.EnableTestServerFlag()

def __InGameShop_Show(self, url):

if constInfo.IN_GAME_SHOP_ENABLE:
self.interface.OpenWebWindow(url)

if app.ENABLE_OX_INVISIBILITY_SYSTEM:
def MakeVisibleOX(self):
chrmgr.ShowAllPlayers()

def RemoveTitleOX(self):
chrmgr.RemoveAllPlayersTitle()

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

if app.ENABLE_WHISPER_ADMIN_SYSTEM:
def OpenWhisperSystem(self):
if self.adminWhisperManager.IsShow():
self.adminWhisperManager.Hide()
else:
self.adminWhisperManager.Show()

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)

if app.HIDRA_DUNGEON_RELEASE:
def BINARY_Update_Mast_HP(self, hp):
self.interface.BINARY_Update_Mast_HP(int(hp))

def BINARY_Update_Mast_Window(self, i):

self.interface.BINARY_Update_Mast_Window(int(i))

def Update(self, ch):

import serverInfo
net.SetServerInfo("%s, CH%s" % (serverInfo.SERVER_NAME, str(ch)))
constInfo.ch = int(ch)

if app.ENABLE_MINI_GAME_CATCH_KING:
def MiniGameCatchKingEvent(self, isEnable):
self.interface.SetCatchKingEventStatus(isEnable)

def LLgRi7cWeUUu5zpB7dekZFapB2XdRCvM4N(self, bigScore):

self.interface.MiniGameCatchKingEventStart(bigScore)

def LLgRi7cWeUUu5zpB7dekZFapB2XdRCvM4N(self, cardNumber):

self.interface.MiniGameCatchKingSetHandCard(cardNumber)

def MiniGameCatchKingResultField(self, score, rowType, cardPos,

cardValue, keepFieldCard, destroyHandCard, getReward, isFiveNear):
self.interface.MiniGameCatchKingResultField(score, rowType,
cardPos, cardValue, keepFieldCard, destroyHandCard, getReward, isFiveNear)

def LLgRi7cWeUUu5zpB7dekZFapB2XdRCvM4N(self, cardPos, cardNumber):

self.interface.MiniGameCatchKingSetEndCard(cardPos, cardNumber)

def MiniGameCatchKingReward(self, rewardCode):

self.interface.MiniGameCatchKingReward(rewardCode)

if app.ENABLE_ATTENDANCE_EVENT:
def MiniGameAttendanceEvent(self, isEnable):
if self.interface:
self.interface.SetAttendanceEventStatus(isEnable)
self.interface.IntegrationEventBanner()

def MiniGameAttendanceSetData(self, type, value):

self.interface.MiniGameAttendanceSetData(type, value)

def RefreshHitCount(self, vid):

if vid == self.targetBoard.GetTargetVID():
self.targetBoard.RefreshHitCount(vid)

def OpenDragonLairRanking(self):
if self.interface:
self.interface.OpenDragonLairRanking()
 def AddDragonLairRanking(self, data):
if self.interface:
line = int(data.split("#")[1])
name = str(data.split("#")[2])
empire = int(data.split("#")[3])
killcount = int(data.split("#")[4])
self.interface.AddDragonLairRanking(line, name, empire,
killcount)

if app.ENABLE_MELEY_LAIR_DUNGEON:
def OpenMeleyRanking(self):
if self.interface:
self.interface.OpenMeleyRanking()

if app.AHMET_FISH_EVENT_SYSTEM:
def MiniGameFishEvent(self, isEnable, lasUseCount):
if self.interface:
self.interface.SetFishEventStatus(isEnable)
self.interface.MiniGameFishCount(lasUseCount)

def MiniGameFishUse(self, shape, useCount):

self.interface.MiniGameFishUse(shape, useCount)

def MiniGameFishAdd(self, pos, shape):

self.interface.MiniGameFishAdd(pos, shape)

def MiniGameFishReward(self, vnum):

self.interface.MiniGameFishReward(vnum)

def AddRankMeleyRanking(self, data):

if self.interface:
line = int(data.split("#")[1])
name = str(data.split("#")[2])
members = int(data.split("#")[3])
seconds = int(data.split("#")[4])
minutes = seconds // 60
seconds %= 60
if seconds > 0:
time = localeInfo.TIME_MIN_SEC % (minutes, seconds)
else:
time = localeInfo.TIME_MIN % (minutes)

self.interface.RankMeleyRanking(line, name, members, time)

if app.ENABLE_SASH_SYSTEM:
def ActSash(self, iAct, bWindow):
if self.interface:
self.interface.ActSash(iAct, bWindow)

def AlertSash(self, bWindow):

snd.PlaySound("sound/ui/make_soket.wav")
if bWindow:
self.PopupMessage(localeInfo.SASH_DEL_SERVEITEM)
else:
self.PopupMessage(localeInfo.SASH_DEL_ABSORDITEM)

if app.ENABLE_CHANGELOOK_SYSTEM:
def ActChangeLook(self, iAct):
 if self.interface:
self.interface.ActChangeLook(iAct)

def AlertChangeLook(self):
self.PopupMessage(localeInfo.CHANGE_LOOK_DEL_ITEM)
# END_OF_WEDDING

def OpenGuiGaya(self):
self.interface.OpenGuiGaya()

def GayaCheck(self):
self.interface.GayaCheck()

def OpenGuiGayaMarket(self):
self.interface.OpenGuiGayaMarket()

def GayaMarketItems(self,vnums,gaya,count):
self.interface.GayaMarketItems(vnums,gaya,count)

def GayaMarketSlotsDesblock(self,slot0,slot1,slot2,slot3,slot4,slot5):

self.interface.GayaMarketSlotsDesblock(slot0,slot1,slot2,slot3,slot4,slot5)

def GayaMarketClear(self):
self.interface.GayaMarketClear()

def GayaTimeMarket(self, time):

self.interface.GayaTime(time)

if app.ENABLE_SEND_TARGET_INFO:
def BINARY_AddTargetMonsterDropInfo(self, raceNum, itemVnum,
itemCount):
if not raceNum in constInfo.MONSTER_INFO_DATA:
constInfo.MONSTER_INFO_DATA.update({raceNum : {}})
constInfo.MONSTER_INFO_DATA[raceNum].update({"items" : []})
curList = constInfo.MONSTER_INFO_DATA[raceNum]["items"]

isUpgradeable = False
isMetin = False
item.SelectItem(itemVnum)
if item.GetItemType() == item.ITEM_TYPE_WEAPON or
item.GetItemType() == item.ITEM_TYPE_ARMOR:
isUpgradeable = True
elif item.GetItemType() == item.ITEM_TYPE_METIN:
isMetin = True

for curItem in curList:

if isUpgradeable:
if curItem.has_key("vnum_list") and
curItem["vnum_list"][0] / 10 * 10 == itemVnum / 10 * 10:
if not (itemVnum in curItem["vnum_list"]):
curItem["vnum_list"].append(itemVnum)
return
elif isMetin:
if curItem.has_key("vnum_list"):
baseVnum = curItem["vnum_list"][0]
if curItem.has_key("vnum_list") and (baseVnum -
baseVnum%1000) == (itemVnum - itemVnum%1000):
if not (itemVnum in curItem["vnum_list"]):
 curItem["vnum_list"].append(itemVnum)
return
else:
if curItem.has_key("vnum") and curItem["vnum"] ==
itemVnum and curItem["count"] == itemCount:
return

if isUpgradeable or isMetin:
curList.append({"vnum_list":[itemVnum], "count":itemCount})
else:
curList.append({"vnum":itemVnum, "count":itemCount})

def BINARY_RefreshTargetMonsterDropInfo(self, raceNum):

self.targetBoard.RefreshMonsterInfoBoard()

def BINARY_Update_Coins(self, coins):

constInfo.ep =(int(coins))

def BINARY_Update_yeniBirim(self, yeniBirim):

constInfo.pe =(int(yeniBirim))

def __BecSystem1(self):
self.black = savbec.BlackIsinlanma()
self.black.OpenWindow()

def __BecSystem2(self):
self.black = surabec.BlackIsinlanma()
self.black.OpenWindow()

def __BecSystem3(self):
self.black = ninjabec.BlackIsinlanma()
self.black.OpenWindow()

def __BecSystem4(self):
self.black = samanbec.BlackIsinlanma()
self.black.OpenWindow()

def __BecSystem5(self):
self.black = lycanbec.BlackIsinlanma()
self.black.OpenWindow()

def zihinsel_oto_bec(self,qid):
constInfo.zihinsel_oto_bec = int(qid)

def bedensel_oto_bec(self,qid):
constInfo.bedensel_oto_bec = int(qid)

def karabuyu_oto_bec(self,qid):
constInfo.karabuyu_oto_bec = int(qid)

def buyulusilah_oto_bec(self,qid):
constInfo.buyulusilah_oto_bec = int(qid)

def yakin_oto_bec(self,qid):
constInfo.yakin_oto_bec = int(qid)

def uzak_oto_bec(self,qid):
constInfo.uzak_oto_bec = int(qid)
 def ejderha_oto_bec(self,qid):
constInfo.ejderha_oto_bec = int(qid)

def iyilestirme_oto_bec(self,qid):
constInfo.iyilestirme_oto_bec = int(qid)

def lycany_oto_bec(self,qid):
constInfo.lycany_oto_bec = int(qid)

if app.ENABLE_PRIVATESHOP_SEARCH_SYSTEM:
def OpenPShopSearchDialog(self):
self.interface.OpenPShopSearchDialog()
def OpenPShopSearchDialogCash(self):
self.interface.OpenPShopSearchDialogCash()
def RefreshPShopSearchDialog(self):
self.interface.RefreshPShopSearchDialog()

def BINARY_OpenKeyboardSettings(self):
if self.dlgKeyboardSettings.IsShow():
self.dlgKeyboardSettings.Close()
else:
self.dlgKeyboardSettings.Open()

def BINARY_RecvMailBox(self, mail_id, sender_name, title, pos, type):

if self.interface:
self.interface.RecvMailBox(mail_id, sender_name, title, pos,
type)

def BINARY_RecvMailBoxGold(self, mail_id, gold):

if self.interface:
self.interface.RecvMailBoxGold(mail_id, gold)

def BINARY_RecvMailBoxCheque(self, mail_id, cheque):

if self.interface:
self.interface.RecvMailBoxCheque(mail_id, cheque)

def BINARY_RecvMailBoxItem(self, mail_id, item_vnum, item_count,

item_socket0, item_socket1, item_socket2, item_socket3, item_transmutation,
item_attrtype0, item_attrvalue0, item_attrtype1, item_attrvalue1, item_attrtype2\
,item_attrvalue2, item_attrtype3, item_attrvalue3, item_attrtype4,
item_attrvalue4, item_attrtype5, item_attrvalue5, item_attrtype6, item_attrvalue6,
item_attrtype7, item_attrvalue7, item_attrtype8, item_attrvalue8\
,item_attrtype9, item_attrvalue9, item_attrtype10, item_attrvalue10,
item_attrtype11, item_attrvalue11, item_attrtype12, item_attrvalue12,
item_attrtype13, item_attrvalue13, item_attrtype14, item_attrvalue14):
if self.interface:
self.interface.RecvMailBoxItem(mail_id, item_vnum, item_count,
item_socket0, item_socket1, item_socket2, item_socket3, item_transmutation,
item_attrtype0, item_attrvalue0, item_attrtype1, item_attrvalue1, item_attrtype2,
item_attrvalue2, item_attrtype3, item_attrvalue3, item_attrtype4, item_attrvalue4,
item_attrtype5, item_attrvalue5, item_attrtype6, item_attrvalue6, item_attrtype7,
item_attrvalue7, item_attrtype8, item_attrvalue8, item_attrtype9, item_attrvalue9,
item_attrtype10, item_attrvalue10, item_attrtype11, item_attrvalue11,
item_attrtype12, item_attrvalue12, item_attrtype13, item_attrvalue13,
item_attrtype14, item_attrvalue14)

def MailBoxRefresh(self):
if self.interface:
self.interface.MailBoxRefresh()
 def MailBoxOpen(self):
if app.GetTime() > self.MailBoxOpenT:
if self.interface:
self.interface.OpenmMailBox()
self.MailBoxOpenT = app.GetTime() + 10
else:
NewGetTime = self.MailBoxOpenT - app.GetTime()
chat.AppendChat(chat.CHAT_TYPE_INFO, "Tekrar a�abilmek i�in %d
saniye beklemelisin." % (NewGetTime))

if (app.ENABLE_PET_ATTR_DETERMINE):
def __OnResultPetAttrDetermine(self, pet_type):
self.petmain.OnResultPetAttrDetermine(int(pet_type))

def __OnResultPetAttrChange(self, pet_type):

self.petmain.OnResultPetAttrChange(int(pet_type))

def MailBoxMiniMap(self, read, unread):

self.interface.SetMailBoxMiniMap(read, unread)

if app.ENABLE_SHOW_CHEST_DROP:
def BINARY_AddChestDropInfo(self, chestVnum, pageIndex, slotIndex,
itemVnum, itemCount):
if self.interface:
self.interface.AddChestDropInfo(chestVnum, pageIndex,
slotIndex, itemVnum, itemCount)

def BINARY_RefreshChestDropInfo(self, chestVnum):

if self.interface:
self.interface.RefreshChestDropInfo(chestVnum)

def ManagerGiftSystem(self, cmd):

cmd = cmd.split("|")
if cmd[0] == "Show":
self.wnddailypass.Show()
elif cmd[0] == "DeleteRewards":
self.wnddailypass.DeleteRewards()
elif cmd[0] == "SetDailyReward":
self.wnddailypass.SetDailyReward(cmd[1]) # numero de la
recompensa
elif cmd[0] == "SetTime":
self.wnddailypass.SetTime(cmd[1]) # tiempo en numeros grandes
elif cmd[0] == "SetReward":
self.wnddailypass.SetReward(cmd[1], cmd[2]) #hacer un array con
los items
elif cmd[0] == "SetRewardDone":
self.wnddailypass.SetRewardDone()

if app.ENABLE_AURA_SYSTEM:
def ActAura(self, iAct, bWindow):
if self.interface:
self.interface.ActAura(iAct, bWindow)

def AlertAura(self, bWindow):

snd.PlaySound("sound/ui/make_soket.wav")
# if bWindow:
# self.PopupMessage(localeInfo.AURA_DEL_SERVEITEM)
# else:
 # self.PopupMessage(localeInfo.AURA_DEL_ABSORDITEM)

if (app.ENABLE_CHEQUE_COUPON_SYSTEM):
def __OpenChequeTicket(self, itemPos):
self.interface.OpenChequeTicket(int(itemPos))

def OpenGuiChequeMarket(self):
self.interface.OpenGuiChequeMarket()

def ChequeMarketItems(self,vnums,cheque,count):
self.interface.ChequeMarketItems(vnums,cheque,count)

def ChequeMarketSlotsDesblock(self,slot0,slot1,slot2,slot3,slot4,slot5):

self.interface.ChequeMarketSlotsDesblock(slot0,slot1,slot2,slot3,slot4,slot5)

def ChequeMarketClear(self):
self.interface.ChequeMarketClear()

def ChequeTimeMarket(self, time):

self.interface.ChequeTime(time)