Untitled

From Reliable Hamster, 5 Years ago, written in Plain Text.

Embed

Download Paste or View Raw
Hits: 305

import os

import app

import dbg

import grp

import item

import background

import chr

import chrmgr

import player

import snd

import chat

import textTail

import snd

import net

import effect

import wndMgr

import fly

import systemSetting

import quest

import guild

import skill

import messenger

import localeInfo

import constInfo

import exchange

import ime

import ui

import uiCommon

import uiPhaseCurtain

import uiMapNameShower

import uiAffectShower

import uiPlayerGauge

import uiCharacter

import uiTarget

import uiteleport

import event

import uipoli

import uiboost

import uiBonus

import uidaily

import uiPosition

import uiTombola

# PRIVATE_SHOP_PRICE_LIST

import uiPrivateShopBuilder

# END_OF_PRIVATE_SHOP_PRICE_LIST

import mouseModule

import consoleModule

import localeInfo

import playerSettingModule

import interfaceModule

import musicInfo

import debugInfo

import stringCommander

from _weakref import proxy

# TEXTTAIL_LIVINGTIME_CONTROL

#if localeInfo.IsJAPAN():

# app.SetTextTailLivingTime(8.0)

# END_OF_TEXTTAIL_LIVINGTIME_CONTROL

# SCREENSHOT_CWDSAVE

SCREENSHOT_CWDSAVE = False

SCREENSHOT_DIR = None

if localeInfo.IsEUROPE():

SCREENSHOT_CWDSAVE = True

if localeInfo.IsCIBN10():

SCREENSHOT_CWDSAVE = False

SCREENSHOT_DIR = "YT2W"

cameraDistance = 1550.0

cameraPitch = 27.0

cameraRotation = 0.0

cameraHeight = 100.0

testAlignment = 0

class GameWindow(ui.ScriptWindow):

def __init__(self, stream):

self.wndDaily = None

self.wndDaily = uidaily.DailyWindow()

self.wndBonus = uiBonus.BonusWindow()

self.SklepP = uipoli.PoliShop()

self.BoostWindow = uiboost.BoostWindow()

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

self.SetWindowName("game")

net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)

player.SetGameWindow(self)

constInfo.wndTombola = uiTombola.TombolaWindow()

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.wndPosition = uiPosition.PositionWindow()

self.playerGauge = uiPlayerGauge.PlayerGauge(self)

self.playerGauge.Hide()

#wj 2014.1.2. ESCŰ�� 켱��8�� DropQuestionDialog�� . �� ó=�� itemDropQuestionDialog�� Ǿ� �� ʾ� ERROR�� ߻��Ͽ� init�� ÿ� �ʱ�ȭ ��Ŵ.

self.itemDropQuestionDialog = None

self.__SetQuickSlotMode()

self.__ServerCommand_Build()

self.__ProcessPreservedServerCommand()

self.teleport = uiteleport.TeleportWindow()

self.ClickBoostWindow = uiboost.BoostWindow()

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

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

# START_GAME_ERROR_EXIT

try:

self.StartGame()

except:

import exception

exception.Abort("GameWindow.Open")

# END_OF_START_GAME_ERROR_EXIT

# NPC�� ť��ý��8�� ִ� ��۵�� ; ĳ��

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

self.cubeInformation = {}

self.currentCubeNPC = 0

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

self.wndDaily = None

chat.Close()

snd.StopAllSound()

grp.InitScreenEffect()

chr.Destroy()

textTail.Clear()

quest.Clear()

background.Destroy()

guild.Destroy()

messenger.Destroy()

skill.ClearSkillData()

wndMgr.Unlock()

constInfo.wndTombola.Close()

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.PrintMousePos = 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()

if self.teleport.IsShow():

self.teleport.Open()

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

def __BuildKeyDict(self):

onPressKeyDict = {}

##PressKey �� ִ� �� Ǵ� Ű�̴�.

## �� Ű ��Կ� �̿�ȴ�.(�� ڵ鵵 �� Կ� ��)

## F12 �� Ŭ�� ׿� Ű�̹Ƿ� �� ʴ� �� t�.

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

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

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

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

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

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

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

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

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

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

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

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

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

onPressKeyDict[app.DIK_F5] = lambda: self.interface.wndItemShop.RequestOpen()

onPressKeyDict[app.DIK_F8] = lambda : self.ShowDaily()

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

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

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

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

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

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

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

onPressKeyDict[app.DIK_M] = lambda : self.interface.PressMKey()

#onPressKeyDict[app.DIK_H] = lambda : self.interface.OpenHelpWindow()

onPressKeyDict[app.DIK_ADD] = lambda : self.interface.MiniMapScaleUp()

onPressKeyDict[app.DIK_SUBTRACT] = lambda : self.interface.MiniMapScaleDown()

onPressKeyDict[app.DIK_L] = lambda : self.interface.ToggleChatLogWindow()

onPressKeyDict[app.DIK_LSHIFT] = lambda : self.__SetQuickPageMode()

onPressKeyDict[app.DIK_J] = lambda : self.__PressJKey()

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

onPressKeyDict[app.DIK_H] = lambda : self.__PressHKey()

onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()

onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()

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

# onPressKeyDict[app.DIK_F7] = lambda : self.ShowPositionWindow()

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

self.wndBonus.Show()

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*player.INVENTORY_PAGE_COUNT):

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

interfaceModule.IsQBHide = 1

self.interface.HideAllQuestButton()

else:

interfaceModule.IsQBHide = 0

self.interface.ShowAllQuestButton()

else:

app.RotateCamera(app.CAMERA_TO_NEGATIVE)

def __SetQuickSlotMode(self):

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

def __SetQuickPageMode(self):

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

def __PressQuickSlot(self, localSlotIndex):

if localeInfo.IsARABIC():

if 0 <= localSlotIndex and localSlotIndex < 4:

player.RequestUseLocalQuickSlot(3-localSlotIndex)

else:

player.RequestUseLocalQuickSlot(11-localSlotIndex)

else:

player.RequestUseLocalQuickSlot(localSlotIndex)

def __SelectQuickPage(self, pageIndex):

self.quickSlotPageIndex = pageIndex

player.SetQuickPage(pageIndex)

def ToggleDebugInfo(self):

self.isShowDebugInfo = not self.isShowDebugInfo

if self.isShowDebugInfo:

self.PrintCoord.Show()

self.FrameRate.Show()

self.Pitch.Show()

self.Splat.Show()

self.TextureNum.Show()

self.ObjectNum.Show()

self.ViewDistance.Show()

self.PrintMousePos.Show()

else:

self.PrintCoord.Hide()

self.FrameRate.Hide()

self.Pitch.Hide()

self.Splat.Hide()

self.TextureNum.Hide()

self.ObjectNum.Hide()

self.ViewDistance.Hide()

self.PrintMousePos.Hide()

def __BuildDebugInfo(self):

## Character Position Coordinate

self.PrintCoord = ui.TextLine()

self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)

self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)

## Frame Rate

self.FrameRate = ui.TextLine()

self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)

self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20)

## Camera Pitch

self.Pitch = ui.TextLine()

self.Pitch.SetFontName(localeInfo.UI_DEF_FONT)

self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40)

## Splat

self.Splat = ui.TextLine()

self.Splat.SetFontName(localeInfo.UI_DEF_FONT)

self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60)

##

self.PrintMousePos = ui.TextLine()

self.PrintMousePos.SetFontName(localeInfo.UI_DEF_FONT)

self.PrintMousePos.SetPosition(wndMgr.GetScreenWidth() - 270, 80)

# TextureNum

self.TextureNum = ui.TextLine()

self.TextureNum.SetFontName(localeInfo.UI_DEF_FONT)

self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)

# �:�gƮ �׸��

self.ObjectNum = ui.TextLine()

self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)

self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)

# �þ߰Ÿ�

self.ViewDistance = ui.TextLine()

self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)

self.ViewDistance.SetPosition(0, 0)

def __NotifyError(self, msg):

chat.AppendChat(chat.CHAT_TYPE_INFO, msg)

def ChangePKMode(self):

if not app.IsPressed(app.DIK_LCONTROL):

return

if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:

self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))

return

curTime = app.GetTime()

