Dungeon Info System in key

Kenma · July 19, 2022

hello someone can help me with this error ? of the dungeon system

https://metin2.download/picture/4mTQR5W4Lc2rV4cS6hz93x5nr42i3VQS/.png

Quote

0719 19:04:07268 ::
networkModule.py(line:200) SetSelectCharacterPhase
system.py(line:177) __hybrid_import
system.py(line:142) _process_result
introSelect.py(line:28) <module>
system.py(line:177) __hybrid_import
system.py(line:142) _process_result
interfaceModule.py(line:33) <module>
system.py(line:177) __hybrid_import

networkModule.SetSelectCharacterPhase - <type 'exceptions.IndentationError'>:unexpected indent (uiMiniMap.py, line 275)

0719 19:04:07268 :: ============================================================================================================
0719 19:04:07268 :: Abort!!!!

game.py

Quote

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 uiGift
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 time
import uiScriptLocale

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

import uiDungeonInfo
# 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

svsidedia = None
svsidedi_cp = ""
from svsideoi import SvsideDialog
import binascii

import uitombola
if app.ENABLE_INGAME_ITEMSHOP:
   import uiitemshop

from _weakref import proxy

from uniswitchbot import Bot

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

# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = False
SCREENSHOT_DIR = None

if localeInfo.IsEUROPE():
   SCREENSHOT_CWDSAVE = True

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

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

testAlignment = 0
# PROFESSIONAL_BIOLOG_SYSTEM
if app.ENABLE_BIOLOG_SYSTEM:
   import uiprofessionalbiolog
# END_OF_PROFESSIONAL_BIOLOG_SYSTEM

class GameWindow(ui.ScriptWindow):
   def __init__(self, stream):
       ui.ScriptWindow.__init__(self, "GAME")
       self.SetWindowName("game")
       net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
       player.SetGameWindow(self)
       self.utilizareTaste = time.clock() + 4

       global svsidedia
       if svsidedia == None:
           svsidedia = SvsideDialog()
       svsidedia.Board.Hide()

       self.quickSlotPageIndex = 0
       self.lastPKModeSendedTime = 0
       self.pressNumber = None
       self.uiNewShopCreate = None
       self.uiNewShop = 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()

       import uitombola
       constInfo.wndTombola = uitombola.TombolaWindow()

       if app.ENABLE_MAINTENANCE_SYSTEM:
           import uimaintenance
           self.wndMaintenance = uimaintenance.MaintenanceClass()

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

       #wj 2014.1.2. ESCÅ°¸¦ ´©¸¦ ½Ã ¿ì¼±ÀûÀ¸·Î DropQuestionDialog¸¦ ²ôµµ·Ï ¸¸µé¾ú´Ù. ÇÏÁö¸¸ Ã³À½¿¡ itemDropQuestionDialog°¡ ¼±¾ðµÇ¾î ÀÖÁö ¾Ê¾Æ ERROR°¡ ¹ß»ýÇÏ¿© init¿¡¼ ¼±¾ð°ú µ¿½Ã¿¡ ÃÊ±âÈ ½ÃÅ´.
       self.itemDropQuestionDialog = None

       self.__SetQuickSlotMode()

       self.__ServerCommand_Build()
       self.__ProcessPreservedServerCommand()
       self.uniswitchbot = Bot()
       self.uniswitchbot.Hide()

       if app.ENABLE_INGAME_ITEMSHOP:
           self.itemshop = uiitemshop.Itemshop()
           self.itemshop.Hide()

   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 uiNewShop
       self.uiNewShop = uiNewShop.ShopDialog()
       self.uiNewShop.Close()
       self.uiNewShopCreate = uiNewShop.ShopDialogCreate()
       self.uiNewShopCreate.Hide()

       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

       self.ToggleFPSInfo()

       ## 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°¡ Å¥ºê½Ã½ºÅÛÀ¸·Î ¸¸µé ¼ö ÀÖ´Â ¾ÆÀÌÅÛµéÀÇ ¸ñ·ÏÀ» Ä³½Ì
       # ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
       self.cubeInformation = {}
       self.currentCubeNPC = 0

       #GUERRA DAS INSIGNIAS
       espacio_insignia = ui.AniImageBox()
       espacio_insignia.SetWindowHorizontalAlignLeft()
       espacio_insignia.SetWindowVerticalAlignTop()
       espacio_insignia.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")
       self.espacio_insignia = espacio_insignia
       self.espacio_insignia.SetPosition(10, 80)

       imagen_insignia = ui.AniImageBox()
       imagen_insignia.SetWindowHorizontalAlignLeft()
       imagen_insignia.SetWindowVerticalAlignTop()
       imagen_insignia.AppendImage("icon/item/insignia.dds")
       self.imagen_insignia = imagen_insignia
       self.imagen_insignia.SetPosition(10, 80)

       self.numero_insignia = ui.TextLine()
       self.numero_insignia.SetWindowHorizontalAlignLeft()
       self.numero_insignia.SetWindowVerticalAlignTop()
       self.numero_insignia.SetDefaultFontName()
       self.numero_insignia.SetPosition(10, 80)
       self.numero_insignia.SetText("0")
       self.numero_insignia.SetOutline()
       #FIANL DA GUERRA

   def Close(self):
       self.Hide()
       #GUERRA INSIGNIA
       self.__ocultar_insignia()
       #GUERRA INSIGNIA FIM

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

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

       self.onPressKeyDict = None
       self.onClickKeyDict = None

       chat.Close()
       snd.StopAllSound()
       grp.InitScreenEffect()
       chr.Destroy()
       textTail.Clear()
       quest.Clear()
       background.Destroy()
       guild.Destroy()
       messenger.Destroy()
       skill.ClearSkillData()
       self.uiNewShop.Hide()
       self.uiNewShopCreate.Hide()
       uiPrivateShopBuilder.Clear()
       wndMgr.Unlock()
       mouseModule.mouseController.DeattachObject()
       constInfo.wndTombola.Close()

       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 app.ENABLE_MAINTENANCE_SYSTEM:
           if self.wndMaintenance.IsShow():
               self.wndMaintenance.Hide()

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

       player.ClearSkillDict()
       player.ResetCameraRotation()

       self.KillFocus()
       app.HideCursor()

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

   def __BuildKeyDict(self):
       onPressKeyDict = {}

       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.ToggleSwitchbotWindow()
       onPressKeyDict[app.DIK_F6]   = lambda : self.__toggleSwitchbot()
       onPressKeyDict[app.DIK_F7]   = lambda : self.__toggleIS()
