import os

import app

import dbg

import grp

import item

import background

import chr

import chrmgr

import player

import oyunicisiralama

import loncasiralama

import uiboard

import snd

import chat

import event

import textTail

import snd

import net

import effect

import wndMgr

import fly

import systemSetting

import quest

import guild

import skill

import albay

import messenger

import uiadmintool

import localeInfo

import constInfo

import gameInfo

import exchange

import ime

import uisaplingsw

import time

import BKTrade

import ui

import uiCommon

import uiPhaseCurtain

import uiMapNameShower

import uiAffectShower

import uiPlayerGauge

import uiCharacter

import uiTarget

import uiarayuz

import uiPrivateShopBuilder

import uiOfflineShopBuilder

import uiOfflineShop

import mouseModule

import consoleModule

import localeInfo

import loncatanit

import playerSettingModule

import interfaceModule

import marek38

import record

import uibiyolog

import itemchance

import uiRoulette

import uimarbleshop

import background

import musicInfo

import debugInfo

import stringCommander

import uisupportsystem

import uibkoku

import uiruhtasi

import uievent

import skybox

if app.ENABLE_PVP_ADVANCED:

import constInfo as pvp

import uiCommon as message

import uiduel

from _weakref import proxy

# TEXTTAIL_LIVINGTIME_CONTROL

#if localeInfo.IsJAPAN():

# app.SetTextTailLivingTime(8.0)

# END_OF_TEXTTAIL_LIVINGTIME_CONTROL

# 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

# PROFESSIONAL_BIOLOG_SYSTEM

if app.ENABLE_BIOLOG_SYSTEM:

import uiprofessionalbiolog

# END_OF_PROFESSIONAL_BIOLOG_SYSTEM

BPisLodaded = 0

class GameWindow(ui.ScriptWindow):

def __init__(self, stream):

ui.ScriptWindow.__init__(self, "GAME")

self.SetWindowName("game")

net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)

player.SetGameWindow(self)

self.boardgift = uiboard.GiftBoard()

self.boardgift.Hide()

self.quickSlotPageIndex = 0

self.lastPKModeSendedTime = 0

self.pressNumber = None

self.guildWarQuestionDialog = None

self.interface = None

self.skybox = None

self.targetBoard = None

self.console = None

self.mapNameShower = None

self.affectShower = None

self.playerGauge = None

self.arayuz = None

# Kral Lonca && Oyuncu Sistemi

self.endTime = 0

# Kral Lonca && Oyuncu Sistemi

self.stream=stream

self.interface = interfaceModule.Interface()

self.interface.MakeInterface()

self.interface.ShowDefaultWindows()

self.curtain = uiPhaseCurtain.PhaseCurtain()

self.curtain.speed = 0.03

self.curtain.Hide()

self.biyoekran = uibiyolog.BiyologEkran()

self.biyoekran.Hide()

self.recordscreen = record.recordwindow()

self.oyunicisiralama = oyunicisiralama.oyunicisirala()

self.loncasiralama = loncasiralama.loncasiralama()

self.loncanitanit = loncatanit.loncatanit()

self.BKTradeSys = BKTrade.BKTrade()

self.BKTradeSys.Close()

self.targetBoard = uiTarget.TargetBoard()

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

self.targetBoard.Hide()

self.console = consoleModule.ConsoleWindow()

self.console.BindGameClass(self)

self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200)

self.console.Hide()

self.supportpg = uisupportsystem.SupportMainGui()

self.mapNameShower = uiMapNameShower.MapNameShower()

self.affectShower = uiAffectShower.AffectShower()

self.wndMarbleShop = uimarbleshop.MarbleShopWindow()

import uimaintenance

self.wndMaintenance = uimaintenance.MaintenanceClass()

if app.ENABLE_PVP_ADVANCED:

self.wndDuelGui = uiduel.Initializate()

self.wndDuelLive = uiduel.WindowLiveInformations()

self.wndAdminTool = uiadmintool.AdminTool()

import uibankamanger

self.managerAccountBank = uibankamanger.BankGui()

self.managerAccountBank.Hide()

import uiticket

self.wndTicket = uiticket.TicketBoard()

self.wndTicketStaff = uiticket.TicketBoardAdmin()

self.wndTicketReply = uiticket.TicketBoardInformationsID()

self.playerGauge = uiPlayerGauge.PlayerGauge(self)

self.playerGauge.Hide()

self.playerGauge = uiPlayerGauge.PlayerGauge(self)

self.playerGauge.Hide()

self.arayuz = uiarayuz.arayuzdialog()

self.arayuz.Show()

self.bkoku = uibkoku.BKOku()

self.bkoku.Hide()

self.ruhtasi = uiruhtasi.RuhTasi()

self.ruhtasi.Hide()

self.itemDropQuestionDialog = None

self.titletimer = 0

self.__SetQuickSlotMode()

self.__ServerCommand_Build()

self.__ProcessPreservedServerCommand()

self.wndItemChance = itemchance.ItemChance()

self.Roulette = uiRoulette.RouletteWindow()

def __del__(self):

player.SetGameWindow(0)

net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)

ui.ScriptWindow.__del__(self)

def Open(self):

app.SetFrameSkip(1)

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

self.quickSlotPageIndex = 0

self.PickingCharacterIndex = -1

self.PickingItemIndex = -1

self.consoleEnable = False

self.isShowDebugInfo = False

self.ShowNameFlag = False

self.enableXMasBoom = False

self.startTimeXMasBoom = 0.0

self.indexXMasBoom = 0

self.mapNameTextLine = ui.TextLine()

self.mapNameTextLine.SetFontName(localeInfo.UI_DEF_FONT_LARGE)

self.mapNameTextLine.SetFeather()

self.mapNameTextLine.SetOutline()

self.mapNameTextLine.Show()

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

uiPrivateShopBuilder.Clear()

uiOfflineShopBuilder.Clear()

exchange.InitTrading()

if debugInfo.IsDebugMode():

self.ToggleDebugInfo()

## Sound

snd.SetMusicVolume(systemSetting.GetMusicVolume()*net.GetFieldMusicVolume())

snd.SetSoundVolume(systemSetting.GetSoundVolume())

netFieldMusicFileName = net.GetFieldMusicFileName()

if netFieldMusicFileName:

snd.FadeInMusic("BGM/" + netFieldMusicFileName)

elif musicInfo.fieldMusic != "":

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

self.__SetQuickSlotMode()

self.__SelectQuickPage(self.quickSlotPageIndex)

self.SetFocus()

self.Show()

app.ShowCursor()

net.SendEnterGamePacket()

# START_GAME_ERROR_EXIT

try:

self.StartGame()

except:

import exception

exception.Abort("GameWindow.Open")

# END_OF_START_GAME_ERROR_EXIT

# NPC°¡ Å¥ºê½Ã½ºÅÛÀ¸·Î ¸¸µé ¼ö ÀÖ´Â ¾ÆÀÌÅÛµéÀÇ ¸ñ·ÏÀ» ij½Ì

# ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]

self.cubeInformation = {}

self.currentCubeNPC = 0

def bkac(self):

self.bkoku.Show()

def ruhcac(self):

self.ruhtasi.Show()

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

if self.loncanitanit.IsShow():

self.loncanitanit.Open()

self.guildNameBoard = None

self.partyRequestQuestionDialog = None

self.partyInviteQuestionDialog = None

self.guildInviteQuestionDialog = None

self.guildWarQuestionDialog = None

self.messengerAddFriendQuestion = None

self.itemDropQuestionDialog = None

if self.recordscreen.IsShow():

self.recordscreen.Open()

if self.oyunicisiralama.IsShow():

self.oyunicisiralama.Open()

if self.loncasiralama.IsShow():

self.loncasiralama.Open()

# QUEST_CONFIRM

self.confirmDialog = None

# END_OF_QUEST_CONFIRM

if app.TOURNAMENT_PVP_SYSTEM:

constInfo.TOURNAMENT_WINDOW_IS_SHOWED = 0

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

self.playerGauge = None

self.managerAccountBank = None

self.mapNameShower = None

self.affectShower = None

if self.bkoku:

self.bkoku.Destroy()

self.bkoku = None

if self.ruhtasi:

self.ruhtasi.Destroy()

self.ruhtasi = None

if self.console:

self.console.BindGameClass(0)

self.console.Close()

self.console=None

if self.wndMaintenance.IsShow():

self.wndMaintenance.Hide()

if app.ENABLE_PVP_ADVANCED:

if self.wndDuelLive.IsShow():

self.wndDuelLive.Hide()

if self.targetBoard:

self.targetBoard.Destroy()