if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:

return

self.lastPKModeSendedTime = curTime

curPKMode = player.GetPKMode()

nextPKMode = curPKMode + 1

if nextPKMode == player.PK_MODE_PROTECT:

if 0 == player.GetGuildID():

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

nextPKMode = 0

else:

nextPKMode = player.PK_MODE_GUILD

elif nextPKMode == player.PK_MODE_MAX_NUM:

nextPKMode = 0

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

print "/PKMode " + str(nextPKMode)

def OnChangePKMode(self):

self.interface.OnChangePKMode()

try:

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

except KeyError:

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

if constInfo.PVPMODE_TEST_ENABLE:

curPKMode = player.GetPKMode()

alignment, grade = chr.testGetPKData()

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

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

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

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

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

## Game Callback Functions

# Start

def StartGame(self):

self.RefreshInventory()

self.RefreshEquipment()

self.RefreshCharacter()

self.RefreshSkill()

# Refresh

def CheckGameButton(self):

if self.interface:

self.interface.CheckGameButton()

def RefreshAlignment(self):

self.interface.RefreshAlignment()

def RefreshStatus(self):

self.CheckGameButton()

if self.interface:

self.interface.RefreshStatus()

if self.playerGauge:

self.playerGauge.RefreshGauge()

def RefreshStamina(self):

self.interface.RefreshStamina()

def RefreshSkill(self):

self.CheckGameButton()

if self.interface:

self.interface.RefreshSkill()

def RefreshQuest(self):

self.interface.RefreshQuest()

def RefreshMessenger(self):

self.interface.RefreshMessenger()

def RefreshGuildInfoPage(self):

self.interface.RefreshGuildInfoPage()

def RefreshGuildBoardPage(self):

self.interface.RefreshGuildBoardPage()

def RefreshGuildMemberPage(self):

self.interface.RefreshGuildMemberPage()

def RefreshGuildMemberPageGradeComboBox(self):

self.interface.RefreshGuildMemberPageGradeComboBox()

def RefreshGuildSkillPage(self):

self.interface.RefreshGuildSkillPage()

def RefreshGuildGradePage(self):

self.interface.RefreshGuildGradePage()

def RefreshMobile(self):

if self.interface:

self.interface.RefreshMobile()

def OnMobileAuthority(self):

self.interface.OnMobileAuthority()

def OnBlockMode(self, mode):

self.interface.OnBlockMode(mode)

def OpenQuestWindow(self, skin, idx):

if constInfo.CApiSetHide == 1:

net.SendQuestInputStringPacket(str(constInfo.SendString))

constInfo.CApiSetHide = 0

elif constInfo.INPUT_IGNORE == 0:

self.interface.OpenQuestWindow(skin, idx)

def AskGuildName(self):

guildNameBoard = uiCommon.InputDialog()

guildNameBoard.SetTitle(localeInfo.GUILD_NAME)

guildNameBoard.SetAcceptEvent(ui.__mem_func__(self.ConfirmGuildName))

guildNameBoard.SetCancelEvent(ui.__mem_func__(self.CancelGuildName))

guildNameBoard.Open()

self.guildNameBoard = guildNameBoard

def ConfirmGuildName(self):

guildName = self.guildNameBoard.GetText()

if not guildName:

return

if net.IsInsultIn(guildName):

self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)

return

net.SendAnswerMakeGuildPacket(guildName)

self.guildNameBoard.Close()

self.guildNameBoard = None

return True

def CancelGuildName(self):

self.guildNameBoard.Close()

self.guildNameBoard = None

return True

## Refine

def PopupMessage(self, msg):

self.stream.popupWindow.Close()

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

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

self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, type)

def AppendMaterialToRefineDialog(self, vnum, count):

self.interface.AppendMaterialToRefineDialog(vnum, count)

def RunUseSkillEvent(self, slotIndex, coolTime):

self.interface.OnUseSkill(slotIndex, coolTime)

def ClearAffects(self):

self.affectShower.ClearAffects()

def SetAffect(self, affect):

self.affectShower.SetAffect(affect)

def ResetAffect(self, affect):

self.affectShower.ResetAffect(affect)

# UNKNOWN_UPDATE

def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):

self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)

if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:

self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)

elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:

self.BINARY_DragonSoulGiveQuilification()

def BINARY_NEW_RemoveAffect(self, type, pointIdx):

self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)

if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:

self.interface.DragonSoulDeactivate()

# END_OF_UNKNOWN_UPDATE

def ActivateSkillSlot(self, slotIndex):

if self.interface:

self.interface.OnActivateSkill(slotIndex)

def DeactivateSkillSlot(self, slotIndex):

if self.interface:

self.interface.OnDeactivateSkill(slotIndex)

def RefreshEquipment(self):

if self.interface:

self.interface.RefreshInventory()

def RefreshInventory(self):

if self.interface:

self.interface.RefreshInventory()

def RefreshCharacter(self):

if self.interface:

self.interface.RefreshCharacter()

def OnGameOver(self):

self.CloseTargetBoard()

self.OpenRestartDialog()

def OpenRestartDialog(self):

self.interface.OpenRestartDialog()

def ChangeCurrentSkill(self, skillSlotNumber):

self.interface.OnChangeCurrentSkill(skillSlotNumber)

## TargetBoard

def SetPCTargetBoard(self, vid, name):

self.targetBoard.Open(vid, name)

if app.IsPressed(app.DIK_LCONTROL):

if not player.IsSameEmpire(vid):

return

if player.IsMainCharacterIndex(vid):

return

elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):

return

self.interface.OpenWhisperDialog(name)

def RefreshTargetBoardByVID(self, vid):

self.targetBoard.RefreshByVID(vid)

def RefreshTargetBoardByName(self, name):

self.targetBoard.RefreshByName(name)

def __RefreshTargetBoard(self):

self.targetBoard.Refresh()

def SetHPTargetBoard(self, vid, hpPercentage):

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

self.targetBoard.ResetTargetBoard()

self.targetBoard.SetEnemyVID(vid)

self.targetBoard.SetHP(hpPercentage)

self.targetBoard.Show()

def CloseTargetBoardIfDifferent(self, vid):

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

self.targetBoard.Close()

def CloseTargetBoard(self):

self.targetBoard.Close()

## View Equipment

def OpenEquipmentDialog(self, vid):

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

self.interface.OnPickMoneyNew(money)

def OnShopError(self, type):

try:

self.PopupMessage(localeInfo.SHOP_ERROR_DICT[type])

except KeyError:

self.PopupMessage(localeInfo.SHOP_ERROR_UNKNOWN % (type))

def OnSafeBoxError(self):

self.PopupMessage(localeInfo.SAFEBOX_ERROR)

def OnFishingSuccess(self, isFish, fishName):

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

# ADD_FISHING_MESSAGE

def OnFishingNotifyUnknown(self):

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

def OnFishingWrongPlace(self):

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

# END_OF_ADD_FISHING_MESSAGE

def OnFishingNotify(self, isFish, fishName):

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

def OnFishingFailure(self):

chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_FAILURE, 2000)

def OnCannotPickItem(self):

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

# 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.ENABLE_OFFLINE_SHOP:

def StartShop(self, vid, owner_vid, grid_type):

self.interface.OpenShopDialog(vid, owner_vid, grid_type)

else:

def StartShop(self, vid):

self.interface.OpenShopDialog(vid)

def EndShop(self):

self.interface.CloseShopDialog()

def RefreshShop(self):

self.interface.RefreshShopDialog()

if app.ENABLE_OFFLINE_SHOP:

def RefreshShopMoney(self):

self.interface.RefreshShopDialogMoney()

def SetShopSellingPrice(self, Price):

pass

## Exchange

def StartExchange(self):

self.interface.StartExchange()

def EndExchange(self):

self.interface.EndExchange()

def RefreshExchange(self):

self.interface.RefreshExchange()

## Party

def RecvPartyInviteQuestion(self, leaderVID, leaderName):

partyInviteQuestionDialog = uiCommon.QuestionDialog()

partyInviteQuestionDialog.SetText(leaderName + localeInfo.PARTY_DO_YOU_JOIN)

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

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

partyInviteQuestionDialog.Open()