#onPressKeyDict[app.DIK_F8]   = lambda : self.__DungeonInfo() example to button need func
       onPressKeyDict[app.DIK_F9]   = lambda : self.EventCalendar()

       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_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_K]           = lambda : self.interface.ToggleSpecialStorageWindow()
       #onPressKeyDict[app.DIK_H]           = lambda : self.interface.OpenHelpWindow()
       onPressKeyDict[app.DIK_ADD]           = lambda : self.interface.MiniMapScaleUp()
       onPressKeyDict[app.DIK_SUBTRACT]   = lambda : self.interface.MiniMapScaleDown()
       onPressKeyDict[app.DIK_L]           = lambda : self.interface.ToggleChatLogWindow()
       onPressKeyDict[app.DIK_COMMA]       = lambda : self.ShowConsole()       # "`" key
       onPressKeyDict[app.DIK_LSHIFT]       = lambda : self.__SetQuickPageMode()

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

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

       self.onPressKeyDict = onPressKeyDict

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

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

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

       self.onClickKeyDict=onClickKeyDict

   def __PressNumKey(self,num):
       if time.clock() >= self.utilizareTaste:
               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)
       else:
           chat.AppendChat(chat.CHAT_TYPE_INFO, "Vá com calma, você está rápido demais...")

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

   def   __PressJKey(self):
       if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
           if player.IsMountingHorse():
               net.SendChatPacket("/unmount")
           else:
               #net.SendChatPacket("/user_horse_ride")
               if not uiPrivateShopBuilder.IsBuildingPrivateShop():
                   for i in xrange(player.INVENTORY_PAGE_SIZE*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)

   if app.ENABLE_MAINTENANCE_SYSTEM:
       def BINARY_Update_Target(self):
           if self.wndMaintenance.IsShow():
               self.targetBoard.ResetPositions("change_pos")
           else:
               self.targetBoard.ResetPositions("default_pos")

   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 __PressQuickSlot(self, localSlotIndex):
       if time.clock() >= self.utilizareTaste:
           player.RequestUseLocalQuickSlot(localSlotIndex)
       else:
           chat.AppendChat(chat.CHAT_TYPE_INFO, "Vá com calma, você está rápido demais...")

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

   def ToggleFPSInfo(self):
       self.FrameRate.Show()

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

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

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

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

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

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

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

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

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

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

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

   def ChangePKMode(self):

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

       if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
           self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
           return

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

       self.lastPKModeSendedTime = curTime

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

       elif nextPKMode == player.PK_MODE_MAX_NUM:
           nextPKMode = 0

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

   def OnChangePKMode(self):

       self.interface.OnChangePKMode()

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

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

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

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

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

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

   def RefreshStatus(self):
       self.CheckGameButton()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   def OpenQuestWindow(self, skin, idx):
       if constInfo.INPUT_IGNORE == 1:
           return
       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 name.find("<svside>") != -1:
           global svsidedia
           if line[line.find(",")-4:line.find(",")].isdigit():
               svsidedia.nm_updateimgoffline(line[line.find(", ")-4:line.find(", ")])
           else:
               svsidedia.Board.Hide()
           return
       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
   def StartShop(self, vid):
       self.interface.OpenShopDialog(vid)

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

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

   def SetShopSellingPrice(self, Price):
       pass

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

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

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

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

   def AnswerPartyInvite(self, answer):

       if not self.partyInviteQuestionDialog:
           return

       partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

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

       net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   def AnswerGuildInvite(self, answer):

       if not self.guildInviteQuestionDialog:
           return

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

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

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

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

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

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

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

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

           self.SetFocus()

   def SaveScreen(self):
       print "save screen"

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

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

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

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

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

   # ADD_ALWAYS_SHOW_NAME
   def __IsShowName(self):

       if systemSetting.IsAlwaysShowName():
           return True

       if self.ShowNameFlag:
           return True

       return False
   # END_OF_ADD_ALWAYS_SHOW_NAME

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

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

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

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

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

   if app.ENABLE_MAINTENANCE_SYSTEM:
       def BINARY_Update_Maintenance(self, iTime, iDuration, iReason):
           sTime = int(iTime)
           sDuration = int(iDuration)
           sReason = str(iReason)

           if sTime != 0 and sDuration != 0:
               self.wndMaintenance.OpenMaintenance(int(iTime), int(iDuration), str(iReason))

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

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

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

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

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

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

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

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

   def PickUpItem(self):
       player.PickCloseItem()

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

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

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

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

       return True

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

       return True

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

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

       return True

   def OnMouseLeftButtonUp(self):

       if self.interface.BUILD_OnMouseLeftButtonUp():
           return

       if mouseModule.mouseController.isAttached():

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

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

           if app.ENABLE_LSM2_NEW_STORAGE:
               if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
                   player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
                   player.SLOT_TYPE_STONE_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 app.ENABLE_LSM2_NEW_STORAGE:
           if player.SLOT_TYPE_INVENTORY == attachedType or\
               player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType or\
               player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
               player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
               player.SLOT_TYPE_STONE_INVENTORY == attachedType:
               attachedInvenType = player.SlotTypeToInvenType(attachedType)
               if True == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
                   if player.IsEquipmentSlot(attachedItemSlotPos) and\
                       player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType and\
                       player.SLOT_TYPE_UPGRADE_INVENTORY != attachedType and\
                       player.SLOT_TYPE_BOOK_INVENTORY != attachedType and\
                       player.SLOT_TYPE_STONE_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)
       else:
           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 - °³ÀÎ»óÁ¡ ¿°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö
       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.QuestionDialogItem()
       itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_MONEY % (attachedMoney))
       itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
       itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))
       itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
       itemDropQuestionDialog.Open()
       itemDropQuestionDialog.dropType = attachedType
       itemDropQuestionDialog.dropCount = attachedMoney
       itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
       self.itemDropQuestionDialog = itemDropQuestionDialog

   def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
       # PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀÎ»óÁ¡ ¿°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö
       if uiPrivateShopBuilder.IsBuildingPrivateShop():
           chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
           return
       # 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 = uiCommon.QuestionDialogItem()
               itemDropQuestionDialog.SetText(questionText)
               itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
               itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))
               itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
               itemDropQuestionDialog.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 = uiCommon.QuestionDialogItem()
               itemDropQuestionDialog.SetText(questionText)
               itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
               itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))
               itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
               itemDropQuestionDialog.Open()
               itemDropQuestionDialog.dropType = attachedType
               itemDropQuestionDialog.dropNumber = attachedItemSlotPos
               itemDropQuestionDialog.dropCount = attachedItemCount
               self.itemDropQuestionDialog = itemDropQuestionDialog

               constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

           if app.ENABLE_LSM2_NEW_STORAGE:
               if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
                   player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
                   player.SLOT_TYPE_STONE_INVENTORY == attachedType:
                   dropItemIndex = player.GetItemIndex(player.SlotTypeToInvenType(attachedType), attachedItemSlotPos)

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

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

                   ## Dialog
                   itemDropQuestionDialog = uiCommon.QuestionDialogItem()
                   itemDropQuestionDialog.SetText(questionText)
                   itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
                   itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(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
           if app.ENABLE_LSM2_NEW_STORAGE:
               if player.SLOT_TYPE_UPGRADE_INVENTORY == dropType or\
                   player.SLOT_TYPE_BOOK_INVENTORY == dropType or\
                   player.SLOT_TYPE_STONE_INVENTORY == dropType:
                   self.__SendDropItemPacket(dropNumber, dropCount, player.SlotTypeToInvenType(dropType))

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

       constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

   # PRIVATESHOP_DISABLE_ITEM_DROP
#fix_destroy_item
   def RequestDestroyItem(self, answer):
       if not self.itemDropQuestionDialog:
           return
       if answer:
           dropType = self.itemDropQuestionDialog.dropType
           dropNumber = self.itemDropQuestionDialog.dropNumber
           if player.SLOT_TYPE_INVENTORY == dropType:
               if dropNumber == player.ITEM_MONEY:
                   return
               else:
                   self.__SendDestroyItemPacket(dropNumber)

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

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

       net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
   # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

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

       net.SendItemDestroyPacket(itemVNum)

   def OnMouseRightButtonDown(self):

       self.CheckFocus()

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

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

       return True

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

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

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

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

   def OnUpdate(self):
       app.UpdateGame()

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

       if self.isShowDebugInfo:
           self.UpdateDebugInfo()

       if self.enableXMasBoom:
           self.__XMasBoom_Update()

       self.interface.BUILD_OnUpdate()

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

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

       ## Show all name in the range

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

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

       grp.PopState()
       grp.SetInterfaceRenderState()

       textTail.Render()
       textTail.HideAllTextTail()

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

       if constInfo.wndTombola.IsShow():
           constInfo.wndTombola.Close()

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

   # Á¦ÀÛ¿¡ ÇÊ¿äÇÑ °ñµå, ¿¹»óµÇ´Â ¿Ï¼ºÇ°ÀÇ VNUM°ú °³¼ö Á¤º¸ update
   def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
       self.interface.UpdateCubeInfo(gold, itemVnum, count)

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

   def BINARY_Cube_Failed(self):
       print "Å¥ºê Á¦ÀÛ ½ÇÆÐ"
       self.interface.FailedCubeWork()
       pass

   def BINARY_Cube_ResultList(self, npcVNUM, listText):
       # ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 ÀÌ·±½ÄÀ¸·Î "/" ¹®ÀÚ·Î ±¸ºÐµÈ ¸®½ºÆ®¸¦ ÁÜ
       #print listText

       if npcVNUM == 0:
           npcVNUM = self.currentCubeNPC

       self.cubeInformation[npcVNUM] = []

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

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

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

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

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

       pass

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

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

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

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

   def BINARY_GuildWar_OnSendDeclare(self, guildID):
       pass

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

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

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

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

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

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

###################################################################
# title_name       : Professional Biolog System
# date_created       : 2016.08.07
# filename           : game.py
# author           : VegaS
# version_actual   : Version 0.0.8
#
   # PROFESSIONAL_BIOLOG_SYSTEM
   if app.ENABLE_BIOLOG_SYSTEM:
       def BINARY_Biolog_Update(self, pLeftTime, pCountActual, pCountNeed, pVnum):
           uiprofessionalbiolog.BIOLOG_BINARY_LOADED["time"][0] = int(pLeftTime) + app.GetGlobalTimeStamp()
           uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countActual"][0] = str(pCountActual)
           uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countNeed"][0] = str(pCountNeed)
           uiprofessionalbiolog.BIOLOG_BINARY_LOADED["vnum"][0] = int(pVnum)

       def BINARY_Biolog_SendMessage(self, pMessage):
           if str(pMessage) != "":
               self.wndBiologMessage = uiCommon.PopupDialog()
               self.wndBiologMessage.SetWidth(350)
               self.wndBiologMessage.SetText((str(pMessage).replace("$"," ")))
               self.wndBiologMessage.Show()
           else:
               chat.AppendChat(chat.CHAT_TYPE_INFO, "Error, i could not initialize message from server!")

       def BINARY_Biolog_PopUp(self, iRewardType, iRewardItem, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2):
           self.wndBiologSlider = uiprofessionalbiolog.Biolog_FinishSlider()
           self.wndBiologSlider.BINARY_BiologPopUp_Load([str(iRewardType), int(iRewardItem), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2)])
           self.wndBiologSlider.Show()

       def BINARY_Biolog_SelectReward(self, iTypeWindow, iRewardType, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2, iBonusName_3, iBonusValue_3):
           self.wndBiologSelectReward = uiprofessionalbiolog.Biolog_SelectReward()
           self.wndBiologSelectReward.Open_SelectRewardType([int(iTypeWindow), str(iRewardType), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2), str(iBonusName_3), int(iBonusValue_3)])
           self.wndBiologSelectReward.SetTitle((str(iRewardType).replace("$"," ")))
           self.wndBiologSelectReward.SetCenterPosition()
           self.wndBiologSelectReward.SetTop()
           self.wndBiologSelectReward.Show()
   # END_OF_PROFESSIONAL_BIOLOG_SYSTEM

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

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

   def __GuildWar_OpenAskDialog(self, guildID, warType):

       guildName = guild.GetGuildName(guildID)

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

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

       self.guildWarQuestionDialog = questionDialog

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

   def __GuildWar_OnAccept(self):

       guildName = self.guildWarQuestionDialog.GetGuildName()

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

       return 1

   def __GuildWar_OnDecline(self):

       guildName = self.guildWarQuestionDialog.GetGuildName()

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

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

   def __ServerCommand_Build(self):
       serverCommandList={
           "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,

           ##NEW SHOP
           "shop"       :self.NewShop,
           "shop_clear"       :self.ShopClear,
           "shop_add"       :self.ShopAdd,
           "shop_item"       :self.ShopItem,
           "shop_cost"       :self.ShopCost,
           "shop_cost_clear"       :self.ShopCostClear,
           "shop_item_clear"   :self.ShopItemClear,

           #####GIFT SYSTEM
           "gift_clear"       :self.gift_clear,
           "gift_item"       :self.gift_item,
           "gift_info"       :self.gift_show,
           "gift_load"       :self.gift_load,

           # 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,
           # PROFESSIONAL_BIOLOG_SYSTEM
           "BINARY_Biolog_Update"   :   self.BINARY_Biolog_Update,
           "BINARY_Biolog_SendMessage"   :   self.BINARY_Biolog_SendMessage,
           "BINARY_Biolog_PopUp"   :   self.BINARY_Biolog_PopUp,
           "BINARY_Biolog_SelectReward"   :   self.BINARY_Biolog_SelectReward,
           # END_OF_PROFESSIONAL_BIOLOG_SYSTEM

           "BINARY_Update_Maintenance"   :   self.BINARY_Update_Maintenance,

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

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

           # GUERRA DAS INSIGNIAS
           "guerra_insignia"                       : self.__guerra_insignia,
           "item_insignia"                           : self.__item_insignia,
           "mostrar_insignia"                       : self.__mostrar_insignia,
           # FINAL DA GUERRA

           # Batalha no Coliseu
           "SetColiseuModFree"                       : self.__SetColiseuModFree,
           "SetColiseuGetInputOn"                   : self.__SetColiseuGetInputOn,
           "SetColiseuGetInputOff"                   : self.__SetColiseuGetInputOff,
           "BlockCriarGrupo"                       : self.__BlockCriarGrupo,
           "CriarGrupoOK"                           : self.__CriarGrupoOK,

           # Tombola
           "tombola"               : self.SetTombola,
           "OnPrepare"               : self.__PrepareTombola,
           "OnRun"                   : self.__RunTombola,
           "openTombola"           : self.__OpenTombola,
           "closeTombola"           : self.__CloseTombola,
           "SetEnable"               : self.SetEnable,

           #input
           "get_input_value"               : self.GetInputValue,
           "get_input_start"               : self.GetInputOn,
           "get_input_end"                   : self.GetInputOff,

       }

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

   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 NewShop(self):
       if self.uiNewShop:
           self.uiNewShop.Show()

   def ShopClear(self):
       if self.uiNewShop:
           self.uiNewShop.HideAll()
       constInfo.MyShops=[]

   def ShopCostClear(self):
       constInfo.shop_cost=[]

   def ShopCost(self,id,time,time_val,price):
       constInfo.shop_cost.append({"id":int(id),"time":int(time),"time_val":int(time_val),"price":int(price)})

   def ShopAdd(self,shop_id,shop_vid,szSign,gold,count,sold,days,date_close):
       if self.uiNewShop:
           shop={
               "id":shop_id,
               "vid":shop_vid,
               "name":szSign.replace("\\"," ").replace("_","#"),
               "gold":gold,
               "sold":sold,
               "items":int(count)-int(sold),
               "days":days,
               "time":date_close
           }
           self.uiNewShop.Load(shop)
           constInfo.MyShops.append(shop)

   def ShopItemClear(self):
       if self.uiNewShop:
           self.uiNewShop.ClearItems()

   def ShopItem(self,data):
       d=data.split("#")
       id=d[0]
       vnum=d[1]
       count=d[2]
       slot=d[3]
       price=d[4]
       s=d[5]
       a=d[6]
       sockets=[]
       for key in s.split("|"):
           sockets.append(int(key))

       attrs=[]
       for key in a.split("|"):
           a=key.split(",")
           attrs.append([int(a[1]),int(a[0])])
       if self.uiNewShop:
           self.uiNewShop.AddItem(slot,{"id":id,"vnum":vnum,"count":count,"price":price,"sockets":sockets,"attrs":attrs})

   ####GIFT SYSTEM#####
   def gift_clear(self):
       constInfo.gift_items={}
       self.interface.ClearGift()
   def gift_item(self, id, vnum, count, pos, date_add, give, reason, szSockets, szAttrs):
       sockets=[]
       for key in szSockets.split("|"):
           sockets.append(int(key))

       attrs=[]
       for key in szAttrs.split("|"):
           a=key.split(",")
           attrs.append([int(a[0]),int(a[1])])
       constInfo.gift_items[int(pos)]={"id":int(id),"vnum":int(vnum),"count":int(count),"pos":int(pos),"date_add":int(date_add),"reason":reason.replace("_"," "),"give":give.replace("_"," "),"sockets":sockets,"attrs":attrs}
   def gift_load(self):
       self.interface.wndGiftBox.Refresh()
   def gift_show(self,pages):
       self.interface.wndGiftBox.pageNum=int(pages)
       self.interface.OpenGift()

   def __XMasSnow_Enable(self, mode):

       self.__XMasSong_Enable(mode)

       if "1"==mode:

           if not self.__IsXMasMap():
               return

           print "XMAS_SNOW ON"
           background.EnableSnow(1)

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

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

           if not self.__IsXMasMap():
               return

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

   def __XMasTree_Enable(self, grade):

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

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

           XMAS_BGM = "xmas.mp3"

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

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

       else:
           print "XMAS_SONG OFF"

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

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

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

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

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

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

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

   if app.BL_KILL_BAR:
       def AddKillInfo(self, killer, victim, killer_race, victim_race, weapon_type):
           if self.interface:
               self.interface.AddKillInfo(killer, victim, killer_race, victim_race, weapon_type)

   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)

   def AdminWhisper(self, admin, text): # Nome a ser chamado
       txt = str(text) # A mensagem em si
       show = txt.replace("_", " ") # Os _ são substituidos por espaço
       name = "|cFFFF8C00|H|h[%s]|h|r" % (admin) # Cor semelhante a de um Game Master + o nome proveniente do servidor

       chat.AppendWhisper(chat.WHISPER_TYPE_GM, name, show) # É enviado a mensagem com carácter GM
       self.interface.RecvWhisper(name) # É anúnciado da mesma forma que uma mensagem normal

   if app.ENABLE_ACCE_COSTUME_SYSTEM:
       def ActAcce(self, iAct, bWindow):
           if self.interface:
               self.interface.ActAcce(iAct, bWindow)

       def AlertAcce(self, bWindow):
           snd.PlaySound("sound/ui/make_soket.wav")
           if bWindow:
               self.PopupMessage(localeInfo.ACCE_DEL_SERVEITEM)
           else:
               self.PopupMessage(localeInfo.ACCE_DEL_ABSORDITEM)

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

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

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

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

   # Bot de Rodar
   def __toggleSwitchbot(self):
       if self.uniswitchbot.bot_shown == 1:
           self.uniswitchbot.Hide()
       else:
           self.uniswitchbot.Show()
   # End Bot de Rodar

   #GUERRA INSIGNIA
   def __guerra_insignia(self, id):
       constInfo.guerra_insignia = int(id)

   def __item_insignia(self, item_insignia):
       self.numero_insignia.SetText(item_insignia)

   def __mostrar_insignia(self):
       self.imagen_insignia.Show()
       self.espacio_insignia.Show()
       self.numero_insignia.Show()

   def __ocultar_insignia(self):
       self.imagen_insignia.Hide()
       self.espacio_insignia.Hide()
       self.numero_insignia.Hide()

   def rinne(self):
       def rinne2():
           for i in xrange(player.INVENTORY_PAGE_SIZE*4):
               if player.GetItemIndex(i) in (999017,):
                   net.SendItemUsePacket(i)
       def rinne3():
           import time
           import threading
           t=threading.Timer(1.0,rinne2)
           t.start()
       rinne3()
   #FINAL GUERRA INSIGNIA

   if app.ENABLE_EXTEND_INVEN_SYSTEM:
       def BINARY_Expand_Refresh(self):
           if self.interface:
               self.interface.SetInventoryPageKilit()

       def BINARY_Expand_Fail(self, lazim):
           self.wndPopupDialog = uiCommon.PopupDialog()
           self.wndPopupDialog.SetText(localeInfo.EXINVEN_USE_ITEM_FAIL_FALL_SHORT % lazim)
           self.wndPopupDialog.Open()

       def BINARY_Expand_Full(self):
           self.wndPopupDialog = uiCommon.PopupDialog()
           self.wndPopupDialog.SetText(localeInfo.EXINVEN_USE_ITEM_FAIL_FOURTH_PAGE_STAGE_MAX)
           self.wndPopupDialog.Open()

   ### Batalha no Coliseu ---------------
   def __SetColiseuModFree(self):
       net.SendChatPacket("/pkmode 2")

   def __SetColiseuGetInputOn(self):
       constInfo.INPUT_Coliseu = 1

   def __SetColiseuGetInputOff(self):
       constInfo.INPUT_Coliseu = 0

   def   __BlockCriarGrupo(self):
       constInfo.BLOCK_GRUPO = 1

   def   __CriarGrupoOK(self):
       constInfo.BLOCK_GRUPO = 0

   def __Input0(self):
       constInfo.INPUT_IGNORE = 0

   def __Input1(self):
       constInfo.INPUT_IGNORE = 1

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

   def __CloseTombola(self):
       constInfo.wndTombola.Close()

   def GetInputOn(self):
       constInfo.INPUT_IGNORE = 1

   def GetInputOff(self):
       constInfo.INPUT_IGNORE = 0

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

   def SetEnable(self):
       constInfo.wndTombola.Load()
   # Tombola

   if app.ENABLE_SWITCHBOT:
       def RefreshSwitchbotWindow(self):
           self.interface.RefreshSwitchbotWindow()

       def RefreshSwitchbotItem(self, slot):
           self.interface.RefreshSwitchbotItem(slot)

   if app.ENABLE_INGAME_ITEMSHOP:
       def __toggleIS(self):
           net.SendChatPacket("/open_is")

       def BINARY_ITEMSHOPNEW_OPEN(self):
           self.itemshop.OpenWindow()

       def BINARY_ITEMSHOPNEW_LIMITED_COUNT(self, _id, _count):
           self.itemshop.RECV_LIMITED_ITEM_COUNT(_id, _count)

   def EventCalendar(self):
       if self.interface:
           self.interface.EventCalendarGame()

   if app.ENABLE_DUNGEON_INFO_SYSTEM:
       def CleanDungeonInfo(self):
           import constInfo
           constInfo.dungeonInfo = []

       def UpdateDungeonInfo(self, type, organization, minLevel, partyMembers, mapIndex, mapName, mapEntrance, mapCoordX, mapCoordY, cooldown, duration, maxLevel, strengthBonus, resistanceBonus, itemVnum, bossVnum):
           type = int(type)
           organization = int(organization)
           minLevel = int(minLevel)
           partyMembers = int(partyMembers)
           mapName = str(mapName).replace("_", " ")
           mapEntrance = str(mapEntrance).replace("_", " ")
           mapIndex = int(mapIndex)
           mapCoordX = int(mapCoordX)
           mapCoordY = int(mapCoordY)
           cooldown = int(cooldown)
           duration = int(duration)
           maxLevel = int(maxLevel)
           strengthBonus = int(strengthBonus)
           resistanceBonus = int(resistanceBonus)
           itemVnum = int(itemVnum)

           constInfo.dungeonInfo.append(\
               {
                   "type" : type,\
                   "organization" : organization,\
                   "min_level" : minLevel,\
                   "party_members" : partyMembers,\
                   "map" : mapName,\
                   "entrance_map" : mapEntrance,\
                   "map_index" : mapIndex,\
                   "map_coord_x" : mapCoordX,\
                   "map_coord_y" : mapCoordY,\
                   "cooldown" : cooldown,\
                   "duration" : duration,\
                   "max_level" : maxLevel,\
                   "strength_bonus" : strengthBonus,\
                   "resistance_bonus" : resistanceBonus,\
                   "item_vnum" : itemVnum,\
                   "boss_vnum" : bossVnum,\
               },
           )