self.targetBoard = None

if self.wndMarbleShop:

self.wndMarbleShop.Hide()

if self.wndAdminTool:

self.wndAdminTool.Hide()

if self.wndTicket:

self.wndTicket.Hide()

if self.Roulette.IsShow():

self.Roulette.Open()

if self.wndTicketReply:

self.wndTicketReply.Hide()

if self.wndTicketStaff:

self.wndTicketStaff.Hide()

if self.interface:

self.interface.HideAllWindows()

self.interface.Close()

self.interface=None

if self.managerAccountBank:

self.managerAccountBank.Close()

player.ClearSkillDict()

player.ResetCameraRotation()

self.KillFocus()

app.HideCursor()

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

if self.wndItemChance.IsShow():

self.wndItemChance.Open()

def __BuildKeyDict(self):

onPressKeyDict = {}

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

## ¼ıÀÚ ´ÜÃàÅ° Äü½½·Ô¿¡ ÀÌ¿ëµÈ´Ù.(ÀÌÈÄ ¼ıÀڵ鵵 Äü ½½·Ô¿ë ¿¹¾à)

## F12 ´Â Ŭ¶ó µğ¹ö±×¿ë Å°À̹ǷΠ¾²Áö ¾Ê´Â °Ô ÁÁ´Ù.

onPressKeyDict[app.DIK_1] = lambda : self.__PressNumKey(1)

onPressKeyDict[app.DIK_2] = lambda : self.__PressNumKey(2)

onPressKeyDict[app.DIK_3] = lambda : self.__PressNumKey(3)

onPressKeyDict[app.DIK_4] = lambda : self.__PressNumKey(4)

onPressKeyDict[app.DIK_5] = lambda : self.__PressNumKey(5)

onPressKeyDict[app.DIK_6] = lambda : self.__PressNumKey(6)

onPressKeyDict[app.DIK_7] = lambda : self.__PressNumKey(7)

onPressKeyDict[app.DIK_8] = lambda : self.__PressNumKey(8)

onPressKeyDict[app.DIK_9] = lambda : self.__PressNumKey(9)

onPressKeyDict[app.DIK_F1] = lambda : self.__PressQuickSlot(4)

onPressKeyDict[app.DIK_F2] = lambda : self.__PressQuickSlot(5)

onPressKeyDict[app.DIK_F3] = lambda : self.__PressQuickSlot(6)

onPressKeyDict[app.DIK_F4] = lambda : self.__PressQuickSlot(7)

onPressKeyDict[app.DIK_F6] = lambda : self.SkyboxSelectMode()

onPressKeyDict[app.DIK_NUMPAD3] = lambda : self.recordac()

onPressKeyDict[app.DIK_NUMPAD2] = lambda : self.loncasiralamaopen()

onPressKeyDict[app.DIK_NUMPAD1] = lambda : self.siralamaopen()

onPressKeyDict[app.DIK_U] = lambda : self.__EventSystem()

onPressKeyDict[app.DIK_Y] = lambda : self.OpenTicketReply()

onPressKeyDict[app.DIK_P] = lambda : self.OpenTicketStaff()

onPressKeyDict[app.DIK_F12] = lambda : self.OpenTicket()

onPressKeyDict[app.DIK_F9] = lambda : self.OpenAdminTool()

onPressKeyDict[app.DIK_F11] = lambda : self.OpenMarbleShop()

onPressKeyDict[app.DIK_LALT] = lambda : self.ShowName()

onPressKeyDict[app.DIK_LCONTROL] = lambda : self.ShowMouseImage()

onPressKeyDict[app.DIK_SYSRQ] = lambda : self.SaveScreen()

onPressKeyDict[app.DIK_SPACE] = lambda : self.StartAttack()

#ij¸¯ÅÍ À̵¿Å°

onPressKeyDict[app.DIK_UP] = lambda : self.MoveUp()

onPressKeyDict[app.DIK_DOWN] = lambda : self.MoveDown()

onPressKeyDict[app.DIK_LEFT] = lambda : self.MoveLeft()

onPressKeyDict[app.DIK_RIGHT] = lambda : self.MoveRight()

onPressKeyDict[app.DIK_W] = lambda : self.MoveUp()

onPressKeyDict[app.DIK_S] = lambda : self.MoveDown()

onPressKeyDict[app.DIK_A] = lambda : self.MoveLeft()

onPressKeyDict[app.DIK_D] = lambda : self.MoveRight()

onPressKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_TO_NEGATIVE)

#onPressKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_G] = self.__PressGKey

onPressKeyDict[app.DIK_Q] = self.__PressQKey

#onPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()

onPressKeyDict[app.DIK_NUMPAD9] = lambda : self.getir()

onPressKeyDict[app.DIK_NUMPAD8] = lambda : self.gotur()

#onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)

#onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)

#onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)

#onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)

#onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)

#onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()

onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()

onPressKeyDict[app.DIK_C] = lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)

onPressKeyDict[app.DIK_V] = lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)

#onPressKeyDict[app.DIK_B] = lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)

onPressKeyDict[app.DIK_N] = lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)

onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()

onPressKeyDict[app.DIK_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()

# CUBE_TEST

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

# CUBE_TEST_END

self.onPressKeyDict = onPressKeyDict

onClickKeyDict = {}

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

onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()

onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()

onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()

onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()

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

onClickKeyDict[app.DIK_S] = lambda : self.StopDown()

onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()

onClickKeyDict[app.DIK_D] = lambda : self.StopRight()

onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)

onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)

onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)

onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)

onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)

onPressKeyDict[app.DIK_X] = lambda state = "Bonus": self.interface.ToggleCharacterWindow(state)

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_F5] = lambda: self.OpenSupportGui()

onClickKeyDict[app.DIK_F10] = lambda: self.__CanBoard()

if app.WJ_SPLIT_INVENTORY_SYSTEM:

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

#if constInfo.PVPMODE_ACCELKEY_ENABLE:

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

self.onClickKeyDict=onClickKeyDict

if app.WJ_SPLIT_INVENTORY_SYSTEM:

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:

#net.SendChatPacket("/user_horse_ride")

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)

def OpenTicket(self):

if self.wndTicket.IsShow():

self.wndTicket.Hide()

else:

self.wndTicket.Show()

def OpenTicketReply(self):

if self.wndTicketReply.IsShow():

self.wndTicketReply.Hide()

else:

self.wndTicketReply.Show()

def OpenTicketStaff(self):

if self.wndTicketStaff.IsShow():

self.wndTicketStaff.Hide()

else:

self.wndTicketStaff.Show()

def OpenAdminTool(self):

if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL): # Open window with CTRL + F5

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 0==interfaceModule.IsQBHide:

interfaceModule.IsQBHide = 1

self.interface.HideAllQuestButton()

else:

interfaceModule.IsQBHide = 0

self.interface.ShowAllQuestButton()

else:

app.RotateCamera(app.CAMERA_TO_NEGATIVE)

def __SetQuickSlotMode(self):

self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)

def __SetQuickPageMode(self):

self.pressNumber=ui.__mem_func__(self.__SelectQuickPage)

def __PressQuickSlot(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 __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)

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)

def OnChangePKMode(self):

self.interface.OnChangePKMode()

try:

self.__NotifyError(localeInfo.OPTION_PVPMODE_MESSAGE_DICT[player.GetPKMode()])

except KeyError:

print "UNKNOWN PVPMode[%d]" % (player.GetPKMode())

if constInfo.PVPMODE_TEST_ENABLE:

curPKMode = player.GetPKMode()

alignment, grade = chr.testGetPKData()

self.pkModeNameDict = { 0 : "PEACE", 1 : "REVENGE", 2 : "FREE", 3 : "PROTECT", }

self.testPKMode.SetText("Current PK Mode : " + self.pkModeNameDict.get(curPKMode, "UNKNOWN"))

self.testAlignment.SetText("Current Alignment : " + str(alignment) + " (" + localeInfo.TITLE_NAME_LIST[grade] + ")")

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

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

## Game Callback Functions

# Start

def StartGame(self):

self.RefreshInventory()

self.RefreshEquipment()

self.RefreshCharacter()

self.RefreshSkill()

# Refresh

def CheckGameButton(self):

if self.interface:

self.interface.CheckGameButton()

def RefreshAlignment(self):

self.interface.RefreshAlignment()

def RefreshStatus(self):

self.CheckGameButton()

if self.interface:

self.interface.RefreshStatus()

if self.playerGauge:

self.playerGauge.RefreshGauge()

def RefreshStamina(self):

self.interface.RefreshStamina()

def RefreshSkill(self):