partyInviteQuestionDialog.partyLeaderVID = leaderVID

self.partyInviteQuestionDialog = partyInviteQuestionDialog

def AnswerPartyInvite(self, answer):

if not self.partyInviteQuestionDialog:

return

partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

distance = player.GetCharacterDistance(partyLeaderVID)

if distance < 0.0 or distance > 5000:

answer = False

net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

self.partyInviteQuestionDialog.Close()

self.partyInviteQuestionDialog = None

def AddPartyMember(self, pid, name):

self.interface.AddPartyMember(pid, name)

def UpdatePartyMemberInfo(self, pid):

self.interface.UpdatePartyMemberInfo(pid)

def RemovePartyMember(self, pid):

self.interface.RemovePartyMember(pid)

self.__RefreshTargetBoard()

def LinkPartyMember(self, pid, vid):

self.interface.LinkPartyMember(pid, vid)

def UnlinkPartyMember(self, pid):

self.interface.UnlinkPartyMember(pid)

def UnlinkAllPartyMember(self):

self.interface.UnlinkAllPartyMember()

def ExitParty(self):

self.interface.ExitParty()

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

def ChangePartyParameter(self, distributionMode):

self.interface.ChangePartyParameter(distributionMode)

## Messenger

def OnMessengerAddFriendQuestion(self, name):

messengerAddFriendQuestion = uiCommon.QuestionDialog2()

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

messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)

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

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

messengerAddFriendQuestion.Open()

messengerAddFriendQuestion.name = name

self.messengerAddFriendQuestion = messengerAddFriendQuestion

def OnAcceptAddFriend(self):

name = self.messengerAddFriendQuestion.name

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

self.OnCloseAddFriendQuestionDialog()

return True

def OnDenyAddFriend(self):

name = self.messengerAddFriendQuestion.name

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

self.OnCloseAddFriendQuestionDialog()

return True

def OnCloseAddFriendQuestionDialog(self):

self.messengerAddFriendQuestion.Close()

self.messengerAddFriendQuestion = None

return True

## SafeBox

def OpenSafeboxWindow(self, size):

self.interface.OpenSafeboxWindow(size)

def RefreshSafebox(self):

self.interface.RefreshSafebox()

def RefreshSafeboxMoney(self):

self.interface.RefreshSafeboxMoney()

if app.ENABLE_OFFLINE_SHOP:

def AppendOfflineShopInfo(self, name, vid, mapIdx, x, y):

self.interface.AppendOfflineShopData(name, vid, mapIdx, x, y)

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

def Teleport_otwarty(self):

self.teleport.Open()

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

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

## Event Handler

def OnKeyDown(self, key):

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

return

if key == app.DIK_ESC:

self.RequestDropItem(False)

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

try:

self.onPressKeyDict[key]()

except KeyError:

pass

except:

raise

return True

def OnKeyUp(self, key):

try:

self.onClickKeyDict[key]()

except KeyError:

pass

except:

raise

return True

def OnMouseLeftButtonDown(self):

if self.interface.BUILD_OnMouseLeftButtonDown():

return

if mouseModule.mouseController.isAttached():

self.CheckFocus()

else:

hyperlink = ui.GetHyperlink()

if hyperlink:

return

else:

self.CheckFocus()

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

return True

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():

return

if mouseModule.mouseController.isAttached():

attachedType = mouseModule.mouseController.GetAttachedType()

attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()

## QuickSlot

if player.SLOT_TYPE_QUICK_SLOT == attachedType:

player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)

## Inventory

elif player.SLOT_TYPE_INVENTORY == attachedType:

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:

attachedInvenType = player.SlotTypeToInvenType(attachedType)

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

if player.IsEquipmentSlot(attachedItemSlotPos) and player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType:

self.stream.popupWindow.Close()

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

else:

if chr.IsNPC(dstChrID):

net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)

else:

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)

else:

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

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

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

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeElkAddPacket(attachedMoney)

else:

self.__DropMoney(attachedType, attachedMoney)

def __DropMoney(self, attachedType, attachedMoney):

# PRIVATESHOP_DISABLE_ITEM_DROP - ��λ�a �� ִ� ��

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_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.QuestionDialog()

itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_MONEY % (attachedMoney))

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

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

itemDropQuestionDialog.Open()

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropCount = attachedMoney

itemDropQuestionDialog.dropNumber = player.ITEM_MONEY

self.itemDropQuestionDialog = itemDropQuestionDialog

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

# PRIVATESHOP_DISABLE_ITEM_DROP - ��λ�a �� ִ� ��

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

if player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):

self.stream.popupWindow.Close()

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

else:

if player.SLOT_TYPE_INVENTORY == attachedType:

dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

item.SelectItem(dropItemIndex)

dropItemName = item.GetItemName()

## Question Text

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

itemDropQuestionDialog = uiCommon.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_QUESTION_DIALOG_STATUS(1)

elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:

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

item.SelectItem(dropItemIndex)

dropItemName = item.GetItemName()

## Question Text

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

itemDropQuestionDialog = uiCommon.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_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

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)

# PRIVATESHOP_DISABLE_ITEM_DROP

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

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemDropPacketNew(itemInvenType, 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):

self.wndDaily.DailyUpdate()

app.UpdateGame()

if self.mapNameShower.IsShow():

self.mapNameShower.Update()

if self.isShowDebugInfo:

self.UpdateDebugInfo()

if self.enableXMasBoom:

self.__XMasBoom_Update()

self.interface.BUILD_OnUpdate()

self.interface.BsUpdate()

self.interface.BiologUpdate()

if app.ENABLE_OFFLINE_SHOP:

self.interface.OFFSHOP_OnUpdate()

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

textTail.UpdateShowingTextTail()

textTail.ArrangeTextTail()

if -1 != self.PickingItemIndex:

textTail.SelectItemName(self.PickingItemIndex)

grp.PopState()

grp.SetInterfaceRenderState()

textTail.Render()

textTail.HideAllTextTail()

def OnPressEscapeKey(self):

if constInfo.wndTombola.IsShow():

constInfo.wndTombola.Close()

return

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

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

# f�ۿ� �ʿ�� , ��Ǵ� �ϼ�ǰ�� VNUM�� d�� update

def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):

self.interface.UpdateCubeInfo(gold, itemVnum, count)

def BINARY_Cube_Succeed(self, itemVnum, count):

print "ť�� f�� "

self.interface.SucceedCubeWork(itemVnum, count)

pass

def BINARY_Cube_Failed(self):

print "ť�� f�� "

self.interface.FailedCubeWork()

pass

def BINARY_Cube_ResultList(self, npcVNUM, listText):

# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 �̷��8�� "/" ��ڷ� ��е� ��Ʈ��

#print listText

if npcVNUM == 0:

npcVNUM = self.currentCubeNPC

self.cubeInformation[npcVNUM] = []

try:

for eachInfoText in listText.split("/"):

eachInfo = eachInfoText.split(",")

itemVnum = int(eachInfo[0])

itemCount = int(eachInfo[1])

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

self.interface.wndCube.AddCubeResultItem(itemVnum, itemCount)

resultCount = len(self.cubeInformation[npcVNUM])

requestCount = 7

modCount = resultCount % requestCount

splitCount = resultCount / requestCount

for i in xrange(splitCount):

#print("/cube r_info %d %d" % (i * requestCount, requestCount))

net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount))

if 0 < modCount:

#print("/cube r_info %d %d" % (splitCount * requestCount, modCount))

net.SendChatPacket("/cube r_info %d %d" % (splitCount * requestCount, modCount))

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

pass

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

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

try:

#print listText

if 3 > len(listText):

dbg.TraceError("Wrong Cube Material Infomation")

return 0

eachResultList = listText.split("@")

cubeInfo = self.cubeInformation[self.currentCubeNPC]

itemIndex = 0

for eachResultText in eachResultList:

cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]

materialList = cubeInfo[startIndex + itemIndex]["materialList"]

gold = 0

splitResult = eachResultText.split("/")

if 1 < len(splitResult):

gold = int(splitResult[1])

#print "splitResult : ", splitResult

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

i = 0

for eachMaterialText in eachMaterialList:

complicatedList = eachMaterialText.split("|")

