• 0
Sign in to follow this  
ricou77

en cours Problème avec le système de costume

Question

Bonjour à tous,

 

j'ai tenté d'implanter le système de costume proposé sur elitpvp. L'implantation côté serveur est OK, mais niveau client... Lorsque je choisi mon personnage tout va bien mais une fois le chargement fini rien ne se passe.

 

Voilà le sysser:

 

0712 14:33:15792 :: CMapOutdoor::Load - LoadMonsterAreaInfo ERROR
0712 14:33:22552 :: Traceback (most recent call last):

0712 14:33:22553 ::   File "networkModule.py", line 231, in SetGamePhase

0712 14:33:22553 ::   File "system.py", line 130, in __pack_import

0712 14:33:22553 ::   File "
0712 14:33:22553 :: 
0712 14:33:22553 :: ", line 
0712 14:33:22553 :: 2002
0712 14:33:22553 :: 

0712 14:33:22553 ::     
0712 14:33:22553 :: # END_OF_COSTUME_SYSTEM
0712 14:33:22553 :: 

0712 14:33:22553 ::     
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 ::  
0712 14:33:22553 :: ^

0712 14:33:22553 :: SyntaxError
0712 14:33:22553 :: : 
0712 14:33:22553 :: invalid syntax
0712 14:33:22553 :: 

 

Je vous fourni le fichier python mentionné dans le sysser où il a fallut ajouté du code.

 

Voici le game.py:

import os
import app
import dbg
import grp
import item
import background
import chr
import chrmgr
import player
import snd
import chat
import textTail
import snd
import net
import effect
import wndMgr
import fly
import systemSetting
import quest
import guild
import skill
import messenger
import locale
import constInfo
import exchange
import ime

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

# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LIST

import mouseModule
import consoleModule
import locale

import playerSettingModule
import interfaceModule

import musicInfo
import debugInfo
import stringCommander

from _weakref import proxy

# TEXTTAIL_LIVINGTIME_CONTROL
#if locale.IsJAPAN():
#	app.SetTextTailLivingTime(8.0)
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL

# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = None

if locale.IsEUROPE():
SCREENSHOT_CWDSAVE = TRUE

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

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

testAlignment = 0

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

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

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

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

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

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

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

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

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

	self.__SetQuickSlotMode()

	self.__ServerCommand_Build()
	self.__ProcessPreservedServerCommand()

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

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

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

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

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

	global cameraDistance, cameraPitch, cameraRotation, cameraHeight

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

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

	# TWO_HANDED_WEAPON_ATTACK_SPEED_UP
	constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
	# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP

	import event
	event.SetLeftTimeString(locale.UI_LEFT_TIME)

	textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)

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

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

	self.__BuildKeyDict()
	self.__BuildDebugInfo()

	# PRIVATE_SHOP_PRICE_LIST
	uiPrivateShopBuilder.Clear()
	# END_OF_PRIVATE_SHOP_PRICE_LIST

	# UNKNOWN_UPDATE
	exchange.InitTrading()
	# END_OF_UNKNOWN_UPDATE

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

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

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

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

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

	net.SendEnterGamePacket()

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

def Close(self):
	self.Hide()

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

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

	self.onPressKeyDict = None
	self.onClickKeyDict = None

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

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

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

	# UNKNOWN_UPDATE
	self.itemDropQuestionDialog = None
	# END_OF_UNKNOWN_UPDATE

	# QUEST_CONFIRM
	self.confirmDialog = None
	# END_OF_QUEST_CONFIRM

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

	self.ClearDictionary()

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

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

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

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

	player.ClearSkillDict()
	player.ResetCameraRotation()

	self.KillFocus()
	app.HideCursor()

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