self.CheckGameButton()

if self.interface:

self.interface.RefreshSkill()

def RefreshQuest(self):

self.interface.RefreshQuest()

def RefreshMessenger(self):

self.interface.RefreshMessenger()

def RefreshGuildInfoPage(self):

self.interface.RefreshGuildInfoPage()

def RefreshGuildBoardPage(self):

self.interface.RefreshGuildBoardPage()

def RefreshGuildMemberPage(self):

self.interface.RefreshGuildMemberPage()

def RefreshGuildMemberPageGradeComboBox(self):

self.interface.RefreshGuildMemberPageGradeComboBox()

def RefreshGuildSkillPage(self):

self.interface.RefreshGuildSkillPage()

def RefreshGuildGradePage(self):

self.interface.RefreshGuildGradePage()

def RefreshMobile(self):

if self.interface:

self.interface.RefreshMobile()

def OnMobileAuthority(self):

self.interface.OnMobileAuthority()

def OnBlockMode(self, mode):

self.interface.OnBlockMode(mode)

def OpenQuestWindow(self, skin, idx):

if gameInfo.INPUT_IGNORE == 1:

return

if gameInfo.INPUT==1:

return

if gameInfo.INPUT_IGNORE:

return

if constInfo.INPUT == 1:

return

if constInfo.INPUT_IGNORE == 1:

return

self.interface.OpenQuestWindow(skin, idx)

def __StoneWheel(self, getInfo):

CMD = getInfo.split("/")

if CMD[0]=="config":

string = CMD[1].split("|")

constInfo.STONEWHEEL_BY_KILROY[0] = (int(string[0]))

constInfo.STONEWHEEL_BY_KILROY[1] = (int(string[1]))

self.wndItemChance.SetToVars(string[2].split("#"), 1)

elif CMD[0]=="input":

net.SendQuestInputStringPacket(str(constInfo.STONEWHEEL_BY_KILROY[2]))

elif CMD[0]=="setrand":

self.wndItemChance.SetToVars(CMD[1].split("#"), 2)

elif CMD[0]=="yangstatus":

self.wndItemChance.YangAnswerFromServer(int(CMD[1]))

def __StoneWheelOpen(self):

self.wndItemChance.Open()

def __SchicksalRad(self, cmd):

CMD = cmd.split("/")

if CMD[0]=="index":

constInfo.SCHICKSAL_RAD["index"] = int(CMD[1])

constInfo.SCHICKSAL_RAD["kosten"] = int(CMD[2])

constInfo.SCHICKSAL_RAD["free"] = int(CMD[3])

elif CMD[0]=="input":

net.SendQuestInputStringPacket(str(constInfo.SCHICKSAL_RAD["ServerCMD"]))

elif CMD[0]=="free":

constInfo.SCHICKSAL_RAD["free"] = int(CMD[1])

elif CMD[0]=="Answer":

self.SchicksalRad.SetVars(CMD[1], CMD[2], CMD[3], CMD[4], CMD[5])

constInfo.SCHICKSAL_RAD["free"] = int(CMD[6])

def __SchicksalRadOpen(self):

self.SchicksalRad.Open()

def __uiRoulette(self, info):

CMD = info.split("/")

if CMD[0]=="index":

constInfo.uiRoulette["index"] = int(CMD[1])

elif CMD[0]=="gui":

constInfo.uiRoulette["kugel"] = int(CMD[1])

constInfo.uiRoulette["max_points"] = int(CMD[2])

constInfo.uiRoulette["points"] = int(CMD[3])

def __uiRouletteOpen(self):

self.Roulette.Open()

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)

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

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_PVP_ADVANCED:

pvp.DUEL_IS_SHOW_EQUIP = 0

pvp.DUEL_SAVE_VID = (int(vid))

self.interface.OpenEquipmentDialog(vid)

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

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

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

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

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

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

# SHOW_LOCAL_MAP_NAME

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

if self.interface:

self.interface.SetMapName(mapName)

try:

mapNameT = localeInfo.MINIMAP_ZONE_NAME_DICT[mapName]

self.mapNameTextLine.SetText(mapNameT)

self.mapNameTextLine.SetPosition(wndMgr.GetScreenWidth() - 6 * len(mapNameT) - 125, 10)

except:

self.mapNameTextLine.SetText(mapName)

# END_OF_SHOW_LOCAL_MAP_NAME

def BINARY_OpenAtlasWindow(self):

self.interface.BINARY_OpenAtlasWindow()

## Chat

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

if mode == chat.WHISPER_TYPE_GM:

self.interface.RegisterGameMasterName(name)

if line.find("#zacqooleavenEnvanter_Teklifi#") != -1:

if os.path.exists(str(constInfo.CLIENT_YOL)+"profil_"+str(player.GetName())+".kf"):

return

if line.find("#Sorgu#") != -1:

self.EnvanterDialog = uiCommon.QuestionDialog()

self.EnvanterDialog.SetText(localeInfo.OYUN_ENVANTER % (str(name)))

self.EnvanterDialog.SetAcceptEvent(lambda arg=TRUE: self.OnEnvanterDialog(name, 1))

self.EnvanterDialog.SetCancelEvent(lambda arg=FALSE: self.OnEnvanterDialog(name, 0))

self.EnvanterDialog.Open()

else:

if line.find("Red") != -1:

self.uyari = uiCommon.PopupDialog()

self.uyari.SetText(localeInfo.ENVANTER_RED)

self.uyari.Open()

return

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OYUN_ENVANTER_CHAT % (name))

net.SendChatPacket("/view_equip " + str(constInfo.ENVANTER_TARGET_VID))

return

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 OnEnvanterDialog(self, ad, flag):

if flag == 0:

self.EnvanterDialog.Close()

return

self.EnvanterDialog.Close()

net.SendWhisperPacket(ad, "#zacqooleavenEnvanter_Teklifi#Cevap#")

def RecvWhisper(self, name):

self.interface.RecvWhisper(name)

def OnPickMoney(self, money):

self.interface.OnPickMoneyNew(money)

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)

self.interface.OnPickitemNew(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

def StartShop(self, vid):

self.interface.OpenShopDialog(vid)

def EndShop(self):

self.interface.CloseShopDialog()

def RefreshShop(self):

self.interface.RefreshShopDialog()

def StartOfflineShop(self, vid):

self.interface.OpenOfflineShopDialog(vid)

def EndOfflineShop(self):

self.interface.CloseOfflineShopDialog()

def RefreshOfflineShop(self):

self.interface.RefreshOfflineShopDialog()

def SetShopSellingPrice(self, Price):

pass

## Exchange

def StartExchange(self):

self.interface.StartExchange()

def EndExchange(self):

self.interface.EndExchange()

def RefreshExchange(self):

self.interface.RefreshExchange()

## Party

def RecvPartyInviteQuestion(self, leaderVID, leaderName):

partyInviteQuestionDialog = uiCommon.QuestionDialog()

partyInviteQuestionDialog.SetText(leaderName + localeInfo.PARTY_DO_YOU_JOIN)

partyInviteQuestionDialog.SetAcceptEvent(lambda arg=True: self.AnswerPartyInvite(arg))

partyInviteQuestionDialog.SetCancelEvent(lambda arg=False: self.AnswerPartyInvite(arg))

partyInviteQuestionDialog.Open()

partyInviteQuestionDialog.partyLeaderVID = leaderVID

self.partyInviteQuestionDialog = partyInviteQuestionDialog

def AnswerPartyInvite(self, answer):

if not self.partyInviteQuestionDialog:

return

partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

distance = player.GetCharacterDistance(partyLeaderVID)

if distance < 0.0 or distance > 5000:

answer = False

net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

self.partyInviteQuestionDialog.Close()

self.partyInviteQuestionDialog = None

def AddPartyMember(self, pid, name):

self.interface.AddPartyMember(pid, name)

def UpdatePartyMemberInfo(self, pid):

self.interface.UpdatePartyMemberInfo(pid)

def RemovePartyMember(self, pid):

self.interface.RemovePartyMember(pid)

self.__RefreshTargetBoard()

def LinkPartyMember(self, pid, vid):

self.interface.LinkPartyMember(pid, vid)

def UnlinkPartyMember(self, pid):

self.interface.UnlinkPartyMember(pid)

def UnlinkAllPartyMember(self):

self.interface.UnlinkAllPartyMember()

def ExitParty(self):

self.interface.ExitParty()

self.RefreshTargetBoardByVID(self.targetBoard.GetTargetVID())

def ChangePartyParameter(self, distributionMode):

self.interface.ChangePartyParameter(distributionMode)

## Messenger

def OnMessengerAddFriendQuestion(self, name):

messengerAddFriendQuestion = uiCommon.QuestionDialog2()

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

messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)

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

messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))

messengerAddFriendQuestion.Open()

messengerAddFriendQuestion.name = name

self.messengerAddFriendQuestion = messengerAddFriendQuestion

def OnAcceptAddFriend(self):

name = self.messengerAddFriendQuestion.name

net.SendChatPacket("/messenger_auth y " + name)

self.OnCloseAddFriendQuestionDialog()

return True

def OnDenyAddFriend(self):

name = self.messengerAddFriendQuestion.name

net.SendChatPacket("/messenger_auth n " + name)

self.OnCloseAddFriendQuestionDialog()

return True

def OnCloseAddFriendQuestionDialog(self):

self.messengerAddFriendQuestion.Close()

self.messengerAddFriendQuestion = None

return True

## SafeBox

def OpenSafeboxWindow(self, size):

self.interface.OpenSafeboxWindow(size)

def RefreshSafebox(self):

self.interface.RefreshSafebox()

def RefreshSafeboxMoney(self):

self.interface.RefreshSafeboxMoney()

# ITEM_MALL

def OpenMallWindow(self, size):

self.interface.OpenMallWindow(size)

def RefreshMall(self):

self.interface.RefreshMall()

# END_OF_ITEM_MALL

## Guild

def RecvGuildInviteQuestion(self, guildID, guildName):

guildInviteQuestionDialog = uiCommon.QuestionDialog()

guildInviteQuestionDialog.SetText(guildName + 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, name + localeInfo.SCREENSHOT_SAVE1)

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE2)