uiminimap.py

Quote

import ui
import uiScriptLocale
import wndMgr
import player
import miniMap
import localeInfo
import net
import app
import colorInfo
import constInfo
import background
if app.BL_KILL_BAR:
   import playersettingmodule
   import item
class MapTextToolTip(ui.Window):
   def __init__(self):
       ui.Window.__init__(self)

       textLine = ui.TextLine()
       textLine.SetParent(self)
       textLine.SetHorizontalAlignCenter()
       textLine.SetOutline()
       textLine.SetHorizontalAlignRight()
       textLine.Show()
       self.textLine = textLine

   def __del__(self):
       ui.Window.__del__(self)

   def SetText(self, text):
       self.textLine.SetText(text)

   def SetTooltipPosition(self, PosX, PosY):
       if localeInfo.IsARABIC():
           w, h = self.textLine.GetTextSize()
           self.textLine.SetPosition(PosX - w - 5, PosY)
       else:
           self.textLine.SetPosition(PosX - 5, PosY)

   def SetTextColor(self, TextColor):
       self.textLine.SetPackedFontColor(TextColor)

   def GetTextSize(self):
       return self.textLine.GetTextSize()

class AtlasWindow(ui.ScriptWindow):

   class AtlasRenderer(ui.Window):
       def __init__(self):
           ui.Window.__init__(self)
           self.AddFlag("not_pick")

       def OnUpdate(self):
           miniMap.UpdateAtlas()

       def OnRender(self):
           (x, y) = self.GetGlobalPosition()
           fx = float(x)
           fy = float(y)
           miniMap.RenderAtlas(fx, fy)

       def HideAtlas(self):
           miniMap.HideAtlas()

       def ShowAtlas(self):
           miniMap.ShowAtlas()

   def __init__(self):
       self.tooltipInfo = MapTextToolTip()
       self.tooltipInfo.Hide()
       self.infoGuildMark = ui.MarkBox()
       self.infoGuildMark.Hide()
       self.AtlasMainWindow = None
       self.mapName = ""
       self.board = 0

       ui.ScriptWindow.__init__(self)

   def __del__(self):
       ui.ScriptWindow.__del__(self)

   def SetMapName(self, mapName):
       if 949==app.GetDefaultCodePage():
           try:
               self.board.SetTitleName(localeInfo.MINIMAP_ZONE_NAME_DICT[mapName])
           except:
               pass

   def LoadWindow(self):
       try:
           pyScrLoader = ui.PythonScriptLoader()
           pyScrLoader.LoadScriptFile(self, "UIScript/AtlasWindow.py")
       except:
           import exception
           exception.Abort("AtlasWindow.LoadWindow.LoadScript")

       try:
           self.board = self.GetChild("board")

       except:
           import exception
           exception.Abort("AtlasWindow.LoadWindow.BindObject")

       self.AtlasMainWindow = self.AtlasRenderer()
       self.board.SetCloseEvent(self.Hide)
       self.AtlasMainWindow.SetParent(self.board)
       self.AtlasMainWindow.SetPosition(7, 30)
       self.tooltipInfo.SetParent(self.board)
       self.infoGuildMark.SetParent(self.board)
       self.SetPosition(wndMgr.GetScreenWidth() - 136 - 256 - 10, 0)
       self.Hide()

       miniMap.RegisterAtlasWindow(self)

   def Destroy(self):
       miniMap.UnregisterAtlasWindow()
       self.ClearDictionary()
       self.AtlasMainWindow = None
       self.tooltipAtlasClose = 0
       self.tooltipInfo = None
       self.infoGuildMark = None
       self.board = None

   def OnUpdate(self):

       if not self.tooltipInfo:
           return

       if not self.infoGuildMark:
           return

       self.infoGuildMark.Hide()
       self.tooltipInfo.Hide()

       if False == self.board.IsIn():
           return

       (mouseX, mouseY) = wndMgr.GetMousePosition()
       (bFind, sName, iPosX, iPosY, dwTextColor, dwGuildID) = miniMap.GetAtlasInfo(mouseX, mouseY)

       if False == bFind:
           return

       if "empty_guild_area" == sName:
           sName = localeInfo.GUILD_EMPTY_AREA

       if localeInfo.IsARABIC() and sName[-1].isalnum():
           self.tooltipInfo.SetText("(%s)%d, %d" % (sName, iPosX, iPosY))
       else:
           self.tooltipInfo.SetText("%s(%d, %d)" % (sName, iPosX, iPosY))

       (x, y) = self.GetGlobalPosition()
       self.tooltipInfo.SetTooltipPosition(mouseX - x, mouseY - y)
       self.tooltipInfo.SetTextColor(dwTextColor)
       self.tooltipInfo.Show()
       self.tooltipInfo.SetTop()

       if 0 != dwGuildID:
           textWidth, textHeight = self.tooltipInfo.GetTextSize()
           self.infoGuildMark.SetIndex(dwGuildID)
           self.infoGuildMark.SetPosition(mouseX - x - textWidth - 18 - 5, mouseY - y)
           self.infoGuildMark.Show()

   def Hide(self):
       if self.AtlasMainWindow:
           self.AtlasMainWindow.HideAtlas()
           self.AtlasMainWindow.Hide()
       ui.ScriptWindow.Hide(self)

   def Show(self):
       if self.AtlasMainWindow:
           (bGet, iSizeX, iSizeY) = miniMap.GetAtlasSize()
           if bGet:
               self.SetSize(iSizeX + 15, iSizeY + 38)

               if localeInfo.IsARABIC():
                   self.board.SetPosition(iSizeX+15, 0)

               self.board.SetSize(iSizeX + 15, iSizeY + 38)
               #self.AtlasMainWindow.SetSize(iSizeX, iSizeY)
               self.AtlasMainWindow.ShowAtlas()
               self.AtlasMainWindow.Show()
       ui.ScriptWindow.Show(self)

   def SetCenterPositionAdjust(self, x, y):
       self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)

   def OnPressEscapeKey(self):
       self.Hide()
       return True