def __BuildKeyDict(self):
	onPressKeyDict = {}

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

	## ¼ýÀÚ ´ÜÃàÅ° Äü½½·Ô¿¡ ÀÌ¿ëµÈ´Ù.(ÀÌÈÄ ¼ýÀڵ鵵 Äü ½½·Ô¿ë ¿¹¾à)
	## F12 ´Â Ŭ¶ó µð¹ö±×¿ë Å°À̹ǷΠ¾²Áö ¾Ê´Â °Ô ÁÁ´Ù.
	onPressKeyDict[app.DIK_1]	= lambda : self.__PressNumKey(1)
	onPressKeyDict[app.DIK_2]	= lambda : self.__PressNumKey(2)
	onPressKeyDict[app.DIK_3]	= lambda : self.__PressNumKey(3)
	onPressKeyDict[app.DIK_4]	= lambda : self.__PressNumKey(4)
	onPressKeyDict[app.DIK_5]	= lambda : self.__PressNumKey(5)
	onPressKeyDict[app.DIK_6]	= lambda : self.__PressNumKey(6)
	onPressKeyDict[app.DIK_7]	= lambda : self.__PressNumKey(7)
	onPressKeyDict[app.DIK_8]	= lambda : self.__PressNumKey(8)
	onPressKeyDict[app.DIK_9]	= lambda : self.__PressNumKey(9)
	onPressKeyDict[app.DIK_F1]	= lambda : self.__PressQuickSlot(4)
	onPressKeyDict[app.DIK_F2]	= lambda : self.__PressQuickSlot(5)
	onPressKeyDict[app.DIK_F3]	= lambda : self.__PressQuickSlot(6)
	onPressKeyDict[app.DIK_F4]	= lambda : self.__PressQuickSlot(7)

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

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

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

	onPressKeyDict[app.DIK_NUMPAD9]		= lambda: app.MovieResetCamera()
	onPressKeyDict[app.DIK_NUMPAD4]		= lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
	onPressKeyDict[app.DIK_NUMPAD6]		= lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
	onPressKeyDict[app.DIK_PGUP]		= lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
	onPressKeyDict[app.DIK_PGDN]		= lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
	onPressKeyDict[app.DIK_NUMPAD8]		= lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
	onPressKeyDict[app.DIK_NUMPAD2]		= lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)
	onPressKeyDict[app.DIK_GRAVE]		= lambda : self.PickUpItem()
	onPressKeyDict[app.DIK_Z]			= lambda : self.PickUpItem()
	onPressKeyDict[app.DIK_C]			= lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)
	onPressKeyDict[app.DIK_V]			= lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)
	#onPressKeyDict[app.DIK_B]			= lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)
	onPressKeyDict[app.DIK_N]			= lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)
	onPressKeyDict[app.DIK_I]			= lambda : self.interface.ToggleInventoryWindow()
	onPressKeyDict[app.DIK_M]			= lambda : self.interface.PressMKey()
	#onPressKeyDict[app.DIK_H]			= lambda : self.interface.OpenHelpWindow()
	onPressKeyDict[app.DIK_ADD]			= lambda : self.interface.MiniMapScaleUp()
	onPressKeyDict[app.DIK_SUBTRACT]	= lambda : self.interface.MiniMapScaleDown()
	onPressKeyDict[app.DIK_L]			= lambda : self.interface.ToggleChatLogWindow()
	onPressKeyDict[app.DIK_COMMA]		= lambda : self.ShowConsole()		# "`" key
	onPressKeyDict[app.DIK_LSHIFT]		= lambda : self.__SetQuickPageMode()

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

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

	self.onPressKeyDict = onPressKeyDict

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

	onClickKeyDict[app.DIK_W] = lambda : self.StopUp()
	onClickKeyDict[app.DIK_S] = lambda : self.StopDown()
	onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()
	onClickKeyDict[app.DIK_D] = lambda : self.StopRight()
	onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)
	onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)
	onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)
	onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)
	onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)
	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()

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

	self.onClickKeyDict=onClickKeyDict

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def ChangePKMode(self):

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

	if player.GetStatus(player.LEVEL)			self.__NotifyError(locale.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
		return

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

	self.lastPKModeSendedTime = curTime

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

	elif nextPKMode == player.PK_MODE_MAX_NUM:
		nextPKMode = 0

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

def OnChangePKMode(self):

	self.interface.OnChangePKMode()

	try:
		self.__NotifyError(locale.OPTION_PVPMODE_MESSAGE_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) + " (" + locale.TITLE_NAME_LIST[grade] + ")")

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

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

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

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

def RefreshStatus(self):
	self.CheckGameButton()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def AskGuildName(self):

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

	self.guildNameBoard = guildNameBoard

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## Chat
def OnRecvWhisper(self, 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 locale.WHISPER_ERROR.has_key(mode):
		chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, locale.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, locale.GAME_PICK_MONEY % (money))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def SetShopSellingPrice(self, Price):
	pass

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

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

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

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

def AnswerPartyInvite(self, answer):

	if not self.partyInviteQuestionDialog:
		return

	partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

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

	net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

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

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

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

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

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

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

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

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

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

