kodepiko

You got full tutorial in thread you mentioned files and functions are the same, if you get any errors just report them here.

As I remember only locale changed to localeInfo and some other things comparing old "binary" to new binary, so what is the problem implementing this system?

all main functions are same

PS. you should do #refresh instead of push, lol - you push everywhere, change nickname to MrPush 

You need to include also quest name from where get flag "ap"

for ex:

ch->GetQuestFlag("achievements.ap");

achievements is QUEST name

ap is flag inside this quest for ex: pc.setqf("ap", 500)

Hello guys,

OLD move style:

NEW:

It's really annoying, I take gifs from WOM2 board, they fixed it

I tried changing normal rotation (like horse) at clientside but it's other thing to do in this case

Any ideas?

It doesn't crash core so... game.core will not be created. I think you messed with packets like extending gold / exp value etc... so packets are not right at server/clientside there can be strange bugs like this 

Man, try to reverse your last changes (and check your client syserr)

4 hours ago, Thorer said:

ChatPacket is from CHARACTER class, not description.

 

Its POINTER, pointing on adress of process, you cannot merge it to another process.

I also think in that way, but what @Denis said it seemed to work in my case, lol.

Thank you guys for respond.

Damn, so there's no any option to use CHAR functions on player at other core/channel? It's so sad 

Anyway, thanks

20 hours ago, Qwertyu said:

I have..

Try running Debug version of WE, you will see logs at this sector without buildings also in .txt file

Hello guys,

can you tell me method to get LPCHARACTER pointer of player (online) but on another core/channel by having player name or something?

I want to use CHAR class functions with this.

This method is working only on same game core

LPCHARACTER pkChr = CHARACTER_MANAGER::instance().FindPC(name);

Regards

Maybe you don't have unpacked zone/property at d:ymir work

You need to change function of PointChange to take int argument what I remember it's also for align or there is other functions like SetAlignment so...

just check GM command set alignment and change data type of arguments in alignment function

I think it's McAfee false positive, you just compiled binary and it shows so.. I doubt there is a trojan inside of code, by man who sell his source?

If you got notepad++ (text editor) try to search in unpacked root at .py files (select root folder):

**

I have another idea, check insult.txt at locale_xx because there can be a censorship of word | or something

So it's possible that at serverside input_main.cpp whisper function you got replacing | to **

just look what you change in this file or replace with original one

3 minutes ago, andreidey said:

  Reveal hidden contents

import os
import app
import dbg
import grp
import item
import background
import chr
import chrmgr
import player
import chat
import textTail
import event
import uibonuspage

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 constInfo2

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

# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LIST

# OFFLINE_SHOP_PRICE_LIST
import uiOfflineShopBuilder
# END_OF_OFFLINE_SHOP_PRICE_LIST
import uiOfflineShop

import mouseModule
import consoleModule
import localeInfo

import playerSettingModule
import interfaceModule

import musicInfo
import debugInfo
import stringCommander
import uiScriptLocale
import uianinu
import uiteleport