if 0 < len(complicatedList):

for complicatedText in complicatedList:

(itemVnum, itemCount) = complicatedText.split(",")

itemVnum = int(itemVnum)

itemCount = int(itemCount)

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

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

else:

itemVnum, itemCount = eachMaterialText.split(",")

itemVnum = int(itemVnum)

itemCount = int(itemCount)

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

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

i = i + 1

itemIndex = itemIndex + 1

self.interface.wndCube.Refresh()

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

pass

# END_OF_CUBE

# ��ȥ��

def BINARY_Highlight_Item(self, inven_type, inven_pos):

# @fixme003 (+if self.interface:)

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

if app.ENABLE_OFFLINE_SHOP:

def BINARY_SetOfflineShopMoveMode(self, isEnable):

self.interface.BINARY_SetMoveShopMode(isEnable)

## BINARY CALLBACK

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

def __ServerCommand_Build(self):

serverCommandList={

"tombola" : self.SetTombola,

"OnPrepare" : self.__PrepareTombola,

"OnRun" : self.__RunTombola,

"openTombola" : self.__OpenTombola,

"TombolaSetEnable" : self.TombolaSetEnable,

"get_input_value" : self.GetInputValue,

"daily_update" : self.__Daily_Update,

"GetInputStart" : self.GetInputStart,

"GetInputStop" : self.GetInputStop,

"GetInput" : self.GetInput,

"MarmurShopQuest" : self.MarmurShop,

"offline_wyplacanie" : self.__setWyplacanieYangOffline,

"obieranie_itemshop" : self.__odbieranie_itemshop,

"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

"SetItemShopCash" : self.interface.wndItemShop.SetCash,

"OpenShopWindow" : self.interface.wndItemShop.Open,

"SetItemShopItems" : self.interface.wndItemShop.AddItem,

"UpdateItemShopItem" : self.interface.wndItemShop.UpdateItem,

"ClearItemShopItems" : self.interface.wndItemShop.ClearItems,

"RefreshItemShopPage" : self.interface.wndItemShop.RefreshPage,

"DeleteItemShopItem" : self.interface.wndItemShop.DeleteItem,

"ItemShopEditor" : self.interface.wndItemShop.SetEditorFlag,

# Zapisywanie pozycji

"SavePosition" : self.ZapisanePozycje1,

"SaveMapNames" : self.ZapisaneNazwyMap,

# koniec zapisu

#biolog

"Biolog" : self.__Biolog,

"Biolog_hide" : self.__BiologHide,

"Biolog_status" : self.__Biolog_status,

# koniec biologa

# Teleport

"Teleport" : self.Teleport,

# koniec teleportu

}

if app.ENABLE_OFFLINE_SHOP:

serverCommandList.update({"offlineshop_info" : self.AppendOfflineShopInfo })

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(localeInfo.REFINE_SUCCESS)

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

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

if app.ENABLE_OFFLINE_SHOP:

def __PrivateShop_Open(self, hasCoin, hasGoldbar, hasWon):

self.interface.OpenPrivateShopInputNameDialog(hasCoin, hasGoldbar, hasWon)

else:

def __PrivateShop_Open(self):

self.interface.OpenPrivateShopInputNameDialog()

def BINARY_PrivateShop_Appear(self, vid, text):

if app.ENABLE_OFFLINE_SHOP:

fmName = "%s's Offline shop" % player.GetName()

if (systemSetting.IsShowOfflineShop() != 1 and not player.IsMainCharacterIndex(vid)) and (systemSetting.IsShowOfflineShop() == 2 and chr.GetNameByVID(vid) != fmName):

return

if chr.GetVirtualNumber(vid) < 30000:

return

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

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)

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)

# END_OF_WEDDING

if app.ENABLE_SEND_TARGET_INFO:

def BINARY_AddTargetMonsterDropInfo(self, raceNum, itemVnum, itemCount):

if not raceNum in constInfo.MONSTER_INFO_DATA:

constInfo.MONSTER_INFO_DATA.update({raceNum : {}})

constInfo.MONSTER_INFO_DATA[raceNum].update({"items" : []})

curList = constInfo.MONSTER_INFO_DATA[raceNum]["items"]

isUpgradeable = False

isMetin = False

item.SelectItem(itemVnum)

if item.GetItemType() == item.ITEM_TYPE_WEAPON or item.GetItemType() == item.ITEM_TYPE_ARMOR:

isUpgradeable = True

elif item.GetItemType() == item.ITEM_TYPE_METIN:

isMetin = True

for curItem in curList:

if isUpgradeable:

if curItem.has_key("vnum_list") and curItem["vnum_list"][0] / 10 * 10 == itemVnum / 10 * 10:

if not (itemVnum in curItem["vnum_list"]):

curItem["vnum_list"].append(itemVnum)

return

elif isMetin:

if curItem.has_key("vnum_list"):

baseVnum = curItem["vnum_list"][0]

if curItem.has_key("vnum_list") and (baseVnum - baseVnum%1000) == (itemVnum - itemVnum%1000):

if not (itemVnum in curItem["vnum_list"]):

curItem["vnum_list"].append(itemVnum)

return

else:

if curItem.has_key("vnum") and curItem["vnum"] == itemVnum and curItem["count"] == itemCount:

return

if isUpgradeable or isMetin:

curList.append({"vnum_list":[itemVnum], "count":itemCount})

else:

curList.append({"vnum":itemVnum, "count":itemCount})

def BINARY_RefreshTargetMonsterDropInfo(self, raceNum):

self.targetBoard.RefreshMonsterInfoBoard()

def __setWyplacanieYangOffline(self, value):

constInfo.OFFLINE_WYPLACANIE_YANG = int(value)

def __odbieranie_itemshop(self, value):

constInfo.OdbieranieIs = int(value)

def ClickPoliShopButton(self):

if FALSE == player.IsObserverMode():

self.SklepP.Show()

def BoostWindowShopButton(self):

if FALSE == player.IsObserverMode():

self.BoostWindow.Show()

def MarmurShop(self, qid):

constInfo.MarmurShopQuest = int(qid)

def GetInputStart(self):

constInfo.INPUT_IGNORE = 1

def ShowPositionWindow(self):

self.wndPosition.Show()

def ShowPositionWindow(self):

self.wndPosition.Show()

def GetInputStop(self):

constInfo.INPUT_IGNORE = 0

def GetInput(self):

net.SendQuestInputStringPacket(str(constInfo.INPUT_DATA))

def ShowDaily(self):

self.wndDaily.Show()

def __Daily_Update(self, arg):

data = arg.split("|")

constInfo.DAILY_DAY = int(data[0])

constInfo.DAILY_TIME = int(data[1])

def __Biolog(self, arg):

data = arg.split("|")

constInfo.BIOLOG_ITEM = int(data[0])

constInfo.BIOLOG_TIME = int(data[1])

constInfo.BIOLOG_COUNT = int(data[2])

constInfo.BIOLOG_SZANSA = int(data[3])

def __Biolog_status(self, arg):

constInfo.BIOLOG_STATUS = int(arg)

def __BiologHide(self, arg):

constInfo.BIOLOG_ITEM = int(arg)

self.interface.HideBiologWindow()

def ZapisanePozycje1(self, qid):

constInfo.ZapiszPozycje = int(qid)

def ZapisaneNazwyMap(self, data):

constInfo.SAVE_MAP_NAME = data

self.wndPosition.UpdateMapNames()

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

net.SendQuestInputStringPacket(str(constInfo.VIDT))

def TombolaSetEnable(self):

constInfo.wndTombola.EnableButton()

def __OpenTombola(self):

constInfo.wndTombola.Open()

def __PrepareTombola(self, data):

constInfo.wndTombola.OnPrepare(str(data))

def __RunTombola(self, number):

constInfo.wndTombola.OnRun(str(number))

def SetTombola(self, qid):

constInfo.TOMBOLA = int(qid)

Author

Title

Language

Your paste - Paste your paste here

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

import ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
import uiteleport
import event
import uipoli  
import uiboost  
import uiBonus
import uidaily
import uiPosition
import uiTombola

# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LIST

import mouseModule
import consoleModule
import localeInfo

import playerSettingModule
import interfaceModule