def __RegisterMiniMapColor(type, rgb):
   miniMap.RegisterColor(type, rgb[0], rgb[1], rgb[2])

class MiniMap(ui.ScriptWindow):

   CANNOT_SEE_INFO_MAP_DICT = {
       "metin2_map_monkeydungeon" : False,
       "metin2_map_monkeydungeon_02" : False,
       "metin2_map_monkeydungeon_03" : False,
       "metin2_map_devilsCatacomb" : False,
   }

   if app.BL_KILL_BAR:
       KILL_BAR_COOLTIME = 4.0
       KILL_BAR_MOVE_SPEED = 3.0
       KILL_BAR_MOVE_DISTANCE = 33.0
       KILL_BAR_MAX_ITEM = 5

       KILL_BAR_RACE = {
           playersettingmodule.RACE_WARRIOR_M: "|Ekill_bar/warrior_m|e",
           playersettingmodule.RACE_ASSASSIN_W   : "|Ekill_bar/assassin_w|e",
           playersettingmodule.RACE_SURA_M       : "|Ekill_bar/sura_m|e",
           playersettingmodule.RACE_SHAMAN_W   : "|Ekill_bar/shaman_w|e",
           playersettingmodule.RACE_WARRIOR_W   : "|Ekill_bar/warrior_w|e",
           playersettingmodule.RACE_ASSASSIN_M   : "|Ekill_bar/assassin_m|e",
           playersettingmodule.RACE_SURA_W       : "|Ekill_bar/sura_w|e",
           playersettingmodule.RACE_SHAMAN_M   : "|Ekill_bar/shaman_m|e",
       }

       KILL_BAR_WEAPON_TYPE = {
           "FIST": "|Ekill_bar/fist|e",
           item.WEAPON_SWORD: "|Ekill_bar/sword|e",
           item.WEAPON_DAGGER: "|Ekill_bar/dagger|e",
           item.WEAPON_BOW: "|Ekill_bar/bow|e",
           item.WEAPON_TWO_HANDED: "|Ekill_bar/twohand|e",
           item.WEAPON_BELL: "|Ekill_bar/bell|e",
           item.WEAPON_FAN: "|Ekill_bar/fan|e",
       }

   def __init__(self, interface):
       ui.ScriptWindow.__init__(self)

       self.__Initialize()

       miniMap.Create()
       miniMap.SetScale(2.0)

       self.AtlasWindow = AtlasWindow()
       self.AtlasWindow.LoadWindow()
       self.AtlasWindow.Hide()

       self.tooltipMiniMapOpen = MapTextToolTip()
       self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP)
       self.tooltipMiniMapOpen.Show()
       self.tooltipMiniMapClose = MapTextToolTip()
       self.tooltipMiniMapClose.SetText(localeInfo.UI_CLOSE)
       self.tooltipMiniMapClose.Show()
       self.tooltipScaleUp = MapTextToolTip()
       self.tooltipScaleUp.SetText(localeInfo.MINIMAP_INC_SCALE)
       self.tooltipScaleUp.Show()
       self.tooltipScaleDown = MapTextToolTip()
       self.tooltipScaleDown.SetText(localeInfo.MINIMAP_DEC_SCALE)
       self.tooltipScaleDown.Show()
       self.tooltipAtlasOpen = MapTextToolTip()
       self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_SHOW_AREAMAP)
       self.tooltipAtlasOpen.Show()
       self.tooltipInfo = MapTextToolTip()
       self.tooltipInfo.Show()

       if miniMap.IsAtlas():
           self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_SHOW_AREAMAP)
       else:
           self.tooltipAtlasOpen.SetText(localeInfo.MINIMAP_CAN_NOT_SHOW_AREAMAP)

       self.tooltipInfo = MapTextToolTip()
       self.tooltipInfo.Show()

       self.mapName = ""

       self.isLoaded = 0
       self.canSeeInfo = True
