game nemodificat

import os
import app
import dbg
import grp
import item
import background
import chr
import chrmgr
import player
import chat
import translate
import textTail
import event
import uibonuspage
import uipetsystem
import snd
import net
import effect
import wndMgr
import fly
import systemSetting
import quest
import guild
import skill
import messenger
if app.ENABLE_ADMIN_BAN_MANAGER:
	import uiadmintool
import uimarbleshop
import localeInfo
import constInfo
import exchange
import uiHealth
import ime
import constInfo2
import mounting
import ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
import uiTaskbar
import uiteleport
import uiguildstorage
import schicksalrad
# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LIST
import time
# 5Lv Oto Bec Sistemi
import savbec
import surabec
import ninjabec
import samanbec
import lycanbec
import BKTrade
import serverInfo
import mouseModule
import consoleModule
import localeInfo
import gameInfo
import uibkoku
import uiruhtasi
import uinpcekran
import uibiyolog
import uimarbleshop

import playerSettingModule
import interfaceModule

import musicInfo
import debugInfo
import stringCommander
import uiPrivateShopSearch

#AKIRA_EVENT_SYSTEM
import uiAkiraEvent
#END_OF_AKIRA_EVENT_SYSTEM
if app.ENABLE_SUPPORT_SYSTEM:
	import uisupportsystem
if app.ENABLE_SWITCHER_MIJAGO:
	from switchbot import Bot
import oyunicisiralama
import loncasiralama
import record
import loncatanit
import uilider
import otoavinfo
import uikeyboard
if app.ENABLE_COSTUME_AURA:
	import UiRefineAura

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

import guildwarkillcounter
import uiGuild

if localeInfo.IsEUROPE():
	SCREENSHOT_CWDSAVE = TRUE

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

if app.WJ_OFFLINESHOP_SYSTEM:
	import uiOfflineShopBuilder
	import uiOfflineShop

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

testAlignment = 0
BPisLodaded={0:0}
pet_gui_activado = 0
bonuspp = 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.quickSlotPageIndex = 0
		if app.ENABLE_SWITCHER_MIJAGO:
			self.switchbot = Bot()
			self.switchbot.Hide()
		self.lastPKModeSendedTime = 0
		self.LastBoniSwitcherId = 0
		if app.ENABLE_NEW_QUICK_SLOT_SYSTEM:
			self.newquickSlotPageIndex = 0
			self.pressNewNumber = None

		self.pressNumber = None
		self.npcekran = None
		self.npcekran = uinpcekran.NPCEkran()
		self.npcekran.Hide()
		if (app.WJ_COMBAT_ZONE):
			import uicombatzone
			self.wndCombatZone = uicombatzone.CombatZoneWindow()

		self.guildWarQuestionDialog = None
		self.interface = None
		self.targetBoard = None
		self.console = None
		self.mapNameShower = None
		self.affectShower = None
		self.playerGauge = None
		self.endTime = 0
		self.PrivateShopSearch = None
		self.petInventoryWnd = None
		self.boniSwitcherWnd = []
		constInfo.BONI_SWITCHER_LOAD = FALSE
		self.itemShopWnd = None
		#import uiBoniSwitcher
		#for i in xrange(constInfo.SWITCHER_COUNT):
			#self.boniSwitcherWnd.append(uiBoniSwitcher.BoniSwitcherDialog(i))
			#self.boniSwitcherWnd[i].SetChangeBonusSwitcherEvent(self.__BoniSwitcherShow)
			#self.boniSwitcherWnd[i].GAMESetBoniSwitcherCheckEvent(self.__BoniSwitcherCheckEvent)
		if app.ENABLE_COSTUME_AURA:
			self.RefineAura = UiRefineAura.RefineAura()

		self.stream=stream
		self.interface = interfaceModule.Interface()
		self.interface.SetStream(self.stream)
		self.interface.MakeInterface()
		self.interface.SetOpenBoniSwitcherEvent(self.__BoniSwitcherShow)
		self.interface.ShowDefaultWindows()
		self.stream.isAutoSelect = 0

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

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

		self.oyunicisiralama = oyunicisiralama.oyunicisirala()
		self.loncasiralama = loncasiralama.loncasiralama()
		self.recordscreen = record.recordwindow()
		self.loncanitanit = loncatanit.loncatanit()

		self.GuildStorageWindow = uiguildstorage.GuildStorage()

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

		#AKIRA_EVENT_SYSTEM
		self.akiraEventButton = uiAkiraEvent.AkiraEventButton()
		self.akiraEventButton.LoadWindow()
		self.akiraEventButton.Hide()
		#END_OF_AKIRA_EVENT_SYSTEM

		self.petmain = uipetsystem.PetSystemMain()
		self.petmini = uipetsystem.PetSystemMini()

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

		if app.ENABLE_SUPPORT_SYSTEM:
			self.supportpg = uisupportsystem.SupportMainGui()

		self.mapNameShower = uiMapNameShower.MapNameShower()
		self.LoncaGecmisi = uiGuild.LoncaGecmisUI()
		self.LoncaGecmisi.Hide()
		self.affectShower = uiAffectShower.AffectShower()
		if app.ENABLE_MAINTENANCE_SYSTEM:
			import uimaintenance
			self.wndMaintenance = uimaintenance.MaintenanceClass()
		if app.ENABLE_TICKET_SYSTEM:
			import uiticket
			self.wndTicket = uiticket.TicketBoard()
			self.wndTicketStaff = uiticket.TicketBoardAdmin()
			self.wndTicketReply = uiticket.TicketBoardInformationsID()
		if app.ENABLE_REBORN_SYSTEM:
			import uiReborn
			self.wndReborn = uiReborn.RebornClass()
		if app.ENABLE_ADMIN_BAN_MANAGER:
			self.wndAdminTool = uiadmintool.AdminTool()
		self.wndMarbleShop = uimarbleshop.MarbleShopWindow()
		# if app.ENABLE_TITLE_SYSTEM:
			# import title_system
			# self.wndTitleSystem = title_system.Title_System()

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

		self.guildScoreCounter = guildwarkillcounter.MessageQueue()

		self.bkoku = uibkoku.BKOku()
		self.bkoku.Hide()
		self.ruhtasi = uiruhtasi.RuhTasi()
		self.ruhtasi.Hide()
		self.biyoekran = uibiyolog.BiyologEkran()
		self.biyoekran.Hide()
		#wj 2014.1.2. ESC키를 누를 시 우선적으로 DropQuestionDialog를 끄도록 만들었다. 하지만 처음에 itemDropQuestionDialog가 선언되어 있지 않아 ERROR가 발생하여 init에서 선언과 동시에 초기화 시킴.
		self.itemDropQuestionDialog = None

		self.__SetQuickSlotMode()
		if app.ENABLE_NEW_QUICK_SLOT_SYSTEM:
			self.__SetNewQuickSlotMode()

		self.__ServerCommand_Build()
		self.__ProcessPreservedServerCommand()
		self.teleport = uiteleport.TeleportWindow()
		self.MountingSystem =  mounting.MountWindow()
		self.SchicksalRad = schicksalrad.RadDesSchicksals()

	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())
		if app.ENABLE_NEW_QUICK_SLOT_SYSTEM:
			self.newquickSlotPageIndex = 0

		Espacio = ui.AniImageBox()
		Espacio.SetWindowHorizontalAlignLeft()
		Espacio.SetWindowVerticalAlignTop()
		Espacio.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")
		self.Espacio = Espacio

		self.Espacio.SetPosition(10, 80)

		self.contador_usuarios_guerra = ui.TextLine()
		self.contador_usuarios_guerra.SetWindowHorizontalAlignLeft()
		self.contador_usuarios_guerra.SetWindowVerticalAlignTop()
		self.contador_usuarios_guerra.SetDefaultFontName()
		self.contador_usuarios_guerra.SetPosition(24+8, 37+2 +40)
		self.contador_usuarios_guerra.SetText("0")
		self.contador_usuarios_guerra.SetOutline()

		self.muertos_guerra = ui.TextLine()
		self.muertos_guerra.SetWindowHorizontalAlignLeft()
		self.muertos_guerra.SetWindowVerticalAlignTop()
		self.muertos_guerra.SetDefaultFontName()
		self.muertos_guerra.SetPosition(24+8, 47+2+40)
		self.muertos_guerra.SetText("0")
		self.muertos_guerra.SetOutline()

		self.caido_guerra = ui.TextLine()
		self.caido_guerra.SetWindowHorizontalAlignLeft()
		self.caido_guerra.SetWindowVerticalAlignTop()
		self.caido_guerra.SetDefaultFontName()
		self.caido_guerra.SetPosition(24+8, 57+2+40)
		self.caido_guerra.SetText("0")
		self.caido_guerra.SetOutline()

		self.usuarios_guerra = ui.TextLine()
		self.usuarios_guerra.SetWindowHorizontalAlignLeft()
		self.usuarios_guerra.SetWindowVerticalAlignTop()
		self.usuarios_guerra.SetDefaultFontName()
		self.usuarios_guerra.SetPosition(10+8, 37+2+40)
		self.usuarios_guerra.SetText("U:")
		self.usuarios_guerra.SetOutline()

		self.ranking_guerra = ui.TextLine()
		self.ranking_guerra.SetWindowHorizontalAlignLeft()
		self.ranking_guerra.SetWindowVerticalAlignTop()
		self.ranking_guerra.SetDefaultFontName()
		self.ranking_guerra.SetPosition(10+8, 47+2+40)
		self.ranking_guerra.SetText("R:")
		self.ranking_guerra.SetOutline()

		self.ranking_caido = ui.TextLine()
		self.ranking_caido.SetWindowHorizontalAlignLeft()
		self.ranking_caido.SetWindowVerticalAlignTop()
		self.ranking_caido.SetDefaultFontName()
		self.ranking_caido.SetPosition(10 +8, 57 +2+40)
		self.ranking_caido.SetText("M:")
		self.ranking_caido.SetOutline()

		Medallas_gui = ui.AniImageBox()
		Medallas_gui.SetWindowHorizontalAlignLeft()
		Medallas_gui.SetWindowVerticalAlignTop()
		Medallas_gui.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")
		self.Medallas_gui = Medallas_gui

		self.Medallas_gui.SetPosition(10, 40)

		self.muertes = ui.TextLine()
		self.muertes.SetWindowHorizontalAlignLeft()
		self.muertes.SetWindowVerticalAlignTop()
		self.muertes.SetDefaultFontName()
		self.muertes.SetPosition(24, 51)
		self.muertes.SetText("0")
		self.muertes.SetOutline()

		self.primera_muerte = ui.AniImageBox()
		self.primera_muerte.SetWindowHorizontalAlignLeft()
		self.primera_muerte.SetWindowVerticalAlignTop()
		self.primera_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/1.dds")
		self.primera_muerte.SetPosition(43, 40)

		self.doble_muerte = ui.AniImageBox()
		self.doble_muerte.SetWindowHorizontalAlignLeft()
		self.doble_muerte.SetWindowVerticalAlignTop()
		self.doble_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/2.dds")
		self.doble_muerte.SetPosition(43 + 33, 40)

		self.triple_muerte = ui.AniImageBox()
		self.triple_muerte.SetWindowHorizontalAlignLeft()
		self.triple_muerte.SetWindowVerticalAlignTop()
		self.triple_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/3.dds")
		self.triple_muerte.SetPosition(43 + 33 + 33, 40)

		self.exterminio = ui.AniImageBox()
		self.exterminio.SetWindowHorizontalAlignLeft()
		self.exterminio.SetWindowVerticalAlignTop()
		self.exterminio.AppendImage("d:/ymir work/ui/pattern/medallas/4.dds")
		self.exterminio.SetPosition(43+ 33+ 33 + 33, 40)

		self.muertacular = ui.AniImageBox()
		self.muertacular.SetWindowHorizontalAlignLeft()
		self.muertacular.SetWindowVerticalAlignTop()
		self.muertacular.AppendImage("d:/ymir work/ui/pattern/medallas/5.dds")
		self.muertacular.SetPosition(43+ 33+ 33+ 33 + 33, 40)

		self.bestialidad = ui.AniImageBox()
		self.bestialidad.SetWindowHorizontalAlignLeft()
		self.bestialidad.SetWindowVerticalAlignTop()
		self.bestialidad.AppendImage("d:/ymir work/ui/pattern/medallas/6.dds")
		self.bestialidad.SetPosition(43+ 33+ 33+ 33+ 33 + 33, 40)

		self.salvajada = ui.AniImageBox()
		self.salvajada.SetWindowHorizontalAlignLeft()
		self.salvajada.SetWindowVerticalAlignTop()
		self.salvajada.AppendImage("d:/ymir work/ui/pattern/medallas/7.dds")
		self.salvajada.SetPosition(43+ 33+ 33+ 33+ 33+ 33 + 33, 40)

		self.catastrofe = ui.AniImageBox()
		self.catastrofe.SetWindowHorizontalAlignLeft()
		self.catastrofe.SetWindowVerticalAlignTop()
		self.catastrofe.AppendImage("d:/ymir work/ui/pattern/medallas/8.dds")
		self.catastrofe.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)

		self.apocalipsis = ui.AniImageBox()
		self.apocalipsis.SetWindowHorizontalAlignLeft()
		self.apocalipsis.SetWindowVerticalAlignTop()
		self.apocalipsis.AppendImage("d:/ymir work/ui/pattern/medallas/9.dds")
		self.apocalipsis.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)

		self.lluvia_muertos = ui.AniImageBox()
		self.lluvia_muertos.SetWindowHorizontalAlignLeft()
		self.lluvia_muertos.SetWindowVerticalAlignTop()
		self.lluvia_muertos.AppendImage("d:/ymir work/ui/pattern/medallas/10.dds")
		self.lluvia_muertos.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)

		self.super_increible = ui.AniImageBox()
		self.super_increible.SetWindowHorizontalAlignLeft()
		self.super_increible.SetWindowVerticalAlignTop()
		self.super_increible.AppendImage("d:/ymir work/ui/pattern/medallas/11.dds")
		self.super_increible.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)

		#Fin menu

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

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

		global cameraDistance, cameraPitch, cameraRotation, cameraHeight

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

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

		# TWO_HANDED_WEAPON_ATTACK_SPEED_UP
		constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
		# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP

		import event
		event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)

		textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)

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

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

		self.__BuildKeyDict()
		self.__BuildDebugInfo()

		# PRIVATE_SHOP_PRICE_LIST
		uiPrivateShopBuilder.Clear()
		# END_OF_PRIVATE_SHOP_PRICE_LIST

		if app.WJ_OFFLINESHOP_SYSTEM:
			uiOfflineShopBuilder.Clear()

		# UNKNOWN_UPDATE
		exchange.InitTrading()
		# END_OF_UNKNOWN_UPDATE


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

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

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

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

		net.SendEnterGamePacket()

		if app.WJ_SECURITY_SYSTEM:
			if constInfo.open_security == 0:
				net.SendChatPacket("/open_security")
				constInfo.open_security = 1

		if app.PARTY_MATCH:
			constInfo.KILITLE = 0

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

		# NPC가 큐브시스템으로 만들 수 있는 아이템들의 목록을 캐싱
		# ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
		self.cubeInformation = {}
		self.currentCubeNPC = 0
		if app.ENABLE_FOG_FIX:
			if systemSetting.IsFogMode():
				background.SetEnvironmentFog(True)
			else:
				background.SetEnvironmentFog(False)

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

	def Close(self):
		self.Hide()
		#AKIRA_EVENT_SYSTEM
		self.akiraEventButton.Hide()
		#END_OF_AKIRA_EVENT_SYSTEM

		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
		if app.ENABLE_COSTUME_AURA:
			self.RefineAura.Hide()
		uiPrivateShopBuilder.Clear()

		chat.Close()