from _weakref import proxy
from switchbot 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
BPisLodaded = 0
pet_gui_activado = 0
bonuspp = 0
selecttask = open("data/taskbar.cfg", "r")
TASKBAR_EVENT = selecttask.read()
selecttask.close()
if TASKBAR_EVENT == "":
    TASKBAR_EVENT = "taskbar"

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

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

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

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

        self.curtain = uiPhaseCurtain.PhaseCurtain()
        self.curtain.speed = 0.03
        self.curtain.Hide()
        
        self.GuildStorageWindow = uiguildstorage.GuildStorage()
        
        self.targetBoard = uiTarget.TargetBoard()
        self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog))
        self.targetBoard.Hide()

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

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

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

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

        self.__ServerCommand_Build()
        self.__ProcessPreservedServerCommand()
        
        self.switchbot = Bot()
        self.switchbot.Hide()
        
        self.teleport = uiteleport.TeleportWindow()

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

        ##START_PETGUI BY DASKUCHEN
        PetGuiBg5 = ui.AniImageBox()
        PetGuiBg5.AddFlag("not_pick")
        PetGuiBg5.AppendImage("d:/ymir work/ui/pet_aa_5.dds")
        self.PetGuiBg5 = PetGuiBg5
        self.PetGuiBg5.SetPosition(10,50)
        
        PetGuiBg10 = ui.AniImageBox()
        PetGuiBg10.AddFlag("not_pick")
        PetGuiBg10.AppendImage("d:/ymir work/ui/pet_aa_10.dds")
        self.PetGuiBg10 = PetGuiBg10
        self.PetGuiBg10.SetPosition(10,50)

        self.PetIcon = ui.ImageBox()
        self.PetIcon.AddFlag("not_pick")
        self.PetIcon.SetPosition(10+20, 50+20)

        self.PetName = ui.TextLine()
        self.PetName.SetDefaultFontName()
        self.PetName.SetPosition(10+133, 50+19)
        self.PetName.SetHorizontalAlignCenter()
        self.PetName.SetText("Pet_Name")
        self.PetName.SetOutline()
        
        self.PetLevel = ui.TextLine()
        self.PetLevel.SetDefaultFontName()
        self.PetLevel.SetPosition(10+133, 50+39)
        self.PetLevel.SetHorizontalAlignCenter()
        self.PetLevel.SetText("Pets_Level")
        self.PetLevel.SetOutline()

        self.PetBonusTit = ui.TextLine()
        self.PetBonusTit.SetDefaultFontName()
        self.PetBonusTit.SetPosition(10+112, 50+82)
        self.PetBonusTit.SetHorizontalAlignCenter()
        self.PetBonusTit.SetText(uianinu.ANINU_PBONUS)
        self.PetBonusTit.SetOutline()
        
        self.PetBonus1 = ui.TextLine()
        self.PetBonus1.SetDefaultFontName()
        self.PetBonus1.SetPosition(10+112, 50+102)
        self.PetBonus1.SetHorizontalAlignCenter()
        self.PetBonus1.SetText("Bonus_1")
        self.PetBonus1.SetOutline()

        self.PetBonus2 = ui.TextLine()
        self.PetBonus2.SetDefaultFontName()
        self.PetBonus2.SetPosition(10+112, 50+123)
        self.PetBonus2.SetHorizontalAlignCenter()
        self.PetBonus2.SetText("Bonus_2")
        self.PetBonus2.SetOutline()

        self.PetBonus3 = ui.TextLine()
        self.PetBonus3.SetDefaultFontName()
        self.PetBonus3.SetPosition(10+112, 50+144)
        self.PetBonus3.SetHorizontalAlignCenter()
        self.PetBonus3.SetText("Bonus_3")
        self.PetBonus3.SetOutline()            

        self.PetBonus4 = ui.TextLine()
        self.PetBonus4.SetDefaultFontName()
        self.PetBonus4.SetPosition(10+112, 50+165)
        self.PetBonus4.SetHorizontalAlignCenter()
        self.PetBonus4.SetText("Bonus_4")
        self.PetBonus4.SetOutline()            

        self.PetBonus5 = ui.TextLine()
        self.PetBonus5.SetDefaultFontName()
        self.PetBonus5.SetPosition(10+112, 50+186)
        self.PetBonus5.SetHorizontalAlignCenter()
        self.PetBonus5.SetText("Bonus_5")
        self.PetBonus5.SetOutline()            

        self.PetBonus6 = ui.TextLine()
        self.PetBonus6.SetDefaultFontName()
        self.PetBonus6.SetPosition(10+112, 50+207)
        self.PetBonus6.SetHorizontalAlignCenter()
        self.PetBonus6.SetText("Bonus_6")
        self.PetBonus6.SetOutline()            

        self.PetBonus7 = ui.TextLine()
        self.PetBonus7.SetDefaultFontName()
        self.PetBonus7.SetPosition(10+112, 50+228)
        self.PetBonus7.SetHorizontalAlignCenter()
        self.PetBonus7.SetText("Bonus_7")
        self.PetBonus7.SetOutline()            

        self.PetBonus8 = ui.TextLine()
        self.PetBonus8.SetDefaultFontName()
        self.PetBonus8.SetPosition(10+112, 50+249)
        self.PetBonus8.SetHorizontalAlignCenter()
        self.PetBonus8.SetText("Bonus_8")
        self.PetBonus8.SetOutline()            

        self.PetBonus9 = ui.TextLine()
        self.PetBonus9.SetDefaultFontName()
        self.PetBonus9.SetPosition(10+112, 50+270)
        self.PetBonus9.SetHorizontalAlignCenter()
        self.PetBonus9.SetText("Bonus_9")
        self.PetBonus9.SetOutline()            

        self.PetBonus10 = ui.TextLine()
        self.PetBonus10.SetDefaultFontName()
        self.PetBonus10.SetPosition(10+112, 50+291)
        self.PetBonus10.SetHorizontalAlignCenter()
        self.PetBonus10.SetText("Bonus_10")
        self.PetBonus10.SetOutline()            

        PetExpBar = ui.AniImageBox()
        PetExpBar.AddFlag("not_pick")
        PetExpBar.AppendImage("d:/ymir work/ui/pet_exp.tga")
        PetExpBar.SetPercentage(0,1)
        self.PetExpBar = PetExpBar
        self.PetExpBar.SetPosition(10+20, 50+60)
        
        self.PetExpLabel = ui.TextLine()
        self.PetExpLabel.SetDefaultFontName()
        self.PetExpLabel.SetPosition(10+112, 50+58)
        self.PetExpLabel.SetHorizontalAlignCenter()
        self.PetExpLabel.SetText("0.0%")
        self.PetExpLabel.SetOutline()    
        
        ##CLOSE_PETGUI BY DASKUCHEN

        ## START SISTEM ANINU
        self.Activare_Menu = ui.Button()
        self.Activare_Menu.SetPosition(wndMgr.GetScreenWidth()-10,220)
        self.Activare_Menu.SetUpVisual("d:/ymir work/ui/1_1.tga")
        self.Activare_Menu.SetOverVisual("d:/ymir work/ui/1_2.tga")
        self.Activare_Menu.SetDownVisual("d:/ymir work/ui/1_3.tga")
        self.Activare_Menu.SetEvent(ui.__mem_func__(self.__menubg))
        self.Activare_Menu.Hide()

        self.Dezactivare_Menu = ui.Button()
        self.Dezactivare_Menu.SetPosition(wndMgr.GetScreenWidth()-160,220)
        self.Dezactivare_Menu.SetUpVisual("d:/ymir work/ui/2_1.tga")
        self.Dezactivare_Menu.SetOverVisual("d:/ymir work/ui/2_2.tga")
        self.Dezactivare_Menu.SetDownVisual("d:/ymir work/ui/2_3.tga")
        self.Dezactivare_Menu.SetEvent(ui.__mem_func__(self.__menubgEND))
        self.Dezactivare_Menu.Hide()    

        KillGuiBg = ui.AniImageBox()
        KillGuiBg.AppendImage("d:/ymir work/ui/system_kp.tga")
        self.KillGuiBg = KillGuiBg
        self.KillGuiBg.SetPosition(wndMgr.GetScreenWidth()-160,200)
        self.KillGuiBg.Hide()

        self.KillBlauReich = ui.TextLine()
        self.KillBlauReich.SetDefaultFontName()
        self.KillBlauReich.SetPosition((wndMgr.GetScreenWidth()-345)+210, 240)
        self.KillBlauReich.SetText("†: ")
        self.KillBlauReich.SetOutline()
        self.KillBlauReich.Hide()

        self.KillGelbReich = ui.TextLine()
        self.KillGelbReich.SetDefaultFontName()
        self.KillGelbReich.SetPosition((wndMgr.GetScreenWidth()-345)+210, 260)
        self.KillGelbReich.SetText("†: ")
        self.KillGelbReich.SetOutline()
        self.KillGelbReich.Hide()

        self.KillRotReich = ui.TextLine()
        self.KillRotReich.SetDefaultFontName()
        self.KillRotReich.SetPosition((wndMgr.GetScreenWidth()-345)+210, 220)
        self.KillRotReich.SetText("†: ")
        self.KillRotReich.SetOutline()
        self.KillRotReich.Hide()

        self.KillMob = ui.TextLine()
        self.KillMob.SetDefaultFontName()
        self.KillMob.SetPosition((wndMgr.GetScreenWidth()-345)+210, 280)
        self.KillMob.SetText("†: ")
        self.KillMob.SetOutline()
        self.KillMob.Hide()

        self.Puncte = ui.TextLine()
        self.Puncte.SetDefaultFontName()
        self.Puncte.SetPosition((wndMgr.GetScreenWidth()-345)+210, 300)
        self.Puncte.SetText("†: ")
        self.Puncte.SetOutline()
        self.Puncte.Hide()

        self.Minute = ui.TextLine()
        self.Minute.SetDefaultFontName()
        self.Minute.SetPosition((wndMgr.GetScreenWidth()-345)+210, 320)
        self.Minute.SetText("†: ")
        self.Minute.SetOutline()
        self.Minute.Hide()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        global cameraDistance, cameraPitch, cameraRotation, cameraHeight

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

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

        # TWO_HANDED_WEAPON_ATTACK_SPEED_UP
        constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
        # END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP

        import event
        event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)

        textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)

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

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

        self.__BuildKeyDict()
        self.__BuildDebugInfo()

        # PRIVATE_SHOP_PRICE_LIST
        uiPrivateShopBuilder.Clear()
        # END_OF_PRIVATE_SHOP_PRICE_LIST
        
        # OFFLINE_SHOP_PRICE_LIST
        uiOfflineShopBuilder.Clear()
        # END_OF_OFFLINE_SHOP_PRICE_LIST

        # UNKNOWN_UPDATE
        exchange.InitTrading()
        # END_OF_UNKNOWN_UPDATE

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

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

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

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

        net.SendEnterGamePacket()

        # START_GAME_ERROR_EXIT
        try:
            self.StartGame()
        except:
            import exception
            exception.Abort("GameWindow.Open")
        # END_OF_START_GAME_ERROR_EXIT
        
        # NPC가 큐브시스템으로 만들 수 있는 아이템들의 목록을 캐싱
        # ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
        self.cubeInformation = {}
        self.currentCubeNPC = 0
        self.acceInformation = {}
        self.currentAcceNPC = 0
        
    def Close(self):
        self.Hide()

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

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

        self.onPressKeyDict = None
        self.onClickKeyDict = None

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

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

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

        # UNKNOWN_UPDATE
        self.itemDropQuestionDialog = None
        # END_OF_UNKNOWN_UPDATE

        # QUEST_CONFIRM
        self.confirmDialog = None
        # END_OF_QUEST_CONFIRM
        
        

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

        self.ClearDictionary()

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

        if self.console:
            self.console.BindGameClass(0)
            self.console.Close()
            self.console=None
        
        if self.targetBoard:
            self.targetBoard.Destroy()
            self.targetBoard = None
        if self.itemShopWnd:
            self.itemShopWnd.Destroy()
            self.itemShopWnd = None    
        if self.interface:
            self.interface.HideAllWindows()
            self.interface.Close()
            self.interface=None

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

        self.KillFocus()
        app.HideCursor()

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

    def __BuildKeyDict(self):
        onPressKeyDict = {}

        ##PressKey 는 누르고 있는 동안 계속 적용되는 키이다.
        
        ## 숫자 단축키 퀵슬롯에 이용된다.(이후 숫자들도 퀵 슬롯용 예약)
        ## F12 는 클라 디버그용 키이므로 쓰지 않는 게 좋다.
        onPressKeyDict[app.DIK_1]    = lambda : self.__PressNumKey(1)
        onPressKeyDict[app.DIK_2]    = lambda : self.__PressNumKey(2)
        onPressKeyDict[app.DIK_3]    = lambda : self.__PressNumKey(3)
        onPressKeyDict[app.DIK_4]    = lambda : self.__PressNumKey(4)
        onPressKeyDict[app.DIK_5]    = lambda : self.__PressNumKey(5)
        onPressKeyDict[app.DIK_6]    = lambda : self.__PressNumKey(6)
        onPressKeyDict[app.DIK_7]    = lambda : self.__PressNumKey(7)
        onPressKeyDict[app.DIK_8]    = lambda : self.__PressNumKey(8)
        onPressKeyDict[app.DIK_9]    = lambda : self.__PressNumKey(9)
        onPressKeyDict[app.DIK_F1]    = lambda : self.__PressQuickSlot(4)
        onPressKeyDict[app.DIK_F2]    = lambda : self.__PressQuickSlot(5)
        onPressKeyDict[app.DIK_F3]    = lambda : self.__PressQuickSlot(6)
        onPressKeyDict[app.DIK_F4]    = lambda : self.__PressQuickSlot(7)    
        onPressKeyDict[app.DIK_P]    = lambda : self.__BonusPage()
        onPressKeyDict[app.DIK_K]    = lambda : self.__Teleport()
        onPressKeyDict[app.DIK_X]    = lambda : self.__toggleSwitchbot()
        onPressKeyDict[app.DIK_U]    = lambda : self.__quikeqchange()
        onPressKeyDict[app.DIK_Y]    = lambda : self.__fontchange()

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

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

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

        self.onPressKeyDict = onPressKeyDict

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

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

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

        self.onClickKeyDict=onClickKeyDict

    def __PressNumKey(self,num):
        if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
            
            if num >= 1 and num <= 9:
                if(chrmgr.IsPossibleEmoticon(-1)):                
                    chrmgr.SetEmoticon(-1,int(num)-1)
                    net.SendEmoticon(int(num)-1)
        else:
            if num >= 1 and num <= 4:
                self.pressNumber(num-1)

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

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

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

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

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

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

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

    def    __PressJKey(self):
        if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
            if player.IsMountingHorse():
                net.SendChatPacket("/unmount")
            else:
                if not uiPrivateShopBuilder.IsBuildingPrivateShop():
                    for i in xrange(player.INVENTORY_PAGE_SIZE):
                        if player.GetItemIndex(i) in (71114, 71116, 71118, 71120):
                            net.SendItemUsePacket(i)
                            break
    
    def __SetQuickSlotMode(self):
        self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)

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

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

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

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

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

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

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

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

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

        # 오브젝트 그리는 개수
        self.ObjectNum = ui.TextLine()
        self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)
        self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)

        # 시야거리
        self.ViewDistance = ui.TextLine()
        self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)
        self.ViewDistance.SetPosition(0, 0)

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

    def ChangePKMode(self):

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

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

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

        self.lastPKModeSendedTime = curTime

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

        elif nextPKMode == player.PK_MODE_MAX_NUM:
            nextPKMode = 0

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

    def OnChangePKMode(self):

        self.interface.OnChangePKMode()

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

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

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

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

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

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

    def RefreshStatus(self):
        self.CheckGameButton()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def Mozart(self, data):
        dane = data.split("|")
        constInfo.PLAYER_NAME = str(dane[0])
        constInfo.PLAYER_HP = int(dane[1])
        constInfo.PLAYER_MAX_HP = int(dane[2])
        constInfo.PLAYER_SP = int(dane[3])
        constInfo.PLAYER_MAX_SP = int(dane[4])
 
    def Tabulejtor(self, id):
        constInfo.STHX = int(id)
 
    def GetInputOn(self):
        constInfo.INPUT_IGNORE = 1
 
    def GetInputOff(self):
        constInfo.INPUT_IGNORE = 0
 
    def GetInputValue(self):
        net.SendQuestInputStringPacket(str(constInfo.VID))
        
    def AskGuildName(self):

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

        self.guildNameBoard = guildNameBoard

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ## TargetBoard
    def SetPCTargetBoard(self, vid, name):
        self.targetBoard.Open(vid, name)
        
        if app.IsPressed(app.DIK_LCONTROL):
            
            if not player.IsSameEmpire(vid):
                return

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

            self.interface.OpenWhisperDialog(name)
            

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

    def RefreshTargetBoardByName(self, name):
        self.targetBoard.RefreshByName(name)
        
    def __RefreshTargetBoard(self):
        self.targetBoard.Refresh()
        
    def SetHPTargetBoard(self, vid, hpPercentage):
        if vid != self.targetBoard.GetTargetVID():
            self.targetBoard.ResetTargetBoard()
            self.targetBoard.SetEnemyVID(vid)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def OnPickMoney(self, money):
        chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (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
    ## OfflineShop
    def StartOfflineShop(self, vid):
        self.interface.OpenOfflineShopDialog(vid)
        
    def EndOfflineShop(self):
        self.interface.CloseOfflineShopDialog()
        
    def RefreshOfflineShop(self):
        self.interface.RefreshOfflineShopDialog()

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

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

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

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

    def AnswerPartyInvite(self, answer):

        if not self.partyInviteQuestionDialog:
            return

        partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

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

        net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def AnswerGuildInvite(self, answer):

        if not self.guildInviteQuestionDialog:
            return

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

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

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

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

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

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

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

    def CheckFocus(self):
        if FALSE == self.IsFocus():
            if TRUE == self.interface.IsOpenChat():
                self.interface.ToggleChat()

            self.SetFocus()

    def SaveScreen(self):
        print "save screen"

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

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

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

    def ShowConsole(self):
        pass

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

    # ADD_ALWAYS_SHOW_NAME
    def __IsShowName(self):

        if systemSetting.IsAlwaysShowName():
            return TRUE

        if self.ShowNameFlag:
            return TRUE

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

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

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

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

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

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

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

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

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

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

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

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

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

    def PickUpItem(self):
        player.PickCloseItem()

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

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

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

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

        return TRUE

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

        return TRUE

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

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

        return TRUE

    def OnMouseLeftButtonUp(self):

        if self.interface.BUILD_OnMouseLeftButtonUp():
            return

        if mouseModule.mouseController.isAttached():

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

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

            ## Inventory
            elif player.SLOT_TYPE_INVENTORY == attachedType:

                if player.ITEM_MONEY == attachedItemIndex:
                    self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
                else:
                    self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)

            ## DragonSoul
            elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
                self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
            
            mouseModule.mouseController.DeattachObject()

        else:
            hyperlink = ui.GetHyperlink()
            if hyperlink:
                if app.IsPressed(app.DIK_LALT):
                    link = chat.GetLinkFromHyperlink(hyperlink)
                    ime.PasteString(link)
                else:
                    self.interface.MakeHyperlinkTooltip(hyperlink)
                return
            else:
                player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)

        #player.EndMouseWalking()
        return TRUE

    def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
        if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
            attachedInvenType = player.SlotTypeToInvenType(attachedType)
            if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
                if player.IsEquipmentSlot(attachedItemSlotPos):
                    self.stream.popupWindow.Close()
                    self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
                else:
                    if chr.IsNPC(dstChrID):
                        net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
                    else:
                        net.SendExchangeStartPacket(dstChrID)
                        net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
            else:
                self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)

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

    def __DropMoney(self, attachedType, attachedMoney):
        # PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
        if uiPrivateShopBuilder.IsBuildingPrivateShop():            
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
            return
        # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
        
        # OFFLINESHOP_DISABLE_ITEM_DROP
        if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
            return
        # END_OF_OFFLINESHOP_DISABLE_ITEM_DROP
        
        # OFFLINESHOP_DISABLE_ITEM_DROP2
        if (uiOfflineShop.IsEditingOfflineShop()):
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
            return
        # END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2
        
        if attachedMoney>=1000:
            self.stream.popupWindow.Close()
            self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0, localeInfo.UI_OK)
            return

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

    def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
        # PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
        if uiPrivateShopBuilder.IsBuildingPrivateShop():            
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
            return
        # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
        
        # OFFLINESHOP_DISABLE_ITEM_DROP
        if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
            return
        # END_OFF_OFFLINESHOP_DISABLE_ITEM_DROP
        
        # OFFLINESHOP_DISABLE_ITEM_DROP2
        if (uiOfflineShop.IsEditingOfflineShop()):
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
            return
        # END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2
        
        if player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):
            self.stream.popupWindow.Close()
            self.stream.popupWindow.Open(localeInfo.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)

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

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

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

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

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

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

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

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

                constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

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

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

            if player.SLOT_TYPE_INVENTORY == dropType:
                if dropNumber == player.ITEM_MONEY:
                    net.SendGoldDropPacketNew(dropCount)
                    snd.PlaySound("sound/ui/money.wav")
                else:
                    # PRIVATESHOP_DISABLE_ITEM_DROP
                    self.__SendDropItemPacket(dropNumber, dropCount)
                    # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
            elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
                    # PRIVATESHOP_DISABLE_ITEM_DROP
                    self.__SendDropItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
                    # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

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

        constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

    # PRIVATESHOP_DISABLE_ITEM_DROP - OFFLINESHOP_DISABLE_ITEM_DROP
    def __SendDropItemPacket(self, itemVNum, itemCount, itemInvenType = player.INVENTORY):
        if uiPrivateShopBuilder.IsBuildingPrivateShop():
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
            return
            
        if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
            return
            
        if (uiOfflineShop.IsEditingOfflineShop()):
            chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
            return

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

    def OnMouseRightButtonDown(self):

        self.CheckFocus()

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

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

        return TRUE

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

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

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

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

    def OnUpdate(self):    
        app.UpdateGame()
        
        
        if self.mapNameShower.IsShow():
            self.mapNameShower.Update()

        if self.isShowDebugInfo:
            self.UpdateDebugInfo()

        if self.enableXMasBoom:
            self.__XMasBoom_Update()

        self.interface.BUILD_OnUpdate()

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

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

        self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
        xMouse, yMouse = wndMgr.GetMousePosition()
        self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))            

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

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

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

    def OnRender(self):
        app.RenderGame()
        
        if self.console.Console.collision:
            background.RenderCollision()
            chr.RenderCollision()

        (x, y) = app.GetCursorPosition()

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

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

            self.PickingCharacterIndex = chr.Pick()

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

            # ADD_ALWAYS_SHOW_NAME
            if not self.__IsShowName():
                self.PickingItemIndex = item.Pick()
                if -1 != self.PickingItemIndex:
                    textTail.ShowItemTextTail(self.PickingItemIndex)
            # END_OF_ADD_ALWAYS_SHOW_NAME
            
        ## Show all name in the range
        
        # ADD_ALWAYS_SHOW_NAME
        if self.__IsShowName():
            textTail.ShowAllTextTail()
            self.PickingItemIndex = textTail.Pick(x, y)
        # END_OF_ADD_ALWAYS_SHOW_NAME

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

        grp.PopState()
        grp.SetInterfaceRenderState()

        textTail.Render()
        textTail.HideAllTextTail()

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

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

        else:
            self.interface.OpenSystemDialog()

        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_Acce_Open(self, npcVNUM):
        self.interface.OpenAcceWindow()

    def BINARY_Acce_Close(self):
        self.interface.CloseAcceWindow()

    def BINARY_Acce_UpdateInfo(self, gold, itemVnum, count, rItemVnum, rCount):
        self.interface.UpdateAcceInfo(gold, itemVnum, count, rItemVnum, rCount)

    def BINARY_Acce_Succeed(self, itemVnum, count):
        print "Making acce has succesfully!"
        self.interface.SucceedAcceWork(itemVnum, count)
        pass

    def BINARY_Acce_Failed(self):
        print "Making acce has failed!"
        self.interface.FailedAcceWork()
        pass

    def BINARY_Acce_Abs_Open(self, npcVNUM):
        self.interface.OpenAcceAbsWindow()

    def BINARY_Acce_Abs_Succeed(self):
        print "Acce absorption has succesfully!"
        self.interface.SucceedAcceAbsWork()
        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.append((itemVnum, itemCount))
                            
                    else:
                        itemVnum, itemCount = eachMaterialText.split(",")
                        itemVnum = int(itemVnum)
                        itemCount = int(itemCount)
                        self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)
                        
                        materialList.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 Highlight_Item(self, inven_type, inven_pos):
        self.interface.Highligt_Item(inven_type, inven_pos)
    
    def BINARY_DragonSoulGiveQuilification(self):
        self.interface.DragonSoulGiveQuilification()
        
    def BINARY_DragonSoulRefineWindow_Open(self):
        self.interface.OpenDragonSoulRefineWindow()

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

    def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
        self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)
    
    # END of DRAGON SOUL REFINE WINDOW
    
    
    def BINARY_SetBigMessage(self, message):
        self.interface.bigBoard.SetTip(message)

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

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

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

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

    def BINARY_GuildWar_OnSendDeclare(self, guildID):
        pass

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

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

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

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

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

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

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

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

    def __GuildWar_OpenAskDialog(self, guildID, warType):

        guildName = guild.GetGuildName(guildID)

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

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

        self.guildWarQuestionDialog = questionDialog

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

    def __GuildWar_OnAccept(self):

        guildName = self.guildWarQuestionDialog.GetGuildName()

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

        return 1

    def __GuildWar_OnDecline(self):

        guildName = self.guildWarQuestionDialog.GetGuildName()

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

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

    def __ServerCommand_Build(self):
        serverCommandList={
            "getinputbegin"            : self.__Inputget1,
            "getinputend"            : self.__Inputget2,
            "getinput"                : self.__Inputget3,
            "dopes_index"            :self.__bonus_questindex,
            "evento_ultimo_superviviente"            : self.__evento_ultimo_superviviente,
            "ConsoleEnable"            : self.__Console_Enable,
            "DayMode"                : self.__DayMode_Update, 
            "PRESERVE_DayMode"        : self.__PRESERVE_DayMode_Update, 
            "CloseRestartWindow"    : self.__RestartDialog_Close,
            "OpenPrivateShop"        : self.__PrivateShop_Open,
            "OpenOfflineShop"        : self.__OfflineShop_Open,
            "PartyHealReady"        : self.PartyHealReady,
            "ShowMeSafeboxPassword"    : self.AskSafeboxPassword,
            "CloseSafebox"            : self.CommandCloseSafebox,
            "EventTaskBar"            : self.__EventTaskBar,
            "ActivareSysRight"        : self.__ActivareSysRight,
            "DezactivareSysRight"    : self.__DezactivareSysRight,
            "KillRotReich"            : self.__KillRotReich,
            "KillGelbReich"            : self.__KillGelbReich,
            "KillBlauReich"            : self.__KillBlauReich,
            "KillMob"                : self.__KillMob,
            "Puncte"                : self.__Puncte,
            "Minute"                : self.__Minute,

            ##PETGUI BY DASKUCHEN
            "ShowPetGui"            : self.__showpetgui,
            "HidePetGui"            : self.__hidepetgui,
            "HaustierName"            : self.__PetName,
            "HaustierLevel"            : self.__PetLevel,
            "HaustierBonus1"        : self.__PetBoni1,
            "HaustierBonus2"        : self.__PetBoni2,
            "HaustierBonus3"        : self.__PetBoni3,
            "HaustierBonus4"        : self.__PetBoni4,
            "HaustierBonus5"        : self.__PetBoni5,
            "HaustierBonus6"        : self.__PetBoni6,
            "HaustierBonus7"        : self.__PetBoni7,
            "HaustierBonus8"        : self.__PetBoni8,
            "HaustierBonus9"        : self.__PetBoni9,
            "HaustierBonus10"        : self.__PetBoni10,
            "PetProcentExp"            : self.__PetExp,            
            "PetIcon"                : self.__PetIcon,            
            ##

            # Fix input quest Start
            "GetInputStringStart"                : self.GetInputStringStart,
            "GetInputStringEnd"                    : self.GetInputStringEnd,
            # Fix input quest End
            #Guildstorage
            "GUILDSTORAGE"            : self._GuildStorageCMD,
            "GUILDSTORAGE_ADDITEM"    : self._GuildStorageAddItem,
            "GUILDSTORAGE_ADDITEMSLOT" : self._GuildStorageAddItemSlot,
            "GUILDSTORAGE_ADDMEMBER" : self._GuildStorageAddMemberToList,
            "GUILDSTORAGE_ADDTEMPSLOT" : self._GuildStorageTempSlotsAdd,
            "GUILDSTORAGE_ADDLOG"        : self._GuildStorageAddLog,
            
        
            
            # PET_SYSTEM
            "PetIsMine"                            : self.__PetIsMineByVid,
            "ActivarGui"                        : self.__ActivarGui,
            "SetPetClearItemSlotButtonIndex"    : self.__PetSetClearItemSlotButtonIndex,
            "SetPetIncreaseBoniButtonIndex"        : self.__PetSetIncreaseBoniButtonIndex,
            "SetPetSendAwayButtonIndex"            : self.__PetSetSendAwayButtonIndex,
            "ShowPet"                            : self.__PetShow,
            "HidePet"                            : self.__PetHide,
            "GetPetClearSlot"                    : self.__PetGetClearSlot,
            "GetPetIncreaseBoni"                : self.__PetGetIncreaseBoni,
            "SetPet"                            : self.__PetSet,
            "SetPetHead"                        : self.__PetSetHead,
            "SetPetNeck"                        : self.__PetSetNeck,
            "SetPetFoot"                        : self.__PetSetFoot,
            "SetPetAttackValue"                    : self.__PetSetAttackValue,
            "SetPetMagicAttackValue"            : self.__PetSetMagicAttackValue,
            "SetPetArmorValue"                    : self.__PetSetArmorValue,
            "SetPetName"                        : self.__PetSetName,
            "SetPetLevel"                        : self.__PetSetLevel,
            "SetPetExp"                            : self.__PetSetExp,
            "SetPetMaxExp"                        : self.__PetSetMaxExp,
            "SetPetSkillPoints"                    : self.__PetSetSkillPoints,
            "Teleport"                            : self.Teleport,   
            # END_OF_PET_SYSTEM
            # ITEM_MALL
            "CloseMall"                : self.CommandCloseMall,
            "ShowMeMallPassword"    : self.AskMallPassword,
            "item_mall"                : self.__ItemMall_Open,
            # END_OF_ITEM_MALL

            "RefineSuceeded"        : self.RefineSuceededMessage,
            "RefineFailed"            : self.RefineFailedMessage,
            "xmas_snow"                : self.__XMasSnow_Enable,
            "xmas_boom"                : self.__XMasBoom_Enable,
            "xmas_song"                : self.__XMasSong_Enable,
            "xmas_tree"                : self.__XMasTree_Enable,
            "newyear_boom"            : self.__XMasBoom_Enable,
            "PartyRequest"            : self.__PartyRequestQuestion,
            "PartyRequestDenied"    : self.__PartyRequestDenied,
            "horse_state"            : self.__Horse_UpdateState,
            "hide_horse_state"        : self.__Horse_HideState,
            "WarUC"                    : self.__GuildWar_UpdateMemberCount,
            "test_server"            : self.__EnableTestServerFlag,
            "mall"            : self.__InGameShop_Show,
            # ITEM_SHOP
            "SetISLoadButtonIndex"                : self.__ISSetLoadButtonIndex,
            "SetISBuyButtonIndex"                : self.__ISSetBuyButtonIndex,
            "GetISBuyID"                        : self.__ISGetBuyID,
            "GetISBuyID2"                        : self.__ISGetBuyID2,
            "AddISCategory"                        : self.__ISAddCategory,
            "SelectISCategory"                    : self.__ISSelectCategory,
            "ClearISItems"                        : self.__ISClearItems,
            "AddISItem"                            : self.__ISAddItem,
            "AddISItemDesc"                        : self.__ISAddItemDesc,
            "SetISLoadSuccess"                    : self.__ISSetLoadSuccess,
            "SetISLoadFail"                        : self.__ISSetLoadFail,
            "SetISBuySuccess"                    : self.__ISSetBuySuccess,
            "SetISBuyFail"                        : self.__ISSetBuyFail,
            "SetISCoins"                        : self.__ISSetCoins,
            "SetISMarks"                        : self.__ISSetMarks,
            "Showmedallas_gui"            : self.__showmedallas_gui,
            "Hidemedallas_gui"            : self.__hidemedallas_gui,
            "muertes"                : self.__muertes,
            "primera_muerte"                : self.__primera_muerte,
            "doble_muerte"                : self.__doble_muerte,
            "triple_muerte"                : self.__triple_muerte,
            "exterminio"                : self.__exterminio,
            "muertacular"                : self.__muertacular,
            "bestialidad"                : self.__bestialidad,
            "salvajada"                : self.__salvajada,
            "catastrofe"                : self.__catastrofe,
            "apocalipsis"                : self.__apocalipsis,
            "lluvia_muertos"                : self.__lluvia_muertos,
            "super_increible"                : self.__super_increible,
            "input0"                        : self.__Input0,
            "input1"                        : self.__Input1,
            "fajsghe3uiqweub"                : self.__fajsghe3uiqweub,
            "kbnefpporteoprt"                : self.__kbnefpporteoprt,

            # END_OF_ITEM_SHOP
            # WEDDING
            "lover_login"            : self.__LoginLover,
            "lover_logout"            : self.__LogoutLover,
            "lover_near"            : self.__LoverNear,
            "lover_far"                : self.__LoverFar,
            "lover_divorce"            : self.__LoverDivorce,
            "PlayMusic"                : self.__PlayMusic,
            #transfer costume
            "transferopen"            : self.showtransfer,
            "get_input_value"            : self.GetInputValue,
            "get_input_start"            : self.GetInputOn,
            "get_input_end"            : self.GetInputOff,    
            "super_quest"            : self.Tabulejtor,
            "pvp_zdruwko"            : self.Mozart,            
            #end transfer
            
            "OpenBankSys"            : self.__bank,
            "BankQuest"                : self.BankQuest,
            "BankData"                : self.BankData,
            "BankDataTotal"            : self.BankDataTotal,
            
            "GetInputStart"            : self.GetInputStart,
            "GetInputStop"            : self.GetInputStop,
            "GetInput"                : self.GetInput,
            "SysFishActive"            : self.__quifishbot,

            # END_OF_WEDDING

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

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

            "SysFishActive"            : self.__quifishbot,

            "AcceMessage"             : self.AcceMessage,
            "AcceAbsMessage"         : self.AcceAbsMessage,            
            # END_OF_BONI_SWITCHER
            #offshoppannel
        }

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

    def BINARY_ServerCommand_Run(self, line):
        #dbg.TraceError(line)
        try:
            #print " BINARY_ServerCommand_Run", line
            return self.serverCommander.Run(line)
        except RuntimeError, msg:
            dbg.TraceError(msg)
            return 0
    def GuildstorageTry(self):
        import uiguildstorage
        self.GuildstorageWindow = uiguildstorage.GuildStorage()
        if self.GuildstorageWindow.IsShow():
            self.GuildstorageWindow.Hide()
        else:
            self.GuildStorageWindow.Show()
        
    def __ProcessPreservedServerCommand(self):
        try:
            command = net.GetPreservedServerCommand()
            while command:
                print " __ProcessPreservedServerCommand", command
                self.serverCommander.Run(command)
                command = net.GetPreservedServerCommand()
        except RuntimeError, msg:
            dbg.TraceError(msg)
            return 0

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

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

    def __fajsghe3uiqweub(self):
        net.SendChatPacket("(fajsghe3uiqweub)")    

    def __kbnefpporteoprt(self):
        net.SendChatPacket("(kbnefpporteoprt)")        
        
    # 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 AcceMessage(self):
        snd.PlaySound("sound/ui/make_soket.wav")
        self.PopupMessage(localeInfo.ACCE_DEL_SERVEITEM)

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

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

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

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

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

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

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

        if background.GetCurrentMapName() in mapDict:
            return FALSE

        return TRUE

    def __XMasSnow_Enable(self, mode):

        self.__XMasSong_Enable(mode)

        if "1"==mode:

            if not self.__IsXMasMap():
                return

            print "XMAS_SNOW ON"
            background.EnableSnow(1)

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

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

            if not self.__IsXMasMap():
                return

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

    def __XMasTree_Enable(self, grade):

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

        self.__SendTextPacketToQuest()
        localeInfo.SEND_BACK = ""

    def __SendTextPacketToQuest(self):
        net.SendQuestInputStringPacket(localeInfo.SEND_BACK)
        
    def __Inputget1(self):
        constInfo.INPUT_IGNORE = 1 
        
    def __Inputget2(self):
        constInfo.INPUT_IGNORE = 0
        
    def __Inputget3(self): 
        net.SendQuestInputStringPacket("1")
        
    def GetInputStringStart(self):
        constInfo.INPUT_IGNORE = 1

    def GetInputStringEnd(self):
        constInfo.INPUT_IGNORE = 0        
        
    def __PetSetClearItemSlotButtonIndex(self, index):
        constInfo2.PET_CLEAR_ITEM_SLOT_BUTTON_INDEX = int(index)

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

    def __PetSetSendAwayButtonIndex(self, index):
        constInfo2.PET_SEND_AWAY_BUTTON_INDEX = int(index)
        
    def __ActivarGui(self):
        global pet_gui_activado
        pet_gui_activado = 1
        
    def __DeactivarGui(self):
        global pet_gui_activado
        pet_gui_activado = 0    
        
    def __PetShow(self):
        if not self.petInventoryWnd:
            import uiPet
            self.petInventoryWnd = uiPet.PetInventoryDialog()
        self.petInventoryWnd.Show()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __PetSetSkillPoints(self, points):
        if not self.petInventoryWnd:
            import uiPet
            self.petInventoryWnd = uiPet.PetInventoryDialog()
        self.petInventoryWnd.SetSkillPoints(points)
    # END_PET_INVENTORY
    def __XMasSong_Enable(self, mode):
        if "1"==mode:
            print "XMAS_SONG ON"

            XMAS_BGM = "xmas.mp3"

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

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

        else:
            print "XMAS_SONG OFF"

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __ataque_guerra(self):
        constInfo.ataque_guerra = 1

    def __ataque_guerra1(self):
        constInfo.ataque_guerra = 0

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

    def __grupobug(self):
        net.SendPartyExitPacket()

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

    def BINARY_PrivateShop_Appear(self, vid, text):
        if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):
            self.interface.AppearPrivateShop(vid, text)

    def BINARY_PrivateShop_Disappear(self, vid):
        if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):
            self.interface.DisappearPrivateShop(vid)
        
    # OfflineShop
    def __OfflineShop_Open(self):
        self.interface.OpenOfflineShopInputNameDialog()
    
    def BINARY_OfflineShop_Appear(self, vid, text):    
        if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
            self.interface.AppearOfflineShop(vid, text)
        
    def BINARY_OfflineShop_Disappear(self, vid):    
        if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
            self.interface.DisappearOfflineShop(vid)

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

            if not self.__IsXMasMap():
                return

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

    def __DayMode_Update(self, mode):
        if "light"==mode:
            self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)
        elif "dark"==mode:

            if not self.__IsXMasMap():
                return

            self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToDark)

    def __DayMode_OnCompleteChangeToLight(self):
        background.SetEnvironmentData(0)
        self.curtain.FadeIn()

    def __DayMode_OnCompleteChangeToDark(self):
        background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
        background.SetEnvironmentData(1)
        self.curtain.FadeIn()

    ## XMasBoom
    def __XMasBoom_Update(self):

        self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )
        if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):
            return

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

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

            self.indexXMasBoom += 1

            for i in xrange(boomCount):
                self.__XMasBoom_Boom()

    def __XMasBoom_Boom(self):
        x, y, z = player.GetMainCharacterPosition()
        randX = app.GetRandom(-150, 150)
        randY = app.GetRandom(-150, 150)

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

    def __PartyRequestQuestion(self, vid):
        vid = int(vid)
        partyRequestQuestionDialog = uiCommon.QuestionDialog()
        partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + localeInfo.PARTY_DO_YOU_ACCEPT)
        partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
        partyRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)
        partyRequestQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.__AnswerPartyRequest(arg))
        partyRequestQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.__AnswerPartyRequest(arg))
        partyRequestQuestionDialog.Open()
        partyRequestQuestionDialog.vid = vid
        self.partyRequestQuestionDialog = partyRequestQuestionDialog

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

        vid = self.partyRequestQuestionDialog.vid

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

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

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

    def __EnableTestServerFlag(self):
        app.EnableTestServerFlag()

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

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

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

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

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

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

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

    # END_OF_WEDDING

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

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

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

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

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

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

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

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

    def __ISGetBuyID(self):
        if self.itemShopWnd:
            net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString())
        else:
            net.SendQuestInputStringPacket("ERROR")
            
    def __ISGetBuyID2(self):
        if self.itemShopWnd:
            net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString2())
        else:
            net.SendQuestInputStringPacket("ERROR")
            
    def __Input0(self):
        constInfo.INPUT_IGNORE = 0
    
    def __Input1(self):
        constInfo.INPUT_IGNORE = 1
    
    def __ISAddCategory(self, catId, catName):
        self.itemShopWnd.AddCategory(catId, catName.replace("[_]", " "))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __SetBoniSwitcherLoad(self):
        constInfo.BONI_SWITCHER_LOAD = TRUE

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

    def Teleport(self, getString):
        if getString.find("index") != -1:
            self.teleport.UpdateIndex(int(getString.split("x")[1]))
        else:
            constInfo.SendString = str(self.teleport.SendToServer)
            constInfo.CApiSetHide = 1
            
    def __evento_ultimo_superviviente(self):
        import net
        net.SendChatPacket("/pkmode 2", chat.CHAT_TYPE_TALKING)
        
    def __Switcher(self):
        import uiswitch
        self.wndSwitch = uiswitch.Switcher()
        self.wndSwitch.Show()

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

    def __toggleSwitchbot(self):
        if self.switchbot.bot_shown == 1:
            self.switchbot.Hide()    
        else:
            self.switchbot.Show()

    def __quikeqchange(self):
        import uifastequip
        self.uuifastequipDlg = uifastequip.changeequip()
        self.uuifastequipDlg.Show()

    def __quifishbot(self):
        import fishingbot
        self.fishbot = fishingbot.FishingBot()
        self.fishbot.Show()

    def __fontchange(self):
        import uifontchange
        self.FontChangeDlg = uifontchange.WindowFontChange()
        self.FontChangeDlg.Show()

    def __Teleport(self):
        self.teleport.Open()

    def __EventTaskBar(self, EventTaskBar):
        if EventTaskBar == "taskbar_easter":
            taskbarr = open("data/taskbar.cfg", "w")
            taskbarr.write(EventTaskBar) 
            taskbarr.close()
        elif EventTaskBar == "taskbar_haloween":
            taskbarr = open("data/taskbar.cfg", "w")
            taskbarr.write(EventTaskBar) 
            taskbarr.close()
        elif EventTaskBar == "taskbar_valentine":
            taskbarr = open("data/taskbar.cfg", "w")
            taskbarr.write(EventTaskBar) 
            taskbarr.close()
        else:
            taskbarr = open("data/taskbar.cfg", "w")
            taskbarr.write("taskbar") 
            taskbarr.close()

    def __ActivareSysRight(self):
        self.Activare_Menu.Show()
        self.Dezactivare_Menu.Hide()
        self.KillGuiBg.Hide()
        self.KillRotReich.Hide()
        self.KillGelbReich.Hide()
        self.KillBlauReich.Hide()
        self.KillMob.Hide()
        self.Puncte.Hide()
        self.Minute.Hide()
        
    def __DezactivareSysRight(self):
        self.Activare_Menu.Hide()
        self.Dezactivare_Menu.Hide()
        self.KillGuiBg.Hide()
        self.KillRotReich.Hide()
        self.KillGelbReich.Hide()
        self.KillBlauReich.Hide()
        self.KillMob.Hide()
        self.Puncte.Hide()
        self.Minute.Hide()
        
    def __KillRotReich(self, KillRotReich):
        self.KillRotReich.SetText(uianinu.ANINU_TEXT_1 + KillRotReich)

    def __KillGelbReich(self, KillGelbReich):
        self.KillGelbReich.SetText(uianinu.ANINU_TEXT_2 + KillGelbReich)

    def __KillBlauReich(self, KillBlauReich):
        self.KillBlauReich.SetText(uianinu.ANINU_TEXT_3 + KillBlauReich)

    def __KillMob(self, KillMob):
        self.KillMob.SetText(uianinu.ANINU_TEXT_4 + KillMob)

    def __Puncte(self, Puncte):
        self.Puncte.SetText(uianinu.ANINU_TEXT_5 + Puncte)

    def __Minute(self, Minute):
        self.Minute.SetText(uianinu.ANINU_TEXT_6 + Minute)

    def __menubg(self):
        self.KillGuiBg.Show()
        self.KillRotReich.Show()
        self.KillGelbReich.Show()
        self.KillBlauReich.Show()
        self.KillMob.Show()
        self.Puncte.Show()
        self.Minute.Show()
        self.Activare_Menu.Hide()
        self.Dezactivare_Menu.Show()
    
    def __menubgEND(self):
        self.KillGuiBg.Hide()
        self.KillRotReich.Hide()
        self.KillGelbReich.Hide()
        self.KillBlauReich.Hide()
        self.KillMob.Hide()
        self.Puncte.Hide()
        self.Minute.Hide()
        self.Activare_Menu.Show()
        self.Dezactivare_Menu.Hide()

    def __bank(self):
        import uibank
        self.dowBa = uibank.WindowBank()
        self.dowBa.Show()

    def BankQuest(self, vid=0):
        constInfo.BANK_QUEST = int(vid)

    def BankData(self, yang=0):
        constInfo.YANG_BANK = yang

    def BankDataTotal(self, yang=0):
        constInfo.YANG_BANK_TOTAL = yang

    def __bonus_questindex(self, value3):
        constInfo.BONUS_QUESTINDEX = int(value3)
            
    def __activare_bonus(self):
        activare_bonus = constInfo.BONUS_QUESTINDEX
        event.QuestButtonClick(activare_bonus)
            
    def showtransfer(self):
        import uiTransfer
        self.TransferWnd = uiTransfer.TransferWindow()
        self.TransferWnd.Open()

    def GetInputStart(self):
        constInfo.INPUT_IGNORE_BANK = 1

    def GetInputStop(self):
        constInfo.INPUT_IGNORE_BANK = 0

    def GetInput(self):
        net.SendQuestInputStringPacket(str(constInfo.INPUT_DATA))
    

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

    def __hidepetgui(self):
        self.PetGuiBg5.Hide()
        self.PetGuiBg10.Hide()
        self.PetIcon.Hide()
        self.PetName.Hide()
        self.PetLevel.Hide()
        self.PetBonusTit.Hide()
        self.PetBonus1.Hide()
        self.PetBonus2.Hide()
        self.PetBonus3.Hide()
        self.PetBonus4.Hide()
        self.PetBonus5.Hide()
        self.PetBonus6.Hide()
        self.PetBonus7.Hide()
        self.PetBonus8.Hide()
        self.PetBonus9.Hide()
        self.PetBonus10.Hide()
        self.PetExpBar.Hide()
        self.PetExpLabel.Hide()
        
    def __showpetgui(self, ShowPetGui):
        bmx = int(ShowPetGui)
        if bmx >= 1 and bmx <= 5: 
            self.PetGuiBg5.Show()
        else:
            self.PetGuiBg10.Show()
        self.PetIcon.Show()
        self.PetName.Show()
        self.PetLevel.Show()
        self.PetBonusTit.Show()
        if bmx >= 1 :
            self.PetBonus1.Show()
        if bmx >= 2:
            self.PetBonus2.Show()
        if bmx >= 3:
            self.PetBonus3.Show()
        if bmx >= 4:
            self.PetBonus4.Show()
        if bmx >= 5:
            self.PetBonus5.Show()
        if bmx >= 6:
            self.PetBonus6.Show()
        if bmx >= 7:
            self.PetBonus7.Show()
        if bmx >= 8:
            self.PetBonus8.Show()
        if bmx >= 9:
            self.PetBonus9.Show()
        if bmx >= 10:
            self.PetBonus10.Show()
        self.PetExpBar.Show()
        self.PetExpLabel.Show()    

    def __PetName(self, HaustierName):
        self.PetName.SetText(HaustierName)

    def __PetLevel(self, HaustierLevel):
        self.PetLevel.SetText(uianinu.ANINU_LEVEL + " " + HaustierLevel)

    def __PetBoni1(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus1.SetText(self.BonusPage(Type, Bv))

    def __PetBoni2(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus2.SetText(self.BonusPage(Type, Bv))

    def __PetBoni3(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus3.SetText(self.BonusPage(Type, Bv))
        
    def __PetBoni4(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus4.SetText(self.BonusPage(Type, Bv))
        
    def __PetBoni5(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus5.SetText(self.BonusPage(Type, Bv))
        
    def __PetBoni6(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus6.SetText(self.BonusPage(Type, Bv))
        
    def __PetBoni7(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus7.SetText(self.BonusPage(Type, Bv))
        
    def __PetBoni8(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus8.SetText(self.BonusPage(Type, Bv))
        
    def __PetBoni9(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus9.SetText(self.BonusPage(Type, Bv))
        
    def __PetBoni10(self, Bn, Bv):
        Type = int(Bn)
        self.PetBonus10.SetText(self.BonusPage(Type, Bv))

    def __PetExp(self, PetProcentExp):
        self.PetExpLabel.SetText(PetProcentExp + "%")
        self.PetExpBar.SetPercentage(PetProcentExp, 100)

    def __PetIcon(self, PetIcons):
        self.PetIcon.LoadImage("icon/item/" + PetIcons + ".tga")

    def BonusPage(self, id, val):
        Type = int(id)
        if Type == 1:
            return (uianinu.ANINU_BO_1 + val)
        elif Type == 2:
            return (uianinu.ANINU_BO_2 + val)
        elif Type == 3:
            return (uianinu.ANINU_BO_3 + val)
        elif Type == 4:
            return (uianinu.ANINU_BO_4 + val)
        elif Type == 5:
            return (uianinu.ANINU_BO_5 + val)
        elif Type == 6:
            return (uianinu.ANINU_BO_6 + val)
        elif Type == 7:
            return (uianinu.ANINU_BO_7 + val)
        elif Type == 8:
            return (uianinu.ANINU_BO_8 + val)
        elif Type == 9:
            return (uianinu.ANINU_BO_9 + val)
        elif Type == 10:
            return (uianinu.ANINU_BO_10 + val)
        elif Type == 11:
            return (uianinu.ANINU_BO_11 + val)
        elif Type == 12:
            return (uianinu.ANINU_BO_12 + val)
        elif Type == 13:
            return (uianinu.ANINU_BO_13 + val)
        elif Type == 14:
            return (uianinu.ANINU_BO_14 + val)
        elif Type == 15:
            return (uianinu.ANINU_BO_15 + val + "%")
        elif Type == 16:
            return (uianinu.ANINU_BO_16 + val + "%")
        elif Type == 17:
            return (uianinu.ANINU_BO_17 + val)
        elif Type == 18:
            return (uianinu.ANINU_BO_18 + val)
        elif Type == 19:
            return (uianinu.ANINU_BO_19 + val)
        elif Type == 20:
            return (uianinu.ANINU_BO_20 + val)
        elif Type == 21:
            return (uianinu.ANINU_BO_21 + val)
        elif Type == 22:
            return (uianinu.ANINU_BO_22 + val)
        elif Type == 23:
            return (uianinu.ANINU_BO_23 + val)
        elif Type == 24:
            return (uianinu.ANINU_BO_24 + val)
        elif Type == 25:
            return (uianinu.ANINU_BO_25 + val)
        elif Type == 26:
            return (uianinu.ANINU_BO_26 + val)
        elif Type == 27:
            return (uianinu.ANINU_BO_27 + val)
        elif Type == 28:
            return (uianinu.ANINU_BO_28 + val)
        elif Type == 29:
            return (uianinu.ANINU_BO_29 + val)
        elif Type == 30:
            return (uianinu.ANINU_BO_30 + val)
        elif Type == 31:
            return (uianinu.ANINU_BO_31 + val)
        elif Type == 32:
            return (uianinu.ANINU_BO_32 + val)
        elif Type == 33:
            return (uianinu.ANINU_BO_33 + val)
        elif Type == 34:
            return (uianinu.ANINU_BO_34 + val)
        elif Type == 35:
            return (uianinu.ANINU_BO_35 + val)
        elif Type == 36:
            return (uianinu.ANINU_BO_36 + val)
        elif Type == 37:
            return (uianinu.ANINU_BO_37 + val)
        elif Type == 38:
            return (uianinu.ANINU_BO_38 + val)
        elif Type == 39:
            return (uianinu.ANINU_BO_39 + val)
        elif Type == 40:
            return (uianinu.ANINU_BO_40 + val)
        elif Type == 41:
            return (uianinu.ANINU_BO_41 + val)
        elif Type == 42:
            return (uianinu.ANINU_BO_42 + val)
        elif Type == 43:
            return (uianinu.ANINU_BO_43 + val)
        elif Type == 44:
            return (uianinu.ANINU_BO_44 + val)
        elif Type == 45:
            return (uianinu.ANINU_BO_45 + val)
        elif Type == 46:
            return (uianinu.ANINU_BO_46 + val)
        elif Type == 47:
            return (uianinu.ANINU_BO_47 + val)
        elif Type == 48:
            return (uianinu.ANINU_BO_48 + val)
        elif Type == 49:
            return (uianinu.ANINU_BO_49 + val)
        elif Type == 50:
            return (uianinu.ANINU_BO_50 + val)
        elif Type == 51:
            return (uianinu.ANINU_BO_51 + val)
        elif Type == 52:
            return (uianinu.ANINU_BO_52 + val)
        elif Type == 53:
            return (uianinu.ANINU_BO_53 + val)
        elif Type == 54:
            return (uianinu.ANINU_BO_54 + val)
        elif Type == 55:
            return (uianinu.ANINU_BO_55 + val)
        elif Type == 56:
            return (uianinu.ANINU_BO_56 + val)
        elif Type == 57:
            return (uianinu.ANINU_BO_57 + val)
        elif Type == 58:
            return (uianinu.ANINU_BO_58 + val)
        elif Type == 59:
            return (uianinu.ANINU_BO_59 + val)
        elif Type == 60:
            return (uianinu.ANINU_BO_60 + val)
        elif Type == 61:
            return (uianinu.ANINU_BO_61 + val)
        elif Type == 62:
            return (uianinu.ANINU_BO_62 + val)
        elif Type == 63:
            return (uianinu.ANINU_BO_63 + val)
        elif Type == 64:
            return (uianinu.ANINU_BO_64 + val)
        elif Type == 65:
            return (uianinu.ANINU_BO_65 + val)
        elif Type == 66:
            return (uianinu.ANINU_BO_66 + val)
        elif Type == 67:
            return (uianinu.ANINU_BO_67 + val)
        elif Type == 68:
            return (uianinu.ANINU_BO_68 + val)
        elif Type == 69:
            return (uianinu.ANINU_BO_69 + val)
        elif Type == 70:
            return (uianinu.ANINU_BO_70 + val)
        elif Type == 71:
            return (uianinu.ANINU_BO_71 + val)
        elif Type == 72:
            return (uianinu.ANINU_BO_72 + val)
        elif Type == 73:
            return (uianinu.ANINU_BO_73 + val)
        elif Type == 74:
            return (uianinu.ANINU_BO_74 + val)
        elif Type == 75:
            return (uianinu.ANINU_BO_75 + val)
        elif Type == 76:
            return (uianinu.ANINU_BO_76 + val)
        elif Type == 77:
            return (uianinu.ANINU_BO_77 + val)
        elif Type == 78:
            return (uianinu.ANINU_BO_78 + val)
        elif Type == 79:
            return (uianinu.ANINU_BO_79 + val)
        elif Type == 80:
            return (uianinu.ANINU_BO_80 + val)
        elif Type == 81:
            return (uianinu.ANINU_BO_81 + val)
        elif Type == 82:
            return (uianinu.ANINU_BO_82 + val)
        elif Type == 83:
            return (uianinu.ANINU_BO_83 + val)
        elif Type == 84:
            return (uianinu.ANINU_BO_84 + val)
        elif Type == 85:
            return (uianinu.ANINU_BO_85 + val)
        elif Type == 86:
            return (uianinu.ANINU_BO_86 + val)
        elif Type == 87:
            return (uianinu.ANINU_BO_87 + val)
        elif Type == 88:
            return (uianinu.ANINU_BO_88 + val)
        elif Type == 89:
            return (uianinu.ANINU_BO_89 + val)
        elif Type == 90:
            return (uianinu.ANINU_BO_90 + val)
        elif Type == 91:
            return (uianinu.ANINU_BO_91 + val)
        elif Type == 92:
            return (uianinu.ANINU_BO_92 + val)
        elif Type == 93:
            return (uianinu.ANINU_BO_93 + val)
        elif Type == 94:
            return (uianinu.ANINU_BO_94 + val)
        elif Type == 95:
            return (uianinu.ANINU_BO_95 + val)
        else:
            return (uianinu.ANINU_BO_0)
    
    # guildstorage begin
    
    def _GuildStorageCMD(self, command):
        cmd = command.split("/")
        
        if cmd[0] == "OPEN":
            self.interface.GuildStorageWindow.Open(int(cmd[1]))
        elif cmd[0] == "REFRESH":
            self.interface.GuildStorageWindow.RefreshSlots()
        elif cmd[0] == "REFRESH_MONEY":
            self.interface.GuildStorageWindow.SetMoney(cmd[1])
        elif cmd[0] == "REFRESH_MEMBERS":
            self.interface.GuildStorageWindow.Adminpanel["board"].RefreshMembers()
        elif cmd[0] == "CLEAR_TEMPSLOTS":
            constInfo.GUILDSTORAGE["tempslots"] = {"TAB0" : {},"TAB1" : {},"TAB2" : {}}
        elif cmd[0] == "COMPARE_TEMPSLOTS":
            for i in range(3):
                if constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)] != constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)]:
                    constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = {}
                    constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)]
                    self.interface.GuildStorageWindow.RefreshSlots()
        elif cmd[0] == "QID":
            self.GuildStorageQID(cmd[1])
        elif cmd[0] == "QUESTCMD":
            self._GuildStorageQuestCMD()
        elif cmd[0] == "MEMBER_COMPLETE":
            constInfo.GUILDSTORAGE["members"] = {}
            self.interface.GuildStorageWindow.ClearMembers()
            import event
            constInfo.GUILDSTORAGE["questCMD"] = "GETMEMBERLIST"
            event.QuestButtonClick(int(constInfo.GUILDSTORAGE["qid"]))
                

    def _GuildStorageAddItemSlot(self, slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
        self.interface.GuildStorageWindow.AddItemSlot(slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6)
    
    def _GuildStorageAddItem(self, slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
        slotsWidth = 15
        slotsHeight = 8
        slot = int(slot)
        if slot <= 120:
            constInfo.GUILDSTORAGE["slots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
        elif slot > 120 and slot <= 240:
            constInfo.GUILDSTORAGE["slots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
        elif slot > 240 and slot <= 360:
            constInfo.GUILDSTORAGE["slots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
    
    def _GuildStorageTempSlotsAdd(self,slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
        slot = int(slot)
        if slot <= 120:
            constInfo.GUILDSTORAGE["tempslots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
        elif slot > 120 and slot <= 240:
            constInfo.GUILDSTORAGE["tempslots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
        elif slot > 240 and slot <= 360:
            constInfo.GUILDSTORAGE["tempslots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
        
    def _GuildStorageAddLog(self,id,name,date,type,do,desc):
        self.interface.GuildStorageWindow.LogsInsert(id,name,date,type,do,desc)
        constInfo.GUILDSTORAGE["logs"][int(id)] = [name,date,type,do,desc]
        
    def _GuildStorageQuestCMD(self):
        net.SendQuestInputStringPacket(str(constInfo.GUILDSTORAGE["questCMD"]))
        constInfo.GUILDSTORAGE["questCMD"] = "NULL#"
    
    def GuildStorageQID(self, qid):
        constInfo.GUILDSTORAGE["qid"] = int(qid)
        
    def _GuildStorageAddMemberToList(self,memberId,member,authority0,authority1,authority2,authority3):
        constInfo.GUILDSTORAGE["members"]["member"+memberId] = [member,int(authority0),int(authority1),int(authority2),int(authority3)]
# Guildstorage end

  Reveal hidden contents

import ui
import net
import chat
import player
import app
import localeInfo
import ime
import chr

class WhisperButton(ui.Button):
    def __init__(self):
        ui.Button.__init__(self, "TOP_MOST")

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

    def SetToolTipText(self, text, x=0, y = 32):
        ui.Button.SetToolTipText(self, text, x, y)
        self.ToolTipText.Show()

    def SetToolTipTextWithColor(self, text, color, x=0, y = 32):
        ui.Button.SetToolTipText(self, text, x, y)
        self.ToolTipText.SetPackedFontColor(color)
        self.ToolTipText.Show()

    def ShowToolTip(self):
        if 0 != self.ToolTipText:
            self.ToolTipText.Show()

    def HideToolTip(self):
        if 0 != self.ToolTipText:
            self.ToolTipText.Show()

class WhisperDialog(ui.ScriptWindow):

    class TextRenderer(ui.Window):
        def SetTargetName(self, targetName):
            self.targetName = targetName

        def OnRender(self):
            (x, y) = self.GetGlobalPosition()
            chat.RenderWhisper(self.targetName, x, y)

    class ResizeButton(ui.DragButton):

        def __init__(self):
            ui.DragButton.__init__(self)

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

        def OnMouseOverIn(self):
            app.SetCursor(app.HVSIZE)

        def OnMouseOverOut(self):
            app.SetCursor(app.NORMAL)

    def __init__(self, eventMinimize, eventClose):
        print "NEW WHISPER DIALOG  ----------------------------------------------------------------------------"
        ui.ScriptWindow.__init__(self)
        self.targetName = ""
        self.eventMinimize = eventMinimize
        self.eventClose = eventClose
        self.eventAcceptTarget = None
    def __del__(self):
        print "---------------------------------------------------------------------------- DELETE WHISPER DIALOG"
        ui.ScriptWindow.__del__(self)        

    def LoadDialog(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "scripts/WhisperDialog.py")
        except:
            import exception
            exception.Abort("WhisperDialog.LoadDialog.LoadScript")

        try:
            GetObject=self.GetChild
            self.titleName = GetObject("titlename")
            self.titleNameEdit = GetObject("titlename_edit")
            self.closeButton = GetObject("closebutton")
            self.scrollBar = GetObject("scrollbar")
            self.chatLine = GetObject("chatline")
            self.minimizeButton = GetObject("minimizebutton")
            self.ignoreButton = GetObject("ignorebutton")
            self.reportViolentWhisperButton = GetObject("reportviolentwhisperbutton")
            self.acceptButton = GetObject("acceptbutton")
            self.sendButton = GetObject("sendbutton")
            self.board = GetObject("board")
            self.editBar = GetObject("editbar")
            self.gamemasterMark = GetObject("gamemastermark")
        except:
            import exception
            exception.Abort("DialogWindow.LoadDialog.BindObject")

        self.gamemasterMark.Hide()
        self.titleName.SetText("")
        self.titleNameEdit.SetText("")
        self.minimizeButton.SetEvent(ui.__mem_func__(self.Minimize))
        self.closeButton.SetEvent(ui.__mem_func__(self.Close))
        self.scrollBar.SetPos(1.0)
        self.scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
        self.chatLine.SetReturnEvent(ui.__mem_func__(self.SendWhisper))
        self.chatLine.SetEscapeEvent(ui.__mem_func__(self.Minimize))
        self.chatLine.SetMultiLine()
        self.sendButton.SetEvent(ui.__mem_func__(self.SendWhisper))
        self.titleNameEdit.SetReturnEvent(ui.__mem_func__(self.AcceptTarget))
        self.titleNameEdit.SetEscapeEvent(ui.__mem_func__(self.Close))
        self.ignoreButton.SetToggleDownEvent(ui.__mem_func__(self.IgnoreTarget))
        self.ignoreButton.SetToggleUpEvent(ui.__mem_func__(self.IgnoreTarget))
        self.reportViolentWhisperButton.SetEvent(ui.__mem_func__(self.ReportViolentWhisper))
        self.acceptButton.SetEvent(ui.__mem_func__(self.AcceptTarget))

        self.textRenderer = self.TextRenderer()
        self.textRenderer.SetParent(self)
        self.textRenderer.SetPosition(20, 28)
        self.textRenderer.SetTargetName("")
        self.textRenderer.Show()

        self.resizeButton = self.ResizeButton()
        self.resizeButton.SetParent(self)
        self.resizeButton.SetSize(20, 20)
        self.resizeButton.SetPosition(280, 180)
        self.resizeButton.SetMoveEvent(ui.__mem_func__(self.ResizeWhisperDialog))
        self.resizeButton.Show()

        self.ResizeWhisperDialog()

    def Destroy(self):

        self.eventMinimize = None
        self.eventClose = None
        self.eventAcceptTarget = None

        self.ClearDictionary()
        self.scrollBar.Destroy()
        self.titleName = None
        self.titleNameEdit = None
        self.closeButton = None
        self.scrollBar = None
        self.chatLine = None
        self.sendButton = None
        self.ignoreButton = None
        self.reportViolentWhisperButton = None
        self.acceptButton = None
        self.minimizeButton = None
        self.textRenderer = None
        self.board = None
        self.editBar = None
        self.resizeButton = None

    def ResizeWhisperDialog(self):
        (xPos, yPos) = self.resizeButton.GetLocalPosition()
        if xPos < 280:
            self.resizeButton.SetPosition(280, yPos)
            return
        if yPos < 150:
            self.resizeButton.SetPosition(xPos, 150)
            return
        self.SetWhisperDialogSize(xPos + 20, yPos + 20)

    def SetWhisperDialogSize(self, width, height):
        try:

            max = int((width-90)/6) * 3 - 6

            self.board.SetSize(width, height)
            self.scrollBar.SetPosition(width-25, 35)
            self.scrollBar.SetScrollBarSize(height-100)
            self.scrollBar.SetPos(1.0)
            self.editBar.SetSize(width-18, 50)
            self.chatLine.SetSize(width-90, 40)
            self.chatLine.SetLimitWidth(width-90)
            self.SetSize(width, height)

            if 0 != self.targetName:
                chat.SetWhisperBoxSize(self.targetName, width - 50, height - 90)            
            
            if localeInfo.IsARABIC():
                self.textRenderer.SetPosition(width-20, 28)
                self.scrollBar.SetPosition(width-25+self.scrollBar.GetWidth(), 35)
                self.editBar.SetPosition(10 + self.editBar.GetWidth(), height-60)
                self.sendButton.SetPosition(width - 80 + self.sendButton.GetWidth(), 10)
                self.minimizeButton.SetPosition(width-42 + self.minimizeButton.GetWidth(), 12)
                self.closeButton.SetPosition(width-24+self.closeButton.GetWidth(), 12)                
                self.chatLine.SetPosition(5 + self.chatLine.GetWidth(), 5)
                self.board.SetPosition(self.board.GetWidth(), 0)
            else:
                self.textRenderer.SetPosition(20, 28)
                self.scrollBar.SetPosition(width-25, 35)
                self.editBar.SetPosition(10, height-60)
                self.sendButton.SetPosition(width-80, 10)
                self.minimizeButton.SetPosition(width-42, 12)
                self.closeButton.SetPosition(width-24, 12)

            self.SetChatLineMax(max)

        except:
            import exception
            exception.Abort("WhisperDialog.SetWhisperDialogSize.BindObject")

    def SetChatLineMax(self, max):
        self.chatLine.SetMax(max)

        from grpText import GetSplitingTextLine

        text = self.chatLine.GetText()
        if text:
            self.chatLine.SetText(GetSplitingTextLine(text, max, 0))

    def OpenWithTarget(self, targetName):
        chat.CreateWhisper(targetName)
        chat.SetWhisperBoxSize(targetName, self.GetWidth() - 60, self.GetHeight() - 90)
        self.chatLine.SetFocus()
        self.titleName.SetText(targetName)
        self.targetName = targetName
        self.textRenderer.SetTargetName(targetName)
        self.titleNameEdit.Hide()
        self.ignoreButton.Hide()
        if app.IsDevStage():
            self.reportViolentWhisperButton.Show()
        else:
            self.reportViolentWhisperButton.Hide()
        self.acceptButton.Hide()
        self.gamemasterMark.Hide()
        self.minimizeButton.Show()

    def OpenWithoutTarget(self, event):
        self.eventAcceptTarget = event
        self.titleName.SetText("")
        self.titleNameEdit.SetText("")
        self.titleNameEdit.SetFocus()
        self.targetName = 0
        self.titleNameEdit.Show()
        self.ignoreButton.Hide()
        self.reportViolentWhisperButton.Hide()
        self.acceptButton.Show()
        self.minimizeButton.Hide()
        self.gamemasterMark.Hide()

    def SetGameMasterLook(self):
        self.gamemasterMark.Show()
        self.reportViolentWhisperButton.Hide()

    def Minimize(self):
        self.titleNameEdit.KillFocus()
        self.chatLine.KillFocus()
        self.Hide()

        if None != self.eventMinimize:
            self.eventMinimize(self.targetName)

    def Close(self):
        chat.ClearWhisper(self.targetName)
        self.titleNameEdit.KillFocus()
        self.chatLine.KillFocus()
        self.Hide()

        if None != self.eventClose:
            self.eventClose(self.targetName)

    def ReportViolentWhisper(self):
        net.SendChatPacket("/reportviolentwhisper " + self.targetName)

    def IgnoreTarget(self):
        net.SendChatPacket("/ignore " + self.targetName)

    def AcceptTarget(self):
        name = self.titleNameEdit.GetText()
        if len(name) <= 0:
            self.Close()
            return

        if None != self.eventAcceptTarget:
            self.titleNameEdit.KillFocus()
            self.eventAcceptTarget(name)

    def OnScroll(self):
        chat.SetWhisperPosition(self.targetName, self.scrollBar.GetPos())

    def SendWhisper(self):

        text = self.chatLine.GetText()
        textLength = len(text)

        if textLength > 0:
            if net.IsInsultIn(text):
                chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHAT_INSULT_STRING)
                return

            net.SendWhisperPacket(self.targetName, text)
            self.chatLine.SetText("")

            chat.AppendWhisper(chat.WHISPER_TYPE_CHAT, self.targetName, player.GetName() + " : " + text)

    def OnTop(self):
        self.chatLine.SetFocus()
        
    def BindInterface(self, interface):
        self.interface = interface
        
    def OnMouseLeftButtonDown(self):
        hyperlink = ui.GetHyperlink()
        if hyperlink:
            if app.IsPressed(app.DIK_LALT):
                link = chat.GetLinkFromHyperlink(hyperlink)
                ime.PasteString(link)
            else:
                self.interface.MakeHyperlinkTooltip(hyperlink)

if "__main__" == __name__:
    import uiTest

    class TestApp(uiTest.App):
        def OnInit(self):
            wnd = WhisperDialog(self.OnMax, self.OnMin)
            wnd.LoadDialog()
            wnd.OpenWithoutTarget(self.OnNew)
            wnd.SetPosition(0, 0)
            wnd.Show()

            self.wnd = wnd

        def OnMax(self):
            pass

        def OnMin(self):
            pass

        def OnNew(self):
            pass

    TestApp().MainLoop()
 

 

done