import musicInfo
import debugInfo
import stringCommander

from _weakref import proxy

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

# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = False
SCREENSHOT_DIR = None

if localeInfo.IsEUROPE():
	SCREENSHOT_CWDSAVE = True

if localeInfo.IsCIBN10():
	SCREENSHOT_CWDSAVE = False
	SCREENSHOT_DIR = &quot;YT2W&quot;

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

testAlignment = 0

class GameWindow(ui.ScriptWindow):
	def __init__(self, stream):
		self.wndDaily = None
		self.wndDaily = uidaily.DailyWindow()
		self.wndBonus = uiBonus.BonusWindow()
		self.SklepP = uipoli.PoliShop()
		self.BoostWindow = uiboost.BoostWindow()
		ui.ScriptWindow.__init__(self, &quot;GAME&quot;)
		self.SetWindowName(&quot;game&quot;)
		net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
		player.SetGameWindow(self)
		constInfo.wndTombola = uiTombola.TombolaWindow()

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.wndPosition = uiPosition.PositionWindow()

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

#wj 2014.1.2. ESCŰ�� ���� �� �켱��8�� DropQuestionDialog�� ��� ������. ���� ó=�� itemDropQuestionDialog�� ����Ǿ� ���� �ʾ� ERROR�� �߻��Ͽ� init���� ����� ���ÿ� �ʱ�ȭ ��Ŵ.
		self.itemDropQuestionDialog = None

self.__SetQuickSlotMode()

self.__ServerCommand_Build()
		self.__ProcessPreservedServerCommand()
		self.teleport = uiteleport.TeleportWindow()
		self.ClickBoostWindow = uiboost.BoostWindow()

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

# 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(&quot;BGM/&quot; + netFieldMusicFileName)
		elif musicInfo.fieldMusic != &quot;&quot;:
			snd.FadeInMusic(&quot;BGM/&quot; + 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(&quot;GameWindow.Open&quot;)
		# END_OF_START_GAME_ERROR_EXIT

# NPC�� ť��ý���8�� ���� �� �ִ� �����۵��� ���; ĳ��
		# ex) cubeInformation[20383] = [ {&quot;rewordVNUM&quot;: 72723, &quot;rewordCount&quot;: 1, &quot;materialInfo&quot;: &quot;101,1&amp;102,2&quot;, &quot;price&quot;: 999 }, ... ]
		self.cubeInformation = {}
		self.currentCubeNPC = 0

def Close(self):
		self.Hide()

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

if musicInfo.fieldMusic != &quot;&quot;:
			snd.FadeOutMusic(&quot;BGM/&quot;+ musicInfo.fieldMusic)

self.onPressKeyDict = None
		self.onClickKeyDict = None
		self.wndDaily = None

chat.Close()
		snd.StopAllSound()
		grp.InitScreenEffect()
		chr.Destroy()
		textTail.Clear()
		quest.Clear()
		background.Destroy()
		guild.Destroy()
		messenger.Destroy()
		skill.ClearSkillData()
		wndMgr.Unlock()
		constInfo.wndTombola.Close()
		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.PrintMousePos = 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()
		
		if self.teleport.IsShow():
			self.teleport.Open()

print &quot;---------------------------------------------------------------------------- CLOSE GAME WINDOW&quot;

def __BuildKeyDict(self):
		onPressKeyDict = {}

##PressKey �� ������ �ִ� ���� ��� ���Ǵ� Ű�̴�.

## ���� ����Ű ��Կ� �̿�ȴ�.(���� ���ڵ鵵 �� ���Կ� ����)
		## F12 �� Ŭ�� ���׿� Ű�̹Ƿ� ���� �ʴ� �� �t�.
		onPressKeyDict[app.DIK_1]	= lambda : self.__PressNumKey(1)
		onPressKeyDict[app.DIK_2]	= lambda : self.__PressNumKey(2)
		onPressKeyDict[app.DIK_3]	= lambda : self.__PressNumKey(3)
		onPressKeyDict[app.DIK_4]	= lambda : self.__PressNumKey(4)
		onPressKeyDict[app.DIK_5]	= lambda : self.__PressNumKey(5)
		onPressKeyDict[app.DIK_6]	= lambda : self.__PressNumKey(6)
		onPressKeyDict[app.DIK_7]	= lambda : self.__PressNumKey(7)
		onPressKeyDict[app.DIK_8]	= lambda : self.__PressNumKey(8)
		onPressKeyDict[app.DIK_9]	= lambda : self.__PressNumKey(9)
		onPressKeyDict[app.DIK_F1]	= lambda : self.__PressQuickSlot(4)
		onPressKeyDict[app.DIK_F2]	= lambda : self.__PressQuickSlot(5)
		onPressKeyDict[app.DIK_F3]	= lambda : self.__PressQuickSlot(6)
		onPressKeyDict[app.DIK_F4]	= lambda : self.__PressQuickSlot(7)
		onPressKeyDict[app.DIK_F5] = lambda: self.interface.wndItemShop.RequestOpen()
		onPressKeyDict[app.DIK_F8]	= lambda : self.ShowDaily()

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_TAB]			= lambda : self.Teleport_otwarty()
		onPressKeyDict[app.DIK_C]			= lambda state = &quot;STATUS&quot;: self.interface.ToggleCharacterWindow(state)
		onPressKeyDict[app.DIK_V]			= lambda state = &quot;SKILL&quot;: self.interface.ToggleCharacterWindow(state)
		#onPressKeyDict[app.DIK_B]			= lambda state = &quot;EMOTICON&quot;: self.interface.ToggleCharacterWindow(state)
		onPressKeyDict[app.DIK_N]			= lambda state = &quot;QUEST&quot;: self.interface.ToggleCharacterWindow(state)
		onPressKeyDict[app.DIK_I]			= lambda : self.interface.ToggleInventoryWindow()
		onPressKeyDict[app.DIK_O]			= lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
		onPressKeyDict[app.DIK_M]			= lambda : self.interface.PressMKey()
		#onPressKeyDict[app.DIK_H]			= lambda : self.interface.OpenHelpWindow()
		onPressKeyDict[app.DIK_ADD]			= lambda : self.interface.MiniMapScaleUp()
		onPressKeyDict[app.DIK_SUBTRACT]	= lambda : self.interface.MiniMapScaleDown()
		onPressKeyDict[app.DIK_L]			= lambda : self.interface.ToggleChatLogWindow()
		onPressKeyDict[app.DIK_LSHIFT]		= lambda : self.__SetQuickPageMode()

onPressKeyDict[app.DIK_J]			= lambda : self.__PressJKey()
		onPressKeyDict[app.DIK_X]			= lambda : self.__PressXKey()
		onPressKeyDict[app.DIK_H]			= lambda : self.__PressHKey()
		onPressKeyDict[app.DIK_B]			= lambda : self.__PressBKey()
		onPressKeyDict[app.DIK_F]			= lambda : self.__PressFKey()
		onPressKeyDict[app.DIK_F6]          = lambda : self.ClickPoliShopButton()
#		onPressKeyDict[app.DIK_F7]			= lambda : self.ShowPositionWindow()

# 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 &gt;= 1 and num &lt;= 9:
				if(chrmgr.IsPossibleEmoticon(-1)):
					chrmgr.SetEmoticon(-1,int(num)-1)
					net.SendEmoticon(int(num)-1)
		else:
			if num &gt;= 1 and num &lt;= 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	__PressXKey(self):
		self.wndBonus.Show()
				
	def	__PressJKey(self):
		if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
			if player.IsMountingHorse():
				net.SendChatPacket(&quot;/unmount&quot;)
			else:
				#net.SendChatPacket(&quot;/user_horse_ride&quot;)
				if not uiPrivateShopBuilder.IsBuildingPrivateShop():
					for i in xrange(player.INVENTORY_PAGE_SIZE*player.INVENTORY_PAGE_COUNT):
						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(&quot;/user_horse_ride&quot;)
		else:
			self.interface.OpenHelpWindow()

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

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

def __PressGKey(self):
		if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
			net.SendChatPacket(&quot;/ride&quot;)
		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==interfaceModule.IsQBHide:
				interfaceModule.IsQBHide = 1
				self.interface.HideAllQuestButton()
			else:
				interfaceModule.IsQBHide = 0
				self.interface.ShowAllQuestButton()
		else:
			app.RotateCamera(app.CAMERA_TO_NEGATIVE)

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

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