#		self.menu_bg.Hide()
#		self.Dezactivare_Menu.Hide()
#		self.Activare_Menu.Hide()
#		self.menu_bg2.Hide()
#		self.Dezactivare_Menu2.Hide()
#		self.Activare_Menu2.Hide()
		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.oyunicisiralama.IsShow():
			self.oyunicisiralama.Open()

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

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

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

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

		# UNKNOWN_UPDATE
		self.itemDropQuestionDialog = None
		# END_OF_UNKNOWN_UPDATE

		# QUEST_CONFIRM
		self.confirmDialog = None
		# END_OF_QUEST_CONFIRM
		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()

		if app.ENABLE_SUPPORT_SYSTEM:
			self.supportpg.Close()

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

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

		#uiPrivateShopBuilder.Clear()

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

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

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

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

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

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

		if self.targetBoard:
			self.targetBoard.Destroy()
			self.targetBoard = None
		if app.ENABLE_TICKET_SYSTEM:
			if self.wndTicket:
				self.wndTicket.Hide()

			if self.wndTicketReply:
				self.wndTicketReply.Hide()

			if self.wndTicketStaff:
				self.wndTicketStaff.Hide()
		if (app.WJ_COMBAT_ZONE):
			if self.wndCombatZone:
				self.wndCombatZone.Close()
		if app.ENABLE_ADMIN_BAN_MANAGER:
			if self.wndAdminTool:
				self.wndAdminTool.Hide()
		if self.wndMarbleShop:
			self.wndMarbleShop.Hide()
		# if app.ENABLE_TITLE_SYSTEM:
			# self.wndTitleSystem.Close()
		if app.ENABLE_REBORN_SYSTEM:
			if self.wndReborn.IsShow():
				self.wndReborn.Hide()

		if app.ENABLE_MAINTENANCE_SYSTEM:
			if self.wndMaintenance.IsShow():
				self.wndMaintenance.Hide()

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

		for i in xrange(len(self.boniSwitcherWnd)):
			if self.boniSwitcherWnd[i]:
				self.boniSwitcherWnd[i].Destroy()
				self.boniSwitcherWnd[i] = None
		if self.petInventoryWnd:
			self.petInventoryWnd.Destroy()
			self.petInventoryWnd = None
		player.ClearSkillDict()
		player.ResetCameraRotation()

		self.KillFocus()
		app.HideCursor()

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

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

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

	def biyolog(self, bioitem, verilen, toplam, kalansure):
		self.interface.SetBiyolog(bioitem, verilen, toplam, kalansure)

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

	def bkac(self):
		self.bkoku.Show()

	def npcac(self):
		self.npcekran.Show()

	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)

		#if app.ENABLE_SWITCHER_MIJAGO:
		#	onPressKeyDict[app.DIK_F5] = lambda : self.__toggleSwitchbot()
		#if app.ENABLE_TITLE_SYSTEM:
		#	onPressKeyDict[app.DIK_F5]		= lambda : self.OpenTitleSystem()
		#onPressKeyDict[app.DIK_F5]	= lambda : self.npcac()#UZAKTAN NPC
		#onPressKeyDict[app.DIK_F6]	= lambda : self.recordac()#BOSS SIRALAMA
		#onPressKeyDict[app.DIK_F6]	= lambda : self.siralamaopen()#OYUNCU SIRALAMA
		#onPressKeyDict[app.DIK_F7]	= lambda : self.loncasiralamaopen()#LONCA SIRALAMA
		#onPressKeyDict[app.DIK_F8]	= lambda : self.lonca_tanitim()#LONCA TANITIMI
		#if app.ENABLE_ADMIN_BAN_MANAGER:
		#	onPressKeyDict[app.DIK_F9]	= lambda : self.OpenAdminTool()
		#onPressKeyDict[app.DIK_TAB]	= lambda : self.LoncaIstatistikOpen()

		if app.ENABLE_NEW_QUICK_SLOT_SYSTEM:
			onPressKeyDict[app.DIK_5]	= lambda : self.__PressNumNewKey(5)
			onPressKeyDict[app.DIK_6]	= lambda : self.__PressNumNewKey(6)
			onPressKeyDict[app.DIK_7]	= lambda : self.__PressNumNewKey(7)
			onPressKeyDict[app.DIK_8]	= lambda : self.__PressNumNewKey(8)

			onPressKeyDict[app.DIK_F5]	= lambda : self.__PressNewQuickSlot(4)
			onPressKeyDict[app.DIK_F6]	= lambda : self.__PressNewQuickSlot(5)
			onPressKeyDict[app.DIK_F7]	= lambda : self.__PressNewQuickSlot(6)
			onPressKeyDict[app.DIK_F8]	= lambda : self.__PressNewQuickSlot(7)

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

		#캐릭터 이동키
		onPressKeyDict[app.DIK_UP]			= lambda : self.MoveUp()
		onPressKeyDict[app.DIK_DOWN]		= lambda : self.MoveDown()
		onPressKeyDict[app.DIK_LEFT]		= lambda : self.MoveLeft()
		onPressKeyDict[app.DIK_RIGHT]		= lambda : self.MoveRight()
		onPressKeyDict[app.DIK_W]			= lambda : self.MoveUp()
		onPressKeyDict[app.DIK_S]			= lambda : self.MoveDown()
		onPressKeyDict[app.DIK_A]			= lambda : self.MoveLeft()
		onPressKeyDict[app.DIK_D]			= lambda : self.MoveRight()

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

		onPressKeyDict[app.DIK_NUMPAD9]		= lambda: app.MovieResetCamera()
		onPressKeyDict[app.DIK_NUMPAD4]		= lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
		onPressKeyDict[app.DIK_NUMPAD6]		= lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
		onPressKeyDict[app.DIK_PGUP]		= lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
		onPressKeyDict[app.DIK_PGDN]		= lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
		onPressKeyDict[app.DIK_NUMPAD8]		= lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
		onPressKeyDict[app.DIK_NUMPAD2]		= lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)
		onPressKeyDict[app.DIK_GRAVE]		= lambda : self.PickUpItem()
		onPressKeyDict[app.DIK_Z]			= lambda : self.PickUpItem()
		#onPressKeyDict[app.DIK_X]			= lambda: self.interface.ToggleBonusWindow()
		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_O]			= lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
		onPressKeyDict[app.DIK_I]			= lambda : self.interface.ToggleInventoryWindow()
		onPressKeyDict[app.DIK_M]			= lambda : self.interface.PressMKey()
		#onPressKeyDict[app.DIK_H]			= lambda : self.interface.OpenHelpWindow()
		onPressKeyDict[app.DIK_ADD]			= lambda : self.interface.MiniMapScaleUp()
		onPressKeyDict[app.DIK_SUBTRACT]	= lambda : self.interface.MiniMapScaleDown()
		onPressKeyDict[app.DIK_L]			= lambda : self.interface.ToggleChatLogWindow()
		#onPressKeyDict[app.DIK_COMMA]		= lambda : self.ShowConsole()		# "`" key
		onPressKeyDict[app.DIK_LSHIFT]		= lambda : self.__SetQuickPageMode()

		onPressKeyDict[app.DIK_J]			= lambda : self.__PressJKey()
		onPressKeyDict[app.DIK_H]			= lambda : self.__PressHKey()
		onPressKeyDict[app.DIK_B]			= lambda : self.__PressBKey()
		onPressKeyDict[app.DIK_F]			= lambda : self.__PressFKey()

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

		#onPressKeyDict[app.DIK_B]	= lambda : self.test()
		#onPressKeyDict[app.DIK_X]	= lambda : self.OtomatikAv()

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

		self.onPressKeyDict = onPressKeyDict

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

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

		#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:
				if not uiPrivateShopBuilder.IsBuildingPrivateShop() or not uiOfflineShopBuilder.IsBuildingOfflineShop():
					if app.ENABLE_MOUNT_SYSTEM:
						for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
							index = player.GetItemIndex(i)
							if index:
								item.SelectItem(index)
								subType = item.GetItemSubType()
								if subType == item.USE_MOUNT:
									allow = 0
									net.SendItemUsePacket(i)
									break
					else:
						for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
							if player.GetItemIndex(i) in (52043, 52044, 52045, 71164, 71165, 71166, 71167, 71168, 52091, 52092, 52093, 52094, 52095, 52096, 52097, 52098, 71161, 71131, 52033, 52005, 52019, 71176, 71177):
								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("/user_mount_ride")
		else:
			if self.ShowNameFlag:
				self.interface.ToggleGuildWindow()
			else:
				app.PitchCamera(app.CAMERA_TO_POSITIVE)

	"""def __PressGKey(self):
		if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
			if player.IsMountingHorse():
				net.SendChatPacket("/ride")
			else:
				if not uiPrivateShopBuilder.IsBuildingPrivateShop():
					if app.ENABLE_MOUNT_SYSTEM:
						for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
							index = player.GetItemIndex(i)
							if index:
								item.SelectItem(index)
								subType = item.GetItemSubType()
								if subType == item.USE_MOUNT:
									allow = 0
									net.SendItemUsePacket(i)
									break
					else:
						for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
							if player.GetItemIndex(i) in (52043, 52044, 52045, 71164, 71165, 71166, 71167, 71168, 52091, 52092, 52093, 52094, 52095, 52096, 52097, 52098, 71161, 71131, 52033, 52005, 52019, 71176, 71177):
								net.SendItemUsePacket(i)
								break
		else:
			app.PitchCamera(app.CAMERA_TO_POSITIVE)"""

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

	# if app.ENABLE_TITLE_SYSTEM:
		# def OpenTitleSystem(self):
			# self.wndTitleSystem.OpenWindow()

	if app.ENABLE_ADMIN_BAN_MANAGER:
		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 __PressJKey(self):
		if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
			if player.IsmountingHorse():
				net.SendChatPacket("/unmount")
			else:
				self.teleport.Open()

	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)

	if app.ENABLE_NEW_QUICK_SLOT_SYSTEM:
		def __PressNumNewKey(self, key):
			if key > 8:
				return
			if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):

				if key >= 5 and key <= 8:
					if(chrmgr.IsPossibleEmoticon(- 1)):
						chrmgr.SetEmoticon(- 1, int(key) - 1)
						net.SendEmoticon(int(key) - 1)
			else:
				self.pressNewNumber((key - 1) - 4)

		def __SetNewQuickSlotMode(self):
			self.pressNewNumber = ui.__mem_func__(self.__PressNewQuickSlot)

		def __SetNewQuickPageMode(self):
			self.pressNewNumber = ui.__mem_func__(self.__SelectNewQuickPage)

		def __PressNewQuickSlot(self, localSlotIndex):
			player.RequestUseLocalNewQuickSlot(localSlotIndex)

		def __SelectNewQuickPage(self, pageIndex):
			self.newquickSlotPageIndex = pageIndex
			player.SetNewQuickPage(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()
		szNameValue = "[%s]" % (player.GetName())
		app.SetTitle(szNameValue)

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

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

	if app.WJ_SHOW_ALL_CHANNEL:
		def BINARY_OnChannelPacket(self, channel):
			import net
			server_name = net.GetServerInfo().split(" - ")[0]
			net.SetServerInfo((localeInfo.TEXT_CHANNEL % (server_name, channel)).strip())
			if self.interface:
				self.interface.wndMiniMap.serverInfo.SetText(net.GetServerInfo())

	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 constInfo.CApiSetHide == 1:
			net.SendQuestInputStringPacket(str(constInfo.SendString))
			constInfo.CApiSetHide = 0
			return

		if constInfo.INPUT_IGNORE == 1:
			return

		self.interface.OpenQuestWindow(skin, idx)

	def Mozart(self, data):
		dane = data.split("|")
		constInfo.PLAYER_NAME = str(dane[0])
		constInfo.PLAYER_HP = int(dane[1])
		constInfo.PLAYER_MAX_HP = int(dane[2])
		constInfo.PLAYER_SP = int(dane[3])
		constInfo.PLAYER_MAX_SP = int(dane[4])

	def Tabulejtor(self, id):
		constInfo.STHX = int(id)

	def GetInputOn(self):
		constInfo.INPUT_IGNORE = 1

	def GetInputOff(self):
		constInfo.INPUT_IGNORE = 0

	def GetInputValue(self):
		net.SendQuestInputStringPacket(str(constInfo.VID))

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


	def __teleporttahtasi(self):
		if app.WJ_SECURITY_SYSTEM and player.IsSecurityActivate():
			return
		import uiisinlanma
		self.isinlanmaxd = uiisinlanma.Isinlanma()
		self.isinlanmaxd.Show()

	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):
		#chat.AppendChat(chat.CHAT_TYPE_INFO, "type: %s | pointIdx: %s | value: %s | duration: %s" % (str(type), str(pointIdx), str(value), str(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)

	if app.WJ_SHOW_STROKE_INFO:
		def RegisterStroke(self, targetVID, value):
			self.targetBoard.RegisterStroke(targetVID, value)

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

		if app.IsPressed(app.DIK_LCONTROL):

			if not player.IsSameEmpire(vid):
				return

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

			self.interface.OpenWhisperDialog(name)


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

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

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

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

			self.targetBoard.SetHP(hpPercentage, iMinHP, iMaxHP)
			self.targetBoard.SetElementImage(bElement)
			self.targetBoard.Show()
	else:
		def SetHPTargetBoard(self, vid, hpPercentage):
			if vid != self.targetBoard.GetTargetVID():
				self.targetBoard.ResetTargetBoard()
				self.targetBoard.SetEnemyVID(vid)

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

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

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

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

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

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

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

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

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

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

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

	## Chat
	def OnRecvWhisper(self, mode, name, line):
		if mode == chat.WHISPER_TYPE_GM:
			self.interface.RegisterGameMasterName(name)
		chat.AppendWhisper(mode, name, line)
		self.interface.RecvWhisper(name)

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

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

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

	#def OnPickMoney(self, money):
		#chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (money))
		#chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.PrettyNumber(money) + localeInfo.GAME_PICK_MONEY)

	#YangDrop
	def OnPickMoney(self, money):
		if constInfo.YangDrop == 1:
			#chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (money))
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.PrettyNumber(money) + localeInfo.GAME_PICK_MONEY)
		else:
			return
	#YangDrop

	if app.ENABLE_CHEQUE_SYSTEM:
		def OnPickCheque(self, cheque):
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHEQUE_SYSTEM_PICK_WON % (cheque))

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

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

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

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

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

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

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

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

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

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

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

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

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

	## Shop
	if (app.WJ_COMBAT_ZONE):
		def StartShop(self, vid, points, curLimit, maxLimit):
			self.interface.OpenShopDialog(vid, points, curLimit, maxLimit)
	else:
		def StartShop(self, vid):
			self.interface.OpenShopDialog(vid)

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

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

	def SetShopSellingPrice(self, Price):
		pass

	if app.WJ_OFFLINESHOP_SYSTEM:
		def StartOfflineShop(self, vid):
			if(vid == constInfo.MARKED_SHOP_VID):
				background.DeletePrivateShopPos()
				constInfo.MARKED_SHOP_VID = 0
			self.interface.OpenOfflineShopDialog(vid)

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

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

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

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

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

	## Party
	def RecvPartyInviteQuestion(self, leaderVID, leaderName):
		partyInviteQuestionDialog = uiCommon.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):
		pass

	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)
		if app.ENABLE_NEW_QUICK_SLOT_SYSTEM:
			player.SetNewQuickPage(self.newquickSlotPageIndex)

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

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

	def StartAttack(self):
		MapName = str(background.GetCurrentMapName())
		if MapName == "mapa_guerra" and constInfo.ataque_guerra == 1:
			return
		player.SetAttackKeyState(TRUE)

	if app.ENABLE_REBORN_SYSTEM:
		def SetReborn(self, app):
			import chat
			func_modul = str(app)
			#chat.AppendChat(chat.CHAT_TYPE_INFO, "vegas print number [%s]" % str(app))
			if func_modul == "arg1":
				self.wndReborn.OpenArgument("reborn_1")
			elif func_modul == "arg2":
				self.wndReborn.OpenArgument("reborn_2")
			elif func_modul == "arg3":
				self.wndReborn.OpenArgument("reborn_3")
			elif func_modul == "pro_1":
				self.wndReborn.OpenArgument("pro_1")
			elif func_modul == "pro_0":
				self.wndReborn.OpenArgument("pro_0")

	if app.ENABLE_MAINTENANCE_SYSTEM:
		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))

	if app.ENABLE_HIDE_COSTUME_SYSTEM:
		def COSTUME_HIDE_CLEAR(self):
			self.interface.costume_hide_clear()
		def COSTUME_HIDE_LIST(self,slot,index):
			self.interface.costume_hide_list(slot,index)
		def COSTUME_HIDE_LOAD(self):
			self.interface.costume_hide_load()

	if app.ENABLE_COSTUME_AURA:
		def ClearDirRefine(self):
			constInfo.ITEM_REFINE_DIR = {}

		def SetDirRefine(self, i, vnum):
			constInfo.ITEM_REFINE_DIR[i] = vnum

		def AuraRefineInformation(self, result1, result2, item_vn_1, item_co_1, item_vn_2, item_co_2, item_vn_3, item_co_3, item_vn_4, item_co_4, price):
			constInfo.REFINE_ITEM_RESULT_1 = result1
			constInfo.REFINE_ITEM_RESULT_2 = result2
			constInfo.ITEM_VNUM_1 = item_vn_1
			constInfo.ITEM_COUNT_1 = item_co_1
			constInfo.ITEM_VNUM_2 = item_vn_2
			constInfo.ITEM_COUNT_2 = item_co_2
			constInfo.ITEM_VNUM_3 = item_vn_3
			constInfo.ITEM_COUNT_3 = item_co_3
			constInfo.ITEM_VNUM_4 = item_vn_4
			constInfo.ITEM_COUNT_4 = item_co_4
			constInfo.PRICE_R = price

		def OpenBoardRefine(self):
			if (self.RefineAura.IsShow()):
				self.RefineAura.Hide()
			else:
				self.RefineAura.Show()

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

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

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

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

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

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

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

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

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

	def PickUpItem(self):
		player.PickCloseItem()

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

	def OnKeyDown(self, key):
		if self.interface.wndWeb and self.interface.wndWeb.IsShow():
			return

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

			if app.ENABLE_NEW_QUICK_SLOT_SYSTEM:
				if player.SLOT_TYPE_NEW_QUICK_SLOT == attachedType:
					player.RequestDeleteGlobalNewQuickSlot(attachedItemSlotPos)

			## 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:
			elif player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType or player.SLOT_TYPE_STONE_INVENTORY == attachedType or player.SLOT_TYPE_GIFT_BOX_INVENTORY == attachedType:
				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 or player.SLOT_TYPE_GIFT_BOX_INVENTORY == attachedType:
			attachedInvenType = player.SlotTypeToInvenType(attachedType)
			if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
				if player.IsEquipmentSlot(attachedItemSlotPos):
					self.stream.popupWindow.Close()
					self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
				else:
					if chr.IsNPC(dstChrID):
						net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
					else:
						if app.ENABLE_MELEY_LAIR_DUNGEON:
							if chr.IsStone(dstChrID):
								net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
							else:
								net.SendExchangeStartPacket(dstChrID)
								net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
						else:
							net.SendExchangeStartPacket(dstChrID)
							net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
			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

		if app.WJ_OFFLINESHOP_SYSTEM:
			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

		# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
		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.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(arg))
		itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
		itemDropQuestionDialog.Open()
		itemDropQuestionDialog.dropType = attachedType
		itemDropQuestionDialog.dropCount = attachedMoney
		itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
		self.itemDropQuestionDialog = itemDropQuestionDialog

	def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
		# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
		if uiPrivateShopBuilder.IsBuildingPrivateShop():
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
			return

		if app.WJ_OFFLINESHOP_SYSTEM:
			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

		# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
		if player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):
			self.stream.popupWindow.Close()
			self.stream.popupWindow.Open(localeInfo.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)

		else:
			if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType or player.SLOT_TYPE_STONE_INVENTORY == attachedType or player.SLOT_TYPE_GIFT_BOX_INVENTORY == attachedType:
				dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

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

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

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

				constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
			elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
				dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)

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

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

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

				constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)


	def RequestDropItem(self, answer):
		if not self.itemDropQuestionDialog:
			return

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

			if player.SLOT_TYPE_INVENTORY == dropType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or player.SLOT_TYPE_STONE_INVENTORY == dropType or player.SLOT_TYPE_GIFT_BOX_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 or player.SLOT_TYPE_GIFT_BOX_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 RequestSellItem(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 or player.SLOT_TYPE_GIFT_BOX_INVENTORY == dropType:
				if dropNumber == player.ITEM_MONEY:
					return
				else:
					self.__SendSellItemPacket(dropNumber)

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

	def __SendDestroyItemPacket(self, itemVNum, itemInvenType = player.INVENTORY):
		if uiPrivateShopBuilder.IsBuildingPrivateShop():
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
			return
		net.SendItemDestroyPacket(itemVNum)

	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 app.WJ_OFFLINESHOP_SYSTEM:
			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 __SendSellItemPacket(self, itemVNum, itemInvenTyoe = player.INVENTORY):
		if uiPrivateShopBuilder.IsBuildingPrivateShop():
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
			return
		if app.WJ_OFFLINESHOP_SYSTEM:
			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.SendChatPacket("/itemsat %d" % (int(itemVNum)))

	def OnMouseRightButtonDown(self):

		self.CheckFocus()

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

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

		return TRUE

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

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

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

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

	def OnUpdate(self):
		app.UpdateGame()

		# if app.ENABLE_TITLE_SYSTEM:
			# self.wndTitleSystem.OnUpdate()

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

		if gameInfo.SYSTEMS_PAKET1==1:
			self.npcac()
			gameInfo.SYSTEMS_PAKET1=0

		if gameInfo.SYSTEMS_PAKET2==1:
			self.lonca_tanitim()
			gameInfo.SYSTEMS_PAKET2=0

		if gameInfo.SYSTEMS_PAKET3==1:
			self.loncasiralamaopen()
			gameInfo.SYSTEMS_PAKET3=0

		if gameInfo.SYSTEMS_PAKET4==1:
			self.siralamaopen()
			gameInfo.SYSTEMS_PAKET4=0

		if gameInfo.SYSTEMS_PAKET5==1:
			self.recordac()
			gameInfo.SYSTEMS_PAKET5=0

		if gameInfo.SYSTEMS_PAKET6==1:
			self.OpenMarbleShop()
			gameInfo.SYSTEMS_PAKET6=0

		if gameInfo.SYSTEMS_PAKET7==1:
			self.OpenTitleSystem()
			gameInfo.SYSTEMS_PAKET7=0

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

		if self.isShowDebugInfo:
			self.UpdateDebugInfo()

		if self.enableXMasBoom:
			self.__XMasBoom_Update()

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

		self.interface.BUILD_OnUpdate()
		"""lastTime = max(0, self.endTime - time.clock())
		if 0 == lastTime:
			self.YoutuberKimdir()
			curTime = time.clock()
			self.endTime = curTime + 4"""

	"""def YoutuberKimdir(self):
		if player.IsYoutuber():
			if player.IsSecurityActivate():
				return
			#net.SendChatPacket("(youtuber)")"""

	def UpdateDebugInfo(self):
		#
		# 캐릭터 좌표 및 FPS 출력
		(x, y, z) = player.GetMainCharacterPosition()
		nUpdateTime = app.GetUpdateTime()
		nUpdateFPS = app.GetUpdateFPS()
		nRenderFPS = app.GetRenderFPS()
		nFaceCount = app.GetFaceCount()
		fFaceSpeed = app.GetFaceSpeed()
		nST=background.GetRenderShadowTime()
		(fAveRT, nCurRT) =  app.GetRenderTime()
		(iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo()
		(iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum()
		if iPatch == 0:
			iPatch = 1

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

		self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
		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

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

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

		grp.PopState()
		grp.SetInterfaceRenderState()

		textTail.Render()
		textTail.HideAllTextTail()

	def OnPressEscapeKey(self):


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

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

		else:
			self.interface.OpenSystemDialog()

		if self.recordscreen.IsShow():
			self.recordscreen.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
	######################################################################################

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

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

	if app.WJ_ITEM_COMBINATION_SYSTEM:
		## Costume
		def BINARY_Item_Combination_Open(self, npcVNUM):
			self.interface.OpenItemCombinationWindow()

		def BINARY_Item_Combination_Succeed(self):
			print "Item Combination has succesfully!"
			self.interface.SucceedItemCombinationWork()
			pass

		## SkillBook
		def BINARY_Skill_Book_Combination_Open(self, npcVNUM):
			self.interface.OpenSkillBookCombinationWindow()

		def BINARY_Skill_Book_Combination_Succeed(self):
			print "Item Combination has succesfully!"
			self.interface.SucceedSkillBookCombinationWork()
			pass

		## Close
		def BINARY_Combination_Close(self):
			self.interface.CloseCombinationWindow()

	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_Cards_UpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points):
		self.interface.UpdateCardsInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points)

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

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

	# def BINARY_Cards_ShowIcon(self, icon):
		# self.interface.CardsShowIcon(icon)

	def BINARY_Cards_Open(self, safemode):
		self.interface.OpenCardsWindow(safemode)

	# 용혼석
	def BINARY_Highlight_Item(self, inven_type, inven_pos):
		if self.interface:
			self.interface.Highligt_Item(inven_type, inven_pos)

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

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

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

	def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
		self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)

	# END of DRAGON SOUL REFINE WINDOW


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

	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_ProcessKillInput(self, killerName, killerRace, victimName, victimRace):
		self.guildScoreCounter.OnMessage(killerName, killerRace, victimName, victimRace)

	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={
			"karakter_kilit"				: self.karakter_kilit,
			"getinputbegin"			: self.__Inputget1,
			"getinputend"			: self.__Inputget2,
			"getinput"				: self.__Inputget3,
			"depozit_index"			:self.__depozit_questindex,
			"antiexp_index"			:self.__antiexp_questindex,
			"Telep"		:self.__MakeTelep,
			"dopes_index"			:self.__bonus_questindex,
			"evento_ultimo_superviviente"			: self.__evento_ultimo_superviviente,
			"ConsoleEnable"			: self.__Console_Enable,
			"gorup_match_search"	: self.open_group,
			"DayMode"				: self.__DayMode_Update,
			"PRESERVE_DayMode"		: self.__PRESERVE_DayMode_Update,
			"CloseRestartWindow"	: self.__RestartDialog_Close,
			"OpenPrivateShop"		: self.__PrivateShop_Open,
			"OpenOfflineShop"		: self.__OfflineShop_Open,
			"PartyHealReady"		: self.PartyHealReady,
			"ShowMeSafeboxPassword"	: self.AskSafeboxPassword,
			"CloseSafebox"			: self.CommandCloseSafebox,
			"Teleport"				: self.Teleport,
			"YansitmaBaslat"		: self.interface.OpenYansitma,

			# Fix input quest Start
			"GetInputStringStart"				: self.GetInputStringStart,
			"GetInputStringEnd"					: self.GetInputStringEnd,
			# Fix input quest End
			#Guildstorage
			"GUILDSTORAGE"			: self._GuildStorageCMD,
			"GUILDSTORAGE_ADDITEM"	: self._GuildStorageAddItem,
			"GUILDSTORAGE_ADDITEMSLOT" : self._GuildStorageAddItemSlot,
			"GUILDSTORAGE_ADDMEMBER" : self._GuildStorageAddMemberToList,
			"GUILDSTORAGE_ADDTEMPSLOT" : self._GuildStorageTempSlotsAdd,
			"GUILDSTORAGE_ADDLOG"		: self._GuildStorageAddLog,
			##

			"OtomatikAvWindow"		: self.__otomatikavstart,
			"sorgu"					: self.Uzaktan_ticaret_soru,
			"recordquest"				: self.__recordscreen,
			"recordwarning"				: self.recordwarning,
			"oyunicisiralama"				: self.__oyunicisirala,
			"uyarisiralama"				: self.uyarisiralama,
			"loncasiralama"				: self.__oyunicilonca,
			"uyariloncasira"				: self.uyariloncasira,
			"lonca_tanit"			: self.lonca_tanitim,
			"loncatanitim"			: self.__loncatanitim,
			"lonca_tanitimi"		: self.loncatanitekran,
			"uyari"					: self.uyari,
			"lonca_lider_q"			: self.lonca_lider_q,
			"lider_ekle"			: self.lider_ekle,
			"lider_sifirla"			: self.lider_sifirla,

			"""#ticaret_gecmisi
			"tic_id"	:	self.__tic_quest_id,
			"tic_ekle"	:	self.__tic_gecmis_bilgi_gir,
			"tic_ac"	:	self.__tic_gecmis_ac,
			"tic_gotur"	:	self.Close_tic,

			"pazar_log_q"	:	self.__pazar_log_q,
			"itemi_alan"	:	self.__itemi_alan,
			"item_isim"	:	self.__item_isim,
			"item_fiyat"	:	self.__item_fiyat,
			"pazar_log_q_id"	:	self.__pazar_log_q_id,
			"pazar_ekle"	:	self.__pazar_log_bilgi_gir,
			"pazar_ac"	:	self.__pazar_log_ac,
			"pazar_gotur"	:	self.Close_p_log,"""

			# PET_SYSTEM
			"PetIsMine"							: self.__PetIsMineByVid,
			"ActivarGui"						: self.__ActivarGui,
			"SetPetClearItemSlotButtonIndex"	: self.__PetSetClearItemSlotButtonIndex,
			"SetPetIncreaseBoniButtonIndex"		: self.__PetSetIncreaseBoniButtonIndex,
			"SetPetSendAwayButtonIndex"			: self.__PetSetSendAwayButtonIndex,
			"ShowPet"							: self.__PetShow,
			"HidePet"							: self.__PetHide,
			"GetPetClearSlot"					: self.__PetGetClearSlot,
			"GetPetIncreaseBoni"				: self.__PetGetIncreaseBoni,
			"SetPet"							: self.__PetSet,
			"SetPetHead"						: self.__PetSetHead,
			"SetPetNeck"						: self.__PetSetNeck,
			"SetPetFoot"						: self.__PetSetFoot,
			"SetPetAttackValue"					: self.__PetSetAttackValue,
			"SetPetMagicAttackValue"			: self.__PetSetMagicAttackValue,
			"SetPetArmorValue"					: self.__PetSetArmorValue,
			"SetPetName"						: self.__PetSetName,
			"SetPetLevel"						: self.__PetSetLevel,
			"SetPetExp"							: self.__PetSetExp,
			"SetPetMaxExp"						: self.__PetSetMaxExp,
			"SetPetSkillPoints"					: self.__PetSetSkillPoints,
			# END_OF_PET_SYSTEM
			# ITEM_MALL
			"CloseMall"				: self.CommandCloseMall,
			"ShowMeMallPassword"	: self.AskMallPassword,
			"item_mall"				: self.__ItemMall_Open,
			# END_OF_ITEM_MALL

			"RefineSuceeded"		: self.RefineSuceededMessage,
			"RefineFailed"			: self.RefineFailedMessage,
			"xmas_snow"				: self.__XMasSnow_Enable,
			"xmas_boom"				: self.__XMasBoom_Enable,
			"xmas_song"				: self.__XMasSong_Enable,
			"xmas_tree"				: self.__XMasTree_Enable,
			"newyear_boom"			: self.__XMasBoom_Enable,
			"PartyRequest"			: self.__PartyRequestQuestion,
			"PartyRequestDenied"	: self.__PartyRequestDenied,
			"horse_state"			: self.__Horse_UpdateState,
			"hide_horse_state"		: self.__Horse_HideState,
			"WarUC"					: self.__GuildWar_UpdateMemberCount,
			"test_server"			: self.__EnableTestServerFlag,
			"mall"			: self.__InGameShop_Show,
			#PET_SYSTEM
			"PetEvolution"			: self.SetPetEvolution,
			"PetName"				: self.SetPetName,
			"PetLevel"				: self.SetPetLevel,
			"PetDuration"			: self.SetPetDuration,
			"PetAgeDuration"		: self.SetPetAgeDuration,
			"PetBonus"				: self.SetPetBonus,
			"PetSkill"				: self.SetPetskill,
			"PetIcon"				: self.SetPetIcon,
			"PetExp"				: self.SetPetExp,
			"PetUnsummon"			: self.PetUnsummon,
			"OpenPetIncubator"		: self.OpenPetIncubator,
			#PET_SYSTEM
			# ITEM_SHOP
			"SetISLoadButtonIndex"				: self.__ISSetLoadButtonIndex,
			"SetISBuyButtonIndex"				: self.__ISSetBuyButtonIndex,
			"GetISBuyID"						: self.__ISGetBuyID,
			"GetISBuyID2"						: self.__ISGetBuyID2,
			"AddISCategory"						: self.__ISAddCategory,
			"SelectISCategory"					: self.__ISSelectCategory,
			"ClearISItems"						: self.__ISClearItems,
			"AddISItem"							: self.__ISAddItem,
			"AddISItemDesc"						: self.__ISAddItemDesc,
			"SetISLoadSuccess"					: self.__ISSetLoadSuccess,
			"SetISLoadFail"						: self.__ISSetLoadFail,
			"SetISBuySuccess"					: self.__ISSetBuySuccess,
			"SetISBuyFail"						: self.__ISSetBuyFail,
			"SetISCoins"						: self.__ISSetCoins,
			"SetISMarks"						: self.__ISSetMarks,
			"Showmedallas_gui"			: self.__showmedallas_gui,
			"Hidemedallas_gui"			: self.__hidemedallas_gui,
			"muertes"				: self.__muertes,
			"primera_muerte"				: self.__primera_muerte,
			"doble_muerte"				: self.__doble_muerte,
			"triple_muerte"				: self.__triple_muerte,
			"exterminio"				: self.__exterminio,
			"muertacular"				: self.__muertacular,
			"bestialidad"				: self.__bestialidad,
			"salvajada"				: self.__salvajada,
			"catastrofe"				: self.__catastrofe,
			"apocalipsis"				: self.__apocalipsis,
			"lluvia_muertos"				: self.__lluvia_muertos,
			"super_increible"				: self.__super_increible,
			"input0"						: self.__Input0,
			"input1"						: self.__Input1,

			# END_OF_ITEM_SHOP
			# WEDDING
			"lover_login"			: self.__LoginLover,
			"lover_logout"			: self.__LogoutLover,
			"lover_near"			: self.__LoverNear,
			"lover_far"				: self.__LoverFar,
			"lover_divorce"			: self.__LoverDivorce,
			"PlayMusic"				: self.__PlayMusic,
			#transfer costume
			"transferopen"			: self.showtransfer,
			"get_input_value"			: self.GetInputValue,
			"get_input_start"			: self.GetInputOn,
			"get_input_end"			: self.GetInputOff,
			"super_quest"			: self.Tabulejtor,
			"pvp_zdruwko"			: self.Mozart,
			#end transfer
			# END_OF_WEDDING

			"SupportLv"					: self.SetSupportLevel,
			"SupportName"				: self.SetSupportName,
			"SupportLeave"				: self.SupportLeave,
			"SupporInt"					: self.SupportInt,
			"SupportExp"				: self.SetSupportExp,
			"SupportIcon"				: self.SetSupportIcon,
			"SupportSpeciality"			: self.SetSupportSpeciality,

			########Anti Exp Button by Sanii##########
			"anti_exp"				: self.AntiExp,
			"anti_exp_state"		: self.AntiExpState,
			"mostrar_usuarios"		: self.__mostrar_usuarios,
			"ocultar_usuarios"		: self.__ocultar_usuarios,
			"muerto_guerras"		: self.__muerto_guerras,
			"alubias"				: self.__alubias,
			"proteccion_guerra"		: self.__proteccion_guerra,
			"contador_usuarios_guerra"	: self.__contador_usuarios_guerra,
			"muertos_guerra"		: self.__muertos_guerra,
			"caido_guerra"			: self.__caido_guerra,
			"ataque_guerra"			: self.__ataque_guerra,
			"ataque_guerra1"		: self.__ataque_guerra1,
			"activar_libre"			: self.__activar_libre,
			"cerrar_grupo"			: self.__grupobug,
			"spirit2"				: self.__spirit2,

			# PRIVATE_SHOP_PRICE_LIST
			"MyShopPriceList"		: self.__PrivateShop_PriceList,
			"AppendLoncaGecmisi"	: self.__Append_Lonca_Gecmisi,
			"WarPlayerCheckReq"		: self.__Do_Check_War_Player,
			"loncaistatistik"		: self.loncaistatistik,

			"gecmis_q"				: self.lonca_gecmis_q,
			"lonca_gecmis_ekle"		: self.lonca_gecmis_ekle,
			"gecmistemizle"			: self.gecmistemizle,
			"isim_ver"				: self.isim_ver,

			# END_OF_PRIVATE_SHOP_PRICE_LIST

			# END_OF_BONI_SWITCHER
			#offshoppannel
			"MountSystem"			: self.__MountSystem,
			"SCHICKSAL_RAD"			: self.__SchicksalRad,
			# 5Lv Oto Bec Sistemi
			"item_kilit_q"			: self.item_kilit_q,
			"kilit"					: self._kilit,
			# Savasci Beceri
			"OpenBec1Gui"				: self.__BecSystem1,
			"zihinsel_oto_bec"			: self.zihinsel_oto_bec,
			"bedensel_oto_bec"			: self.bedensel_oto_bec,

			# Sura Beceri
			"OpenBec3Gui"				: self.__BecSystem2,
			"karabuyu_oto_bec"			: self.karabuyu_oto_bec,
			"buyulusilah_oto_bec"			: self.buyulusilah_oto_bec,

			# Ninja Becerileri
			"OpenBec2Gui"				: self.__BecSystem3,
			"yakin_oto_bec"			: self.yakin_oto_bec,
			"uzak_oto_bec"			: self.uzak_oto_bec,

			# Saman Becerileri
			"OpenBec4Gui"				: self.__BecSystem4,
			"ejderha_oto_bec"			: self.ejderha_oto_bec,
			"iyilestirme_oto_bec"			: self.iyilestirme_oto_bec,

			# Lycan Becerileri
			"OpenBec5Gui"				: self.__BecSystem5,
			"lycany_oto_bec"			: self.lycany_oto_bec,
			#"lycanu_oto_bec"			: self.lycanu_oto_bec,
			#Bk Takas
			"bk_trade_sys"				: self.__BKTradeSys,
			"""YoutuberKimdir"			: self.YoutuberKimdir,"""

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

			"OpenGuiGaya"	: self.OpenGuiGaya,
			"GayaCheck"		: self.GayaCheck,

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

			"ruhtasiekranac"	: self.ruhcac,
			"bkekranac"			: self.bkac,

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

			"SetReborn"	:	self.SetReborn,

			"GW_Kill_Update"		: self.__GuildWar_ProcessKillInput,
			"AkiraEventSys"			: self.__AkiraEventDataAppend,
			"COSTUME_HIDE_CLEAR"	: self.COSTUME_HIDE_CLEAR,
			"COSTUME_HIDE_LIST"		: self.COSTUME_HIDE_LIST,
			"COSTUME_HIDE_LOAD"		: self.COSTUME_HIDE_LOAD,
			}

		if app.WJ_SECURITY_SYSTEM:
			serverCommandList.update({"OpenSecurityCreate" : self.OpenSecurityCreate })
			serverCommandList.update({"OpenSecurityDialog" : self.OpenSecurityDialog })
			serverCommandList.update({"CloseSecurityCreate" : self.CloseSecurityCreate })
			serverCommandList.update({"CloseSecurityDialog" : self.CloseSecurityDialog })

		if app.ENABLE_MAINTENANCE_SYSTEM:
			serverCommandList.update({"BINARY_Update_Maintenance" : self.BINARY_Update_Maintenance })

		# if app.ENABLE_HIDE_COSTUME_SYSTEM:
			# serverCommandList["COSTUME_HIDE_CLEAR"] = self.COSTUME_HIDE_CLEAR
			# serverCommandList["COSTUME_HIDE_LIST"] = self.COSTUME_HIDE_LIST
			# serverCommandList["COSTUME_HIDE_LOAD"] = self.COSTUME_HIDE_LOAD
		if app.ENABLE_COSTUME_AURA:
			serverCommandList["ClearDirRefine"] = self.ClearDirRefine
			serverCommandList["SetDirRefine"] = self.SetDirRefine
			serverCommandList["AuraRefineInformation"] = self.AuraRefineInformation
			serverCommandList["OpenBoardRefine"] = self.OpenBoardRefine

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

		if app.ENABLE_NEW_ENCHANT_ATTR:
			self.serverCommander.SAFE_RegisterCallBack("EnchantAttr_open", self.__OpenEnchantAttr)

		if app.ENABLE_MELEY_LAIR_DUNGEON:
			self.serverCommander.SAFE_RegisterCallBack("meley_open", self.OpenMeleyRanking)
			self.serverCommander.SAFE_RegisterCallBack("meley_rank", self.AddRankMeleyRanking)

	def __MakeTelep(self, qid):
		constInfo.Telepqin= int(qid)

	if app.ENABLE_NEW_ENCHANT_ATTR:
		def __OpenEnchantAttr(self, cell):
			if self.interface:
				new_cell = int(cell.split("#")[1])
				attrType0 = int(cell.split("#")[2])
				attrValue0 = int(cell.split("#")[3])
				attrType1 = int(cell.split("#")[4])
				attrValue1 = int(cell.split("#")[5])
				attrType2 = int(cell.split("#")[6])
				attrValue2 = int(cell.split("#")[7])
				attrType3 = int(cell.split("#")[8])
				attrValue3 = int(cell.split("#")[9])
				attrType4 = int(cell.split("#")[10])
				attrValue4 = int(cell.split("#")[11])
				new_attrSlot = [
									[attrType0, attrValue0],
									[attrType1, attrValue1],
									[attrType2, attrValue2],
									[attrType3, attrValue3],
									[attrType4, attrValue4],
				]

				self.interface.OpenEnchantAttrWindow(new_cell, new_attrSlot)

	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 loncaistatistik(self,isim,level,durum,oldurme,olum,member):
		self.loncaistatistiktemizle(member)


		if int(member) == 1:
			constInfo.isim1 = "1 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme1 = str(oldurme)
			constInfo.olum1 = str(olum)
			if int(durum) == 0:
				constInfo.durum1 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum1 = "|cffff0000|Hemp|hOlu"

		if int(member) == 2:
			constInfo.isim2 = "2 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme2 = str(oldurme)
			constInfo.olum2 = str(olum)
			if int(durum) == 0:
				constInfo.durum2 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum2 = "|cffff0000|Hemp|hOlu"

		if int(member) == 3:
			constInfo.isim3 = "3 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme3 = str(oldurme)
			constInfo.olum3 = str(olum)
			if int(durum) == 0:
				constInfo.durum3 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum3 = "|cffff0000|Hemp|hOlu"

		if int(member) == 4:
			constInfo.isim4 = "4 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme4 = str(oldurme)
			constInfo.olum4 = str(olum)
			if int(durum) == 0:
				constInfo.durum4 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum4 = "|cffff0000|Hemp|hOlu"

		if int(member) == 5:
			constInfo.isim5 = "5 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme5 = str(oldurme)
			constInfo.olum5 = str(olum)
			if int(durum) == 0:
				constInfo.durum5 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum5 = "|cffff0000|Hemp|hOlu"

		if int(member) == 6:
			constInfo.isim6 = "6 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme6 = str(oldurme)
			constInfo.olum6 = str(olum)
			if int(durum) == 0:
				constInfo.durum6 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum6 = "|cffff0000|Hemp|hOlu"

		if int(member) == 7:
			constInfo.isim7 = "7 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme7 = str(oldurme)
			constInfo.olum7 = str(olum)
			if int(durum) == 0:
				constInfo.durum7 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum7 = "|cffff0000|Hemp|hOlu"

		if int(member) == 8:
			constInfo.isim8 = "8 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme8 = str(oldurme)
			constInfo.olum8 = str(olum)
			if int(durum) == 0:
				constInfo.durum8 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum8 = "|cffff0000|Hemp|hOlu"

		if int(member) == 9:
			constInfo.isim9 = "9 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme9 = str(oldurme)
			constInfo.olum9 = str(olum)
			if int(durum) == 0:
				constInfo.durum9 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum9 = "|cffff0000|Hemp|hOlu"

		if int(member) == 10:
			constInfo.isim10 = "10 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme10 = str(oldurme)
			constInfo.olum10 = str(olum)
			if int(durum) == 0:
				constInfo.durum10 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum10 = "|cffff0000|Hemp|hOlu"

		if int(member) == 11:
			constInfo.isim11 = "11 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme11 = str(oldurme)
			constInfo.olum11 = str(olum)
			if int(durum) == 0:
				constInfo.durum11 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum11 = "|cffff0000|Hemp|hOlu"

		if int(member) == 12:
			constInfo.isim12 = "12 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme12 = str(oldurme)
			constInfo.olum12 = str(olum)
			if int(durum) == 0:
				constInfo.durum12 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum12 = "|cffff0000|Hemp|hOlu"

		if int(member) == 13:
			constInfo.isim13 = "13 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme13 = str(oldurme)
			constInfo.olum13 = str(olum)
			if int(durum) == 0:
				constInfo.durum13 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum13 = "|cffff0000|Hemp|hOlu"

		if int(member) == 14:
			constInfo.isim14 = "14 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme14 = str(oldurme)
			constInfo.olum14 = str(olum)
			if int(durum) == 0:
				constInfo.durum14 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum14 = "|cffff0000|Hemp|hOlu"

		if int(member) == 15:
			constInfo.isim15 = "15 - "+str(isim)+"(|cff00ff00|H|hNivel."+str(level)+"|h|r)"
			constInfo.oldurme15 = str(oldurme)
			constInfo.olum15 = str(olum)
			if int(durum) == 0:
				constInfo.durum15 = "|cff00ff00|H|hYasiyor"
			if int(durum) == 1:
				constInfo.durum15 = "|cffff0000|Hemp|hOlu"


	def loncaistatistiktemizle(self,member):
		if int(member) == 1:
			constInfo.isim2 = ""
			constInfo.durum2 = ""
			constInfo.oldurme2 = ""
			constInfo.olum2 = ""

			constInfo.isim3 = ""
			constInfo.durum3 = ""
			constInfo.oldurme3 = ""
			constInfo.olum3 = ""

			constInfo.isim4 = ""
			constInfo.durum4 = ""
			constInfo.oldurme4 = ""
			constInfo.olum4 = ""

			constInfo.isim5 = ""
			constInfo.durum5 = ""
			constInfo.oldurme5 = ""
			constInfo.olum5 = ""

			constInfo.isim6 = ""
			constInfo.durum6 = ""
			constInfo.oldurme6 = ""
			constInfo.olum6 = ""

			constInfo.isim7 = ""
			constInfo.durum7 = ""
			constInfo.oldurme7 = ""
			constInfo.olum7 = ""

			constInfo.isim8 = ""
			constInfo.durum8 = ""
			constInfo.oldurme8 = ""
			constInfo.olum8 = ""

			constInfo.isim9 = ""
			constInfo.durum9 = ""
			constInfo.oldurme9 = ""
			constInfo.olum9 = ""

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 2:

			constInfo.isim3 = ""
			constInfo.durum3 = ""
			constInfo.oldurme3 = ""
			constInfo.olum3 = ""

			constInfo.isim4 = ""
			constInfo.durum4 = ""
			constInfo.oldurme4 = ""
			constInfo.olum4 = ""

			constInfo.isim5 = ""
			constInfo.durum5 = ""
			constInfo.oldurme5 = ""
			constInfo.olum5 = ""

			constInfo.isim6 = ""
			constInfo.durum6 = ""
			constInfo.oldurme6 = ""
			constInfo.olum6 = ""

			constInfo.isim7 = ""
			constInfo.durum7 = ""
			constInfo.oldurme7 = ""
			constInfo.olum7 = ""

			constInfo.isim8 = ""
			constInfo.durum8 = ""
			constInfo.oldurme8 = ""
			constInfo.olum8 = ""

			constInfo.isim9 = ""
			constInfo.durum9 = ""
			constInfo.oldurme9 = ""
			constInfo.olum9 = ""

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 3:

			constInfo.isim4 = ""
			constInfo.durum4 = ""
			constInfo.oldurme4 = ""
			constInfo.olum4 = ""

			constInfo.isim5 = ""
			constInfo.durum5 = ""
			constInfo.oldurme5 = ""
			constInfo.olum5 = ""

			constInfo.isim6 = ""
			constInfo.durum6 = ""
			constInfo.oldurme6 = ""
			constInfo.olum6 = ""

			constInfo.isim7 = ""
			constInfo.durum7 = ""
			constInfo.oldurme7 = ""
			constInfo.olum7 = ""

			constInfo.isim8 = ""
			constInfo.durum8 = ""
			constInfo.oldurme8 = ""
			constInfo.olum8 = ""

			constInfo.isim9 = ""
			constInfo.durum9 = ""
			constInfo.oldurme9 = ""
			constInfo.olum9 = ""

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 4:

			constInfo.isim5 = ""
			constInfo.durum5 = ""
			constInfo.oldurme5 = ""
			constInfo.olum5 = ""

			constInfo.isim6 = ""
			constInfo.durum6 = ""
			constInfo.oldurme6 = ""
			constInfo.olum6 = ""

			constInfo.isim7 = ""
			constInfo.durum7 = ""
			constInfo.oldurme7 = ""
			constInfo.olum7 = ""

			constInfo.isim8 = ""
			constInfo.durum8 = ""
			constInfo.oldurme8 = ""
			constInfo.olum8 = ""

			constInfo.isim9 = ""
			constInfo.durum9 = ""
			constInfo.oldurme9 = ""
			constInfo.olum9 = ""

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 5:

			constInfo.isim6 = ""
			constInfo.durum6 = ""
			constInfo.oldurme6 = ""
			constInfo.olum6 = ""

			constInfo.isim7 = ""
			constInfo.durum7 = ""
			constInfo.oldurme7 = ""
			constInfo.olum7 = ""

			constInfo.isim8 = ""
			constInfo.durum8 = ""
			constInfo.oldurme8 = ""
			constInfo.olum8 = ""

			constInfo.isim9 = ""
			constInfo.durum9 = ""
			constInfo.oldurme9 = ""
			constInfo.olum9 = ""

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 6:

			constInfo.isim7 = ""
			constInfo.durum7 = ""
			constInfo.oldurme7 = ""
			constInfo.olum7 = ""

			constInfo.isim8 = ""
			constInfo.durum8 = ""
			constInfo.oldurme8 = ""
			constInfo.olum8 = ""

			constInfo.isim9 = ""
			constInfo.durum9 = ""
			constInfo.oldurme9 = ""
			constInfo.olum9 = ""

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 7:

			constInfo.isim8 = ""
			constInfo.durum8 = ""
			constInfo.oldurme8 = ""
			constInfo.olum8 = ""

			constInfo.isim9 = ""
			constInfo.durum9 = ""
			constInfo.oldurme9 = ""
			constInfo.olum9 = ""

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 8:

			constInfo.isim9 = ""
			constInfo.durum9 = ""
			constInfo.oldurme9 = ""
			constInfo.olum9 = ""

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 9:

			constInfo.isim10 = ""
			constInfo.durum10 = ""
			constInfo.oldurme10 = ""
			constInfo.olum10 = ""

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 10:

			constInfo.isim11 = ""
			constInfo.durum11 = ""
			constInfo.oldurme11 = ""
			constInfo.olum11 = ""

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 11:

			constInfo.isim12 = ""
			constInfo.durum12 = ""
			constInfo.oldurme12 = ""
			constInfo.olum12 = ""

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 12:

			constInfo.isim13 = ""
			constInfo.durum13 = ""
			constInfo.oldurme13 = ""
			constInfo.olum13 = ""

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 13:

			constInfo.isim14 = ""
			constInfo.durum14 = ""
			constInfo.oldurme14 = ""
			constInfo.olum14 = ""

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

		if int(member) == 14:

			constInfo.isim15 = ""
			constInfo.durum15 = ""
			constInfo.oldurme15 = ""
			constInfo.olum15 = ""

	def LoncaIstatistikOpen(self):
		import net
		net.SendChatPacket("/loncaistatistik")
		import uiloncaistatistik
		self.loncaistatistik = uiloncaistatistik.LoncaIstatistik()
		self.loncaistatistik.Show()

	def GuildstorageTry(self):
		import uiguildstorage
		self.GuildstorageWindow = uiguildstorage.GuildStorage()
		if self.GuildstorageWindow.IsShow():
			self.GuildstorageWindow.Hide()
		else:
			self.GuildStorageWindow.Show()

	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

	#AKIRA_EVENT_SYSTEM
	def __AkiraEventDataAppend(self,event_data):
		self.akiraEventButton.Open(event_data)
	#END_OF_AKIRA_EVENT_SYSTEM

	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 karakter_kilit(self,qid):
		constInfo.karakter_kilit = int(qid)

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

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

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

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

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

	def __deschidere_magazin_questindex(self, value):
		constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX = int(value)

	def __deschidere_magazin(self):
		deschidere_magazin = constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX
		event.QuestButtonClick(deschidere_magazin)

	def RefineSuceededMessage(self):
		snd.PlaySound("sound/ui/make_soket.wav")
		self.PopupMessage(localeInfo.REFINE_SUCCESS)
		translate.yenile=3

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

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

	# PRIVATE_SHOP_PRICE_LIST
	def __PrivateShop_PriceList(self, itemVNum, itemPrice):
		if app.WJ_OFFLINESHOP_SYSTEM:
			uiOfflineShopBuilder.SetOfflineShopItemPrice(itemVNum, itemPrice)
	# END_OF_PRIVATE_SHOP_PRICE_LIST

	def __Append_Lonca_Gecmisi(self, guildName, joinDate, joinTime, memberPosition):
		lastPosition = ""
		if int(memberPosition) == 1:
			lastPosition = "Lider"
		else:
			lastPosition = "Uye"

		lastDate = "%s %s" % (str(joinDate), str(joinTime))

		self.LoncaGecmisi.AppendNewMember(str(guildName), str(lastPosition), str(lastDate))

	def __Do_Check_War_Player(self, targetName, killCount, deadCount):
		warPlayerCheckQuestionDialog = uiCommon.QuestionDialog3()
		warPlayerCheckQuestionDialog.SetText1("%s isimli oyuncu ajan olabilir." % (targetName))
		warPlayerCheckQuestionDialog.SetText2("Olme: %s Oldurme: %s" % (str(deadCount), str(killCount)))
		warPlayerCheckQuestionDialog.SetText3("Savastan atilsin mi?")
		warPlayerCheckQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
		warPlayerCheckQuestionDialog.SetCancelText(localeInfo.UI_DENY)
		warPlayerCheckQuestionDialog.SetAcceptEvent(lambda arg=True: self.__AnswerWarCheckRequest(arg))
		warPlayerCheckQuestionDialog.SetCancelEvent(lambda arg=False: self.__AnswerWarCheckRequest(arg))
		warPlayerCheckQuestionDialog.Open()
		warPlayerCheckQuestionDialog.name = targetName
		self.warPlayerCheckQuestionDialog = warPlayerCheckQuestionDialog

	def __AnswerWarCheckRequest(self, answer):
		if not self.warPlayerCheckQuestionDialog:
			return

		targetName = self.warPlayerCheckQuestionDialog.name

		if answer:
			net.SendChatPacket("/kovkopegi %s" % (str(targetName)))

		self.warPlayerCheckQuestionDialog.Close()
		self.warPlayerCheckQuestionDialog = None

	def SetPetEvolution(self, evo):
		petname = ["Tanar", "Salbatic", "Curajos", "Eroic"]
		self.petmain.SetEvolveName(petname[int(evo)])

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

	def SetPetLevel(self, level):
		self.petmain.SetLevel(level)

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

	def SetPetAgeDuration(self, age):
		if (int(age)) > 0:
			self.petmain.SetAgeDuration(age)

	def SetPetBonus(self, hp, dif, sp):
		self.petmain.SetHp(hp)
		self.petmain.SetDef(dif)
		self.petmain.SetSp(sp)

	def SetPetskill(self, slot, idx, lv):
		if int(lv) > 0:
			self.petmini.SetSkill(slot, idx, lv)
		self.petmain.SetSkill(slot, idx, lv)
		self.affectShower.BINARY_NEW_AddAffect(5400+int(idx),int(constInfo.LASTAFFECT_POINT)+1,int(constInfo.LASTAFFECT_VALUE)+1, 0)
		if int(slot)==0:
			constInfo.SKILL_PET1=5400+int(idx)
		if int(slot)==1:
			constInfo.SKILL_PET2=5400+int(idx)
		if int(slot)==2:
			constInfo.SKILL_PET3=5400+int(idx)

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

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

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

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


	def OpenPetIncubator(self, pet_new = 0):
		import uipetincubatrice
		self.petinc = uipetincubatrice.PetSystemIncubator(pet_new)
		self.petinc.Show()
		self.petinc.SetTop()

	def OpenPetMini(self):
		self.petmini.Show()
		self.petmini.SetTop()

	def OpenPetFeed(self):

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

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

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

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

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

		if background.GetCurrentMapName() in mapDict:
			return FALSE

		return TRUE

	def __XMasSnow_Enable(self, mode):

		self.__XMasSong_Enable(mode)

		if "1"==mode:

			if not self.__IsXMasMap():
				return

			print "XMAS_SNOW ON"
			background.EnableSnow(1)

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

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

			if not self.__IsXMasMap():
				return

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

	def __XMasTree_Enable(self, grade):

		print "XMAS_TREE ", grade
		background.SetXMasTree(int(grade))
	# PET_INVENTORY
	def __PetIsMineByVid(self, vid):
		targetName = chr.GetNameByVID(int(vid))
		charName = player.GetName() or chr.GetMainCharacterName()
		if targetName[0:len(charName)] == charName:
			localeInfo.SEND_BACK = "true"
		else:
			localeInfo.SEND_BACK = "false"

		self.__SendTextPacketToQuest()
		localeInfo.SEND_BACK = ""

	def __SendTextPacketToQuest(self):
		net.SendQuestInputStringPacket(localeInfo.SEND_BACK)

	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 __PetSetClearItemSlotButtonIndex(self, index):
		constInfo2.PET_CLEAR_ITEM_SLOT_BUTTON_INDEX = int(index)

	def __PetSetIncreaseBoniButtonIndex(self, index):
		constInfo2.PET_INCREASE_BONI_BUTTON_INDEX = int(index)

	def __PetSetSendAwayButtonIndex(self, index):
		constInfo2.PET_SEND_AWAY_BUTTON_INDEX = int(index)

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

	def item_kilit_q(self, id):
		constInfo.ITEM_KILIT = int(id)

	def _kilit(self):
		item_sil_idd = str(constInfo.kilit_id)
		net.SendQuestInputStringPacket(item_sil_idd)

	def __ActivarGui(self):
		global pet_gui_activado
		pet_gui_activado = 1

	def __DeactivarGui(self):
		global pet_gui_activado
		pet_gui_activado = 0

	def __PetShow(self):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.Show()

	def __PetHide(self):
		if self.petInventoryWnd:
			self.petInventoryWnd.Hide()

	def __PetGetClearSlot(self):
		net.SendQuestInputStringPacket(str(self.petInventoryWnd.GetClearSlot()))

	def __PetGetIncreaseBoni(self):
		net.SendQuestInputStringPacket(str(self.petInventoryWnd.GetIncreaseBoni()))

	def __PetSet(self, itemVnum):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetPet(itemVnum)

	def __PetSetHead(self, itemVnum):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		if int(itemVnum) > 0:
			self.petInventoryWnd.SetHeadItem(itemVnum)
		else:
			self.petInventoryWnd.ClearHeadItem()

	def __PetSetNeck(self, itemVnum):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		if int(itemVnum) > 0:
			self.petInventoryWnd.SetNeckItem(itemVnum)
		else:
			self.petInventoryWnd.ClearNeckItem()

	def __PetSetFoot(self, itemVnum):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		if int(itemVnum) > 0:
			self.petInventoryWnd.SetFootItem(itemVnum)
		else:
			self.petInventoryWnd.ClearFootItem()

	def __PetSetAttackValue(self, value):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetAttackValue(value)

	def __PetSetMagicAttackValue(self, value):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetMagicAttackValue(value)

	def __PetSetArmorValue(self, value):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetArmorValue(value)

	def __PetSetName(self, name):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetName(name.replace("[_]", " "))

	def __PetSetLevel(self, level):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetLevel(level)

	def __PetSetExp(self, exp):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetExp(exp)
		self.petInventoryWnd.UpdateExpBar()

	def __PetSetMaxExp(self, maxexp):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetMaxExp(maxexp)
		self.petInventoryWnd.UpdateExpBar()

	def __PetSetSkillPoints(self, points):
		if not self.petInventoryWnd:
			import uiPet
			self.petInventoryWnd = uiPet.PetInventoryDialog()
		self.petInventoryWnd.SetSkillPoints(points)
	# END_PET_INVENTORY
	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):
		otoavinfo.Start = 1

	def OtomatikAv(self):
		import uiotomatikav
		self.otomatikav = uiotomatikav.otomatikav()
		self.otomatikav.Show()

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

	if app.PARTY_MATCH:
		def open_group(self, ayar, index):
			import uipartymatch
			self.wndPartyMatch = uipartymatch.PartyMatchWindow()
			if ayar == "61":
				# self.wndPartyMatch.sifir()
				constInfo.KILITLE = 0
			else:
				if self.interface:
					self.interface.wndMiniMap.open_party_match(ayar, index)
					if ayar == "1":
						self.wndPartyMatch.bilgi_ver(index)
						constInfo.KILITLE = 61
					else:
						constInfo.KILITLE = 0

	def __muerto_guerras(self, id):
		constInfo.muerto_guerras = int(id)

	def __alubias(self):
		for i in xrange(player.INVENTORY_PAGE_SIZE*2):
			if player.GetItemIndex(i) in (70102,):
				net.SendItemUsePacket(i)
				net.SendItemUsePacket(i)
				net.SendItemUsePacket(i)
				net.SendItemUsePacket(i)
				net.SendItemUsePacket(i)
				net.SendItemUsePacket(i)
				break

	def __spirit2(self):
		net.SendChatPacket("(spirit2)")

	def __proteccion_guerra(self):
		net.SendChatPacket("(proteccion_guerra)")

	def __contador_usuarios_guerra(self, contador_usuarios_guerra):
		self.contador_usuarios_guerra.SetText(contador_usuarios_guerra)

	def __muertos_guerra(self, muertos_guerra):
		self.muertos_guerra.SetText(muertos_guerra)

	def __caido_guerra(self, caido_guerra):
		self.caido_guerra.SetText(caido_guerra)

	def __mostrar_usuarios(self):
		self.Espacio.Show()
		self.contador_usuarios_guerra.Show()
		self.muertos_guerra.Show()
		self.caido_guerra.Show()
		self.usuarios_guerra.Show()
		self.ranking_guerra.Show()
		self.ranking_caido.Show()

	def __ocultar_usuarios(self):
		self.Espacio.Hide()
		self.contador_usuarios_guerra.Hide()
		self.muertos_guerra.Hide()
		self.caido_guerra.Hide()
		self.usuarios_guerra.Hide()
		self.ranking_guerra.Hide()
		self.ranking_caido.Hide()

	def __ataque_guerra(self):
		constInfo.ataque_guerra = 1

	def __ataque_guerra1(self):
		constInfo.ataque_guerra = 0

	def __activar_libre(self):
		net.SendChatPacket("/pkmode 2")

	def __grupobug(self):
		net.SendPartyExitPacket()

	## PrivateShop
	def __PrivateShop_Open(self):
		self.uiNewShop.Show()

	def BINARY_PrivateShop_Appear(self, vid, text):
		if chr.GetInstanceType(vid) in [chr.INSTANCE_TYPE_PLAYER, chr.INSTANCE_TYPE_NPC]:
			self.interface.AppearPrivateShop(vid, text)

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

	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)

	def BINARY_OfflineShopGui(self, result, i, time):
		if result == 0:
			self.interface.ToggleOfflineShopAdminPanelWindow2()
		else:
			self.interface.ToggleOfflineShopAdminPanelWindow(i, time)

	## 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.WJ_COMBAT_ZONE):
		def BINARY_CombatZone_Manager(self, tokens, arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0):
			if tokens == "OpenWindow":
				self.wndCombatZone.Open(arg1, arg2, arg3, arg4)

			elif tokens == "RegisterRank":
				self.wndCombatZone.RegisterRanking()

			elif tokens == "StartFlashing":
				if self.interface:
					self.interface.wndMiniMap.btnCombatZone.FlashEx()

			elif tokens == "RefreshShop":
				if self.interface:
					self.interface.dlgShop.SetCombatZonePoints(arg1)
					self.interface.dlgShop.SetLimitCombatZonePoints(arg2, arg3)

	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 __LoverFar(self):
		if self.affectShower:
			self.affectShower.HideLoverState()

	if app.ENABLE_TICKET_SYSTEM:
		def BINARY_Ticket_Sort_Admin(self, token, val):
			if token == "r":
				if self.wndTicket.IsShow():
					chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.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)

	def	OpenMarbleShop(self):
		if app.WJ_SECURITY_SYSTEM and player.IsSecurityActivate():
			return
		if self.wndMarbleShop.IsShow():
			self.wndMarbleShop.Hide()
		else:
			self.wndMarbleShop.Show()

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

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

	# END_OF_WEDDING

	"""# Ticaret LOG #
	def OpenTicaretLog(self):
		self.Board = ui.BoardWithTitleBar()
		self.Board.SetSize(241+30+215, 271+40+40-17-17)
		self.Board.SetCenterPosition()
		self.Board.AddFlag('movable')
		self.Board.AddFlag('float')
		self.Board.SetTitleName('Ticaret Kayitlarin')
		self.Board.SetCloseEvent(self.Kapat)
		self.Board.Show()


		#self.Ticaret = 1
		self.Bekle3 = app.GetTime()

		self.TekliflerText = ui.TextLine_Alisveris()
		self.TekliflerText.SetParent(self.Board)
		self.TekliflerText.SetPosition(0, 30)
		self.TekliflerText.SetText(str(player.GetName()))
		self.TekliflerText.SetWindowHorizontalAlignCenter()
		self.TekliflerText.SetHorizontalAlignCenter()
		self.TekliflerText.Show()

		self.ThinBoard = ui.ThinBoard()
		self.ThinBoard.SetParent(self.Board)
		self.ThinBoard.SetSize(241-18+26+215, 250)
		self.ThinBoard.SetPosition(10+9-5-3, 48)
		self.ThinBoard.Show()

		self.ListBox=ui.ListBox_Scroll()
		self.ListBox.SetParent(self.Board)
		self.ListBox.SetPosition(10+9, 50)
		self.ListBox.SetSize(241-18+26-8+215, 250)
		#self.ListBox.SetEvent(ui.__mem_func__(self.__OnSelectListBox))
		self.ListBox.Show()


		self.ListBox.ClearItem()

		pos = 0
		if os.path.exists(str(systemInfo.CLIENT_YOL)+"ticaret_"+str(player.GetName())+".cfg"):
			ac = open(str(systemInfo.CLIENT_YOL)+"ticaret_"+str(player.GetName())+".cfg", "r").readlines()
			for i in ac:
				bol = i.split("#")
				self.ListBox.InsertItem(pos, str(bol[1]) + " adli oyuncu ile (" + str(bol[2]) + ") tarihinde ticaret gerceklesti.")
				pos += 1
		else:
			self.ListBox.InsertItem(0, "Yapilan hic ticaret kaydi yok.")

	def Kapat(self):
		self.Board.Hide()
		self.TekliflerText.Hide()
		self.ThinBoard.Hide()
		self.ListBox.Hide()
		self.Ticaret = 0

	##Log Bilgi Ekran
	def log_ekran(self):
		self.log_Board = ui.BoardWithTitleBar()
		self.log_Board.SetSize(225, 160)
		self.log_Board.SetCenterPosition()
		self.log_Board.AddFlag('movable')
		self.log_Board.AddFlag('float')
		self.log_Board.SetTitleName('Log Sistemi')
		self.log_Board.SetCloseEvent(self.log_Close)
		self.log_Board.Show()
		self.comp = Component()
		self.pazar_img = self.comp.ExpandedImage(self.log_Board , 56, 60, 'd:/ymir work/ui/logsistem/pazar.tga')
		self.tic_img = self.comp.ExpandedImage(self.log_Board , 140, 60, 'd:/ymir work/ui/logsistem/tic.tga')#140
		self.pazar_button = self.comp.Button(self.log_Board, 'Pazar', '', 44, 105, self.__pazar_log_ac, 'd:/ymir work/ui/public/middle_button_01.sub', 'd:/ymir work/ui/public/middle_button_02.sub', 'd:/ymir work/ui/public/middle_button_03.sub')
		self.tic_button = self.comp.Button(self.log_Board, 'Ticaret', '', 127, 105, self.__tic_gecmis_ac, 'd:/ymir work/ui/public/middle_button_01.sub', 'd:/ymir work/ui/public/middle_button_02.sub', 'd:/ymir work/ui/public/middle_button_03.sub')


	def log_Close(self):
		self.log_Board.Hide()


	##Pazar_log

	def pazar_log_gui(self):
		constInfo.KONTROL2=1
		self.p_log = ui.BoardWithTitleBar()
		self.p_log.SetSize(450, 300)
		self.p_log.SetCenterPosition()
		self.p_log.AddFlag('movable')
		self.p_log.AddFlag('float')
		self.p_log.SetTitleName(translate.GECMIS)
		self.p_log.SetCloseEvent(self.Close_p_log)
		self.p_log.Show()
		self.comp_p_log = Component()

		self.pazar_bilgi_yenile = self.comp_p_log.Button(self.p_log, 'Yenile', translate.YENILEGEC, 0, 0, self.pazar_log_getir, 'd:/ymir work/ui/public/middle_button_01.sub', 'd:/ymir work/ui/public/middle_button_02.sub', 'd:/ymir work/ui/public/middle_button_03.sub')
		self.noo1 = self.comp_p_log.TextLine(self.p_log, '', 44, 48, self.comp_p_log.RGB(255, 125, 0))
		self.kisii1 = self.comp_p_log.TextLine(self.p_log, '', 69, 48, self.comp_p_log.RGB(255, 255, 255))
		self.noo2 = self.comp_p_log.TextLine(self.p_log, '', 44, 68, self.comp_p_log.RGB(255, 125, 0))
		self.kisii2 = self.comp_p_log.TextLine(self.p_log, '', 69, 68, self.comp_p_log.RGB(255, 255, 255))
		self.noo3 = self.comp_p_log.TextLine(self.p_log, '', 44, 88, self.comp_p_log.RGB(255, 125, 0))
		self.kisii3 = self.comp_p_log.TextLine(self.p_log, '', 69, 88, self.comp_p_log.RGB(255, 255, 255))
		self.noo4 = self.comp_p_log.TextLine(self.p_log, '', 44, 108, self.comp_p_log.RGB(255, 125, 0))
		self.kisii4 = self.comp_p_log.TextLine(self.p_log, '', 69, 108, self.comp_p_log.RGB(255, 255, 255))
		self.noo5 = self.comp_p_log.TextLine(self.p_log, '', 44, 128, self.comp_p_log.RGB(255, 125, 0))
		self.kisii5 = self.comp_p_log.TextLine(self.p_log, '', 69, 128, self.comp_p_log.RGB(255, 255, 255))
		self.noo6 = self.comp_p_log.TextLine(self.p_log, '', 44, 148, self.comp_p_log.RGB(255, 125, 0))
		self.kisii6 = self.comp_p_log.TextLine(self.p_log, '', 69, 148, self.comp_p_log.RGB(255, 255, 255))
		self.noo7 = self.comp_p_log.TextLine(self.p_log, '', 44, 168, self.comp_p_log.RGB(255, 125, 0))
		self.kisii7 = self.comp_p_log.TextLine(self.p_log, '', 69, 168, self.comp_p_log.RGB(255, 255, 255))
		self.noo8 = self.comp_p_log.TextLine(self.p_log, '', 44, 188, self.comp_p_log.RGB(255, 125, 0))
		self.kisii8 = self.comp_p_log.TextLine(self.p_log, '', 69, 188, self.comp_p_log.RGB(255, 255, 255))
		self.noo9 = self.comp_p_log.TextLine(self.p_log, '', 44, 208, self.comp_p_log.RGB(255, 125, 0))
		self.kisii9 = self.comp_p_log.TextLine(self.p_log, '', 69, 208, self.comp_p_log.RGB(255, 255, 255))
		self.noo10 = self.comp_p_log.TextLine(self.p_log, '', 44, 228, self.comp_p_log.RGB(255, 125, 0))
		self.kisii10 = self.comp_p_log.TextLine(self.p_log, '', 69, 228, self.comp_p_log.RGB(255, 255, 255))


		import event
		event.QuestButtonClick(constInfo.pazar_log_q_id)

	def Close_p_log(self):
		if constInfo.KONTROL2==1:
			self.p_log.Hide()
			constInfo.KONTROL2=0

	def pazar_log_getir(self):
		if gameInfo.PAZAR_CAN==0:
			import event
			event.QuestButtonClick(constInfo.pazar_log_q_id)
			gameInfo.PAZAR_OPEN=1
			gameInfo.PAZAR_TIME=app.GetTime() + 60
			gameInfo.PAZAR_CAN=1
		else:
			chat.AppendChat(chat.CHAT_TYPE_INFO, translate.YENILE1DK)

	def __pazar_log_ac(self):
		self.pazar_log_gui()

	def __pazar_log_bilgi_gir(self, no, alanname, vnum, fiyat, tarih):
		kod = int(vnum)
		item.SelectItem(kod)
		item_isim = item.GetItemName()
		if no == "1":
			self.noo1.SetText(no)
			self.kisii1.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 120)
			self.pazar_bilgi_yenile.SetPosition(204, 800)
		elif no == "2":
			self.noo2.SetText(no)
			self.kisii2.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 140)
			self.pazar_bilgi_yenile.SetPosition(204, 100)
		elif no == "3":
			self.noo3.SetText(no)
			self.kisii3.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 160)
			self.pazar_bilgi_yenile.SetPosition(204, 120)
		elif no == "4":
			self.noo4.SetText(no)
			self.kisii4.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 180)
			self.pazar_bilgi_yenile.SetPosition(204, 140)
		elif no == "5":
			self.noo5.SetText(no)
			self.kisii5.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 200)
			self.pazar_bilgi_yenile.SetPosition(204, 160)
		elif no == "6":
			self.noo6.SetText(no)
			self.kisii6.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 220)
			self.pazar_bilgi_yenile.SetPosition(204, 180)
		elif no == "7":
			self.noo7.SetText(no)
			self.kisii7.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 240)
			self.pazar_bilgi_yenile.SetPosition(204, 200)
		elif no == "8":
			self.noo8.SetText(no)
			self.kisii8.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 260)
			self.pazar_bilgi_yenile.SetPosition(204, 220)
		elif no == "9":
			self.noo9.SetText(no)
			self.kisii9.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 280)
			self.pazar_bilgi_yenile.SetPosition(204, 240)
		elif no == "10":
			self.noo10.SetText(no)
			self.kisii10.SetText(alanname + " oyuncusu " + item_isim + " itemini " + fiyat + translate.YANGKAR + tarih + " tarihinde aldi")
			self.p_log.SetSize(600, 300)
			self.pazar_bilgi_yenile.SetPosition(204, 260)

	def __pazar_log_q_id(self, id):
		constInfo.pazar_log_q_id = int(id)


	def __pazar_log_q(self, id):
		constInfo.pazar_log_q = int(id)


	def __item_fiyat(self):
		fiyat = constInfo.item_fiyat
		net.SendQuestInputStringPacket(fiyat)

	def __item_isim(self):
		isim = constInfo.item_isim
		net.SendQuestInputStringPacket(isim)

	def __itemi_alan(self):
		alanname = constInfo.itemi_alan
		net.SendQuestInputStringPacket(alanname)

	#Ticaret Gecmi?i
	def __tic_quest_id(self, id):
		constInfo.tic_gecmis = int(id)

	##Ticaret Gecmi?i
	def ticaret_gecmisi(self):
		constInfo.KONTROL1=1
		self.Board_tic = ui.BoardWithTitleBar()
		self.Board_tic.SetSize(450, 300)
		self.Board_tic.SetCenterPosition()
		self.Board_tic.AddFlag('movable')
		self.Board_tic.AddFlag('float')
		self.Board_tic.SetTitleName('Ticaret Gecmi?i')
		self.Board_tic.SetCloseEvent(self.Close_tic)
		self.Board_tic.Show()
		self.__BuildKeyDict()
		self.comp_tic = Component()


		self.tic_bilgi_yenile = self.comp_tic.Button(self.Board_tic, 'Yenile', 'Ticaret Gecmi?ini Yenile', 0, 0, self.tic_gecmis_getir, 'd:/ymir work/ui/public/middle_button_01.sub', 'd:/ymir work/ui/public/middle_button_02.sub', 'd:/ymir work/ui/public/middle_button_03.sub')
		self.no1 = self.comp_tic.TextLine(self.Board_tic, '', 44, 48, self.comp_tic.RGB(255, 125, 0))
		self.kisi1 = self.comp_tic.TextLine(self.Board_tic, '', 69, 48, self.comp_tic.RGB(255, 255, 255))
		self.no2 = self.comp_tic.TextLine(self.Board_tic, '', 44, 68, self.comp_tic.RGB(255, 125, 0))
		self.kisi2 = self.comp_tic.TextLine(self.Board_tic, '', 69, 68, self.comp_tic.RGB(255, 255, 255))
		self.no3 = self.comp_tic.TextLine(self.Board_tic, '', 44, 88, self.comp_tic.RGB(255, 125, 0))
		self.kisi3 = self.comp_tic.TextLine(self.Board_tic, '', 69, 88, self.comp_tic.RGB(255, 255, 255))
		self.no4 = self.comp_tic.TextLine(self.Board_tic, '', 44, 108, self.comp_tic.RGB(255, 125, 0))
		self.kisi4 = self.comp_tic.TextLine(self.Board_tic, '', 69, 108, self.comp_tic.RGB(255, 255, 255))
		self.no5 = self.comp_tic.TextLine(self.Board_tic, '', 44, 128, self.comp_tic.RGB(255, 125, 0))
		self.kisi5 = self.comp_tic.TextLine(self.Board_tic, '', 69, 128, self.comp_tic.RGB(255, 255, 255))
		self.no6 = self.comp_tic.TextLine(self.Board_tic, '', 44, 148, self.comp_tic.RGB(255, 125, 0))
		self.kisi6 = self.comp_tic.TextLine(self.Board_tic, '', 69, 148, self.comp_tic.RGB(255, 255, 255))
		self.no7 = self.comp_tic.TextLine(self.Board_tic, '', 44, 168, self.comp_tic.RGB(255, 125, 0))
		self.kisi7 = self.comp_tic.TextLine(self.Board_tic, '', 69, 168, self.comp_tic.RGB(255, 255, 255))
		self.no8 = self.comp_tic.TextLine(self.Board_tic, '', 44, 188, self.comp_tic.RGB(255, 125, 0))
		self.kisi8 = self.comp_tic.TextLine(self.Board_tic, '', 69, 188, self.comp_tic.RGB(255, 255, 255))
		self.no9 = self.comp_tic.TextLine(self.Board_tic, '', 44, 208, self.comp_tic.RGB(255, 125, 0))
		self.kisi9 = self.comp_tic.TextLine(self.Board_tic, '', 69, 208, self.comp_tic.RGB(255, 255, 255))
		self.no10 = self.comp_tic.TextLine(self.Board_tic, '', 44, 228, self.comp_tic.RGB(255, 125, 0))
		self.kisi10 = self.comp_tic.TextLine(self.Board_tic, '', 69, 228, self.comp_tic.RGB(255, 255, 255))


		import event
		event.QuestButtonClick(constInfo.tic_gecmis)

	def Close_tic(self):
		if constInfo.KONTROL1==1:
			self.Board_tic.Hide()
			constInfo.KONTROL1=0

	def tic_gecmis_getir(self):
		if gameInfo.TICARET_CAN==0:
			import event
			event.QuestButtonClick(constInfo.tic_gecmis)
			gameInfo.TICARET_OPEN=1
			gameInfo.TICARET_TIME=app.GetTime() + 60
			gameInfo.TICARET_CAN=1
		else:
			chat.AppendChat(chat.CHAT_TYPE_INFO, translate.TICYENILE)


	def __tic_gecmis_ac(self):
		self.ticaret_gecmisi()

	def __tic_gecmis_bilgi_gir(self, no, kisi1, kisii2, tarih):
		if no == "1":
			self.no1.SetText(no)
			self.kisi1.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 120)
			self.tic_bilgi_yenile.SetPosition(204, 800)
		elif no == "2":
			self.no2.SetText(no)
			self.kisi2.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 140)
			self.tic_bilgi_yenile.SetPosition(204, 100)
		elif no == "3":
			self.no3.SetText(no)
			self.kisi3.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 160)
			self.tic_bilgi_yenile.SetPosition(204, 120)
		elif no == "4":
			self.no4.SetText(no)
			self.kisi4.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 180)
			self.tic_bilgi_yenile.SetPosition(204, 140)
		elif no == "5":
			self.no5.SetText(no)
			self.kisi5.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 200)
			self.tic_bilgi_yenile.SetPosition(204, 160)
		elif no == "6":
			self.no6.SetText(no)
			self.kisi6.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 220)
			self.tic_bilgi_yenile.SetPosition(204, 180)
		elif no == "7":
			self.no7.SetText(no)
			self.kisi7.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 240)
			self.tic_bilgi_yenile.SetPosition(204, 200)
		elif no == "8":
			self.no8.SetText(no)
			self.kisi8.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 260)
			self.tic_bilgi_yenile.SetPosition(204, 220)
		elif no == "9":
			self.no9.SetText(no)
			self.kisi9.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 280)
			self.tic_bilgi_yenile.SetPosition(204, 240)
		elif no == "10":
			self.no10.SetText(no)
			self.kisi10.SetText(kisi1 + " ile " + kisii2 + " oyuncusu " + tarih + " tarihinde ticaret yapti")
			self.Board_tic.SetSize(450, 300)
			self.tic_bilgi_yenile.SetPosition(204, 260)"""

	def Uzaktan_ticaret_soru(self, isim, level):
		uzaktan_sorusu = uiCommon.QuestionDialog()
		uzaktan_sorusu.SetText("|cffFDD017|H|h" + str(isim)+ "|cff00ccff" + "(Nivel."+str(level)+")"+ "|h|r" + " Doreste sa negocieze la distanta cu tine.")
		uzaktan_sorusu.SetAcceptEvent(lambda arg=TRUE: self.kabul(isim))
		uzaktan_sorusu.SetCancelEvent(lambda arg=FALSE: self.hayir(isim))
		uzaktan_sorusu.Open()
		self.uzaktan_sorusu = uzaktan_sorusu
		return

	def kabul(self, isim):
		net.SendChatPacket("/uzaktan_ticaret_kabul " + str(isim))
		self.uzaktan_sorusu.Close()

	def hayir(self, isim):
		net.SendChatPacket("/uzaktan_ticaret_hayir " + str(isim))
		self.uzaktan_sorusu.Close()

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

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

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

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

		def BINARY_RefreshTargetMonsterDropInfo(self, raceNum):
			self.targetBoard.RefreshMonsterInfoBoard()

	########Anti Exp Button by Sanii##########
	def AntiExp(self, qid):
		constInfo.ANTI_EXP = int(qid)

	def AntiExpState(self, state):
		constInfo.ANTI_EXP_STATE = int(state)

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

	# BONI_SWITCHER
	def __BoniSwitcherChangeVisible(self):
		if not self.boniSwitcherWnd[self.LastBoniSwitcherId].IsShow():
			self.__HideAllBoniSwitcher()
			self.boniSwitcherWnd[self.LastBoniSwitcherId].Show(FALSE)
		else:
			self.__HideAllBoniSwitcher()

	def __BoniSwitcherShow(self, id):
		lastId = self.LastBoniSwitcherId
		self.LastBoniSwitcherId = id
		if not self.boniSwitcherWnd[id].IsShow():
			self.__HideAllBoniSwitcher()
			(x, y) = self.boniSwitcherWnd[lastId].GetGlobalPosition()
			self.boniSwitcherWnd[id].SetPosition(x, y)
			self.boniSwitcherWnd[id].Show(FALSE)

	def __BoniSwitcherHide(self, id):
		if self.boniSwitcherWnd[id]:
			self.boniSwitcherWnd[id].Hide()

	def __HideAllBoniSwitcher(self):
		for i in xrange(len(self.boniSwitcherWnd)):
			self.__BoniSwitcherHide(i)

	def __ResetBoniFromSwitcher(self):
		constInfo.BONI_LIST_WEAPON = []
		constInfo.BONI_LIST_WEAPON_ADDON = []
		constInfo.BONI_LIST_ARMOR = []
		constInfo.BONI_LIST_BRACELET = []
		constInfo.BONI_LIST_BOOTS = []
		constInfo.BONI_LIST_NECKLACE = []
		constInfo.BONI_LIST_HELMET = []
		constInfo.BONI_LIST_SHIELD = []
		constInfo.BONI_LIST_EARRINGS = []
	# ITEM_SHOP
	def __ItemShopShow(self):
		if not self.itemShopWnd:
			import uiItemShop
			self.itemShopWnd = uiItemShop.ItemShopBoard()
		self.itemShopWnd.Show()

	def __ISSetLoadButtonIndex(self, index):
		constInfo.ITEM_SHOP_LOAD_BUTTON_INDEX = int(index)

	def __ISSetBuyButtonIndex(self, index):
		constInfo.ITEM_SHOP_BUY_BUTTON_INDEX = int(index)

	def __ISGetBuyID(self):
		if self.itemShopWnd:
			net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString())
		else:
			net.SendQuestInputStringPacket("ERROR")

	def __ISGetBuyID2(self):
		if self.itemShopWnd:
			net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString2())
		else:
			net.SendQuestInputStringPacket("ERROR")

	def __Input0(self):
		constInfo.INPUT_IGNORE = 0

	def __Input1(self):
		constInfo.INPUT_IGNORE = 1

	def __ISAddCategory(self, catId, catName):
		self.itemShopWnd.AddCategory(catId, catName.replace("[_]", " "))

	def __primera_muerte(self):
		self.primera_muerte.Show()
		snd.PlaySound("sound/ui/primera_muerte.wav")
		net.SendChatPacket("(primera_muerte)")

	def __doble_muerte(self):
		self.doble_muerte.Show()
		snd.PlaySound("sound/ui/doble_muerte.wav")
		net.SendChatPacket("(doble_muerte)")

	def __triple_muerte(self):
		self.triple_muerte.Show()
		snd.PlaySound("sound/ui/triple_muerte.wav")
		net.SendChatPacket("(triple_muerte)")

	def __exterminio(self):
		self.exterminio.Show()
		snd.PlaySound("sound/ui/exterminio.wav")
		net.SendChatPacket("(exterminio)")

	def __muertacular(self):
		self.muertacular.Show()
		snd.PlaySound("sound/ui/muertacular.wav")
		net.SendChatPacket("(muertacular)")

	def __bestialidad(self):
		self.bestialidad.Show()
		snd.PlaySound("sound/ui/bestialidad.wav")
		net.SendChatPacket("(bestialidad)")

	def __salvajada(self):
		self.salvajada.Show()
		snd.PlaySound("sound/ui/salvajada.wav")
		net.SendChatPacket("(salvajada)")

	def __catastrofe(self):
		self.catastrofe.Show()
		snd.PlaySound("sound/ui/catastrofe.wav")
		net.SendChatPacket("(catastrofe)")

	def __apocalipsis(self):
		self.apocalipsis.Show()
		snd.PlaySound("sound/ui/apocalipsis.wav")
		net.SendChatPacket("(apocalipsis)")

	def __lluvia_muertos(self):
		self.lluvia_muertos.Show()
		snd.PlaySound("sound/ui/lluvia_muertos.wav")
		net.SendChatPacket("(lluvia_muertos)")

	def __super_increible(self):
		self.super_increible.Show()
		snd.PlaySound("sound/ui/super_increible.wav")
		net.SendChatPacket("(super_increible)")

	def __hidemedallas_gui(self):
		self.Medallas_gui.Hide()
		self.primera_muerte.Hide()
		self.doble_muerte.Hide()
		self.triple_muerte.Hide()
		self.exterminio.Hide()
		self.muertacular.Hide()
		self.bestialidad.Hide()
		self.salvajada.Hide()
		self.catastrofe.Hide()
		self.apocalipsis.Hide()
		self.lluvia_muertos.Hide()
		self.super_increible.Hide()
		self.muertes.Hide()

	def __showmedallas_gui(self):
		self.Medallas_gui.Show()
		self.muertes.Show()

	def __muertes(self, muertes):
		self.muertes.SetText(muertes)

	def __ISSelectCategory(self, catId):
		self.itemShopWnd.SelectCategory(catId)

	def __ISClearItems(self):
		self.itemShopWnd.Clear()

	def __ISAddItem(self, catId, itemId, itemVnum, itemCount, itemCost, itemCostType, attr1, val1, attr2, val2, attr3, val3, attr4, val4, attr5, val5, attr6, val6, attr7, val7, sock1, sock2, sock3):
		itemAttr = [[attr1, val1], [attr2, val2], [attr3, val3], [attr4, val4], [attr5, val5], [attr6, val6], [attr7, val7]]
		for attr in itemAttr:
			attr[0] = int(attr[0])
			attr[1] = int(attr[1])
		itemSocket = [int(sock1), int(sock2), int(sock3)]
		self.curIsItem = {
			"cat" : catId,
			"id" : itemId,
			"vnum" : itemVnum,
			"count" : itemCount,
			"desc" : "",
			"cost" : itemCost,
			"cost_type" : itemCostType,
			"attr" : itemAttr,
			"socket" : itemSocket,
		}

	def __ISAddItemDesc(self, itemDesc):
		obj = self.curIsItem
		if not obj:
			return
		obj["desc"] += itemDesc.replace("[_]", " ")

		self.itemShopWnd.AddItem(obj["cat"], obj["id"], obj["vnum"], obj["count"], obj["desc"], obj["cost"], obj["cost_type"], obj["attr"], obj["socket"])
		self.curIsItem = None

	def __ISSetLoadSuccess(self):
		self.itemShopWnd.SetLoadSuccess()

	def __ISSetLoadFail(self):
		self.itemShopWnd.SetLoadFail()

	def __ISSetBuySuccess(self):
		self.itemShopWnd.SetItemBuySuccess()

	def __ISSetBuyFail(self):
		self.itemShopWnd.SetItemBuyFail()

	def __ISSetCoins(self, coins):
		self.itemShopWnd.SetCoins(coins)

	def __ISSetMarks(self, marks):
		self.itemShopWnd.SetMarks(marks)
	# END_ITEM_SHOP
	def __AddBoniToSwitcher(self, EquipType, boniType):
		EquipType = int(EquipType)
		if EquipType == 1:
			constInfo.BONI_LIST_WEAPON.append(int(boniType))
			constInfo.BONI_LIST_WEAPON_ADDON.append(int(boniType))
		elif EquipType == 2:
			constInfo.BONI_LIST_ARMOR.append(int(boniType))
		elif EquipType == 3:
			constInfo.BONI_LIST_BRACELET.append(int(boniType))
		elif EquipType == 4:
			constInfo.BONI_LIST_BOOTS.append(int(boniType))
		elif EquipType == 5:
			constInfo.BONI_LIST_NECKLACE.append(int(boniType))
		elif EquipType == 6:
			constInfo.BONI_LIST_HELMET.append(int(boniType))
		elif EquipType == 7:
			constInfo.BONI_LIST_SHIELD.append(int(boniType))
		elif EquipType == 8:
			constInfo.BONI_LIST_EARRINGS.append(int(boniType))
		elif EquipType == 9:
			constInfo.BONI_LIST_WEAPON_ADDON.append(int(boniType))

	def __AddMaxValueToBoni(self, boniType, maxValue):
		constInfo.BONI_LIST_MAX_VALUE[int(boniType)] = int(maxValue)

	def __SetBoniSwitcherLoad(self):
		constInfo.BONI_SWITCHER_LOAD = TRUE

	def __BoniSwitcherCheckEvent(self, slotPos):
		for boniSwitcher in self.boniSwitcherWnd:
			if boniSwitcher.aktItemPos == int(slotPos):
				return TRUE
		return FALSE
	# END_BONI_SWITCHER


	def Teleport(self, getString):
		if getString.find("index") != -1:
			self.teleport.UpdateIndex(int(getString.split("x")[1]))
		else:
			constInfo.SendString = str(self.teleport.SendToServer)
			constInfo.CApiSetHide = 1

	def __evento_ultimo_superviviente(self):
		import net
		net.SendChatPacket("/pkmode 2", chat.CHAT_TYPE_TALKING)

	def __Switcher(self):
		import uiswitch
		self.wndSwitch = uiswitch.Switcher()
		self.wndSwitch.Show()