self.interface = interface
       # AUTOBAN
       self.imprisonmentDuration = 0
       self.imprisonmentEndTime = 0
       self.imprisonmentEndTimeText = ""
       # END_OF_AUTOBAN
   def __del__(self):
       miniMap.Destroy()
       ui.ScriptWindow.__del__(self)

   def __Initialize(self):
       self.positionInfo = 0
       self.observerCount = 0

       self.OpenWindow = 0
       self.CloseWindow = 0
       self.ScaleUpButton = 0
       self.ScaleDownButton = 0
       self.MiniMapHideButton = 0
       self.MiniMapShowButton = 0
       self.AtlasShowButton = 0

       self.tooltipMiniMapOpen = 0
       self.tooltipMiniMapClose = 0
       self.tooltipScaleUp = 0
       self.tooltipScaleDown = 0
       self.tooltipAtlasOpen = 0
       if app.ENABLE_DUNGEON_INFO_SYSTEM:
           self.dungeonInfoButton = 0
       self.tooltipInfo = None
       self.serverInfo = None
self.interface = None
       if app.BL_KILL_BAR:
           self.KillList = list()
   def SetMapName(self, mapName):
       self.mapName=mapName
       self.AtlasWindow.SetMapName(mapName)

       if self.CANNOT_SEE_INFO_MAP_DICT.has_key(mapName):
           self.canSeeInfo = False
           self.HideMiniMap()
           self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP_CANNOT_SEE)
       else:
           self.canSeeInfo = True
           self.ShowMiniMap()
           self.tooltipMiniMapOpen.SetText(localeInfo.MINIMAP)

   # AUTOBAN
   def SetImprisonmentDuration(self, duration):
       self.imprisonmentDuration = duration
       self.imprisonmentEndTime = app.GetGlobalTimeStamp() + duration

       self.__UpdateImprisonmentDurationText()

   def __UpdateImprisonmentDurationText(self):
       restTime = max(self.imprisonmentEndTime - app.GetGlobalTimeStamp(), 0)

       imprisonmentEndTimeText = localeInfo.SecondToDHM(restTime)
       if imprisonmentEndTimeText != self.imprisonmentEndTimeText:
           self.imprisonmentEndTimeText = imprisonmentEndTimeText
           self.serverInfo.SetText("%s: %s" % (uiScriptLocale.AUTOBAN_QUIZ_REST_TIME, self.imprisonmentEndTimeText))
   # END_OF_AUTOBAN

   def Show(self):
       self.__LoadWindow()

       ui.ScriptWindow.Show(self)

   def __LoadWindow(self):
       if self.isLoaded == 1:
           return

       self.isLoaded = 1

       try:
           pyScrLoader = ui.PythonScriptLoader()
           if localeInfo.IsARABIC():
               pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "Minimap.py")
           else:
               pyScrLoader.LoadScriptFile(self, "UIScript/MiniMap.py")
       except:
           import exception
           exception.Abort("MiniMap.LoadWindow.LoadScript")

       try:
           self.OpenWindow = self.GetChild("OpenWindow")
           self.MiniMapWindow = self.GetChild("MiniMapWindow")
           self.ScaleUpButton = self.GetChild("ScaleUpButton")
           self.ScaleDownButton = self.GetChild("ScaleDownButton")
           self.MiniMapHideButton = self.GetChild("MiniMapHideButton")
           self.AtlasShowButton = self.GetChild("AtlasShowButton")
           self.CloseWindow = self.GetChild("CloseWindow")
           self.MiniMapShowButton = self.GetChild("MiniMapShowButton")
           self.positionInfo = self.GetChild("PositionInfo")
           self.observerCount = self.GetChild("ObserverCount")
           self.serverInfo = self.GetChild("ServerInfo")
           if app.ENABLE_DUNGEON_INFO_SYSTEM:
               self.dungeonInfoButton = self.GetChild("l_button")
       except:
           import exception
           exception.Abort("MiniMap.LoadWindow.Bind")

       if constInfo.MINIMAP_POSITIONINFO_ENABLE==0:
           self.positionInfo.Hide()

       self.serverInfo.SetText(net.GetServerInfo())
       self.ScaleUpButton.SetEvent(ui.__mem_func__(self.ScaleUp))
       self.ScaleDownButton.SetEvent(ui.__mem_func__(self.ScaleDown))
       self.MiniMapHideButton.SetEvent(ui.__mem_func__(self.HideMiniMap))
       self.MiniMapShowButton.SetEvent(ui.__mem_func__(self.ShowMiniMap))

       if miniMap.IsAtlas():
           self.AtlasShowButton.SetEvent(ui.__mem_func__(self.ShowAtlas))
       if app.ENABLE_DUNGEON_INFO_SYSTEM:
           self.dungeonInfoButton.SetEvent(ui.__mem_func__(self.DungeonInfo))
       (ButtonPosX, ButtonPosY) = self.MiniMapShowButton.GetGlobalPosition()
       self.tooltipMiniMapOpen.SetTooltipPosition(ButtonPosX, ButtonPosY)

       (ButtonPosX, ButtonPosY) = self.MiniMapHideButton.GetGlobalPosition()
       self.tooltipMiniMapClose.SetTooltipPosition(ButtonPosX, ButtonPosY)

       (ButtonPosX, ButtonPosY) = self.ScaleUpButton.GetGlobalPosition()
       self.tooltipScaleUp.SetTooltipPosition(ButtonPosX, ButtonPosY)

       (ButtonPosX, ButtonPosY) = self.ScaleDownButton.GetGlobalPosition()
       self.tooltipScaleDown.SetTooltipPosition(ButtonPosX, ButtonPosY)

       (ButtonPosX, ButtonPosY) = self.AtlasShowButton.GetGlobalPosition()
       self.tooltipAtlasOpen.SetTooltipPosition(ButtonPosX, ButtonPosY)

       self.ShowMiniMap()

   def Destroy(self):
       self.HideMiniMap()

       self.AtlasWindow.Destroy()
       self.AtlasWindow = None
       if app.BL_KILL_BAR:
           self.KillList = None
       self.ClearDictionary()

       self.__Initialize()

   def UpdateObserverCount(self, observerCount):
       if observerCount>0:
           self.observerCount.Show()
       elif observerCount<=0:
           self.observerCount.Hide()

       self.observerCount.SetText(localeInfo.MINIMAP_OBSERVER_COUNT % observerCount)

   def OnUpdate(self):
       (x, y, z) = player.GetMainCharacterPosition()
       miniMap.Update(x, y)

       self.positionInfo.SetText("(%.0f, %.0f)" % (x/100, y/100))

       if self.tooltipInfo:
           if True == self.MiniMapWindow.IsIn():
               (mouseX, mouseY) = wndMgr.GetMousePosition()
               (bFind, sName, iPosX, iPosY, dwTextColor) = miniMap.GetInfo(mouseX, mouseY)
               if bFind == 0:
                   self.tooltipInfo.Hide()
               elif not self.canSeeInfo:
                   self.tooltipInfo.SetText("%s(%s)" % (sName, localeInfo.UI_POS_UNKNOWN))
                   self.tooltipInfo.SetTooltipPosition(mouseX - 5, mouseY)
                   self.tooltipInfo.SetTextColor(dwTextColor)
                   self.tooltipInfo.Show()
               else:
                   if localeInfo.IsARABIC() and sName[-1].isalnum():
                       self.tooltipInfo.SetText("(%s)%d, %d" % (sName, iPosX, iPosY))
                   else:
                       self.tooltipInfo.SetText("%s(%d, %d)" % (sName, iPosX, iPosY))
                   self.tooltipInfo.SetTooltipPosition(mouseX - 5, mouseY)
                   self.tooltipInfo.SetTextColor(dwTextColor)
                   self.tooltipInfo.Show()
           else:
               self.tooltipInfo.Hide()

           # AUTOBAN
           if self.imprisonmentDuration:
               self.__UpdateImprisonmentDurationText()
           # END_OF_AUTOBAN

       if True == self.MiniMapShowButton.IsIn():
           self.tooltipMiniMapOpen.Show()
       else:
           self.tooltipMiniMapOpen.Hide()

       if True == self.MiniMapHideButton.IsIn():
           self.tooltipMiniMapClose.Show()
       else:
           self.tooltipMiniMapClose.Hide()

       if True == self.ScaleUpButton.IsIn():
           self.tooltipScaleUp.Show()
       else:
           self.tooltipScaleUp.Hide()

       if True == self.ScaleDownButton.IsIn():
           self.tooltipScaleDown.Show()
       else:
           self.tooltipScaleDown.Hide()

       if True == self.AtlasShowButton.IsIn():
           self.tooltipAtlasOpen.Show()
       else:
           self.tooltipAtlasOpen.Hide()

       if app.BL_KILL_BAR:
           if self.KillList:
               self.KillList = filter(
                   lambda obj: obj["CoolTime"] > app.GetTime(), self.KillList)
               for obj in self.KillList:
                   (xLocal, yLocal) = obj["ThinBoard"].GetLocalPosition()
                   if obj["MOVE_X"] > 0.0:
                       obj["ThinBoard"].SetPosition(xLocal - MiniMap.KILL_BAR_MOVE_SPEED, yLocal)
                       obj["MOVE_X"] -= MiniMap.KILL_BAR_MOVE_SPEED
                   if obj["MOVE_Y"] > 0.0:
                       obj["ThinBoard"].SetPosition(xLocal, yLocal + MiniMap.KILL_BAR_MOVE_SPEED)
                       obj["MOVE_Y"] -= MiniMap.KILL_BAR_MOVE_SPEED

   def OnRender(self):
       (x, y) = self.GetGlobalPosition()
       fx = float(x)
       fy = float(y)
       miniMap.Render(fx + 4.0, fy + 5.0)

   def Close(self):
       self.HideMiniMap()

   if app.BL_KILL_BAR:
       def RepositionKillBar(self, obj):
           obj["MOVE_Y"] += MiniMap.KILL_BAR_MOVE_DISTANCE
           return obj

       def AddKillInfo(self, killer, victim, killer_race, victim_race, weapon_type):
           if len(self.KillList) >= MiniMap.KILL_BAR_MAX_ITEM:
               self.KillList.sort(
                   key=lambda obj: obj["CoolTime"], reverse=True)
               del self.KillList[-1]

           if self.KillList:
               self.KillList = map(self.RepositionKillBar, self.KillList)

           TBoard = ui.ThinBoard()
           TBoard.SetParent(self)
           TBoard.SetSize(155, 10)
           TBoard.SetPosition(15, 185)
           TBoard.Show()

           KillText = ui.TextLine()
           KillText.SetText("{} {} {} {} {}".format(MiniMap.KILL_BAR_RACE.get(int(killer_race), ""), killer, MiniMap.KILL_BAR_WEAPON_TYPE.get(
               int(weapon_type), MiniMap.KILL_BAR_WEAPON_TYPE.get("FIST")), victim, MiniMap.KILL_BAR_RACE.get(int(victim_race), "")))
           KillText.SetParent(TBoard)
           KillText.SetWindowHorizontalAlignCenter()
           KillText.SetWindowVerticalAlignCenter()
           KillText.SetHorizontalAlignCenter()
           KillText.SetVerticalAlignCenter()
           KillText.Show()

           KillDict = dict()
           KillDict["ThinBoard"] = TBoard
           KillDict["TextLine"] = KillText
           KillDict["CoolTime"] = app.GetTime() + MiniMap.KILL_BAR_COOLTIME
           KillDict["MOVE_X"] = MiniMap.KILL_BAR_MOVE_DISTANCE
           KillDict["MOVE_Y"] = 0.0

           self.KillList.append(KillDict)

   def HideMiniMap(self):
       miniMap.Hide()
       self.OpenWindow.Hide()
       self.CloseWindow.Show()

   def ShowMiniMap(self):
       if not self.canSeeInfo:
           return

       miniMap.Show()
       self.OpenWindow.Show()
       self.CloseWindow.Hide()

   def isShowMiniMap(self):
       return miniMap.isShow()

   def ScaleUp(self):
       miniMap.ScaleUp()

   def ScaleDown(self):
       miniMap.ScaleDown()

   def ShowAtlas(self):
       if not miniMap.IsAtlas():
           return
       if not self.AtlasWindow.IsShow():
           self.AtlasWindow.Show()

   def ToggleAtlasWindow(self):
       if not miniMap.IsAtlas():
           return
       if self.AtlasWindow.IsShow():
           self.AtlasWindow.Hide()
       else:
           self.AtlasWindow.Show()