def __PressQuickSlot(self, localSlotIndex):
		if localeInfo.IsARABIC():
			if 0 &lt;= localSlotIndex and localSlotIndex &lt; 4:
				player.RequestUseLocalQuickSlot(3-localSlotIndex)
			else:
				player.RequestUseLocalQuickSlot(11-localSlotIndex)
		else:
			player.RequestUseLocalQuickSlot(localSlotIndex)

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

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

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

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

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

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

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

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

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

# �:�gƮ �׸��� ����
		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)&lt;constInfo.PVPMODE_PROTECTED_LEVEL:
			self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
			return

curTime = app.GetTime()
		if curTime - self.lastPKModeSendedTime &lt; 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(&quot;/PKMode &quot; + str(nextPKMode))
		print &quot;/PKMode &quot; + str(nextPKMode)

def OnChangePKMode(self):

self.interface.OnChangePKMode()

try:
			self.__NotifyError(localeInfo.OPTION_PVPMODE_MESSAGE_DICT[player.GetPKMode()])
		except KeyError:
			print &quot;UNKNOWN PVPMode[%d]&quot; % (player.GetPKMode())

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

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

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

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

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

def RefreshStatus(self):
		self.CheckGameButton()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def OpenQuestWindow(self, skin, idx):
		if constInfo.CApiSetHide == 1:
			net.SendQuestInputStringPacket(str(constInfo.SendString))
			constInfo.CApiSetHide = 0

elif constInfo.INPUT_IGNORE == 0:
			self.interface.OpenQuestWindow(skin, idx)

def AskGuildName(self):

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

self.guildNameBoard = guildNameBoard

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

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

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

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

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

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

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

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

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

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

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

# UNKNOWN_UPDATE
	def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
		self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)
		if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
			self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
		elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
			self.BINARY_DragonSoulGiveQuilification()

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

# END_OF_UNKNOWN_UPDATE

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

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

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

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

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

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

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

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

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

if app.IsPressed(app.DIK_LCONTROL):

if not player.IsSameEmpire(vid):
				return

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

self.interface.OpenWhisperDialog(name)

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

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

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

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

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

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

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

## View Equipment
	def OpenEquipmentDialog(self, vid):
		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, &quot;Whisper Unknown Error(mode=%d, name=%s)&quot; % (mode, name))
		self.interface.RecvWhisper(name)

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

def OnPickMoney(self, money):
		self.interface.OnPickMoneyNew(money)

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

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

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

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

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

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

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

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

# 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.ENABLE_OFFLINE_SHOP:
		def StartShop(self, vid, owner_vid, grid_type):
			self.interface.OpenShopDialog(vid, owner_vid, grid_type)
	else:
		def StartShop(self, vid):
			self.interface.OpenShopDialog(vid)

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

def RefreshShop(self):
		self.interface.RefreshShopDialog()
	if app.ENABLE_OFFLINE_SHOP:
		def RefreshShopMoney(self):
			self.interface.RefreshShopDialogMoney()

def SetShopSellingPrice(self, Price):
		pass

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

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

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

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

def AnswerPartyInvite(self, answer):

if not self.partyInviteQuestionDialog:
			return

partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

distance = player.GetCharacterDistance(partyLeaderVID)
		if distance &lt; 0.0 or distance &gt; 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(&quot;/messenger_auth y &quot; + name)
		self.OnCloseAddFriendQuestionDialog()
		return True

def OnDenyAddFriend(self):
		name = self.messengerAddFriendQuestion.name
		net.SendChatPacket(&quot;/messenger_auth n &quot; + 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()
	if app.ENABLE_OFFLINE_SHOP:
		def AppendOfflineShopInfo(self, name, vid, mapIdx, x, y):
			self.interface.AppendOfflineShopData(name, vid, mapIdx, x, y)

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

def CheckFocus(self):
		if False == self.IsFocus():
			if True == self.interface.IsOpenChat():
				self.interface.ToggleChat()

self.SetFocus()

def SaveScreen(self):
		print &quot;save screen&quot;

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

(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+&quot;screenshot&quot;+os.sep)
		elif SCREENSHOT_DIR:
			(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)
		else:
			(succeeded, name) = grp.SaveScreenShot()
		# END_OF_SCREENSHOT_CWDSAVE

if succeeded:
			pass
			&quot;&quot;&quot;
			chat.AppendChat(chat.CHAT_TYPE_INFO, name + localeInfo.SCREENSHOT_SAVE1)
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE2)
			&quot;&quot;&quot;
		else:
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE_FAILURE)

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()
		
	def Teleport_otwarty(self):
		self.teleport.Open()

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

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

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

return True

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

return True

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

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

return True

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():
			return

if mouseModule.mouseController.isAttached():

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

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

## Inventory
			elif player.SLOT_TYPE_INVENTORY == attachedType:

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

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

def __DropMoney(self, attachedType, attachedMoney):
		# PRIVATESHOP_DISABLE_ITEM_DROP - ���λ�a ���� �ִ� ���� ������ �� ����
		if uiPrivateShopBuilder.IsBuildingPrivateShop():
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
			return
		# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

if attachedMoney&gt;=1000:
			self.stream.popupWindow.Close()
			self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0, localeInfo.UI_OK)
			return

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

def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
		# PRIVATESHOP_DISABLE_ITEM_DROP - ���λ�a ���� �ִ� ���� ������ �� ����
		if uiPrivateShopBuilder.IsBuildingPrivateShop():
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
			return
		# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

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

else:
			if player.SLOT_TYPE_INVENTORY == attachedType:
				dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

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

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

## Dialog
				itemDropQuestionDialog = uiCommon.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_QUESTION_DIALOG_STATUS(1)
			elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
				dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)

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

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

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:
				if dropNumber == player.ITEM_MONEY:
					net.SendGoldDropPacketNew(dropCount)
					snd.PlaySound(&quot;sound/ui/money.wav&quot;)
				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)

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

net.SendItemDropPacketNew(itemInvenType, 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):
		self.wndDaily.DailyUpdate()
		app.UpdateGame()

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

if self.isShowDebugInfo:
			self.UpdateDebugInfo()

if self.enableXMasBoom:
			self.__XMasBoom_Update()