## Messenger
def OnMessengerAddFriendQuestion(self, name):
	messengerAddFriendQuestion = uiCommon.QuestionDialog2()
	messengerAddFriendQuestion.SetText1(locale.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
	messengerAddFriendQuestion.SetText2(locale.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)
	messengerAddFriendQuestion.SetAcceptEvent(ui.__mem_func__(self.OnAcceptAddFriend))
	messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))
	messengerAddFriendQuestion.Open()
	messengerAddFriendQuestion.name = name
	self.messengerAddFriendQuestion = messengerAddFriendQuestion

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

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

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

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

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

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

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

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

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

def AnswerGuildInvite(self, answer):

	if not self.guildInviteQuestionDialog:
		return

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

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


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

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

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

## Emotion
def BINARY_ActEmotion(self, emotionIndex):
	if self.interface.wndCharacter:
		self.interface.wndCharacter.ActEmotion(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 + locale.SCREENSHOT_SAVE1)
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SCREENSHOT_SAVE2)
		"""
	else:
		chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SCREENSHOT_SAVE_FAILURE)

def ShowConsole(self):
	if debugInfo.IsDebugMode() or TRUE == self.consoleEnable:
		player.EndKeyWalkingImmediately()
		self.console.OpenWindow()

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

# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):

	if systemSetting.IsAlwaysShowName():
		return TRUE

	if self.ShowNameFlag:
		return TRUE

	return FALSE
# END_OF_ADD_ALWAYS_SHOW_NAME

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

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

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

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

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

def MoveUp(self):
	player.SetSingleDIKKeyState(app.DIK_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

	constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)

	try:
		self.onPressKeyDict[key]()
	except KeyError:
		pass
	except:
		raise

	return TRUE

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

	return TRUE

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

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

	return TRUE

def OnMouseLeftButtonUp(self):

	if self.interface.BUILD_OnMouseLeftButtonUp():
		return

	if mouseModule.mouseController.isAttached():

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

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

		## Inventory
		elif player.SLOT_TYPE_INVENTORY == attachedType:

			if player.ITEM_MONEY == attachedItemIndex:
				self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
			else:
				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 TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
		if player.IsEquipmentSlot(attachedItemSlotPos):
			self.stream.popupWindow.Close()
			self.stream.popupWindow.Open(locale.EXCHANGE_FAILURE_EQUIP_ITEM, 0, locale.UI_OK)
		else:
			if chr.IsNPC(dstChrID):
				net.SendGiveItemPacket(dstChrID, attachedItemSlotPos, attachedItemCount)
			else:
				net.SendExchangeStartPacket(dstChrID)
				net.SendExchangeItemAddPacket(attachedItemSlotPos, 0)
	else:
		self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)

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

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

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

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

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

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

	else:
		dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

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

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

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

		constInfo.SET_ITEM_DROP_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:
			if dropNumber == player.ITEM_MONEY:
				net.SendGoldDropPacketNew(dropCount)
				snd.PlaySound("sound/ui/money.wav")
			else:
				# PRIVATESHOP_DISABLE_ITEM_DROP
				self.__SendDropItemPacket(dropNumber, dropCount)
				# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

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

	constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)

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

	net.SendItemDropPacketNew(itemVNum, itemCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

def OnMouseRightButtonDown(self):

	self.CheckFocus()

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

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

	return TRUE

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

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

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

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

def OnUpdate(self):	
	app.UpdateGame()

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

	if self.isShowDebugInfo:
		self.UpdateDebugInfo()

	if self.enableXMasBoom:
		self.__XMasBoom_Update()

	self.interface.BUILD_OnUpdate()


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

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

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

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

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

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

def OnRender(self):
	app.RenderGame()

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

	(x, y) = app.GetCursorPosition()

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

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

		self.PickingCharacterIndex = chr.Pick()

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

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

	## Show all name in the range

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

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

	grp.PopState()
	grp.SetInterfaceRenderState()

	textTail.Render()
	textTail.HideAllTextTail()

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

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

	else:
		self.interface.OpenSystemDialog()

	return TRUE

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

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

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

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

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

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

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

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

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

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

# END_OF_CUBE

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

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

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

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

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

def BINARY_GuildWar_OnSendDeclare(self, guildID):
	pass

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

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

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

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

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

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

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

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

def __GuildWar_OpenAskDialog(self, guildID, warType):

	guildName = guild.GetGuildName(guildID)

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

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

	self.guildWarQuestionDialog = questionDialog

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

def __GuildWar_OnAccept(self):

	guildName = self.guildWarQuestionDialog.GetGuildName()

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

	return 1

def __GuildWar_OnDecline(self):

	guildName = self.guildWarQuestionDialog.GetGuildName()

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

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

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

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

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

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

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

		# EFFECTS_BUFF_ITEMS
		"buff1"					: self.__buff1,
		"buff2"					: self.__buff2,
		"buff3"					: self.__buff3,
		"buff4"					: self.__buff4,
		# END_OF_EFFECTS_BUFF_ITEMS

	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if background.GetCurrentMapName() in mapDict:
		return FALSE

	return TRUE

def __XMasSnow_Enable(self, mode):

	self.__XMasSong_Enable(mode)

	if "1"==mode:

		if not self.__IsXMasMap():
			return

		print "XMAS_SNOW ON"
		background.EnableSnow(1)

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

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

		if not self.__IsXMasMap():
			return

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

def __XMasTree_Enable(self, grade):

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

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

		XMAS_BGM = "xmas.mp3"

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

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

	else:
		print "XMAS_SONG OFF"

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

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

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

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

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

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

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

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

		if not self.__IsXMasMap():
			return

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

def __DayMode_Update(self, mode):
	if "light"==mode:
		self.curtain.SAFE_FadeOut(self.__DayMode_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) + locale.PARTY_DO_YOU_ACCEPT)
	partyRequestQuestionDialog.SetAcceptText(locale.UI_ACCEPT)
	partyRequestQuestionDialog.SetCancelText(locale.UI_DENY)
	partyRequestQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.__AnswerPartyRequest(arg))
	partyRequestQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.__AnswerPartyRequest(arg))
	partyRequestQuestionDialog.Open()
	partyRequestQuestionDialog.vid = vid
	self.partyRequestQuestionDialog = partyRequestQuestionDialog

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

	vid = self.partyRequestQuestionDialog.vid

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

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

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

def __EnableTestServerFlag(self):
	app.EnableTestServerFlag()

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

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

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

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

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

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

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

# END_OF_WEDDING

# EFFECTS_BUFF_ITEMS
def __buff1(self):
	net.SendChatPacket("(buff1)")

def __buff2(self):
	net.SendChatPacket("(buff2)")

def __buff3(self):
	net.SendChatPacket("(buff3)")

def __buff4(self):
	net.SendChatPacket("(buff4)")

# END_OF_EFFECTS_BUFF_ITEMS

# COSTUME_SYSTEM
def __Wear(self, type, vnum):
	if str(type) == "armor":
		if str(vnum) == "0":
			constInfo.COSTUME_ARMOR = 0
		else:
			constInfo.COSTUME_ARMOR = vnum
	elif str(type) == "hair":
		if str(vnum) == "0":
			constInfo.COSTUME_HAIR = 0
		else:
			constInfo.COSTUME_HAIR = vnum

def __QuestDeclare(self, quest, id):
	if str(quest) == "armor":
		constInfo.COSTUME_ARMOR_QUEST = id
	elif str(quest) == "hair":
		constInfo.COSTUME_HAIR_QUEST = id


def __ServerCommand_Build(self):
	serverCommandList={

		"Wear"				: self.__Wear,
		"QuestDeclare"		: self.__QuestDeclare,
# END_OF_COSTUME_SYSTEM

 

Le bout ajouté se trouve tout à la fin...

 

Voici le post sur lequel j'ai trouvé le système de costume: http://www.elitepvpers.com/forum/metin2-pserver-guides-strategies/2619172-full-costume-system-pro-area-com.html

 

Mon serveur est sous les files et client 2012.

 

Merci pour votre aide, ricou77.

Share this post


Link to post
Share on other sites

3 answers to this question

Recommended Posts

  • 0

Je ne sais pas d'où sort ton système de costume mais pour ma part, je n'utilise pas celui-ci. Essaye cette version: http://www.elitepvpers.com/forum/metin2-pserver-guides-strategies/2568067-rls-verbesserte-kost-msystem-lite-version.html

J'utilise celle-ci et ça fonctionne parfaitement (sauf la case dans l'inventaire, mais c'est peu important)

N'oublie pas de télécharger "Verbesserte Lite Version.rar " en bas du topic, il y a les autres fichiers nécessaires.

Share this post


Link to post
Share on other sites
  • 0

Bonsoir,

 

Le sujet contient la balise [glow=#800000][Résolu][/glow] ou reste sans réponse depuis deux semaines ou plus, de ce fait il a été déplacé dans la section "Résolu ou sans réponse".

 

Cordialement.

Share this post


Link to post
Share on other sites
Guest
This topic is now closed to further replies.
Sign in to follow this