#	def __menubg2(self):
#		if constInfo.MENU_BG2 == 0:
#			constInfo.MENU_BG2 = 1
#			self.menu_bg2.Show()
#			self.Activare_Menu2.Hide()
#			self.Dezactivare_Menu2.Show()

#		else:
#			constInfo.MENU_BG2 = 0
#			self.menu_bg2.Hide()
#			self.Activare_Menu2.Show()
#			self.Dezactivare_Menu2.Hide()
#	def __DMAGAZIN_questindex(self, value):
#		constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX = int(value)

#	def __DeschidereMagazin(self):
#		DeschidereMagazin = constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX
#		event.QuestButtonClick(DeschidereMagazin)

#	def __menubg(self):
##		if constInfo.MENU_BG == 0:
#			constInfo.MENU_BG = 1
#			self.menu_bg.Show()
#			self.Activare_Menu.Hide()
#			self.Dezactivare_Menu.Show()
#		else:
#			constInfo.MENU_BG = 0
#			self.menu_bg.Hide()
#			self.Activare_Menu.Show()
#			self.Dezactivare_Menu.Hide()

#	def __BonusPage(self):
#		import uibonuspage
#		self.wndBonus = uibonuspage.BonusBoardDialog()
#		self.wndBonus.Show()

		# switchbot