"""

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)

# 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 BINARY_Update_Maintenance(self, iTime, iDuration, iReason):

sTime = int(iTime)

sDuration = int(iDuration)

sReason = str(iReason)

if sTime != 0 and sDuration != 0:

self.wndMaintenance.OpenMaintenance(int(iTime), int(iDuration), str(iReason))

def MoveUp(self):

player.SetSingleDIKKeyState(app.DIK_UP, True)

def MoveDown(self):

player.SetSingleDIKKeyState(app.DIK_DOWN, True)

def MoveLeft(self):

player.SetSingleDIKKeyState(app.DIK_LEFT, True)

def MoveRight(self):

player.SetSingleDIKKeyState(app.DIK_RIGHT, True)

def StopUp(self):

player.SetSingleDIKKeyState(app.DIK_UP, False)

def StopDown(self):

player.SetSingleDIKKeyState(app.DIK_DOWN, False)

def StopLeft(self):

player.SetSingleDIKKeyState(app.DIK_LEFT, False)

def StopRight(self):

player.SetSingleDIKKeyState(app.DIK_RIGHT, False)

def PickUpItem(self):

player.PickCloseItem()

def PickUpMoney(self):

player.PickCloseMoney()

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

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

## Event Handler

def OnKeyDown(self, key):

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

return

if key == app.DIK_ESC:

self.RequestDropItem(False)

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

try:

self.onPressKeyDict[key]()

except KeyError:

pass

except:

raise

return True

def OnKeyUp(self, key):

try:

self.onClickKeyDict[key]()

except KeyError:

pass

except:

raise

return True

def OnMouseLeftButtonDown(self):

if self.interface.BUILD_OnMouseLeftButtonDown():

return

if mouseModule.mouseController.isAttached():

self.CheckFocus()

else:

hyperlink = ui.GetHyperlink()

if hyperlink:

return

else:

self.CheckFocus()

player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);

return True

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():

return

if mouseModule.mouseController.isAttached():

attachedType = mouseModule.mouseController.GetAttachedType()

attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()

## QuickSlot

if player.SLOT_TYPE_QUICK_SLOT == attachedType:

player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)

## Inventory

elif player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY:

if player.ITEM_MONEY == attachedItemIndex:

self.__PutMoney(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:

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:

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)

else:

self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)

def __PutMoney(self, attachedType, attachedMoney, dstChrID):

if True == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeElkAddPacket(attachedMoney)

else:

self.__DropMoney(attachedType, attachedMoney)

def __DropMoney(self, attachedType, attachedMoney):

# PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)

return

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)

return

# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP2

if (uiOfflineShop.IsEditingOfflineShop()):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)

return

# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2

if attachedMoney>=1000:

self.stream.popupWindow.Close()

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

return

itemDropQuestionDialog = uiCommon.QuestionDialogItem()

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.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))

itemDropQuestionDialog.Open()

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropCount = attachedMoney

itemDropQuestionDialog.dropNumber = player.ITEM_MONEY

self.itemDropQuestionDialog = itemDropQuestionDialog

def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):

# PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)

return

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)

return

# END_OFF_OFFLINESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP2

if (uiOfflineShop.IsEditingOfflineShop()):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)

return

# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2

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:

dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

item.SelectItem(dropItemIndex)

dropItemName = item.GetItemName()

## Question Text

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

itemDropQuestionDialog = uiCommon.QuestionDialogItem()

itemDropQuestionDialog.SetText(questionText)

itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))

itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))

itemDropQuestionDialog.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(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

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

itemDropQuestionDialog = uiCommon.QuestionDialogItem()

itemDropQuestionDialog.SetText(questionText)

itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))

itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))

itemDropQuestionDialog.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(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:

if dropNumber == player.ITEM_MONEY:

net.SendGoldDropPacketNew(dropCount)

snd.PlaySound("sound/ui/money.wav")

else:

# PRIVATESHOP_DISABLE_ITEM_DROP

self.__SendDropItemPacket(dropNumber, dropCount)

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

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

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

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:

if dropNumber == player.ITEM_MONEY:

return

else:

self.__SendDestroyItemPacket(dropNumber)

self.itemDropQuestionDialog.Close()

self.itemDropQuestionDialog = None

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

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)

def __SendDestroyItemPacket(self, itemVNum, itemInvenType = player.INVENTORY):

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)

return

import uiCommon

questionDialog = uiCommon.QuestionDialog()

questionDialog.SetText(("|cff00ff00|H|h %s |cffFDD017|H|hisimli eşyay?silmek istedi?ne emin misin?" % (item.GetItemName())))

questionDialog.SetAcceptEvent(lambda arg = True: net.SendItemDestroyPacket(itemVNum) or self.questionDialog.Close())

questionDialog.SetCancelEvent(ui.__mem_func__(self.SendDestrooyItemPacket))

questionDialog.Open()

self.questionDialog = questionDialog

def SendDestrooyItemPacket(self):

self.questionDialog.Close()

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

if 1 == constInfo.premium:

constInfo.premium = 0

self.__premium()

import seapnp

if seapnp.isinlabeni == 1:

self.__CanBoard()

seapnp.isinlabeni = 0

if app.ENABLE_PVP_ADVANCED:

if pvp.DUEL_IS_SHOW_EQUIP == int(1):

self.interface.CloseEquipmentDialog(int(pvp.DUEL_SAVE_VID))

if self.mapNameShower.IsShow():

self.mapNameShower.Update()

if self.isShowDebugInfo:

self.UpdateDebugInfo()

if self.enableXMasBoom:

self.__XMasBoom_Update()

if 0 == constInfo.auto_pick_item:

self.PickUpItem()

if 0 == constInfo.auto_pick_yang:

self.PickUpMoney()

if app.KASMIR_PAKET_SYSTEM:

if marek38.VERI_PAKETI1==1:

self.__PrivateShop_Kasmir_Open()

marek38.VERI_PAKETI1=0

# Kral Lonca && Oyuncu Sistemi

lastTime = max(0, self.endTime - time.clock())

if 0 == lastTime:

self.__ShowKLImage()

curTime = time.clock()

self.endTime = curTime + 4

# Kral Lonca && Oyuncu Sistemi

self.interface.BUILD_OnUpdate()

# Kral Lonca && Oyuncu Sistemi

def __ShowKLImage(self):

KLName = player.GetGuildName()

if KLName[:4] == "[KL]":

net.SendChatPacket("(klicon)")

elif player.GetName().find("[KRAL]") != -1:

net.SendChatPacket("(kralicon)")

# Kral Lonca && Oyuncu Sistemi

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

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

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

xMouse, yMouse = wndMgr.GetMousePosition()

self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))

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

if fAveRT>1.0:

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

self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))

#self.Pitch.SetText("Pitch: %.2f" % (app.GetCameraPitch())

#self.TextureNum.SetText("TN : %s" % (sTextureNum))

#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))

self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))

def OnRender(self):

app.RenderGame()

if self.console.Console.collision:

background.RenderCollision()

chr.RenderCollision()

(x, y) = app.GetCursorPosition()

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

# Picking

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

textTail.UpdateAllTextTail()

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

self.PickingCharacterIndex = chr.Pick()

if -1 != self.PickingCharacterIndex:

textTail.ShowCharacterTextTail(self.PickingCharacterIndex)

if 0 != self.targetBoard.GetTargetVID():

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

# ADD_ALWAYS_SHOW_NAME

if not self.__IsShowName():

self.PickingItemIndex = item.Pick()

if -1 != self.PickingItemIndex:

textTail.ShowItemTextTail(self.PickingItemIndex)

# END_OF_ADD_ALWAYS_SHOW_NAME

## Show all name in the range

# ADD_ALWAYS_SHOW_NAME

if self.__IsShowName():

textTail.ShowAllTextTail()

self.PickingItemIndex = textTail.Pick(x, y)

# END_OF_ADD_ALWAYS_SHOW_NAME

textTail.UpdateShowingTextTail()

textTail.ArrangeTextTail()

if -1 != self.PickingItemIndex:

textTail.SelectItemName(self.PickingItemIndex)

grp.PopState()

grp.SetInterfaceRenderState()

textTail.Render()

textTail.HideAllTextTail()

def OnPressEscapeKey(self):

if app.TARGET == app.GetCursor():

app.SetCursor(app.NORMAL)

elif True == mouseModule.mouseController.isAttached():

mouseModule.mouseController.DeattachObject()

else:

self.interface.OpenSystemDialog()

if self.recordscreen.IsShow():

self.recordscreen.Open()

if self.oyunicisiralama.IsShow():

self.oyunicisiralama.Open()

if self.loncasiralama.IsShow():

self.loncasiralama.Open()

return TRUE

def OnIMEReturn(self):

if app.IsPressed(app.DIK_LSHIFT):

self.interface.OpenWhisperDialogWithoutTarget()

else:

self.interface.ToggleChat()

return True

def OnPressExitKey(self):

self.interface.ToggleSystemDialog()

return True

## BINARY CALLBACK

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

# WEDDING

def BINARY_LoverInfo(self, name, lovePoint):

if self.interface.wndMessenger:

self.interface.wndMessenger.OnAddLover(name, lovePoint)

if self.affectShower:

self.affectShower.SetLoverInfo(name, lovePoint)

def BINARY_UpdateLovePoint(self, lovePoint):

if self.interface.wndMessenger:

self.interface.wndMessenger.OnUpdateLovePoint(lovePoint)

if self.affectShower:

self.affectShower.OnUpdateLovePoint(lovePoint)

# END_OF_WEDDING

# QUEST_CONFIRM

def BINARY_OnQuestConfirm(self, msg, timeout, pid):

confirmDialog = uiCommon.QuestionDialogWithTimeLimit()

confirmDialog.Open(msg, timeout)

confirmDialog.SetAcceptEvent(lambda answer=True, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())

confirmDialog.SetCancelEvent(lambda answer=False, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())

self.confirmDialog = confirmDialog

# END_OF_QUEST_CONFIRM

# 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 oyuncu_black(self, black, sari, kirmizi, mavi):

#blackdragonx61

self.interface.wndMiniMap.online_cok_hojdir_ama_benane(black, sari, kirmizi, mavi)

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

# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 ÀÌ·±½ÄÀ¸·Î "/" ¹®ÀÚ·Î ±¸ºĞµÈ ¸®½ºÆ®¸¦ ÁÜ

#print 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_Highlight_Item(self, inven_type, inven_pos):

self.interface.Highligt_Item(inven_type, inven_pos)

def BINARY_DragonSoulGiveQuilification(self):

self.interface.DragonSoulGiveQuilification()

def __Cofres_Search(self,vnums,counts):

self.interface.ItemsCofres(vnums,counts)

def __Cofres_Search_Refresh(self):

self.interface.ItemsCofresRefresh()

def __Cofres_Search_Refresh_Open(self):

self.interface.ItemsCofreRefreshOpen()

def __CofresShow(self):

self.interface.CofresShow()

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

self.interface.bigBoard.SetTip(message)

def BINARY_SetTipMessage(self, message):

self.interface.tipBoard.SetTip(message)

def BINARY_AppendNotifyMessage(self, type):

if not type in localeInfo.NOTIFY_MESSAGE:

return

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOTIFY_MESSAGE[type])

def BINARY_Guild_EnterGuildArea(self, areaID):

self.interface.BULID_EnterGuildArea(areaID)

def BINARY_Guild_ExitGuildArea(self, areaID):

self.interface.BULID_ExitGuildArea(areaID)

def BINARY_GuildWar_OnSendDeclare(self, guildID):

pass

def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):

mainCharacterName = player.GetMainCharacterName()

masterName = guild.GetGuildMasterName()

if mainCharacterName == masterName:

self.__GuildWar_OpenAskDialog(guildID, warType)

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

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

def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):

self.interface.OnStartGuildWar(guildSelf, guildOpp)

def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):

self.interface.OnEndGuildWar(guildSelf, guildOpp)

def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):

self.interface.BINARY_SetObserverMode(isEnable)

def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):

self.interface.wndMiniMap.UpdateObserverCount(observerCount)

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

# title_name : Professional Biolog System

# date_created : 2016.08.07

# filename : game.py

# author : VegaS

# version_actual : Version 0.0.8

#

# PROFESSIONAL_BIOLOG_SYSTEM

if app.ENABLE_BIOLOG_SYSTEM:

def BINARY_Biolog_Update(self, pLeftTime, pCountActual, pCountNeed, pVnum):

uiprofessionalbiolog.BIOLOG_BINARY_LOADED["time"][0] = int(pLeftTime) + app.GetGlobalTimeStamp()

uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countActual"][0] = str(pCountActual)

uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countNeed"][0] = str(pCountNeed)

uiprofessionalbiolog.BIOLOG_BINARY_LOADED["vnum"][0] = int(pVnum)

def BINARY_Biolog_PopUp(self, iRewardType, iRewardItem, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2):

self.wndBiologSlider = uiprofessionalbiolog.Biolog_FinishSlider()

self.wndBiologSlider.BINARY_BiologPopUp_Load([str(iRewardType), int(iRewardItem), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2)])

self.wndBiologSlider.Show()

def BINARY_Biolog_SendMessage(self):

pass

def BINARY_Biolog_SelectReward(self, iTypeWindow, iRewardType, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2, iBonusName_3, iBonusValue_3):

self.wndBiologSelectReward = uiprofessionalbiolog.Biolog_SelectReward()

self.wndBiologSelectReward.SetCenterPosition()

self.wndBiologSelectReward.SetTop()

self.wndBiologSelectReward.Show()

# END_OF_PROFESSIONAL_BIOLOG_SYSTEM

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

guildID1 = int(guildID1)

guildID2 = int(guildID2)

memberCount1 = int(memberCount1)

memberCount2 = int(memberCount2)

observerCount = int(observerCount)

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

self.interface.wndMiniMap.UpdateObserverCount(observerCount)

def __GuildWar_OpenAskDialog(self, guildID, warType):

guildName = guild.GetGuildName(guildID)

# REMOVED_GUILD_BUG_FIX

if "Noname" == guildName:

return

# END_OF_REMOVED_GUILD_BUG_FIX

import uiGuild

questionDialog = uiGuild.AcceptGuildWarDialog()

questionDialog.SAFE_SetAcceptEvent(self.__GuildWar_OnAccept)

questionDialog.SAFE_SetCancelEvent(self.__GuildWar_OnDecline)

questionDialog.Open(guildName, warType)

self.guildWarQuestionDialog = questionDialog

def __GuildWar_CloseAskDialog(self):

self.guildWarQuestionDialog.Close()

self.guildWarQuestionDialog = None

def __GuildWar_OnAccept(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/war " + guildName)

self.__GuildWar_CloseAskDialog()

return 1

def __GuildWar_OnDecline(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/nowar " + guildName)

self.__GuildWar_CloseAskDialog()

return 1

## BINARY CALLBACK

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

def __ServerCommand_Build(self):

serverCommandList={

"uiRoulette" : self.__uiRoulette,

"exit" : self.__exit,

"uiRoulette_open" : self.__uiRouletteOpen,

"SkyboxSelectMode" : self.SkyboxSelectMode,

"OpenEventGui" : self.__EventSystem,

"SELECT_JOB" : self.SelectJob,

"ruhtasiekranac" : self.ruhcac,

"bkekranac" : self.bkac,

"ConsoleEnable" : self.__Console_Enable,

"sorgu" : self.Uzaktan_ticaret_soru,

"DayMode" : self.__DayMode_Update,

"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,

"CloseRestartWindow" : self.__RestartDialog_Close,

"OtomatikAvWindow" : self.__otomatikavstart,

"OpenPrivateShop" : self.__PrivateShop_Open,

"OpenPrivateShopKasmir" : self.Kasmir_Paketi_Open,

"OpenOfflineShop" : self.__OfflineShop_Open,

"PartyHealReady" : self.PartyHealReady,

"ShowMeSafeboxPassword" : self.AskSafeboxPassword,

"CloseSafebox" : self.CommandCloseSafebox,

"getinputbegin" : self.__Inputget1,

"getinputend" : self.__Inputget2,

"getinput" : self.__Inputget3,

"GetInputStringStart" : self.GetInputStringStart,

"GetInputStringEnd" : self.GetInputStringEnd,

"captcha_exit" : self.__captcha_exit,

"mattius" : self._mattiusefekt,

"bonusgormekistiyor" : self.bonusgormekistiyor,

"bonuslarimigor" : self.bonuslarimigor,

"biyologodul" : self.biyoodulac,

"biyologekrankapa" : self.biyologekrankapa,

"biyolog" : self.biyolog,

"search_cofre_ids" : self.__Cofres_Search,

"search_cofre_refresh" : self.__Cofres_Search_Refresh,

"search_cofre_refresh_open" : self.__Cofres_Search_Refresh_Open,

"sandik_button" : self.__CofresShow,

"gecmis_q" : self.lonca_gecmis_q,

"lonca_gecmis_ekle" : self.lonca_gecmis_ekle,

"gecmistemizle" : self.gecmistemizle,

"isim_ver" : self.isim_ver,

# ITEM_MALL

"CloseMall" : self.CommandCloseMall,

"ShowMeMallPassword" : self.AskMallPassword,

"item_mall" : self.__ItemMall_Open,

# END_OF_ITEM_MALL

# ZIRHLI AT EFFECT

"DEscapeZirhliAt" : self.__DEscapeZirhliAt,

"DEscapeAskerAt" : self.__DEscapeAskerAt,

"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,

"BINARY_Update_Maintenance" : self.BINARY_Update_Maintenance,

"bk_trade_sys" : self.__BKTradeSys,

"OpenSupportGui" : self.OpenSupportGui,

"recordquest" : self.__recordscreen,

"recordwarning" : self.recordwarning,

"oyunicisiralama" : self.__oyunicisirala,

"uyarisiralama" : self.uyarisiralama,

"loncasiralama" : self.__oyunicilonca,

"uyariloncasira" : self.uyariloncasira,

"getinputbegin" : self.__Inputget1,

"getinputend" : self.__Inputget2,

"getinput" : self.__Inputget3,

"GetInputStringStart" : self.GetInputStringStart,

"GetInputStringEnd" : self.GetInputStringEnd,

"lonca_lider_q" : self.lonca_lider_q,

"lider_ekle" : self.lider_ekle,

"lider_sifirla" : self.lider_sifirla,

"lonca_tanit" : self.lonca_tanitim,

# WEDDING

"lover_login" : self.__LoginLover,

"lover_logout" : self.__LogoutLover,

"lover_near" : self.__LoverNear,

"lover_far" : self.__LoverFar,

"lover_divorce" : self.__LoverDivorce,

"PlayMusic" : self.__PlayMusic,

"SupportLv" : self.SetSupportLevel,

"SupportName" : self.SetSupportName,

"SupportLeave" : self.SupportLeave,

"SupporInt" : self.SupportInt,

"SupportExp" : self.SetSupportExp,

"SupportIcon" : self.SetSupportIcon,

"SupportSpeciality" : self.SetSupportSpeciality,

"STONEWHEEL" : self.__StoneWheel,

"STONEWHEEL_OPEN" : self.__StoneWheelOpen,

"loncatanitim" : self.__loncatanitim,

"lonca_tanitimi" : self.loncatanitekran,

"uyari" : self.uyari,

"guvenlipc" : self.guvenlipc,

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

# Duel System #

"BINARY_Duel_GetInfo" : self.BINARY_Duel_GetInfo,

"BINARY_Duel_Request" : self.BINARY_Duel_Request,

"BINARY_Duel_LiveInterface" : self.BINARY_Duel_LiveInterface,

"BINARY_Duel_Delete" : self.BINARY_Duel_Delete,

"BINARY_Duel_SendMessage" : self.BINARY_Duel_SendMessage,

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

# END_OF_WEDDING

"envanter" : self.envanter_kilitle_quest,

"antiexpbutton" : self.antiexp_quest,

"binekbutton" : self.binek_quest,

"yuzukbutton" : self.yuzuk_quest,

"sandikbutton" : self.sandik_quest,

"loncabutton" : self.lonca_quest,

"guvenli_pc" : self._guvenli_pc,

"guvenli_pc_bilgi" : self._guvenli_pc_bilgi,

"offlineshopbutton" : self._offlineshopbutton,

"MyShopPriceList" : self.__PrivateShop_PriceList,

}

serverCommandList["BINARY_Account_Bank"] = self.managerAccountBank.Loading

self.serverCommander=stringCommander.Analyzer()

for serverCommandItem in serverCommandList.items():

self.serverCommander.SAFE_RegisterCallBack(

serverCommandItem[0], serverCommandItem[1]

)

def BINARY_ServerCommand_Run(self, line):

#dbg.TraceError(line)

try:

#print " BINARY_ServerCommand_Run", line

return self.serverCommander.Run(line)

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

def bonusgormekistiyor(self,isim,level):

import uiCommon

import constInfo

questionDialogbonus=uiCommon.QuestionDialog()

questionDialogbonus.SetText(str(isim)+"(Lv."+str(level)+")"+" Bonuslar??g?mek istiyor.")

questionDialogbonus.SetAcceptEvent(lambda arg=TRUE: self.bonusgormeevet(isim))

questionDialogbonus.SetCancelEvent(lambda arg=FALSE: self.bonusgormehayir(isim))

questionDialogbonus.Open()

self.questionDialogbonus=questionDialogbonus

return

def bonusgormeevet(self,isim):

net.SendChatPacket("/bonusumu_gorebilirsin " + str(isim))

self.questionDialogbonus.Close()

def bonusgormehayir(self,isim):

net.SendChatPacket("/bonusumu_goremezsin " + str(isim))

self.questionDialogbonus.Close()

def bonuslarimigor(self,name,deliciefsun,kritikefsun,yariinsanefsun,kilicsavunmasiefsun,ciftelsavunmasiefsun,bicaksavunmasiefsun,yelpazesavunmasiefsun,cansavunmasiefsun,oksavunmasiefsun,buyusavunmasiefsun):

import chat

import constInfo

constInfo.efsungorname = "Character Name"

constInfo.kritik = 0

constInfo.delici = 0

constInfo.yariinsan = 0

constInfo.kilic = 0

constInfo.ciftel = 0

constInfo.bicak = 0

constInfo.ok = 0

constInfo.yelpaze = 0

constInfo.can = 0

constInfo.buyu = 0

constInfo.efsungorname = str(name)

constInfo.kritik = int(kritikefsun)

constInfo.delici = int(deliciefsun)

constInfo.yariinsan = int(yariinsanefsun)

constInfo.kilic = int(kilicsavunmasiefsun)

constInfo.ciftel = int(ciftelsavunmasiefsun)

constInfo.bicak = int(bicaksavunmasiefsun)

constInfo.ok = int(oksavunmasiefsun)

constInfo.yelpaze = int(yelpazesavunmasiefsun)

constInfo.can = int(cansavunmasiefsun)

constInfo.buyu = int(buyusavunmasiefsun)

import uiefsungor

self.efsungor = uiefsungor.EfsunGor()

self.efsungor.Show()

if app.ENVANTER_KILIT:

def envanter_kilitle_quest(self, value):

constInfo.ENVANTERRR_BLACK = int(value)

def antiexp_quest(self, value):

constInfo.ANTI_EXP_QUEST = int(value)

def binek_quest(self, value):

constInfo.BINEK_QUEST_BUTTON = int(value)

def yuzuk_quest(self, value):

constInfo.YUZUK_QUEST_BUTTON = int(value)

def lonca_quest(self, value):

constInfo.LONCA_QUEST_BUTTON = int(value)

def sandik_quest(self, value):

constInfo.SANDIK_QUEST_BUTTON = int(value)

def _guvenli_pc(self, value):

constInfo.GUVENLIPC = int(value)

def _guvenli_pc_bilgi(self, value):

constInfo.GUVENLIPCBILGI = int(value)

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

def __DEscapeZirhliAt(self):

net.SendChatPacket("(DEscapeZirhliAt)")

def __DEscapeAskerAt(self):

net.SendChatPacket("(DEscapeAskerAt)")

# ITEM_MALL

def AskMallPassword(self):

self.interface.AskMallPassword()

def _mattiusefekt(self):

net.SendChatPacket("(mattius)")

def __ItemMall_Open(self):

self.interface.OpenItemMall();

def CommandCloseMall(self):

self.interface.CommandCloseMall()

# END_OF_ITEM_MALL

def RefineSuceededMessage(self):

snd.PlaySound("sound/ui/make_soket.wav")

net.SendChatPacket("(xVectors_Basari)")

def RefineFailedMessage(self):

snd.PlaySound("sound/ui/jaeryun_fail.wav")

net.SendChatPacket("(xVectors_Basarisiz)")

def CommandCloseSafebox(self):

self.interface.CommandCloseSafebox()

# PRIVATE_SHOP_PRICE_LIST

def __PrivateShop_PriceList(self, itemVNum, itemPrice):

uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice)

# END_OF_PRIVATE_SHOP_PRICE_LIST

def __Horse_HideState(self):

self.affectShower.SetHorseState(0, 0, 0)

if app.ENABLE_PVP_ADVANCED:

def BINARY_Duel_GetInfo(self, a, b, c, d, e, f, g, h):

self.wndDuelGui.OpenDialog(a, b, c, d, e, f, g, h)

def BINARY_Duel_Request(self, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q):

self.wndDuelGui.OpenDialog(a, b, c, d, e, f, g, h)

self.wndDuelGui.Selected([int(i), int(j), int(k), int(l), int(m), int(n), int(o), int(p), int(q)])

def BINARY_Duel_Delete(self):

self.wndDuelGui.Remove()

if self.wndDuelLive.IsShow():

self.wndDuelLive.Hide()

def BINARY_Duel_LiveInterface(self, a, b, c, d, e, f, g, h, i, j, k, l):

self.wndDuelLive.ShowInformations([str(a), int(b), int(c), int(d), int(e), int(f), int(g), int(h), int(i), int(j), int(k), int(l)])

def BINARY_Duel_SendMessage(self, textLine):

if str(textLine) != "":

self.wndMsg = message.PopupDialog()

self.wndMsg.SetWidth(550)

self.wndMsg.SetText((str(textLine).replace("$"," ")))

self.wndMsg.Show()

else:

chat.AppendChat(chat.CHAT_TYPE_INFO, "Error, i could not initialize message from server!")

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

self.oyunicisiralama.Open()

def __oyunicisirala(self, info):

CMD = info.split("/")

if CMD[0]=="index":

constInfo.oyunicisiralama["index"] = int(CMD[1])

elif CMD[0]=="input":

net.SendQuestInputStringPacket(str(constInfo.oyunicisiralama["CMD"]))

elif CMD[0]=="yeniliste":

constInfo.oyunicisiralama["Liste"] = []

elif CMD[0]=="liste":

constInfo.oyunicisiralama["Liste"].append(CMD[1].split("|"))

elif CMD[0]=="blok":

self.oyunicisiralama.LoadPage(CMD[1])

elif CMD[0]=="sayfa":

self.oyunicisiralama.Setsayfa(CMD[1])

def uyarisiralama(self, msg):

if msg == "bilgiyok":

self.PopupMessage("Henuz bilgi girilmemis!")

elif msg == "oyuncuyok":

self.PopupMessage("Oyuncu bulunamadii")

def loncasiralamaopen(self):

self.loncasiralama.Open()

def __oyunicilonca(self, info):

CMD = info.split("/")

if CMD[0]=="index":

constInfo.loncasiralama["index"] = int(CMD[1])

elif CMD[0]=="input":

net.SendQuestInputStringPacket(str(constInfo.loncasiralama["CMD"]))

elif CMD[0]=="yeniliste":

constInfo.loncasiralama["Liste"] = []

elif CMD[0]=="liste":

constInfo.loncasiralama["Liste"].append(CMD[1].split("|"))

elif CMD[0]=="blok":

self.loncasiralama.LoadPage(CMD[1])

elif CMD[0]=="sayfa":

self.loncasiralama.Setsayfa(CMD[1])

def uyariloncasira(self, msg):

if msg == "bilgiyok":

self.PopupMessage("Henuz bilgi girilmemis!")

elif msg == "oyuncuyok":

self.PopupMessage("Oyuncu bulunamadi")

def recordac(self):

self.recordscreen.Open()

def __recordscreen(self, info):

CMD = info.split("/")

if CMD[0]=="index":

constInfo.record["index"] = int(CMD[1])

elif CMD[0]=="input":

net.SendQuestInputStringPacket(str(constInfo.record["CMD"]))

elif CMD[0]=="yeniliste":

constInfo.record["Liste"] = []

elif CMD[0]=="liste":

constInfo.record["Liste"].append(CMD[1].split("|"))

elif CMD[0]=="blok":

self.recordscreen.LoadPage(CMD[1])

elif CMD[0]=="sayfa":

self.recordscreen.Setsayfa(CMD[1])

def recordwarning(self, msg):

if msg == "bilgiyok":

self.PopupMessage("Bilgi yok!")

elif msg == "oyuncuyok":

self.PopupMessage("Oyuncu bulunamad?")

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

self.__XMasSong_Enable(mode)

if "1"==mode:

if not self.__IsXMasMap():

return

print "XMAS_SNOW ON"

background.EnableSnow(1)

else:

print "XMAS_SNOW OFF"

background.EnableSnow(0)

def __XMasBoom_Enable(self, mode):

if "1"==mode:

if not self.__IsXMasMap():

return

print "XMAS_BOOM ON"

self.__DayMode_Update("dark")

self.enableXMasBoom = True

self.startTimeXMasBoom = app.GetTime()

else:

print "XMAS_BOOM OFF"

self.__DayMode_Update("light")

self.enableXMasBoom = False

def __XMasTree_Enable(self, grade):

print "XMAS_TREE ", grade

background.SetXMasTree(int(grade))

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

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

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

albay.Start = 1

def __Console_Enable(self):

constInfo.CONSOLE_ENABLE = True

self.consoleEnable = True

app.EnableSpecialCameraMode()

ui.EnablePaste(True)

## PrivateShop

def __PrivateShop_Open(self):

self.interface.OpenPrivateShopInputNameDialog()

## Kaşmir Paketi

if app.KASMIR_PAKET_SYSTEM:

def __PrivateShop_Kasmir_Open(self):

self.interface.OpenPrivateShopKasmirInputNameDialog()

if app.KASMIR_PAKET_SYSTEM:

## Kaşmir Paketi

def Kasmir_Paketi_Open(self):

self.interface.OpenKasmirPaketiDialog()

if app.KASMIR_PAKET_SYSTEM:

def BINARY_PrivateShop_Appear(self, vid, baslik, text):

self.interface.AppearPrivateShop(vid, baslik, text)

else:

def BINARY_PrivateShop_Appear(self, vid, text):

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

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:

background.SetEnvironmentData(0)

elif "dark"==mode:

if not self.__IsXMasMap():

return

background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)

background.SetEnvironmentData(1)

def __DayMode_Update(self, mode):

if "light"==mode:

self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)

elif "dark"==mode:

if not self.__IsXMasMap():

return

self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToDark)

def __DayMode_OnCompleteChangeToLight(self):

background.SetEnvironmentData(0)

self.curtain.FadeIn()

def __DayMode_OnCompleteChangeToDark(self):

background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)

background.SetEnvironmentData(1)

self.curtain.FadeIn()

## XMasBoom

def __XMasBoom_Update(self):

self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )

if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):

return

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

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

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

self.indexXMasBoom += 1

for i in xrange(boomCount):

self.__XMasBoom_Boom()

def __XMasBoom_Boom(self):

x, y, z = player.GetMainCharacterPosition()

randX = app.GetRandom(-150, 150)

randY = app.GetRandom(-150, 150)

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

def __PartyRequestQuestion(self, vid):

vid = int(vid)

partyRequestQuestionDialog = uiCommon.QuestionDialog()

partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + 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.TOURNAMENT_PVP_SYSTEM:

def BINARY_Tournament_OnRecvData(self, leftTime, membersOnline_A, membersOnline_B, membersDead_A, membersDead_B, memberLives):

self.interface.AddTournamentResultWindow(leftTime, membersOnline_A, membersOnline_B, membersDead_A, membersDead_B, memberLives)

def __EnableTestServerFlag(self):

app.EnableTestServerFlag()

def __InGameShop_Show(self, url):

if constInfo.IN_GAME_SHOP_ENABLE:

self.interface.OpenWebWindow(url)

# WEDDING

def __LoginLover(self):

if self.interface.wndMessenger:

self.interface.wndMessenger.OnLoginLover()

def __LogoutLover(self):

if self.interface.wndMessenger:

self.interface.wndMessenger.OnLogoutLover()

if self.affectShower:

self.affectShower.HideLoverState()

def __LoverNear(self):

if self.affectShower:

self.affectShower.ShowLoverState()

def BINARY_Account_Bank_Logs(self):

self.managerAccountBank.BINARY_Account_Bank_Logs()

def __LoverFar(self):

if self.affectShower:

self.affectShower.HideLoverState()

def BINARY_Ticket_Sort_Admin(self, token, val):

if token == "r":

if self.wndTicket.IsShow():

chat.AppendChat(chat.CHAT_TYPE_INFO, locale.TICKET_BTN_ERROR_OPEN)

return

else:

self.wndTicketStaff.Append()

elif token == "o":

constInfo.ObjectD["rmdir"][0] = int(val)

self.wndTicket.Append()

def BINARY_Ticket_Logs_Team(self, index, ticked_id, char_name, title, content, priority, create_date, status):

self.wndTicket.AppendLogsTeam(index, ticked_id, char_name, title, content, priority, create_date, status)

def BINARY_Ticket_Logs_General(self):

self.wndTicket.AppendLogs()

def BINARY_Ticket_Logs_Reply(self):

self.wndTicketReply.AppendLogs()

def __LoverDivorce(self):

if self.interface.wndMessenger:

self.interface.wndMessenger.ClearLoverInfo()

if self.affectShower:

self.affectShower.ClearLoverState()

def __PlayMusic(self, flag, filename):

flag = int(flag)

if flag:

snd.FadeOutAllMusic()

musicInfo.SaveLastPlayFieldMusic()

snd.FadeInMusic("BGM/" + filename)

else:

snd.FadeOutAllMusic()

musicInfo.LoadLastPlayFieldMusic()

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

# END_OF_WEDDING

def OpenMarbleShop(self):

if self.wndMarbleShop.IsShow():

self.wndMarbleShop.Hide()

else:

self.wndMarbleShop.Show()

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

# Kickfunction QUEST

def __captcha_exit(self):

app.Exit()

#END_captcha_exit

def BINARY_RefreshTargetMonsterDropInfo(self, raceNum):

self.targetBoard.RefreshMonsterInfoBoard()

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)

def lonca_lider_q(self,qid):

constInfo.lonca_lider_q = int(qid)

def lider_ekle(self, isim, lonca):

import constInfo

constInfo.lider_list.append("#"+isim+"#"+lonca)

def lider_sifirla(self):

import constInfo

constInfo.lider_list = []

def __Inputget1(self):

constInfo.INPUT_IGNORE = 1

def __Inputget2(self):

constInfo.INPUT_IGNORE = 0

def Uzaktan_ticaret_soru(self, isim, level):

uzaktan_sorusu = uiCommon.QuestionDialog()

uzaktan_sorusu.SetText("|cffFDD017|H|h" + str(isim)+ "|cff00ccff" + "(Lv."+str(level)+")"+ "|h|r" + " Seninle uzaktan ticaret yapmak istiyor.")

uzaktan_sorusu.SetAcceptEvent(lambda arg=TRUE: self.tamam_mk(isim))

uzaktan_sorusu.SetCancelEvent(lambda arg=FALSE: self.sie_mq(isim))

uzaktan_sorusu.Open()

self.uzaktan_sorusu = uzaktan_sorusu

return

def tamam_mk(self, isim):

#net.SendExchangeStartPacket(isim)

net.SendChatPacket("/uzaktan_ticaret_kabul " + str(isim))

self.uzaktan_sorusu.Close()

def sie_mq(self, isim):

net.SendChatPacket("/uzaktan_ticaret_hayir " + str(isim))

self.uzaktan_sorusu.Close()

def _offlineshopbutton(self):

print "click_offline_shop_button"

self.interface.ToggleOfflineShopAdminPanelWindow()

def guvenlipc(self):

net.SendQuestInputStringPacket(str(player.GetMacAddress()))

def uyari(self, msg):

if msg == "bilgiyok":

self.PopupMessage("Hicbir bilgi girilmemii")

elif msg == "loncayok":

self.PopupMessage("Lonca bulunamad©¥")

def lonca_tanitim(self):

self.loncanitanit.Open()

def SkyboxSelectMode(self):

import skybox

if not self.skybox:

self.skybox = skybox.OptionDialog()

self.skybox.Show()

def loncatanitekran(self):

self.loncanitanit.Open()

def __loncatanitim(self, info):

CMD = info.split("/")

if CMD[0]=="index":

constInfo.loncani_tanit["index"] = int(CMD[1])

elif CMD[0]=="input":

net.SendQuestInputStringPacket(str(constInfo.loncani_tanit["CMD"]))

elif CMD[0]=="yeniliste":

constInfo.loncani_tanit["Liste"] = []

elif CMD[0]=="liste":

constInfo.loncani_tanit["Liste"].append(CMD[1].split("|"))

elif CMD[0]=="blok":

self.loncanitanit.LoadPage(CMD[1])

elif CMD[0]=="sayfa":

self.loncanitanit.Setsayfa(CMD[1])

def lonca_gecmis_q(self, id):

import constInfo

constInfo.lonca_gecmis_q = int(id)

def lonca_gecmis_ekle(self, isim):

import constInfo

constInfo.lonca_gecmis_list.append(isim)

def __EventSystem(self):

if constInfo.UZAKTAN_PAZ == 0:

self.orosbupazar = uievent.Dialog1()

self.orosbupazar.Open()

constInfo.UZAKTAN_PAZ = 1

else:

self.orosbupazar.Close()

constInfo.UZAKTAN_PAZ = 0

def gecmistemizle(self):

import constInfo

constInfo.lonca_gecmis_list = []

def OpenBank(self):

self.managerAccountBank.Loading("login", 0)

def OpenSupportGui(self):

if constInfo.SUPPORTGUI == 0:

self.supportpg.Show()

self.supportpg.SetTop()

constInfo.SUPPORTGUI = 1

else:

self.supportpg.Close()

constInfo.SUPPORTGUI = 0

def SetSupportLevel(self, level):

self.supportpg.SetLevel(level)

constInfo.SUPPORTLEVEL = int(level)

def SetSupportName(self, name, name2):

self.supportpg.SetName(name, name2)

def SupportLeave(self):

self.supportpg.SetDefaultInfo()

self.supportpg.Close()

def SupportInt(self , ints):

self.supportpg.SetInt(ints)

def SetSupportExp(self, exp, exptot):

if int(exptot) > 0:

self.supportpg.SetExperience(exp, exptot)

self.supportpg.SetExperience(exp, exptot)

def SetSupportIcon(self, vnum):

if int(vnum) > 0:

self.supportpg.SetImageSlot(vnum)

self.supportpg.SetImageSlot(vnum)

def SetSupportSpeciality(self,speciality):

self.supportpg.SetSpeciality(speciality)

def isim_ver(self):

import constInfo

net.SendQuestInputStringPacket(str(constInfo.lonca_gecmis_isim))

def gotur(self):

background.SetVisiblePart(background.PART_TREE, True)#True

def getir(self):

background.SetVisiblePart(background.PART_TREE, False)#True

def __CanBoard(self):

import uiboard

self.boardgift.Show()

def SelectJob(self, cmd):

import uiSelectJob

cmd = cmd.split('#')

if cmd[0] == 'QID':

constInfo.SelectJob['QID'] = int(cmd[1])

elif cmd[0] == 'INPUT':

constInfo.INPUT_IGNORE = int(cmd[1])

elif cmd[0] == 'SEND':

net.SendQuestInputStringPacket(str(constInfo.SelectJob['QCMD']))

constInfo.SelectJob['QCMD'] = ''

elif cmd[0] == 'OPEN':

self.job_select = uiSelectJob.JobSelectWindow()

self.job_select.Open()

elif cmd[0] == 'CLOSE':

self.job_select = uiSelectJob.JobSelectWindow()

self.job_select.RealClose()

def __Inputget1(self):

constInfo.INPUT_IGNORE = 1

def __Inputget2(self):

constInfo.INPUT_IGNORE = 0

def __premium(self):

if constInfo.premiumgoster == 1:

self.affectShower.Show()

elif constInfo.premiumgoster == 0:

self.affectShower.Hide()