self.interface.BUILD_OnUpdate()
		self.interface.BsUpdate()
		self.interface.BiologUpdate()
		if app.ENABLE_OFFLINE_SHOP:
			self.interface.OFFSHOP_OnUpdate()

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(&quot;Coordinate: %.2f %.2f %.2f ATM: %d&quot; % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
		xMouse, yMouse = wndMgr.GetMousePosition()
		self.PrintMousePos.SetText(&quot;MousePosition: %d %d&quot; % (xMouse, yMouse))

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

if fAveRT&gt;1.0:
			self.Pitch.SetText(&quot;RFPS: %3d RT:%.2f(%3d) FC: %d(%.2f) &quot; % (nRenderFPS, fAveRT, nCurRT, nFaceCount, nFaceCount/fAveRT))

self.Splat.SetText(&quot;PATCH: %d SPLAT: %d BAD(%.2f)&quot; % (iPatch, iSplat, fSplatRatio))
		#self.Pitch.SetText(&quot;Pitch: %.2f&quot; % (app.GetCameraPitch())
		#self.TextureNum.SetText(&quot;TN : %s&quot; % (sTextureNum))
		#self.ObjectNum.SetText(&quot;GTI : %d, CRC : %d&quot; % (dwRenderedThing, dwRenderedCRC))
		self.ViewDistance.SetText(&quot;Num : %d, FS : %f, FE : %f, FC : %f&quot; % (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 constInfo.wndTombola.IsShow():
			constInfo.wndTombola.Close()
			return
			
		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

# 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(&quot;/cube r_info&quot;)
		else:
			cubeInfoList = self.cubeInformation[npcVNUM]

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

j = 0
				for materialList in cubeInfo[&quot;materialList&quot;]:
					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()

# f�ۿ� �ʿ��� ���, ����Ǵ� �ϼ�ǰ�� VNUM�� ���� d�� update
	def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
		self.interface.UpdateCubeInfo(gold, itemVnum, count)

def BINARY_Cube_Succeed(self, itemVnum, count):
		print &quot;ť�� f�� ����&quot;
		self.interface.SucceedCubeWork(itemVnum, count)
		pass

def BINARY_Cube_Failed(self):
		print &quot;ť�� f�� ����&quot;
		self.interface.FailedCubeWork()
		pass

def BINARY_Cube_ResultList(self, npcVNUM, listText):
		# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5  �̷���8�� &quot;/&quot; ���ڷ� ���е� ����Ʈ�� ��
		#print listText

if npcVNUM == 0:
			npcVNUM = self.currentCubeNPC

self.cubeInformation[npcVNUM] = []

try:
			for eachInfoText in listText.split(&quot;/&quot;):
				eachInfo = eachInfoText.split(&quot;,&quot;)
				itemVnum	= int(eachInfo[0])
				itemCount	= int(eachInfo[1])

self.cubeInformation[npcVNUM].append({&quot;vnum&quot;: itemVnum, &quot;count&quot;: 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(&quot;/cube r_info %d %d&quot; % (i * requestCount, requestCount))
				net.SendChatPacket(&quot;/cube r_info %d %d&quot; % (i * requestCount, requestCount))

if 0 &lt; modCount:
				#print(&quot;/cube r_info %d %d&quot; % (splitCount * requestCount, modCount))
				net.SendChatPacket(&quot;/cube r_info %d %d&quot; % (splitCount * requestCount, modCount))

except RuntimeError, msg:
			dbg.TraceError(msg)
			return 0

pass

def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText):
		# Material Text Format : 125,1|126,2|127,2|123,5&amp;555,5&amp;555,4/120000
		try:
			#print listText

if 3 &gt; len(listText):
				dbg.TraceError(&quot;Wrong Cube Material Infomation&quot;)
				return 0

eachResultList = listText.split(&quot;@&quot;)

cubeInfo = self.cubeInformation[self.currentCubeNPC]

itemIndex = 0
			for eachResultText in eachResultList:
				cubeInfo[startIndex + itemIndex][&quot;materialList&quot;] = [[], [], [], [], []]
				materialList = cubeInfo[startIndex + itemIndex][&quot;materialList&quot;]

gold = 0
				splitResult = eachResultText.split(&quot;/&quot;)
				if 1 &lt; len(splitResult):
					gold = int(splitResult[1])

#print &quot;splitResult : &quot;, splitResult
				eachMaterialList = splitResult[0].split(&quot;&amp;&quot;)

i = 0
				for eachMaterialText in eachMaterialList:
					complicatedList = eachMaterialText.split(&quot;|&quot;)

if 0 &lt; len(complicatedList):
						for complicatedText in complicatedList:
							(itemVnum, itemCount) = complicatedText.split(&quot;,&quot;)
							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(&quot;,&quot;)
						itemVnum = int(itemVnum)
						itemCount = int(itemCount)
						self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)

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

i = i + 1

itemIndex = itemIndex + 1

self.interface.wndCube.Refresh()

except RuntimeError, msg:
			dbg.TraceError(msg)
			return 0

pass

# END_OF_CUBE

# ��ȥ��
	def BINARY_Highlight_Item(self, inven_type, inven_pos):
		# @fixme003 (+if self.interface:)
		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_OpenAskDialog(self, guildID, warType):

guildName = guild.GetGuildName(guildID)

# REMOVED_GUILD_BUG_FIX
		if &quot;Noname&quot; == 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(&quot;/war &quot; + guildName)
		self.__GuildWar_CloseAskDialog()

return 1

def __GuildWar_OnDecline(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket(&quot;/nowar &quot; + guildName)
		self.__GuildWar_CloseAskDialog()

return 1
	if app.ENABLE_OFFLINE_SHOP:
		def BINARY_SetOfflineShopMoveMode(self, isEnable):
			self.interface.BINARY_SetMoveShopMode(isEnable)
	## BINARY CALLBACK
	######################################################################################

def __ServerCommand_Build(self):
		serverCommandList={
			&quot;tombola&quot;				: self.SetTombola,
			&quot;OnPrepare&quot;				: self.__PrepareTombola,
			&quot;OnRun&quot;					: self.__RunTombola,
			&quot;openTombola&quot;			: self.__OpenTombola,
			&quot;TombolaSetEnable&quot;		: self.TombolaSetEnable,
			&quot;get_input_value&quot;		: self.GetInputValue,
		
			&quot;daily_update&quot;			: self.__Daily_Update,
			&quot;GetInputStart&quot;			: self.GetInputStart,
			&quot;GetInputStop&quot;			: self.GetInputStop,
			&quot;GetInput&quot;				: self.GetInput,
			&quot;MarmurShopQuest&quot;       : self.MarmurShop,
			&quot;offline_wyplacanie&quot;	: self.__setWyplacanieYangOffline,
			&quot;obieranie_itemshop&quot;	: self.__odbieranie_itemshop,
			&quot;ConsoleEnable&quot;			: self.__Console_Enable,
			&quot;DayMode&quot;				: self.__DayMode_Update,
			&quot;PRESERVE_DayMode&quot;		: self.__PRESERVE_DayMode_Update,
			&quot;CloseRestartWindow&quot;	: self.__RestartDialog_Close,
			&quot;OpenPrivateShop&quot;		: self.__PrivateShop_Open,
			&quot;PartyHealReady&quot;		: self.PartyHealReady,
			&quot;ShowMeSafeboxPassword&quot;	: self.AskSafeboxPassword,
			&quot;CloseSafebox&quot;			: self.CommandCloseSafebox,

# ITEM_MALL
			&quot;CloseMall&quot;				: self.CommandCloseMall,
			&quot;ShowMeMallPassword&quot;	: self.AskMallPassword,
			&quot;item_mall&quot;				: self.__ItemMall_Open,
			# END_OF_ITEM_MALL

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

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

# PRIVATE_SHOP_PRICE_LIST
			&quot;MyShopPriceList&quot;		: self.__PrivateShop_PriceList,
			# END_OF_PRIVATE_SHOP_PRICE_LIST
			&quot;SetItemShopCash&quot;          : self.interface.wndItemShop.SetCash,
			&quot;OpenShopWindow&quot;            : self.interface.wndItemShop.Open,
			&quot;SetItemShopItems&quot;          : self.interface.wndItemShop.AddItem,
			&quot;UpdateItemShopItem&quot;        : self.interface.wndItemShop.UpdateItem,
			&quot;ClearItemShopItems&quot;        : self.interface.wndItemShop.ClearItems,
			&quot;RefreshItemShopPage&quot;       : self.interface.wndItemShop.RefreshPage,
			&quot;DeleteItemShopItem&quot;        : self.interface.wndItemShop.DeleteItem,
			&quot;ItemShopEditor&quot;            : self.interface.wndItemShop.SetEditorFlag,
			
			# Zapisywanie pozycji
			&quot;SavePosition&quot;			: self.ZapisanePozycje1,
			&quot;SaveMapNames&quot;			: self.ZapisaneNazwyMap,
			# koniec zapisu
			
			#biolog
			&quot;Biolog&quot;				: self.__Biolog,
			&quot;Biolog_hide&quot;			: self.__BiologHide,
			&quot;Biolog_status&quot;			: self.__Biolog_status,
			# koniec biologa
			# Teleport
			&quot;Teleport&quot;				: self.Teleport,
			# koniec teleportu
		}

if app.ENABLE_OFFLINE_SHOP:
			serverCommandList.update({&quot;offlineshop_info&quot; : self.AppendOfflineShopInfo })
		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 &quot; BINARY_ServerCommand_Run&quot;, line
			return self.serverCommander.Run(line)
		except RuntimeError, msg:
			dbg.TraceError(msg)
			return 0

def __ProcessPreservedServerCommand(self):
		try:
			command = net.GetPreservedServerCommand()
			while command:
				print &quot; __ProcessPreservedServerCommand&quot;, 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(&quot;sound/ui/make_soket.wav&quot;)
		self.PopupMessage(localeInfo.REFINE_SUCCESS)

def RefineFailedMessage(self):
		snd.PlaySound(&quot;sound/ui/jaeryun_fail.wav&quot;)
		self.PopupMessage(localeInfo.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 = ( &quot;metin2_map_n_flame_01&quot;,
					&quot;metin2_map_n_desert_01&quot;,
					&quot;metin2_map_spiderdungeon&quot;,
					&quot;metin2_map_deviltower1&quot;, )

if background.GetCurrentMapName() in mapDict:
			return False

return True

def __XMasSnow_Enable(self, mode):

self.__XMasSong_Enable(mode)

if &quot;1&quot;==mode:

if not self.__IsXMasMap():
				return

print &quot;XMAS_SNOW ON&quot;
			background.EnableSnow(1)

else:
			print &quot;XMAS_SNOW OFF&quot;
			background.EnableSnow(0)

def __XMasBoom_Enable(self, mode):
		if &quot;1&quot;==mode:

if not self.__IsXMasMap():
				return

print &quot;XMAS_BOOM ON&quot;
			self.__DayMode_Update(&quot;dark&quot;)
			self.enableXMasBoom = True
			self.startTimeXMasBoom = app.GetTime()
		else:
			print &quot;XMAS_BOOM OFF&quot;
			self.__DayMode_Update(&quot;light&quot;)
			self.enableXMasBoom = False

def __XMasTree_Enable(self, grade):

print &quot;XMAS_TREE &quot;, grade
		background.SetXMasTree(int(grade))

def __XMasSong_Enable(self, mode):
		if &quot;1&quot;==mode:
			print &quot;XMAS_SONG ON&quot;

XMAS_BGM = &quot;xmas.mp3&quot;

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

musicInfo.fieldMusic=XMAS_BGM
				snd.FadeInMusic(&quot;BGM/&quot; + musicInfo.fieldMusic)

else:
			print &quot;XMAS_SONG OFF&quot;

if musicInfo.fieldMusic != &quot;&quot;:
				snd.FadeOutMusic(&quot;BGM/&quot; + musicInfo.fieldMusic)

musicInfo.fieldMusic=musicInfo.METIN2THEMA
			snd.FadeInMusic(&quot;BGM/&quot; + 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
	if app.ENABLE_OFFLINE_SHOP:
		def __PrivateShop_Open(self, hasCoin, hasGoldbar, hasWon):
			self.interface.OpenPrivateShopInputNameDialog(hasCoin, hasGoldbar, hasWon)
	else:
		def __PrivateShop_Open(self):
			self.interface.OpenPrivateShopInputNameDialog()

def BINARY_PrivateShop_Appear(self, vid, text):
		if app.ENABLE_OFFLINE_SHOP:
			fmName = &quot;%s's Offline shop&quot; % player.GetName()
			if (systemSetting.IsShowOfflineShop() != 1 and not player.IsMainCharacterIndex(vid)) and (systemSetting.IsShowOfflineShop() == 2 and chr.GetNameByVID(vid) != fmName):
				return
			if chr.GetVirtualNumber(vid) &lt; 30000:
				return
		self.interface.AppearPrivateShop(vid, text)

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

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

if not self.__IsXMasMap():
				return

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

def __DayMode_Update(self, mode):
		if &quot;light&quot;==mode:
			self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)
		elif &quot;dark&quot;==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 &gt;= 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 &gt; 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, &quot;sound/common/etc/salute.mp3&quot;)

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(&quot;/party_request_accept &quot; + str(vid))
		else:
			net.SendChatPacket(&quot;/party_request_deny &quot; + str(vid))

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

def __PartyRequestDenied(self):
		self.PopupMessage(localeInfo.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(&quot;BGM/&quot; + filename)
		else:
			snd.FadeOutAllMusic()
			musicInfo.LoadLastPlayFieldMusic()
			snd.FadeInMusic(&quot;BGM/&quot; + musicInfo.fieldMusic)
			
	if app.ENABLE_SASH_SYSTEM:
		def ActSash(self, iAct, bWindow):
			if self.interface:
				self.interface.ActSash(iAct, bWindow)

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

# END_OF_WEDDING
	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({&quot;items&quot; : []})
			curList = constInfo.MONSTER_INFO_DATA[raceNum][&quot;items&quot;]

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(&quot;vnum_list&quot;) and curItem[&quot;vnum_list&quot;][0] / 10 * 10 == itemVnum / 10 * 10:
						if not (itemVnum in curItem[&quot;vnum_list&quot;]):
							curItem[&quot;vnum_list&quot;].append(itemVnum)
						return
				elif isMetin:
					if curItem.has_key(&quot;vnum_list&quot;):
						baseVnum = curItem[&quot;vnum_list&quot;][0]
					if curItem.has_key(&quot;vnum_list&quot;) and (baseVnum - baseVnum%1000) == (itemVnum - itemVnum%1000):
						if not (itemVnum in curItem[&quot;vnum_list&quot;]):
							curItem[&quot;vnum_list&quot;].append(itemVnum)
						return
				else:
					if curItem.has_key(&quot;vnum&quot;) and curItem[&quot;vnum&quot;] == itemVnum and curItem[&quot;count&quot;] == itemCount:
						return

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

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

def __setWyplacanieYangOffline(self, value):
		constInfo.OFFLINE_WYPLACANIE_YANG = int(value)

def __odbieranie_itemshop(self, value):
		constInfo.OdbieranieIs = int(value)
		
	def ClickPoliShopButton(self):
		if FALSE == player.IsObserverMode():
			self.SklepP.Show()
			
	def BoostWindowShopButton(self):
		if FALSE == player.IsObserverMode():
			self.BoostWindow.Show()
			
	def MarmurShop(self, qid):
		constInfo.MarmurShopQuest = int(qid)
		
	def GetInputStart(self):
		constInfo.INPUT_IGNORE = 1
		
	def ShowPositionWindow(self):		
		self.wndPosition.Show()
 
	def ShowPositionWindow(self):		
		self.wndPosition.Show()
 
	def GetInputStop(self):
		constInfo.INPUT_IGNORE = 0
 
	def GetInput(self):
		net.SendQuestInputStringPacket(str(constInfo.INPUT_DATA))
		
	def ShowDaily(self):
		self.wndDaily.Show()
		
	def __Daily_Update(self, arg):
		data = arg.split(&quot;|&quot;)
		constInfo.DAILY_DAY = int(data[0])
		constInfo.DAILY_TIME = int(data[1])
		
	def __Biolog(self, arg):
		data = arg.split(&quot;|&quot;)
		constInfo.BIOLOG_ITEM = int(data[0])
		constInfo.BIOLOG_TIME = int(data[1])
		constInfo.BIOLOG_COUNT = int(data[2])
		constInfo.BIOLOG_SZANSA = int(data[3])

def __Biolog_status(self, arg):
		constInfo.BIOLOG_STATUS = int(arg)

def __BiologHide(self, arg):
		constInfo.BIOLOG_ITEM = int(arg)
		self.interface.HideBiologWindow()
		
	def ZapisanePozycje1(self, qid):
		constInfo.ZapiszPozycje = int(qid)
		
	def ZapisaneNazwyMap(self, data):
		constInfo.SAVE_MAP_NAME = data
		self.wndPosition.UpdateMapNames()
		
	def Teleport(self, getString): 
		if getString.find(&quot;index&quot;) != -1: 
			self.teleport.UpdateIndex(int(getString.split(&quot;x&quot;)[1])) 
		else: 
			constInfo.SendString = str(self.teleport.SendToServer) 
			constInfo.CApiSetHide = 1
	
	def GetInputValue(self):
		net.SendQuestInputStringPacket(str(constInfo.VIDT))
		
	def TombolaSetEnable(self):
		constInfo.wndTombola.EnableButton()
	
	def	__OpenTombola(self):
		constInfo.wndTombola.Open()
		
	def __PrepareTombola(self, data):
		constInfo.wndTombola.OnPrepare(str(data))
		
	def __RunTombola(self, number):
		constInfo.wndTombola.OnRun(str(number))
		
	def SetTombola(self, qid):
		constInfo.TOMBOLA = int(qid)

Private - Private paste aren't shown in recent listings.

Delete After - When should we delete your paste?

Spam protection -

Reply to "Untitled"