#	def __JINHAN(self):
#		import uistatusup
#		self.wndJinHan = uistatusup.StatusUp()
#		self.wndJinHan.Show()
		# END_switchbot

	def __bonus_questindex(self, value3):
		constInfo.BONUS_QUESTINDEX = int(value3)

	def __activare_bonus(self):
		activare_bonus = constInfo.BONUS_QUESTINDEX
		event.QuestButtonClick(activare_bonus)

	def __depozit_questindex(self, qid):
		constInfo.Depoport= int(qid)

	def __activare_depozit(self):
		activare_depozit = constInfo.DEPOZIT_QUESTINDEX
		event.QuestButtonClick(activare_depozit)

	def __antiexp_questindex(self, value1):
		constInfo.ANTIEXP_QUESTINDEX = int(value1)

	def __activare_antiexp(self):
		activare_antiexp = constInfo.ANTIEXP_QUESTINDEX
		event.QuestButtonClick(activare_antiexp)

	def __teleporter_questindex(self, value2):
		constInfo.TELEPORTER_QUESTINDEX = int(value2)

	def __activare_teleporter(self):
		activare_teleporter = constInfo.TELEPORTER_QUESTINDEX
		event.QuestButtonClick(activare_teleporter)

	def showtransfer(self):
		import uiTransfer
		self.TransferWnd = uiTransfer.TransferWindow()
		self.TransferWnd.Open()

	# 5Lv Beceri Sistemi
	# Gui Sistemleri
	def __BecSystem1(self):
		self.black = savbec.BlackIsinlanma()
		self.black.OpenWindow()

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

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

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

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

	# Beceri Sistemleri
	# Savasci Becerileri
	def zihinsel_oto_bec(self,qid):
		constInfo.zihinsel_oto_bec = int(qid)

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

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

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

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

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

	# Saman Becerileri
	def ejderha_oto_bec(self,qid):
		constInfo.ejderha_oto_bec = int(qid)

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

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

	#def lycanu_oto_bec(self,qid):
	#	constInfo.lycanu_oto_bec = int(qid)

	#def __showbonus(self):
	#	serex = uibonuspage.BonusBoardDialog()

	def __showbonus(self):
		import uiBonusPage
		global bonuspp
		try:
			if bonuspp != 1:
				exec 'uiBonusPage.BonusBoardDialog().Show()'
			else:
				pass
		except ImportError:
			import dbg,app
			dbg.Trace('uiBonusPage.py Importing error')
			app.Abort()
	# guildstorage begin

	def _GuildStorageCMD(self, command):
		cmd = command.split("/")

		if cmd[0] == "OPEN":
			self.interface.GuildStorageWindow.Open(int(cmd[1]))
		elif cmd[0] == "REFRESH":
			self.interface.GuildStorageWindow.RefreshSlots()
		elif cmd[0] == "REFRESH_MONEY":
			self.interface.GuildStorageWindow.SetMoney(cmd[1])
		elif cmd[0] == "REFRESH_MEMBERS":
			self.interface.GuildStorageWindow.Adminpanel["board"].RefreshMembers()
		elif cmd[0] == "CLEAR_TEMPSLOTS":
			constInfo.GUILDSTORAGE["tempslots"] = {"TAB0" : {},"TAB1" : {},"TAB2" : {}}
		elif cmd[0] == "COMPARE_TEMPSLOTS":
			for i in range(3):
				if constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)] != constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)]:
					constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = {}
					constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)]
					self.interface.GuildStorageWindow.RefreshSlots()
		elif cmd[0] == "QID":
			self.GuildStorageQID(cmd[1])
		elif cmd[0] == "QUESTCMD":
			self._GuildStorageQuestCMD()
			#self.teleport = uiteleport.TeleportWindow()
		elif cmd[0] == "MEMBER_COMPLETE":
			constInfo.GUILDSTORAGE["members"] = {}
			self.interface.GuildStorageWindow.ClearMembers()
			import event
			constInfo.GUILDSTORAGE["questCMD"] = "GETMEMBERLIST"
			event.QuestButtonClick(int(constInfo.GUILDSTORAGE["qid"]))


	def _GuildStorageAddItemSlot(self, slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
		self.interface.GuildStorageWindow.AddItemSlot(slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6)

	def _GuildStorageAddItem(self, slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
		slotsWidth = 15
		slotsHeight = 8
		slot = int(slot)
		if slot <= 120:
			constInfo.GUILDSTORAGE["slots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
		elif slot > 120 and slot <= 240:
			constInfo.GUILDSTORAGE["slots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
		elif slot > 240 and slot <= 360:
			constInfo.GUILDSTORAGE["slots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]

	def _GuildStorageTempSlotsAdd(self,slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
		slot = int(slot)
		if slot <= 120:
			constInfo.GUILDSTORAGE["tempslots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
		elif slot > 120 and slot <= 240:
			constInfo.GUILDSTORAGE["tempslots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
		elif slot > 240 and slot <= 360:
			constInfo.GUILDSTORAGE["tempslots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]

	def _GuildStorageAddLog(self,id,name,date,type,do,desc):
		self.interface.GuildStorageWindow.LogsInsert(id,name,date,type,do,desc)
		constInfo.GUILDSTORAGE["logs"][int(id)] = [name,date,type,do,desc]

	def _GuildStorageQuestCMD(self):
		net.SendQuestInputStringPacket(str(constInfo.GUILDSTORAGE["questCMD"]))
		constInfo.GUILDSTORAGE["questCMD"] = "NULL#"

	def GuildStorageQID(self, qid):
		constInfo.GUILDSTORAGE["qid"] = int(qid)

	def _GuildStorageAddMemberToList(self,memberId,member,authority0,authority1,authority2,authority3):
		constInfo.GUILDSTORAGE["members"]["member"+memberId] = [member,int(authority0),int(authority1),int(authority2),int(authority3)]
# Guildstorage end
	def __MountSystem(self, info, i=0):
		if info=="Item":
			if i!=0:
					constInfo.MountSystem["index"] = int(i)
			self.MountingSystem.Open()
		elif info=="Input":
			net.SendQuestInputStringPacket(str(constInfo.MountSystem["CMD"]))

	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 __guinameOPEN(self): # use different function names!
		import schicksalrad
		self.SchicksalRad = schicksalrad.RadDesSchicksals()
		self.SchicksalRad.Open()() # naturally use the code which is provided for the GUI

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

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

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

	if app.WJ_SECURITY_SYSTEM:
		def OpenSecurityCreate(self):
			if self.interface:
				self.interface.OpenSecurityCreate()

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

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

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

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

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

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

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

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

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

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

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

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

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

	def GayaTimeMarket(self, time):
		self.interface.GayaTime(time)

	if app.WJ_SHOP_SEARCH_SYSTEM:
		def OpenPrivateShopSearch(self, type):
			if self.interface:
				self.interface.OpenPrivateShopSearch(type)

		def RefreshShopSearch(self):
			self.interface.RefreshShopSearch()

		def BuyShopSearch(self):
			self.interface.RefreshShopSearch()
			self.PopupMessage(localeInfo.PRIVATESHOPSEARCH_BUY_SUCCESS)

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

		def BINARY_RefreshChestDropInfo(self, chestVnum):
			if self.interface:
				self.interface.RefreshChestDropInfo(chestVnum)

	def 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 gecmistemizle(self):
		import constInfo
		constInfo.lonca_gecmis_list = []

	def isim_ver(self):
		import constInfo
		net.SendQuestInputStringPacket(str(constInfo.lonca_gecmis_isim))

	def uyari(self, msg):
		if msg == "bilgiyok":
			self.PopupMessage("Henuz bilgi girilmemis!")
		elif msg == "loncayok":
			self.PopupMessage("Lonca bulunamadi")

	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 bulunamadi!")

	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 bulunamadi!")

	def lonca_tanitim(self):
		self.loncanitanit.Open()

	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_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 __BonusPage(self):
		import PaginaBonusuri
		global BPisLodaded
		try:
			if BPisLodaded[0] == 0:
				BPisLodaded[0] = 1
				exec 'PaginaBonusuri.BonusBoardDialog().Show()'
			else:
				BPisLodaded[0] = 0
				exec 'PaginaBonusuri.BonusBoardDialog().Hide()'

		except ImportError:
			import dbg,app
			dbg.Trace('PaginaBonusuri.py Importing error')
			app.Abort

	if app.ENABLE_SUPPORT_SYSTEM:
		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 test(self):
	#	background.SetVisiblePart(background.PART_TREE, False)#True

class Component:
	def Button(self, parent, buttonName, tooltipText, x, y, func, UpVisual, OverVisual, DownVisual):
		button = ui.Button()
		if parent != None:
			button.SetParent(parent)
		button.SetPosition(x, y)
		button.SetUpVisual(UpVisual)
		button.SetOverVisual(OverVisual)
		button.SetDownVisual(DownVisual)
		button.SetText(buttonName)
		button.SetToolTipText(tooltipText)
		button.Show()
		button.SetEvent(func)
		return button

	def ToggleButton(self, parent, buttonName, tooltipText, x, y, funcUp, funcDown, UpVisual, OverVisual, DownVisual):
		button = ui.ToggleButton()
		if parent != None:
			button.SetParent(parent)
		button.SetPosition(x, y)
		button.SetUpVisual(UpVisual)
		button.SetOverVisual(OverVisual)
		button.SetDownVisual(DownVisual)
		button.SetText(buttonName)
		button.SetToolTipText(tooltipText)
		button.Show()
		button.SetToggleUpEvent(funcUp)
		button.SetToggleDownEvent(funcDown)
		return button

	def EditLine(self, parent, editlineText, x, y, width, heigh, max):
		SlotBar = ui.SlotBar()
		if parent != None:
			SlotBar.SetParent(parent)
		SlotBar.SetSize(width, heigh)
		SlotBar.SetPosition(x, y)
		SlotBar.Show()
		Value = ui.EditLine()
		Value.SetParent(SlotBar)
		Value.SetSize(width, heigh)
		Value.SetPosition(1, 1)
		Value.SetMax(max)
		Value.SetLimitWidth(width)
		Value.SetMultiLine()
		Value.SetText(editlineText)
		Value.Show()
		return SlotBar, Value

	def TextLine(self, parent, textlineText, x, y, color):
		textline = ui.TextLine()
		if parent != None:
			textline.SetParent(parent)
		textline.SetPosition(x, y)
		if color != None:
			textline.SetFontColor(color[0], color[1], color[2])
		textline.SetText(textlineText)
		textline.Show()
		return textline

	def RGB(self, r, g, b):
		return (r*255, g*255, b*255)

	def SliderBar(self, parent, sliderPos, func, x, y):
		Slider = ui.SliderBar()
		if parent != None:
			Slider.SetParent(parent)
		Slider.SetPosition(x, y)
		Slider.SetSliderPos(sliderPos / 100)
		Slider.Show()
		Slider.SetEvent(func)
		return Slider

	def ExpandedImage(self, parent, x, y, img):
		image = ui.ExpandedImageBox()
		if parent != None:
			image.SetParent(parent)
		image.SetPosition(x, y)
		image.LoadImage(img)
		image.Show()
		return image

	def ComboBox(self, parent, text, x, y, width):
		combo = ui.ComboBox()
		if parent != None:
			combo.SetParent(parent)
		combo.SetPosition(x, y)
		combo.SetSize(width, 15)
		combo.SetCurrentItem(text)
		combo.Show()
		return combo

	def ThinBoard(self, parent, moveable, x, y, width, heigh, center):
		thin = ui.ThinBoard()
		if parent != None:
			thin.SetParent(parent)
		if moveable == TRUE:
			thin.AddFlag('movable')
			thin.AddFlag('float')
		thin.SetSize(width, heigh)
		thin.SetPosition(x, y)
		if center == TRUE:
			thin.SetCenterPosition()
		thin.Show()
		return thin

	def Gauge(self, parent, width, color, x, y):
		gauge = ui.Gauge()
		if parent != None:
			gauge.SetParent(parent)
		gauge.SetPosition(x, y)
		gauge.MakeGauge(width, color)
		gauge.Show()
		return gauge

	def ListBoxEx(self, parent, x, y, width, heigh):
		bar = ui.Bar()
		if parent != None:
			bar.SetParent(parent)
		bar.SetPosition(x, y)
		bar.SetSize(width, heigh)
		bar.SetColor(0x77000000)
		bar.Show()
		ListBox=ui.ListBoxEx()
		ListBox.SetParent(bar)
		ListBox.SetPosition(0, 0)
		ListBox.SetSize(width, heigh)
		ListBox.Show()
		scroll = ui.ScrollBar()
		scroll.SetParent(ListBox)
		scroll.SetPosition(width-15, 0)
		scroll.SetScrollBarSize(heigh)
		scroll.Show()
		ListBox.SetScrollBar(scroll)
		return bar, ListBox

	if app.ENABLE_SWITCHER_MIJAGO:
		#Switchbot
		def __toggleSwitchbot(self):
			if self.switchbot.bot_shown == 1:
				self.switchbot.Hide()
			else:
				self.switchbot.Show()
		# END_switchbot

	def __xmas_boom(self, arg1):
		pass