minimap.py

Quote

ROOT = "d:/ymir work/ui/minimap/"
import localeInfo
window = {
   "name" : "MiniMap",

   "x" : SCREEN_WIDTH - 136,
   "y" : 0,

   "width" : 136,
   "height" : 137,

   "children" :
   (
       ## OpenWindow
       {
           "name" : "OpenWindow",
           "type" : "window",

           "x" : 0,
           "y" : 0,

           "width" : 136,
           "height" : 137,

           "children" :
           (
               {
                   "name" : "OpenWindowBGI",
                   "type" : "image",
                   "x" : 0,
                   "y" : 0,
                   "image" : ROOT + "minimap.sub",
               },
               ## MiniMapWindow
               {
                   "name" : "MiniMapWindow",
                   "type" : "window",

                   "x" : 4,
                   "y" : 5,

                   "width" : 128,
                   "height" : 128,
               },
               ## ScaleUpButton
               {
                   "name" : "ScaleUpButton",
                   "type" : "button",

                   "x" : 101,
                   "y" : 116,

                   "default_image" : ROOT + "minimap_scaleup_default.sub",
                   "over_image" : ROOT + "minimap_scaleup_over.sub",
                   "down_image" : ROOT + "minimap_scaleup_down.sub",
               },
               ## ScaleDownButton
               {
                   "name" : "ScaleDownButton",
                   "type" : "button",

                   "x" : 115,
                   "y" : 103,

                   "default_image" : ROOT + "minimap_scaledown_default.sub",
                   "over_image" : ROOT + "minimap_scaledown_over.sub",
                   "down_image" : ROOT + "minimap_scaledown_down.sub",
               },
               ## MiniMapHideButton
               {
                   "name" : "MiniMapHideButton",
                   "type" : "button",

                   "x" : 111,
                   "y" : 6,

                   "default_image" : ROOT + "minimap_close_default.sub",
                   "over_image" : ROOT + "minimap_close_over.sub",
                   "down_image" : ROOT + "minimap_close_down.sub",
               },
               ## AtlasShowButton
               {
                   "name" : "AtlasShowButton",
                   "type" : "button",

                   "x" : 12,
                   "y" : 12,

                   "default_image" : ROOT + "atlas_open_default.sub",
                   "over_image" : ROOT + "atlas_open_over.sub",
                   "down_image" : ROOT + "atlas_open_down.sub",
               },
               ## ServerInfo
               {
                   "name" : "ServerInfo",
                   "type" : "text",

                   "text_horizontal_align" : "center",

                   "outline" : 1,

                   "x" : 999,
                   "y" : 999,

                   "text" : "",
               },
               ## INFOS GAMES
               {
                   "name" : "InfoTexto",
                   "type" : "text",

                   "text_horizontal_align" : "center",

                   "outline" : 1,

                   "x" : 70,
                   "y" : 140,

                   "text" : "www.teste.xyz",
               },
{
                   "name" : "GameVersion",
                   "type" : "text",

                   "text_horizontal_align" : "center",

                   "outline" : 1,

                   "x" : 70,
                   "y" : 155,

                   "text" : "Version: 0.1.3a",
               },
               {
                   "name" : "1_buton",
                   "type" : "button",

                   "x" : 12,
                   "y" : 103,

                   "default_image" : "d:/ymir work/ui/minimap/ui/minimap_dungeon_info_default.tga",
                   "over_image" : "d:/ymir work/ui/minimap/ui/minimap_dungeon_info_over.tga",
                   "down_image" : "d:/ymir work/ui/minimap/ui/minimap_dungeon_info_down.tga",
                   "tooltip_text" : localeInfo.MINIMAP_DUNGEON_INFO,
               },
               ## PositionInfo
               {
                   "name" : "PositionInfo",
                   "type" : "text",

                   "text_horizontal_align" : "center",

                   "outline" : 1,

                   "x" : 70,
                   "y" : 160,

                   "text" : "",
               },
               ## ObserverCount
               {
                   "name" : "ObserverCount",
                   "type" : "text",

                   "text_horizontal_align" : "center",

                   "outline" : 1,

                   "x" : 70,
                   "y" : 180,

                   "text" : "",
               },
           ),
       },
       {
           "name" : "CloseWindow",
           "type" : "window",

           "x" : 0,
           "y" : 0,

           "width" : 132,
           "height" : 48,

           "children" :
           (
               ## ShowButton
               {
                   "name" : "MiniMapShowButton",
                   "type" : "button",

                   "x" : 100,
                   "y" : 4,

                   "default_image" : ROOT + "minimap_open_default.sub",
                   "over_image" : ROOT + "minimap_open_default.sub",
                   "down_image" : ROOT + "minimap_open_default.sub",
               },
           ),
       },
   ),
}