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

import uimg
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
import handelscenter

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

import playerSettingModule
import interfaceModule

import musicInfo
import debugInfo
import stringCommander
import uipetsystem
import uibabysystem

from _weakref import proxy

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

# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = False
SCREENSHOT_DIR = None

if localemg.IsEUROPE():
    SCREENSHOT_CWDSAVE = True

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

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

testAlignment = 0
BPisLoaded = 0

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

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

        self.PointsWindowIsOpen = 0
        self.SkillsWindowIsOpen = 0
        self.SkillInfo = 0
        self.SkillActivatedInfo = 0

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

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

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

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

        self.petmain = self.interface.petmain
        self.petmini = self.interface.petmini

        self.babymain = self.interface.babymain
        self.babymini = self.interface.babymini

        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.wndHandelscenter = handelscenter.Handelscenter()
        constInfo.HANDELSCENTER_STATE = self.wndHandelscenter

        # shop offline
        self.uiNewShopCreate = None
        self.uiNewShop = None

        # Teleportacja
        import uiteleport
        self.teleport = uiteleport.TeleportWindow()

        # Nagroda boss
        import nagroda_boss
        self.NagrodaBoss = nagroda_boss.NagrodaBoss()
        self.NagrodaBoss.Hide()

        # Teleportacja Nowa
        import teleportacja
        self.teleportacja = teleportacja.MapaTeleportacyjna()
        self.teleportacja.Hide()

        # Szarfy
        import uiacce
        self.Acce_okno = uiacce.AcceAbsorbWindow()

        # Tombola
        import tombola
        self.dlgTombola = tombola.TombolaWindow()
        constInfo.TOMBOLA = self.dlgTombola

        # Bonowarka
        import switchbot
        self.wndBonowarka = switchbot.Bot()

        # Mega Wierzchowce
        import uimounty
        self.dlgMegaMounty = uimounty.MountyDialog()

        # Mega Zwierz?tka
        import uipety
        self.dlgMegaPety = uipety.PetyDialog()

        # Marmury Polimorfi
        import sklep_marmur
        self.dlgMarmury = sklep_marmur.marmury()

        # Mega Zwierz?tka
        import uibonus
        self.dlgBonus = uibonus.BonusWindow()

        # Mega Dzieci
        import uidziecko
        self.dlgDziecko = uidziecko.DzieckoDialog()

        # Biolog
        import uibiolog_new
        self.uibiolog_new_open = uibiolog_new.Biolog()
        constInfo.BIOLOG_NEW = self.uibiolog_new_open

        # Wiki
        import uiwiki
        import uibiolog
    #   self.dlgWiki = uiwiki.AgeofPlatonWiki()
    #   self.dlgWiki = uibiolog.VenturisBiolog()

        # Wiki
        import uibony
        self.dlgBonusy = uibony.OknoBonow()

        # Tytuły
        # if app.ENABLE_TITLE_SYSTEM:
            # import title_system
            # self.wndTitleSystem = title_system.Title_System()

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

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

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

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

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

        self.SkillsSystemManage()
        self.PointsWindow()
        self.SkillsWindow()

        global cameraDistance, cameraPitch, cameraRotation, cameraHeight

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

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

        # TWO_HANDED_WEAPON_ATTACK_SPEED_UP
        constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
        # END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP

        import uiNewShop
        self.uiNewShop = uiNewShop.ShopDialog()
        constInfo.NEW_SHOP = self.uiNewShop
        self.uiNewShop.BindInterface(self.interface)
        self.uiNewShop.Close()
        self.uiNewShopCreate = uiNewShop.ShopDialogCreate()
        constInfo.NEW_SHOP_CREATE = self.uiNewShopCreate
        self.uiNewShopCreate.Hide()

        import event
        event.SetLeftTimeString(localemg.UI_LEFT_TIME)

        textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)

        if constInfo.PVPMODE_TEST_ENABLE:
            self.testPKMode = uimg.TextLine()
            self.testPKMode.SetFontName(localemg.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 = uimg.TextLine()
            self.testAlignment.SetFontName(localemg.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

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

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

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

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

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

        net.SendEnterGamePacket()

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

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

        self.PointsBG.Hide()
        self.SkillsBG.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()

        self.uiNewShop.Hide()
        self.uiNewShopCreate.Hide()
        uiPrivateShopBuilder.Clear()

        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.petmain.Close()
        self.petmini.Close()

        self.babymain.Close()
        self.babymini.Close()

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

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

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

        if app.ENABLE_TITLE_SYSTEM:
            self.interface.wndTitle.Close()

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

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

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

    #   onPressKeyDict[app.DIK_F6]  = lambda : self.__Teleport_Open()
        onPressKeyDict[app.DIK_TAB] = lambda : self.__Teleportacja()
    #   onPressKeyDict[app.DIK_F7]  = lambda : self.__OpenAchievementsystemWindow()
        onPressKeyDict[app.DIK_F8]  = lambda : self.__OnClickMagazynButton()
        onPressKeyDict[app.DIK_F9]  = lambda : self.__HandelsOpen()
        onPressKeyDict[app.DIK_F10] = lambda : self.__Tombola()
        onPressKeyDict[app.DIK_F11] = lambda : self.__ClickBon_Switch()
        # onPressKeyDict[app.DIK_P] = lambda : self.OpenPetMainGui()
    #   onPressKeyDict[app.DIK_P]   = lambda : self.__Acce_okno()
        onPressKeyDict[app.DIK_P]   = lambda : self.__MegaPety()
    #   onPressKeyDict[app.DIK_K]   = lambda : self.__Wiki()
        #onPressKeyDict[app.DIK_K]  = lambda : self.__bonusy()
        onPressKeyDict[app.DIK_U] = lambda: self.OpenBabyMainGui()
        if app.ENABLE_TITLE_SYSTEM:
            onPressKeyDict[app.DIK_O]       = lambda : self.OpenTitleSystem()
        onPressKeyDict[app.DIK_F12] = lambda : self.__Bonus()

        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_X]           = lambda state = "BONUS": 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)

    if app.ENABLE_TITLE_SYSTEM:
        def OpenTitleSystem(self):
            self.interface.wndTitle.OpenWindow()

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

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

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

    def __PressQuickSlot(self, localSlotIndex):
        if localemg.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 = uimg.TextLine()
        self.PrintCoord.SetFontName(localemg.UI_DEF_FONT)
        self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)

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

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

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

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

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

        # ???? ??? ??
        self.ObjectNum = uimg.TextLine()
        self.ObjectNum.SetFontName(localemg.UI_DEF_FONT)
        self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)

        # ????
        self.ViewDistance = uimg.TextLine()
        self.ViewDistance.SetFontName(localemg.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(localemg.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, localemg.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(localemg.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) + " (" + localemg.TITLE_NAME_LIST[grade] + ")")

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

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

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

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

    def RefreshStatus(self):
        self.CheckGameButton()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def AskGuildName(self):

        guildNameBoard = uiCommon.InputDialog()
        guildNameBoard.SetTitle(localemg.GUILD_NAME)
        guildNameBoard.SetAcceptEvent(uimg.__mem_func__(self.ConfirmGuildName))
        guildNameBoard.SetCancelEvent(uimg.__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(localemg.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, ("|cffe6d0a2"+localemg.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)

        if constInfo.GUILDSTORAGE["open"] == 1:
            return


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ## Chat
    def OnRecvWhisper(self, mode, name, line):
        if name in constInfo.ZablokowaniGracze and mode != chat.WHISPER_TYPE_GM:
            # chat.AppendWhisper(chat.WHISPER_TYPE_CHAT, name, "Zostałeś zablokowany przez tego gracza!")
            net.SendWhisperPacket(name, "Zostałeś zablokowany przez tego gracza!")
            return
        else:
            if mode == chat.WHISPER_TYPE_GM:
                self.interface.RegisterGameMasterName(name)
            chat.AppendWhisper(mode, name, line)
            self.interface.RecvWhisper(name)

#       if line.find("xxbanasinifiniverxx") != -1:
#           race = net.GetMainActorRace()
#           if not guild.IsGuildEnable():
#               net.SendWhisperPacket(name, "xxbuyursinifimkardesimxx"+str(race)+"xx"+"Brak Gildii.xx"+str(player.GetStatus(player.LEVEL))+"xx")
#           else:
#               net.SendWhisperPacket(name, "xxbuyursinifimkardesimxx"+str(race)+"xx"+str(player.GetGuildName())+"xx"+str(player.GetStatus(player.LEVEL))+"xx")
#           return
#       if line.find("xxbuyursinifimkardesimxx") != -1:
#           constInfo.ticsinif = int(line.split("xx")[2])
#           constInfo.ticlonca = line.split("xx")[3]
#           constInfo.ticlevel = line.split("xx")[4]
#           return

        if line.find("zacqooleavenhpspq") != -1:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localemg.RAKIPKABULETMEDILANXD)
            return
        if line.find("zacqooleavenhpsp") != -1:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localemg.RAKIPKABULETMEDILANXD2)
            return

        if line.find('HP kabul etmedi') != -1:
            chat.AppendChat(chat.CHAT_TYPE_INFO, name + ' adli oyuncu HP ve SP gostermesini redetti. ')
            constInfo.DUELLODAIZINVARMI = "Kabul etmedi."
            return
        elif line.find('HP kabul ettimaq') != -1:
            chat.AppendChat(chat.CHAT_TYPE_INFO, name + " adli oyuncu duello'da HP ve SP gosterme'yi kabul etti. ")
            constInfo.DUELLODAIZINVARMI = "Kabul etti."
            return
        elif line.find('C kabul etmedi') != -1:
            chat.AppendChat(chat.CHAT_TYPE_INFO, name + ' adli oyuncu HP ve SP gotermesini redetti. ')
            constInfo.DUELLODAIZINVARMI = "Kabul etmedi."
            return
        elif line.find('C kabul ettimaq') != -1:
            chat.AppendChat(chat.CHAT_TYPE_INFO, name + " adli oyuncu duello'da HP ve SP gosterme'yi kabul etti. ")
            constInfo.DUELLODAIZINVARMI = "Kabul etti."
            return
        else:
            pass

    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 localemg.WHISPER_ERROR.has_key(mode):
            chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, localemg.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, localemg.GAME_PICK_MONEY % (money))

    def OnShopError(self, type):
        try:
            self.PopupMessage("|cffa08784"+localemg.SHOP_ERROR_DICT[type])
        except KeyError:
            self.PopupMessage("|cffa08784"+localemg.SHOP_ERROR_UNKNOWN % (type))

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

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

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

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

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

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

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

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

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

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

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

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

    ## Shop
    def StartShop(self, vid):
        self.interface.OpenShopDialog(vid)
        if constInfo.GUILDSTORAGE["open"] == 1:
            return

    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()
        if constInfo.GUILDSTORAGE["open"] == 1:
            net.SendExchangeExitPacket()
            chat.AppendChat(chat.CHAT_TYPE_INFO, "Nie mo?esz handlowa? kiedy magazyn gildii jest otwarty.")
            return

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

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

    ## Party
    def RecvPartyInviteQuestion(self, leaderVID, leaderName):
        partyInviteQuestionDialog = uiCommon.QuestionDialog()
        partyInviteQuestionDialog.SetText(leaderName + localemg.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(localemg.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
        messengerAddFriendQuestion.SetText2(localemg.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)
        messengerAddFriendQuestion.SetAcceptEvent(uimg.__mem_func__(self.OnAcceptAddFriend))
        messengerAddFriendQuestion.SetCancelEvent(uimg.__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("|cffa07970"+guildName + "|cffa08784"+localemg.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 + localemg.SCREENSHOT_SAVE1)
            chat.AppendChat(chat.CHAT_TYPE_INFO, localemg.SCREENSHOT_SAVE2)
            """
        else:
            chat.AppendChat(chat.CHAT_TYPE_INFO, localemg.SCREENSHOT_SAVE_FAILURE)

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

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

    # ADD_ALWAYS_SHOW_NAME
    def __IsShowName(self):

        if systemSetting.IsAlwaysShowName():
            return True

        if self.ShowNameFlag:
            return True

        return False
    # END_OF_ADD_ALWAYS_SHOW_NAME

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

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

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

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

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

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

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

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

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

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

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

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

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

    def PickUpItem(self):
        player.PickCloseItem()

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

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

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

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

        return True

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

        return True

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

        if mouseModule.mouseController.isAttached():
            self.CheckFocus()
        else:
            hyperlink = uimg.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 = uimg.GetHyperlink()
            if hyperlink:
                if app.IsPressed(app.DIK_LALT):
                    link = chat.GetLinkFromHyperlink(hyperlink)
                    ime.PasteString(link)
                else:
                    self.interface.MakeHyperlinkTooltip(hyperlink)
                return
            else:
                player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)

        #player.EndMouseWalking()
        return True

    def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
        if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
            attachedInvenType = player.SlotTypeToInvenType(attachedType)
            if True == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
                if player.IsEquipmentSlot(attachedItemSlotPos) and player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType:
                    self.stream.popupWindow.Close()
                    self.stream.popupWindow.Open(localemg.EXCHANGE_FAILURE_EQUIP_ITEM, 0, ("|cffe6d0a2"+localemg.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, localemg.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, localemg.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, localemg.DROP_ITEM_FAILURE_OFFLINE_SHOP)
            return
        # END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2

        if attachedMoney>=1000:
            self.stream.popupWindow.Close()
            self.stream.popupWindow.Open(localemg.DROP_MONEY_FAILURE_1000_OVER, 0, ("|cffe6d0a2"+localemg.UI_OK))
            return

        itemDropQuestionDialog = uiCommon.QuestionDialog()
        itemDropQuestionDialog.SetText(localemg.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, localemg.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, localemg.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, localemg.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(localemg.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, ("|cffe6d0a2"+localemg.UI_OK))

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

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

                ## Question Text
                questionText = localemg.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 = localemg.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)

        if constInfo.GUILDSTORAGE["open"] == 1:
            chat.AppendChat(chat.CHAT_TYPE_INFO, "Nie mo?esz usun?? przedmiotu kiedy magazyn Gildii jest otwarty.")
            return

    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, localemg.DROP_ITEM_FAILURE_PRIVATE_SHOP)
            return

        if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
            chat.AppendChat(chat.CHAT_TYPE_INFO, localemg.DROP_ITEM_FAILURE_OFFLINE_SHOP)
            return

        if (uiOfflineShop.IsEditingOfflineShop()):
            chat.AppendChat(chat.CHAT_TYPE_INFO, localemg.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.SkillActivatedInfo == 1:
            if self.SkillEffectUpdate <= time.clock():
                self.SkillEffectUpdate = time.clock() + 1.5
                self.UpdateSkillEffect()

            self.UpdateSkillTimeBar()

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

        # if app.ENABLE_TITLE_SYSTEM:
            # self.interface.wndTitle.OnUpdate()

    #   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
        if systemSetting.IsShowSalesText():
            uiPrivateShopBuilder.UpdateADBoard()

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

        grp.PopState()
        grp.SetInterfaceRenderState()

        textTail.Render()
        textTail.HideAllTextTail()

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

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

        else:
            self.interface.OpenSystemDialog()

        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):
        # dbg.TraceError(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
        print npcVNUM
        print listText
        dbg.TraceError(npcVNUM)
        dbg.TraceError(listText)

        if npcVNUM == 0:
            npcVNUM = self.currentCubeNPC

        self.cubeInformation[npcVNUM] = []

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

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

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

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

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

        pass

    def BINARY_Cube_ResultList(self, data):
        # ResultList Text Format : 72723,1/72725,1/72730.1/50001,5  ????? "/" ??? ??? ???? ?
        #print listText
        print data
        dbg.TraceError(data)

        comand = data.split("$")
        npcVNUM = comand[0]
        listText = comand[1]


        if npcVNUM == 0:
            npcVNUM = self.currentCubeNPC

        self.cubeInformation[npcVNUM] = []

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

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

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

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

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

        pass

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

            if 3 > len(listText):
                dbg.TraceError("Wrong Cube Material Infomation")
                return 0



            eachResultList = listText.split("@")

            cubeInfo = self.cubeInformation[self.currentCubeNPC]

            itemIndex = 0
            for eachResultText in eachResultList:
                cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]
                materialList = cubeInfo[startIndex + itemIndex]["materialList"]

                gold = 0
                splitResult = eachResultText.split("/")
                if 1 < len(splitResult):
                    gold = int(splitResult[1])

                #print "splitResult : ", splitResult
                eachMaterialList = splitResult[0].split("&")

                i = 0
                for eachMaterialText in eachMaterialList:
                    complicatedList = eachMaterialText.split("|")

                    if 0 < len(complicatedList):
                        for complicatedText in complicatedList:
                            (itemVnum, itemCount) = complicatedText.split(",")
                            itemVnum = int(itemVnum)
                            itemCount = int(itemCount)
                            self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)

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

                    else:
                        itemVnum, itemCount = eachMaterialText.split(",")
                        itemVnum = int(itemVnum)
                        itemCount = int(itemCount)
                        self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)

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

                    i = i + 1



                itemIndex = itemIndex + 1

            self.interface.wndCube.Refresh()


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

        pass

    # def BINARY_Cube_MaterialInfo(self, data):
        # # Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000
        # try:

            # print data
            # dbg.TraceError(data)

            # comand = data.split("$")
            # npcVNUM = comand[0]
            # listText = comand[1]

            # # (self, startIndex, listCount, listText):

            # if 3 > len(listText):
                # dbg.TraceError("Wrong Cube Material Infomation")
                # return 0



            # eachResultList = listText.split("@")

            # cubeInfo = self.cubeInformation[self.currentCubeNPC]

            # itemIndex = 0
            # for eachResultText in eachResultList:
                # cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]
                # materialList = cubeInfo[startIndex + itemIndex]["materialList"]

                # gold = 0
                # splitResult = eachResultText.split("/")
                # if 1 < len(splitResult):
                    # gold = int(splitResult[1])

                # #print "splitResult : ", splitResult
                # eachMaterialList = splitResult[0].split("&")

                # i = 0
                # for eachMaterialText in eachMaterialList:
                    # complicatedList = eachMaterialText.split("|")

                    # if 0 < len(complicatedList):
                        # for complicatedText in complicatedList:
                            # (itemVnum, itemCount) = complicatedText.split(",")
                            # itemVnum = int(itemVnum)
                            # itemCount = int(itemCount)
                            # self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)

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

                    # else:
                        # itemVnum, itemCount = eachMaterialText.split(",")
                        # itemVnum = int(itemVnum)
                        # itemCount = int(itemCount)
                        # self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)

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

                    # i = i + 1



                # itemIndex = itemIndex + 1

            # self.interface.wndCube.Refresh()


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

        # pass

    # END_OF_CUBE

    def BINARY_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_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 localemg.NOTIFY_MESSAGE:
            return
        chat.AppendChat(chat.CHAT_TYPE_INFO, localemg.NOTIFY_MESSAGE[type])

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

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

    def BINARY_GuildWar_OnSendDeclare(self, guildID):
        pass

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

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

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

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

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

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

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

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

    def __GuildWar_OpenAskDialog(self, guildID, warType):

        guildName = guild.GetGuildName(guildID)

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

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

        self.guildWarQuestionDialog = questionDialog

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

    def __GuildWar_OnAccept(self):

        guildName = self.guildWarQuestionDialog.GetGuildName()

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

        return 1

    def __GuildWar_OnDecline(self):

        guildName = self.guildWarQuestionDialog.GetGuildName()

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

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

    def __ServerCommand_Build(self):
        serverCommandList={
            "ConsoleEnable"         : self.__Console_Enable,
            "DayMode"               : self.__DayMode_Update,
            "PRESERVE_DayMode"      : self.__PRESERVE_DayMode_Update,
            "CloseRestartWindow"    : self.__RestartDialog_Close,
            "OpenPrivateShop"       : self.__PrivateShop_Open,
            "OpenOfflineShop"       : self.__OfflineShop_Open,
            "PartyHealReady"        : self.PartyHealReady,
            "ShowMeSafeboxPassword" : self.AskSafeboxPassword,
            "CloseSafebox"          : self.CommandCloseSafebox,
            "Teleport"              : self.Teleport,
            "Klient_Data"           : self.__Data,
            "Klient_Godzina"        : self.__Godzina,
            "SmoczeMonety"          : self.__SM,
            "PunktyOsiagniec"       : self.__PO,
            "Coinsy"                : self.__C,

            ### PVP ###
            "PythonToLua"           : self.__PythonToLua,
            "PythonIslem"           : self.__PythonIslem,
            "LuaToPython"           : self.__LuaToPython,
            ### PVP ###

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

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

            "GUILDSTORAGE"          : self._GuildStorageCMD,
            "GUILDSTORAGE_ADDITEM"  : self._GuildStorageAddItem,
            "GUILDSTORAGE_ADDITEMSLOT" : self._GuildStorageAddItemSlot,
            "GUILDSTORAGE_ADDMEMBER" : self._GuildStorageAddMemberToList,
            "GUILDSTORAGE_ADDTEMPSLOT" : self._GuildStorageTempSlotsAdd,
            "GUILDSTORAGE_ADDLOG"       : self._GuildStorageAddLog,
            "getinputbegin"         : self.__Inputget1,
            "getinputend"           : self.__Inputget2,
            "getinput"              : self.__Inputget3,

            "PStonesQuest"          : self.PStonesQuest,
            "GetInputStart"         : self.GetInputStart,
            "GetInputStop"          : self.GetInputStop,
            "GetInput"              : self.GetInput,

            "gkmanage"              : self.__gkbuild,

            "Handelscenter"         : self.__Handelscenter,

            "load_mini_sklep"       : self.__load_mini_sklep,

            "refresh_skill_droga"   : self.refresh_skill_droga,

            "sklep_marmury"         : self.__sklepmarmury,

            #biolog
            "biolog"                : self.biologui,
            "oddaj"                 : self.oddaj,
            "openbio"               : self.biologopen,
            #biolog

            "BiologWczytaj"         : self.WczytajBiologa,
            "OddajBiolog"           : self.OddajBiologowi,

            #TOMBOLA
            "tombola_start"     : self.__tombola_start,
            "tombola_end"       : self.__tombola_end,
            "tombola_info"      : self.__tombola_info,
            "tombola_prepare"   : self.__tombola_prepare,
            "tombola_run"       : self.__tombola_run,

            #DEMIRGAME & TURKMMO [P-NEW] PVP SYSTEM
            "demirvidgame"          : self.demirvidgame,
            "demirvid"              : self.demirvid,
            "demirstartgame"        : self.demirstartgame,
            "demirongame"           : self.demirongame,
            "demirendgame"          : self.demirendgame,
            "demirwsgame"           : self.demirwsgame,
            "demirwsvidgame"        : self.demirwsgame,
            "demirgogame"           : self.demirgogame,
            "demirgovidgame"        : self.demirgogame,
            "demirwingame"          : self.demirwingame,
            #DEMIRGAME & TURKMMO [P-NEW] PVP 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,
            "ACHIEVEMENTS"          : self.ManagerAchievements,

            "PetEvolution"          : self.SetPetEvolution,
            "PetName"               : self.SetPetName,
            "PetLevel"              : self.SetPetLevel,
            "PetDuration"           : self.SetPetDuration,
            "PetBonus"              : self.SetPetBonus,
            "PetSkill"              : self.SetPetskill,
            "PetIcon"               : self.SetPetIcon,
            "PetExp"                : self.SetPetExp,
            "PetUnsummon"           : self.PetUnsummon,
            "OpenPetIncubator"      : self.OpenPetIncubator,

            "BabyEvolution"         : self.SetBabyEvolution,
            "BabyName"              : self.SetBabyName,
            "BabyLevel"             : self.SetBabyLevel,
            "BabyDuration"          : self.SetBabyDuration,
            "BabyBonus"             : self.SetBabyBonus,
            "BabySkill"             : self.SetBabyskill,
            "BabyIcon"              : self.SetBabyIcon,
            "BabyExp"               : self.SetBabyExp,
            "BabyUnsummon"          : self.BabyUnsummon,
            "OpenBabyIncubator"     : self.OpenBabyIncubator,

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

            "cube_npc_id"           : self.BINARY_Cube_Open,
            "cs_result"             : self.BINARY_Cube_ResultList,
            "cs_need"               : self.BINARY_Cube_MaterialInfo,

            # nowe skile za PO
            "quest_points"              : self.__QuestPoints,
            "points_status"             : self.__PointsStatus,
            "points_item_vnum"          : self.__PointsItem,
            "points_value"              : self.__PointsValue,
            "quest_skills"              : self.__QuestSkills,
            "skills_levels"             : self.__SkillsLevels,
            "skills_points"             : self.__SkillsPoints,
            "skills_val_info"           : self.__SkillsValue,
            "skills_nextval_info"       : self.__SkillsNextValue,
            "skills_dur_info"           : self.__SkillsDuration,
            "skills_mp_info"            : self.__SkillsMP,
            "get_input_status"          : self.__GetInputStatus,
            "GetInput"                  : self.__GetInput,
            "activated_skill"           : self.__SkillActivated,
            "skills_bar"                : self.__SetSkillsBar,
            "PokazSkille"                   : self.PokazOknoSkill,
            "PokazSkille2"                  : self.PokazOknoSkill2,
            # nowe skile za PO koniec
            "Gui_Wybor_Boss_Nagroda"        : self.Gui_Wybor_Boss_Nagroda,
            "Odbierz_Nagrode_Boss"          : self.Odbierz_Nagrode_Boss,

            # PRIVATE_SHOP_PRICE_LIST
            "MyShopPriceList"       : self.__PrivateShop_PriceList,
            # END_OF_PRIVATE_SHOP_PRICE_LIST
            "AcceMessage"               : self.AcceMessage,
            "AcceAbsMessage"            : self.AcceAbsMessage,
        }

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

# twoja droga
    def refresh_skill_droga(self, qid):
        #skill_slot.Show()
        #self.interface.HideAllWindows()
        #self.interface.Close()
        #self.interface=None
        #self.interface = interfaceModule.Interface()
        #self.interface.MakeInterface()
        #self.interface.SetOpenBoniSwitcherEvent(self.__BoniSwitcherShow)
        #self.interface.ShowDefaultWindows()
        #skill.SetSkillOtherIcon(playerSettingModule.SKILL_DROGA,"d:/ymir work/ui/skill/common/support/button_najemnik.sub")
        #playerSettingModule.SKILL_DROGA = int(qid)
        #skill_slot.AppendImage("d:/ymir work/ui/skill/common/support/button_najemnik.sub")
        #skill_slot.Show()
        #self.interface.HideAllWindows()
        #self.interface.Close()
        #self.interface=None
        #self.interface = interfaceModule.Interface()
        #self.interface.MakeInterface()
        #self.interface.SetOpenBoniSwitcherEvent(self.__BoniSwitcherShow)
        #self.interface.ShowDefaultWindows()
        #self.RefreshCharacter()
        #self.RefreshSkill()
        #skill.SetSkillOtherIcon( int(qid), "d:/ymir work/ui/skill/common/support/button_najemnik.sub")
        #self.RefreshCharacter()
        #self.RefreshSkill()
        slotwindow = constInfo.SILLPAGE
        skill_slot = player.GetSkillSlotIndex(playerSettingModule.SKILL_DROGA)
        #chat.AppendChat(chat.CHAT_TYPE_INFO, str(skill_slot))
        player.ClearSlotSkill(skill_slot,playerSettingModule.SKILL_DROGA)
        playerSettingModule.SKILL_DROGA = int(qid)
        player.SetSkill(skill_slot,playerSettingModule.SKILL_DROGA)
        slotwindow.SetSkillSlot(skill_slot, playerSettingModule.SKILL_DROGA, player.GetSkillLevel(skill_slot))

# // twoja droga

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

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

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

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

    def __sklepmarmury(self, vid=0):
        constInfo.MARMURY_BUTTON = int(vid)

    # 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(localemg.ACCE_DEL_SERVEITEM)

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

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

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

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

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

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

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

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

        if background.GetCurrentMapName() in mapDict:
            return False

        return True

    def __XMasSnow_Enable(self, mode):

        self.__XMasSong_Enable(mode)

        if "1"==mode:

            if not self.__IsXMasMap():
                return

            print "XMAS_SNOW ON"
            background.EnableSnow(1)

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

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

            if not self.__IsXMasMap():
                return

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

    def __XMasTree_Enable(self, grade):

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

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

            XMAS_BGM = "xmas.mp3"

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

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

        else:
            print "XMAS_SONG OFF"

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

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

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

    def __Console_Enable(self):
        constInfo.CONSOLE_ENABLE = True
        self.consoleEnable = True
        app.EnableSpecialCameraMode()
        uimg.EnablePaste(True)
    '''
    ## PrivateShop
    def __PrivateShop_Open(self):
        self.interface.OpenPrivateShopInputNameDialog()

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

    def BINARY_PrivateShop_Disappear(self, vid):
        self.interface.DisappearPrivateShop(vid)
    '''
    ## PrivateShop
    def __PrivateShop_Open(self):
    #   self.interface.OpenPrivateShopInputNameDialog()
        self.uiNewShop.Show()

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

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

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

    # 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) + localemg.PARTY_DO_YOU_ACCEPT)
        partyRequestQuestionDialog.SetAcceptText(localemg.UI_ACCEPT)
        partyRequestQuestionDialog.SetCancelText(localemg.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(localemg.PARTY_REQUEST_DENIED)

    def __EnableTestServerFlag(self):
        app.EnableTestServerFlag()

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

    def ManagerAchievements(self, cmd):
        # dbg.TraceError(cmd)
        cmd = cmd.split("#")
        if cmd[0] == 'QID':
            constInfo.Achievements['QID'] = int(cmd[1])
        elif cmd[0] == 'INPUT':
            constInfo.INPUT_IGNORE = int(cmd[1])
        elif cmd[0] == 'SEND':
            net.SendQuestInputStringPacket(constInfo.Achievements['QCMD'])
            constInfo.Achievements['QCMD'] = ''
        elif cmd[0] == 'SET_CATEGORY':
            constInfo.Achievements['achievements'][int(cmd[1])] = []
        elif cmd[0] == 'SET_ACHIEVEMENT':
            constInfo.Achievements['achievements'][int(cmd[1])].append([int(cmd[3]), int(cmd[4]), int(cmd[5]), int(cmd[6]), int(cmd[2])])
        elif cmd[0] == 'SET_ACHIEVEMENT_STRING':
            constInfo.Achievements['achievements'][int(cmd[1])].append([int(cmd[3]), int(cmd[4]), int(cmd[5]), cmd[6].replace('&', ' '), int(cmd[2])])
        elif cmd[0] == 'UPDATE_ACHIEVEMENT':
            for i in xrange(len(constInfo.Achievements['achievements'][int(cmd[1])])):
                if int(cmd[1]) == 2 or int(cmd[1]) == 3:
                    if constInfo.Achievements['achievements'][int(cmd[1])][i][4] == int(cmd[4]):
                        constInfo.Achievements['achievements'][int(cmd[1])][i][0] = int(cmd[3])
                elif constInfo.Achievements['achievements'][int(cmd[1])][i][2] == int(cmd[4]) and constInfo.Achievements['achievements'][int(cmd[1])][i][4] == int(cmd[2]):
                    constInfo.Achievements['achievements'][int(cmd[1])][i][0] = int(cmd[3])
        elif cmd[0] == 'REFRESH_ACHIEVEMENTS':
            self.interface.wndAchievements.RefreshAchievements()
            self.interface.wndAchievements.RefreshGlobalProgress()
        elif cmd[0] == 'CLEAR_LAST_FINISHED':
            constInfo.Achievements['last_achievements'] = []
        elif cmd[0] == 'SET_FINISHED':
            self.interface.wndAchievements.SetAchievementFinisehd(int(cmd[1]), int(cmd[3]), int(cmd[4]), int(cmd[5]))
        elif cmd[0] == 'SET_LAST_FINISHED':
            achievementInfo = cmd[1].split(',')
            constInfo.Achievements['last_achievements'].append([int(achievementInfo[0]), int(achievementInfo[2]), int(achievementInfo[3]), int(achievementInfo[4])])
        elif cmd[0] == 'REFRESH_LAST_FINISHED':
            self.interface.wndAchievements.RefreshLastFinished()
        elif cmd[0] == 'SET_AP':
            constInfo.Achievements['POINTS'] = int(cmd[1])
        elif cmd[0] == 'SET_ACHIEVEMENTSHOP_CATEGORY':
            constInfo.Achievements['achievementshop'][int(cmd[1])] = []
        elif cmd[0] == 'SET_ACHIEVEMENTSHOP_ITEM':
            constInfo.Achievements['achievementshop'][int(cmd[1])].append([int(cmd[2]), int(cmd[3]), int(cmd[4])])

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

    def __Teleportacja(self):
        if FALSE == player.IsObserverMode():
            if FALSE == self.teleportacja.IsShow():
                self.teleportacja.Open()
                self.teleportacja.SetTop()
            else:
                self.teleportacja.Hide()

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

    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 __OnClickMagazynButton(self):
        constInfo.GUILDSTORAGE["questCMD"] = 'OPEN'
        event.QuestButtonClick(int(constInfo.GUILDSTORAGE["qid"]))

    def __OpenAchievementsystemWindow(self):
        import uiAchievements
        self.achievement = uiAchievements.AchievementWindow()
        self.achievement.Open()

    def __SM(self, coins):
        constInfo.SM = int(coins)

    def __PO(self, coins):
        constInfo.PO = int(coins)

    def __C(self, coins):
        constInfo.C = int(coins)

    def __Data(self, coins):
        constInfo.aktualna_data = str(coins)

    def __Godzina(self, coins):
        constInfo.aktualna_godznia = str(coins)

    # 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

    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(0)
        elif cmd[0] == "CLEAR_TEMPSLOTS":
            constInfo.GUILDSTORAGE["tempslots"] = {"TAB0" : {},"TAB1" : {},"TAB2" : {}, "TAB3" : {}, "TAB4" : {}, "TAB5" : {}}
        elif cmd[0] == "COMPARE_TEMPSLOTS":
            for i in range(6):
                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()
            constInfo.GUILDSTORAGE["questCMD"] = "GETMEMBERLIST"
            event.QuestButtonClick(int(constInfo.GUILDSTORAGE["qid"]))

    def __Inputget1(self):
        constInfo.INPUT_IGNORE = 1

    def __Inputget2(self):
        constInfo.INPUT_IGNORE = 0

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

    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)]
        elif slot > 360 and slot <= 480:
            constInfo.GUILDSTORAGE["slots"]["TAB3"][slot-360] = [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 > 480 and slot <= 600:
            constInfo.GUILDSTORAGE["slots"]["TAB4"][slot-480] = [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 > 600 and slot <= 720:
            constInfo.GUILDSTORAGE["slots"]["TAB5"][slot-600] = [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)]
        elif slot > 360 and slot <= 480:
            constInfo.GUILDSTORAGE["tempslots"]["TAB3"][slot-360] = [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 > 480 and slot <= 600:
            constInfo.GUILDSTORAGE["tempslots"]["TAB4"][slot-480] = [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 > 600 and slot <= 720:
            constInfo.GUILDSTORAGE["tempslots"]["TAB5"][slot-600] = [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):
        date = date.replace("+-+"," ")
        desc = desc.replace("+-+"," ")
        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)]

    def __gkbuild(self, cmd):
        l = "/"
        cmd = cmd.split("|")
        if cmd[0] == "QID":
            constInfo.GKMANAGER["GKMANAGEQID"] = int(cmd[1])
        elif cmd[0] == "INFO":
            if cmd[1] == "1":
                constInfo.GKMANAGER["1"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 1
            elif cmd[1] == "2":
                constInfo.GKMANAGER["2"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 2
            elif cmd[1] == "3":
                constInfo.GKMANAGER["3"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 3
            elif cmd[1] == "4":
                constInfo.GKMANAGER["4"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 4
            elif cmd[1] == "5":
                constInfo.GKMANAGER["5"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 5
            elif cmd[1] == "6":
                constInfo.GKMANAGER["6"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 6
            elif cmd[1] == "7":
                constInfo.GKMANAGER["7"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 7
            elif cmd[1] == "8":
                constInfo.GKMANAGER["8"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 8
            elif cmd[1] == "9":
                constInfo.GKMANAGER["9"] = cmd[2]+l+cmd[3]+l+cmd[4]+l+cmd[5]
                constInfo.GKMANAGER["SI"] = 9
        elif cmd[0] == "OPEN":
            import uigkman
            constInfo.GKMANAGER["side"] = 0
            constInfo.GKMANAGER["sideup"] = 1
            uigkman.Dialog1().Show()
        elif cmd[0] == "SIDE":
            net.SendQuestInputStringPacket(str(constInfo.GKMANAGER["side"]))
        elif cmd[0] == "INPUT":
            net.SendQuestInputStringPacket(str(constInfo.GKMANAGER["cmd"]))
            constInfo.GKMANAGER["cmd"] = ""
        elif cmd[0] == "BACKSIDE":
            constInfo.GKMANAGER["side"] = constInfo.GKMANAGER["side"]-1

    def ClickGuildStorageButton(self):
        constInfo.GUILDSTORAGE["questCMD"] = 'OPEN'
        event.QuestButtonClick(int(constInfo.GUILDSTORAGE["qid"]))

    def __Handelscenter(self, info):
        CMD = info.split("/")
        if CMD[0]=="itemvonliste":
            self.wndHandelscenter.SetPercantage(int(CMD[27]), int(CMD[28]))
            constInfo.HANDELSCENTER_CONFIG[CMD[1]].append({"id": CMD[2], "vnum" : int(CMD[3]), "anzahl" : CMD[4], "yang" : CMD[5], "owner" : CMD[6], "boni1" : [int(CMD[7]), int(CMD[8])], "boni2" : [int(CMD[9]), int(CMD[10])], "boni3" : [int(CMD[11]), int(CMD[12])], "boni4" : [int(CMD[13]), int(CMD[14])], "boni5" : [int(CMD[15]), int(CMD[16])], "boni6" : [int(CMD[17]), int(CMD[18])], "boni7" : [int(CMD[19]), int(CMD[20])], "socket0" : int(CMD[21]), "socket1" : int(CMD[22]), "socket2" : int(CMD[23]), "socket3" : int(CMD[24]), "socket4" : int(CMD[25]), "socket5" : int(CMD[26])})
        elif CMD[0]=="logs":
            constInfo.HANDELSCENTER_CONFIG["LOGS"].append({"owner" : CMD[1], "vnum": CMD[2], "count" : CMD[3], "preis": CMD[4], "buyer":CMD[5], "date": CMD[6]})
        elif CMD[0]=="finishlogs":
            self.wndHandelscenter.AddToLog()
        elif CMD[0]=="yangingui":
            constInfo.HANDELSCENTER_CONFIG["YANG"] = int(CMD[1])
        elif CMD[0]=="index":
            constInfo.HANDELSCENTER_CONFIG["index"] = int(CMD[1])
        elif CMD[0]=="noitems":
            constInfo.HANDELSCENTER_CONFIG[CMD[1]] = []
            self.wndHandelscenter.Scrollbar()
        elif CMD[0]=="remove":
            constInfo.HANDELSCENTER_CONFIG[CMD[1]].pop(int(CMD[2]))
            self.wndHandelscenter.Scrollbar()
        elif CMD[0]=="input":
            net.SendQuestInputStringPacket(str(constInfo.HANDELSCENTER_CONFIG["CMD"]))
        elif CMD[0]=="finishsending":
            self.wndHandelscenter.Scrollbar()
        elif CMD[0]=="nologs":
            self.wndHandelscenter.NoLogs()

    def __HandelsOpen(self):
        if  self . wndHandelscenter . IsShow ():
            self . wndHandelscenter . Open ()
        else :
            self . wndHandelscenter . Open ()
            constInfo . HANDELSCENTER_CONFIG [ "CMD" ]  =  "open"
            event . QuestButtonClick ( constInfo . HANDELSCENTER_CONFIG [ "index" ])


    #DEMIRGAME & TURKMMO [P-NEW] PVP SYSTEM
    def demirvidgame(self, id):
        import constInfo
        constInfo.demirvidgame = int(id)

    def demirongame(self):
        constInfo.INPUT_IGNORE = 1

    def demirendgame(self):
        constInfo.INPUT_IGNORE = 0

    def demirstartgame(self):
        net.SendQuestInputStringPacket(str(constInfo.demirstartgame))

    def demirvid(self, id):
        constInfo.demirvid = int(id)

    def demirwsgame(self):
        net.SendChatPacket("(demirwsgame)")
        return

    def demirgogame(self):
        net.SendChatPacket("(demirgogame)")
        return

    def demirwingame(self):
        net.SendChatPacket("(demirwingame)")
        return
    #DEMIRGAME & TURKMMO [P-NEW] PVP SYSTEM

    # Tombola
    def __Tombola(self):
        if FALSE == player.IsObserverMode():
            self.dlgTombola.Open()

    # TOMBOLA
    def __tombola_start(self, qid):
        constInfo.CMDRESOLVER_QUID = qid

    def __tombola_info(self, qid):
        constInfo.TOMBOLA_INFO = qid

    def __tombola_end(self, qid):
        constInfo.CMDRESOLVER_QUID2 = qid

    def __tombola_prepare(self, data):#item_id|item_count|item_id|item_count|item_id|item_count|item_id|item_count
        self.dlgTombola.OnPrepare(str(data))

    def __tombola_run(self, data):#toPosition|speedDown
        self.dlgTombola.OnRun(str(data))

    # Bonowarka
    def __ClickBon_Switch(self):
        if self.wndBonowarka:
            if self.wndBonowarka.IsShow():
                self.wndBonowarka.Hide()
            else:
                self.wndBonowarka.Show()

    def __MegaMounty(self):
        if FALSE == player.IsObserverMode():
            if FALSE == self.dlgMegaMounty.IsShow():
                self.dlgMegaMounty.Show()
                self.dlgMegaMounty.SetTop()
            else:
                self.dlgMegaMounty.Hide()

    def __MegaPety(self):
        if FALSE == player.IsObserverMode():
            if FALSE == self.dlgMarmury.IsShow():
                self.dlgMarmury.Show()
                self.dlgMarmury.SetTop()
            else:
                self.dlgMarmury.Hide()

    def __Bonus(self):
        if FALSE == player.IsObserverMode():
            if FALSE == self.dlgBonus.IsShow():
                self.dlgBonus.Show()
                self.dlgBonus.SetTop()
            else:
                self.dlgBonus.Hide()

    def __Dziecko(self):
        if FALSE == player.IsObserverMode():
            if FALSE == self.dlgDziecko.IsShow():
                self.dlgDziecko.Show()
                self.dlgDziecko.SetTop()
            else:
                self.dlgDziecko.Hide()

    # def __Wiki(self):
        # if FALSE == player.IsObserverMode():
            # if FALSE == self.dlgWiki.IsShow():
                # self.dlgWiki.Show()
                # self.dlgWiki.SetTop()
            # else:
                # self.dlgWiki.Hide()

    def __bonusy(self):
        if FALSE == player.IsObserverMode():
            if FALSE == self.dlgBonusy.IsShow():
                self.dlgBonusy.Show()
                self.dlgBonusy.SetTop()
            else:
                self.dlgBonusy.Hide()

    # Mini Sklep
    def __load_mini_sklep(self, qid):
        constInfo.MINISKLEP = qid

    # biolog
    def oddaj(self, qid):
        constInfo.oddajbiol = int(qid)

    def biologui(self, arg):
        data = arg.split("|")
        constInfo.itembiolog = int(data[0])
        constInfo.czasbiolog = int(data[1])
        constInfo.oddane = int(data[2])
        constInfo.dooddania = int(data[3])
        constInfo.lvlbiolog = int(data[4])

    def biologopen(self):
        self.uibiolog_new_open.Show()

    def PStonesQuest(self, qid):
        constInfo.stones_quest = int(qid)

    def GetInputStart(self):
        constInfo.INPUT_IGNORE = 1

    def GetInputStop(self):
        constInfo.INPUT_IGNORE = 0

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

    # Pet System Official
    def SetPetEvolution(self, evo):
        petname = ["Spokojny", "Drapieżny", "Dziki", "Wrogi"]
        self.petmain.SetEvolveName(petname[int(evo)])

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

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

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

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

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

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

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

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

    def OpenPetMainGui(self):
        self.petmain.Show()
        self.petmain.SetTop()


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

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

    def OpenPetFeed(self):

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

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


    # Pet System Official

    def SetBabyEvolution(self, evo):
        babyname = ["Niemowlę", "Dziewczynka", "Nastolatka", "Dorosła"]
    #   babyname = ["Niemowlę", "Chłopiec", "Nastolatek", "Dorosły"]
        self.babymain.SetEvolveName(babyname[int(evo)])

    def SetBabyName(self, name):
        if len(name) > 1 and name != "":
            self.babymini.Show()
        self.babymain.SetName(name)

    def SetBabyLevel(self, level):
        self.babymain.SetLevel(level)

    def SetBabyDuration(self, dur, durt):
        if int(durt) > 0:
            self.babymini.SetDuration(dur, durt)
        self.babymain.SetDuration(dur, durt)

    def SetBabyBonus(self, hp, dif, sp):
        self.babymain.SetHp(hp)
        self.babymain.SetDef(dif)
        self.babymain.SetSp(sp)

    def SetBabyskill(self, slot, idx, lv):
        if int(lv) > 0:
            self.babymini.SetSkill(slot, idx, lv)
        self.babymain.SetSkill(slot, idx, lv)
        self.affectShower.BINARY_NEW_AddAffect(5500+int(idx),int(constInfo.BABYLASTAFFECT_POINT)+1,int(constInfo.BABYLASTAFFECT_VALUE)+1, 0)
        if int(slot)==0:
            constInfo.SKILL_BABY1=5500+int(idx)
        if int(slot)==1:
            constInfo.SKILL_BABY2=5500+int(idx)
        if int(slot)==2:
            constInfo.SKILL_BABY3=5500+int(idx)

    def SetBabyIcon(self, vnum):
        if int(vnum) > 0:
            self.babymini.SetImageSlot(vnum)
        self.babymain.SetImageSlot(vnum)

    def SetBabyExp(self, exp, expi, exptot):
        if int(exptot) > 0:
            self.babymini.SetExperience(exp, expi, exptot)
        self.babymain.SetExperience(exp, expi, exptot)

    def BabyUnsummon(self):
        self.babymini.SetDefaultInfo()
        self.babymini.Close()
        self.babymain.SetDefaultInfo()
        self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_BABY1),0)
        self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_BABY2),0)
        self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_BABY3),0)
        constInfo.SKILL_BABY1 = 0
        constInfo.SKILL_BABY2 = 0
        constInfo.SKILL_BABY3 = 0

    def OpenBabyMainGui(self):
        self.babymain.Show()
        self.babymain.SetTop()


    def OpenBabyIncubator(self, baby_new = 0):
        import uibabyincubatrice
        self.babyinc = uibabyincubatrice.BabySystemIncubator(baby_new)
        self.babyinc.Show()
        self.babyinc.SetTop()

    def OpenBabyMini(self):
        self.babymini.Show()
        self.babymini.SetTop()

    def OpenBabyFeed(self):

        self.babyfeedwind = uibabyfeed.BabyFeedWindow()
        self.babyfeedwind.Show()
        self.babyfeedwind.SetTop()

    def BabyGift_Show(self):
        if constInfo.BABY_MAIN == 0:
            self.babymain.Show()
            constInfo.BABY_MAIN =1
            self.babymain.SetTop()
        else:
            self.babymain.Hide()
            constInfo.BABY_MAIN =0

    ### PVP ##
    def __PythonToLua(self, id):
        constInfo.PYTHONTOLUA = int(id)

    def __PythonIslem(self, PythonIslem):
        if PythonIslem == "PYTHONISLEM":
            net.SendQuestInputStringPacket(constInfo.PYTHONISLEM)
        elif PythonIslem == "PLAYER_VID":
            net.SendQuestInputStringPacket(str(constInfo.PLAYER_VID))

    def __LuaToPython(self, LuaToPython):
        if LuaToPython.find("#quest_input#") != -1:
            constInfo.INPUT = 1
        elif LuaToPython.find("#quest_inputbitir#") != -1:
            constInfo.INPUT = 0
        elif LuaToPython.find("#rakip_hp_sp#") != -1:
            constInfo.PLAYER_HP = LuaToPython.split("|")[1]
            constInfo.PLAYER_MAX_HP = LuaToPython.split("|")[2]
            constInfo.PLAYER_SP = LuaToPython.split("|")[3]
            constInfo.PLAYER_MAX_SP = LuaToPython.split("|")[4]
    ### PVP ##

    #### nowe skile za PO ###
    def SkillsSystemManage(self):
        self.ManageBG = uimg.AniImageBox()
        self.ManageBG.AppendImage("illumina/skill_system/lapka_po.tga")
        self.ManageBG.SetSize(51, 96)
        #self.ManageBG.SetPosition(6, wndMgr.GetScreenHeight() - 170)
        self.ManageBG.SetPosition(wndMgr.GetScreenWidth() - 185, 0)
        self.ManageBG.AddFlag("float")
        self.ManageBG.Show()

        self.PointsButton = uimg.Button()
        self.PointsButton.SetParent(self.ManageBG)
        self.PointsButton.SetPosition(-3, 11+13)
        self.PointsButton.SetUpVisual("illumina/skill_system/btn_po_01.tga")
        self.PointsButton.SetOverVisual("illumina/skill_system/btn_po_02.tga")
        self.PointsButton.SetDownVisual("illumina/skill_system/btn_po_03.tga")
        self.PointsButton.SetEvent(uimg.__mem_func__(self.OpenPointsWindow))
        self.PointsButton.Show()
        '''
        self.SkillsButton = uimg.Button()
        self.SkillsButton.SetParent(self.ManageBG)
        self.SkillsButton.SetPosition(17, 57+10)
        self.SkillsButton.SetUpVisual("new_skills_system/manage_interface/skills_button.tga")
        self.SkillsButton.SetOverVisual("new_skills_system/manage_interface/skills_button_o.tga")
        self.SkillsButton.SetDownVisual("new_skills_system/manage_interface/skills_button.tga")
        self.SkillsButton.SetEvent(uimg.__mem_func__(self.OpenSkillsWindow))
        self.SkillsButton.Show()
        '''

    def __QuestPoints(self, value):
        constInfo.QUESTPOINTS = int(value)

    def OpenPointsWindow(self):
        if self.PointsWindowIsOpen == 0:
            self.PointsBG.Show()
            self.PointsWindowIsOpen = 1
        else:
            self.PointsBG.Hide()
            self.PointsWindowIsOpen = 0

    def PointsWindow(self):
        self.PointsBG = uimg.AniImageBox()
        self.PointsBG.AppendImage("illumina/skill_system/background_punkty.tga")
        self.PointsBG.SetSize(210, 181)
        self.PointsBG.SetPosition(wndMgr.GetScreenWidth() - 400, 0)
        #self.PointsBG.AddFlag('movable')
        self.PointsBG.AddFlag("float")
        self.PointsBG.Hide()

        self.PointsTitle = uimg.TextLine()
        self.PointsTitle.SetDefaultFontName()
        self.PointsTitle.SetParent(self.PointsBG)
        self.PointsTitle.SetPosition(20+40, 4)
        self.PointsTitle.SetFontName("Tahoma:12")
        self.PointsTitle.SetText("|cffe6d0a2Punkty Umiejętności")
        self.PointsTitle.SetOutline()
        self.PointsTitle.Show()

        self.PointsText = uimg.TextLine()
        self.PointsText.SetDefaultFontName()
        self.PointsText.SetParent(self.PointsBG)
        self.PointsText.SetPosition(79-37, 84-52)
        self.PointsText.SetFontName("Tahoma:12")
        self.PointsText.SetFontColor(0.9, 0.6, 0.5)
        self.PointsText.SetText(skills_language.PointsText)
        self.PointsText.SetOutline()
        self.PointsText.Show()

        self.PointsValueText = uimg.TextLine()
        self.PointsValueText.SetDefaultFontName()
        self.PointsValueText.SetParent(self.PointsBG)
        self.PointsValueText.SetPosition(167-40, 84-52)
        self.PointsValueText.SetFontColor(0.6, 0.9, 0.3)
        self.PointsValueText.SetFontName("Tahoma:12")
        self.PointsValueText.SetText("0")
        self.PointsValueText.SetOutline()
        self.PointsValueText.Show()

        self.PointsBar = uimg.AniImageBox()
        self.PointsBar.AppendImage("illumina/skill_system/pasek_ladowania_po.tga")
        self.PointsBar.SetParent(self.PointsBG)
        self.PointsBar.SetPosition(114-48, 145-74)
        self.PointsBar.SetPercentage(0, 100)
        self.PointsBar.Show()

        self.PointsItemInfo = uimg.TextLine()
        self.PointsItemInfo.SetDefaultFontName()
        self.PointsItemInfo.SetParent(self.PointsBG)
        self.PointsItemInfo.SetPosition(114-34, 125-71)
        self.PointsItemInfo.SetFontColor(1, 0.9, 0.65)
        self.PointsItemInfo.SetFontName("Tahoma:11")
        self.PointsItemInfo.SetText(skills_language.ItemInfo + "x0")
        self.PointsItemInfo.SetOutline()
        self.PointsItemInfo.Show()

        self.PointsStatusText = uimg.TextLine()
        self.PointsStatusText.SetDefaultFontName()
        self.PointsStatusText.SetParent(self.PointsBG)
        self.PointsStatusText.SetPosition(92-55, 170-82)
        self.PointsStatusText.SetFontName("Tahoma:12")
        self.PointsStatusText.SetOutline()
        self.PointsStatusText.Show()

        self.PointsItem = uimg.PointsButton()
        self.PointsItem.SetParent(self.PointsBG)
        self.PointsItem.SetPosition(22, 51)
        self.PointsItem.Hide()

    def __PointsStatus(self, value):
        value = int(value)
        self.PointsStatusText.SetText(skills_language.PointsStatus[value])
        if value == 0:
            self.PointsStatusText.SetFontColor(0.9, 0.6, 0.6)
            self.PointsStatusImg = uimg.AniImageBox()
            self.PointsStatusImg.SetParent(self.PointsBG)
            self.PointsStatusImg.AppendImage("illumina/skill_system/status_po_red.tga")
            self.PointsStatusImg.SetPosition(72-55, 170-82)
            self.PointsStatusImg.Show()
        elif value == 1:
            self.PointsStatusText.SetFontColor(1, 0.7, 0)
            self.PointsStatusImg = uimg.AniImageBox()
            self.PointsStatusImg.SetParent(self.PointsBG)
            self.PointsStatusImg.AppendImage("illumina/skill_system/status_po_yellow.tga")
            self.PointsStatusImg.SetPosition(72-55, 170-82)
            self.PointsStatusImg.Show()
        else:
            self.PointsStatusText.SetFontColor(0.6, 0.9, 0.3)
            self.PointsStatusImg = uimg.AniImageBox()
            self.PointsStatusImg.SetParent(self.PointsBG)
            self.PointsStatusImg.AppendImage("illumina/skill_system/status_po_green.tga")
            self.PointsStatusImg.SetPosition(72-55, 170-82)
            self.PointsStatusImg.Show()

    def __PointsItem(self, value):
        vnum_item = int(value)
        if vnum_item == 0:
            self.PointsItem.Hide()
            self.PointsItemInfo.SetText(skills_language.ItemInfo + "x0")
            self.PointsBar.SetPercentage(0, 100)
        else:
            if vnum_item >= 10901 and vnum_item <= 10910:
                self.PointsItem = uimg.PointsButton()
                self.PointsItem.SetParent(self.PointsBG)
                self.PointsItem.SetPosition(22, 51)
                self.PointsItem.SetUpVisual("icon/inne/item_po_01.tga")
                self.PointsItem.SetOverVisual("icon/inne/item_po_01.tga")
                self.PointsItem.SetDownVisual("icon/inne/item_po_01.tga")
                self.PointsItem.Show()
                self.PointsItemInfo.SetText(skills_language.ItemInfo + "x1")
            elif vnum_item >= 10911 and vnum_item <= 10920:
                self.PointsItem = uimg.PointsButton()
                self.PointsItem.SetParent(self.PointsBG)
                self.PointsItem.SetPosition(22, 51)
                self.PointsItem.SetUpVisual("icon/inne/item_po_02.tga")
                self.PointsItem.SetOverVisual("icon/inne/item_po_02.tga")
                self.PointsItem.SetDownVisual("icon/inne/item_po_02.tga")
                self.PointsItem.Show()
                self.PointsItemInfo.SetText(skills_language.ItemInfo + "x2")
            elif vnum_item >= 10921 and vnum_item <= 10930:
                self.PointsItem = uimg.PointsButton()
                self.PointsItem.SetParent(self.PointsBG)
                self.PointsItem.SetPosition(22, 51)
                self.PointsItem.SetUpVisual("icon/inne/item_po_03.tga")
                self.PointsItem.SetOverVisual("icon/inne/item_po_03.tga")
                self.PointsItem.SetDownVisual("icon/inne/item_po_03.tga")
                self.PointsItem.Show()
                self.PointsItemInfo.SetText(skills_language.ItemInfo + "x3")

            if vnum_item == 10901 or vnum_item == 10911 or vnum_item == 10921:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 0-10%", 0, -17)
                self.PointsBar.SetPercentage(10, 100)
            elif vnum_item == 10902 or vnum_item == 10912 or vnum_item == 10922:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 10-20%", 0, -17)
                self.PointsBar.SetPercentage(20, 100)
            elif vnum_item == 10903 or vnum_item == 10913 or vnum_item == 10923:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 20-30%", 0, -17)
                self.PointsBar.SetPercentage(30, 100)
            elif vnum_item == 10904 or vnum_item == 10914 or vnum_item == 10924:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 30-40%", 0, -17)
                self.PointsBar.SetPercentage(40, 100)
            elif vnum_item == 10905 or vnum_item == 10915 or vnum_item == 10925:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 40-50%", 0, -17)
                self.PointsBar.SetPercentage(50, 100)
            elif vnum_item == 10906 or vnum_item == 10916 or vnum_item == 10926:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 50-60%", 0, -17)
                self.PointsBar.SetPercentage(60, 100)
            elif vnum_item == 10907 or vnum_item == 10917 or vnum_item == 10927:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 60-70%", 0, -17)
                self.PointsBar.SetPercentage(70, 100)
            elif vnum_item == 10908 or vnum_item == 10918 or vnum_item == 10928:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 70-80%", 0, -17)
                self.PointsBar.SetPercentage(80, 100)
            elif vnum_item == 10909 or vnum_item == 10919 or vnum_item == 10929:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 80-90%", 0, -17)
                self.PointsBar.SetPercentage(90, 100)
            elif vnum_item == 10910 or vnum_item == 10920 or vnum_item == 10930:
                self.PointsItem.SetFormToolTipText("TEXT", "Pozosta?: 90-100%", 0, -17)
                self.PointsBar.SetPercentage(100, 100)

    def __PointsValue(self, value):
        self.PointsValueText.SetText(value)

    def OpenSkillsWindow(self):
        if self.SkillsWindowIsOpen == 0:
            self.SkillsBG.Show()
            self.SkillsWindowIsOpen = 1
        else:
            self.SkillsBG.Hide()
            self.SkillsWindowIsOpen = 0

    def SkillsWindow(self):
        self.SkillsBG = uimg.AniImageBox()
        self.SkillsBG.AppendImage("illumina/skill_system/background.tga")
        self.SkillsBG.SetSize(416, 283)
        self.SkillsBG.SetPosition(wndMgr.GetScreenWidth()/2-193, wndMgr.GetScreenHeight()/2 - 135)
        self.SkillsBG.AddFlag('movable')
        self.SkillsBG.AddFlag("float")
        self.SkillsBG.Hide()

        self.SkillsClose = uimg.Button()
        self.SkillsClose.SetParent(self.SkillsBG)
        self.SkillsClose.SetPosition(350+30, 15+1)
        self.SkillsClose.SetUpVisual("illumina/skill_system/close_01.tga")
        self.SkillsClose.SetOverVisual("illumina/skill_system/close_02.tga")
        self.SkillsClose.SetDownVisual("illumina/skill_system/close_03.tga")
        self.SkillsClose.SetEvent(uimg.__mem_func__(self.OpenSkillsWindow))
        self.SkillsClose.Show()

        self.SkillsBar = uimg.AniImageBox()
        self.SkillsBar.AppendImage("illumina/skill_system/pasek_ladowania.tga")
        self.SkillsBar.SetParent(self.SkillsBG)
        self.SkillsBar.SetPosition(32-10, 257-3)
        self.SkillsBar.SetPercentage(100, 100)
        self.SkillsBar.Show()

        self.SkillBarStatus = uimg.TextLine()
        self.SkillBarStatus.SetDefaultFontName()
        self.SkillBarStatus.SetParent(self.SkillsBG)
        self.SkillBarStatus.SetPosition(186-13, 267-30)
        self.SkillBarStatus.SetFontColor(0.8, 0.7, 0.6)
        self.SkillBarStatus.SetFontName("Tahoma:12")
        self.SkillBarStatus.SetText("0/100")
        self.SkillBarStatus.SetOutline()
        self.SkillBarStatus.Show()

        self.SkillBarTitle = uimg.TextLine()
        self.SkillBarTitle.SetDefaultFontName()
        self.SkillBarTitle.SetParent(self.SkillsBG)
        self.SkillBarTitle.SetPosition(186-13-10, 267-30-20)
        self.SkillBarTitle.SetText("|cffe6d0a2Energia Boga Anarchii")
        self.SkillBarTitle.SetOutline()
        self.SkillBarTitle.Show()

        self.SkillTitle = uimg.TextLine()
        self.SkillTitle.SetDefaultFontName()
        self.SkillTitle.SetParent(self.SkillsBG)
        self.SkillTitle.SetPosition(186-13-10-3, 13+9)
        self.SkillTitle.SetText("|cffe6d0a2Anarchiczne Umiejętności")
        self.SkillTitle.SetOutline()
        self.SkillTitle.Show()

        ###### SKILLS ######

        self.Skill1Button = uimg.Button()
        self.Skill1Button.SetParent(self.SkillsBG)
        self.Skill1Button.SetPosition(34-9, 90-19)
        self.Skill1Button.SetUpVisual("illumina/skill_system/skille/skil1_a.tga")
        self.Skill1Button.SetOverVisual("illumina/skill_system/skille/skil1_b.tga")
        self.Skill1Button.SetDownVisual("illumina/skill_system/skille/skil1_c.tga")
        self.Skill1Button.SetEvent(lambda arg=1: self.InfoSkill(arg))
        self.Skill1Button.Show()

        self.Skill2Button = uimg.Button()
        self.Skill2Button.SetParent(self.SkillsBG)
        self.Skill2Button.SetPosition(144+7, 90-19)
        self.Skill2Button.SetUpVisual("illumina/skill_system/skille/skil2_a.tga")
        self.Skill2Button.SetOverVisual("illumina/skill_system/skille/skil2_b.tga")
        self.Skill2Button.SetDownVisual("illumina/skill_system/skille/skil2_c.tga")
        self.Skill2Button.SetEvent(lambda arg=2: self.InfoSkill(arg))
        self.Skill2Button.Show()

        self.Skill3Button = uimg.Button()
        self.Skill3Button.SetParent(self.SkillsBG)
        self.Skill3Button.SetPosition(254+23, 90-19)
        self.Skill3Button.SetUpVisual("illumina/skill_system/skille/skil11_a.tga")
        self.Skill3Button.SetOverVisual("illumina/skill_system/skille/skil11_b.tga")
        self.Skill3Button.SetDownVisual("illumina/skill_system/skille/skil11_c.tga")
        self.Skill3Button.SetEvent(lambda arg=3: self.InfoSkill(arg))
        self.Skill3Button.Show()

        self.Skill4Button = uimg.Button()
        self.Skill4Button.SetParent(self.SkillsBG)
        self.Skill4Button.SetPosition(34-9, 180-26)
        self.Skill4Button.SetUpVisual("illumina/skill_system/skille/skil4_a.tga")
        self.Skill4Button.SetOverVisual("illumina/skill_system/skille/skil4_b.tga")
        self.Skill4Button.SetDownVisual("illumina/skill_system/skille/skil4_c.tga")
        self.Skill4Button.SetEvent(lambda arg=4: self.InfoSkill(arg))
        self.Skill4Button.Show()

        self.Skill5Button = uimg.Button()
        self.Skill5Button.SetParent(self.SkillsBG)
        self.Skill5Button.SetPosition(144+7, 180-26)
        self.Skill5Button.SetUpVisual("illumina/skill_system/skille/skil7_a.tga")
        self.Skill5Button.SetOverVisual("illumina/skill_system/skille/skil7_b.tga")
        self.Skill5Button.SetDownVisual("illumina/skill_system/skille/skil7_c.tga")
        self.Skill5Button.SetEvent(lambda arg=5: self.InfoSkill(arg))
        self.Skill5Button.Show()

        self.Skill6Button = uimg.Button()
        self.Skill6Button.SetParent(self.SkillsBG)
        self.Skill6Button.SetPosition(254+23, 180-26)
        self.Skill6Button.SetUpVisual("illumina/skill_system/skille/skil10_a.tga")
        self.Skill6Button.SetOverVisual("illumina/skill_system/skille/skil10_b.tga")
        self.Skill6Button.SetDownVisual("illumina/skill_system/skille/skil10_c.tga")
        self.Skill6Button.SetEvent(lambda arg=6: self.InfoSkill(arg))
        self.Skill6Button.Show()

        self.Skill1Name = uimg.TextLine()
        self.Skill1Name.SetDefaultFontName()
        self.Skill1Name.SetParent(self.SkillsBG)
        self.Skill1Name.SetPosition(39-13, 72-18)
        self.Skill1Name.SetFontColor(0.8, 0.7, 0.6)
        self.Skill1Name.SetFontName("Tahoma:12")
        self.Skill1Name.SetText(skills_language.SkillName[1])
        self.Skill1Name.SetOutline()
        self.Skill1Name.Show()

        self.Skill2Name = uimg.TextLine()
        self.Skill2Name.SetDefaultFontName()
        self.Skill2Name.SetParent(self.SkillsBG)
        self.Skill2Name.SetPosition(149+3, 72-18)
        self.Skill2Name.SetFontColor(0.8, 0.7, 0.6)
        self.Skill2Name.SetFontName("Tahoma:12")
        self.Skill2Name.SetText(skills_language.SkillName[2])
        self.Skill2Name.SetOutline()
        self.Skill2Name.Show()

        self.Skill3Name = uimg.TextLine()
        self.Skill3Name.SetDefaultFontName()
        self.Skill3Name.SetParent(self.SkillsBG)
        self.Skill3Name.SetPosition(259+19, 72-18)
        self.Skill3Name.SetFontColor(0.8, 0.7, 0.6)
        self.Skill3Name.SetFontName("Tahoma:12")
        self.Skill3Name.SetText(skills_language.SkillName[3])
        self.Skill3Name.SetOutline()
        self.Skill3Name.Show()

        self.Skill4Name = uimg.TextLine()
        self.Skill4Name.SetDefaultFontName()
        self.Skill4Name.SetParent(self.SkillsBG)
        self.Skill4Name.SetPosition(39-13, 162-25)
        self.Skill4Name.SetFontColor(0.8, 0.7, 0.6)
        self.Skill4Name.SetFontName("Tahoma:12")
        self.Skill4Name.SetText(skills_language.SkillName[4])
        self.Skill4Name.SetOutline()
        self.Skill4Name.Show()

        self.Skill5Name = uimg.TextLine()
        self.Skill5Name.SetDefaultFontName()
        self.Skill5Name.SetParent(self.SkillsBG)
        self.Skill5Name.SetPosition(149+3, 162-25)
        self.Skill5Name.SetFontColor(0.8, 0.7, 0.6)
        self.Skill5Name.SetFontName("Tahoma:12")
        self.Skill5Name.SetText(skills_language.SkillName[5])
        self.Skill5Name.SetOutline()
        self.Skill5Name.Show()

        self.Skill6Name = uimg.TextLine()
        self.Skill6Name.SetDefaultFontName()
        self.Skill6Name.SetParent(self.SkillsBG)
        self.Skill6Name.SetPosition(259+19, 162-25)
        self.Skill6Name.SetFontColor(0.8, 0.7, 0.6)
        self.Skill6Name.SetFontName("Tahoma:12")
        self.Skill6Name.SetText(skills_language.SkillName[6])
        self.Skill6Name.SetOutline()
        self.Skill6Name.Show()

        self.Skill1Level = uimg.TextLine()
        self.Skill1Level.SetDefaultFontName()
        self.Skill1Level.SetParent(self.SkillsBG)
        self.Skill1Level.SetPosition(92-8, 89-18)
        self.Skill1Level.SetFontColor(0.9, 0.4, 0.4)
        self.Skill1Level.SetFontName("Tahoma:12")
        self.Skill1Level.SetOutline()
        self.Skill1Level.Show()

        self.Skill2Level = uimg.TextLine()
        self.Skill2Level.SetDefaultFontName()
        self.Skill2Level.SetParent(self.SkillsBG)
        self.Skill2Level.SetPosition(202+8, 89-18)
        self.Skill2Level.SetFontColor(0.9, 0.4, 0.4)
        self.Skill2Level.SetFontName("Tahoma:12")
        self.Skill2Level.SetOutline()
        self.Skill2Level.Show()

        self.Skill3Level = uimg.TextLine()
        self.Skill3Level.SetDefaultFontName()
        self.Skill3Level.SetParent(self.SkillsBG)
        self.Skill3Level.SetPosition(312+24, 89-18)
        self.Skill3Level.SetFontColor(0.9, 0.4, 0.4)
        self.Skill3Level.SetFontName("Tahoma:12")
        self.Skill3Level.SetOutline()
        self.Skill3Level.Show()

        self.Skill4Level = uimg.TextLine()
        self.Skill4Level.SetDefaultFontName()
        self.Skill4Level.SetParent(self.SkillsBG)
        self.Skill4Level.SetPosition(92-8, 179-25)
        self.Skill4Level.SetFontColor(0.9, 0.4, 0.4)
        self.Skill4Level.SetFontName("Tahoma:12")
        self.Skill4Level.SetOutline()
        self.Skill4Level.Show()

        self.Skill5Level = uimg.TextLine()
        self.Skill5Level.SetDefaultFontName()
        self.Skill5Level.SetParent(self.SkillsBG)
        self.Skill5Level.SetPosition(202+8, 179-25)
        self.Skill5Level.SetFontColor(0.9, 0.4, 0.4)
        self.Skill5Level.SetFontName("Tahoma:12")
        self.Skill5Level.SetOutline()
        self.Skill5Level.Show()

        self.Skill6Level = uimg.TextLine()
        self.Skill6Level.SetDefaultFontName()
        self.Skill6Level.SetParent(self.SkillsBG)
        self.Skill6Level.SetPosition(312+24, 179-25)
        self.Skill6Level.SetFontColor(0.9, 0.4, 0.4)
        self.Skill6Level.SetFontName("Tahoma:12")
        self.Skill6Level.SetOutline()
        self.Skill6Level.Show()

        self.Skill1Points = uimg.TextLine()
        self.Skill1Points.SetDefaultFontName()
        self.Skill1Points.SetParent(self.SkillsBG)
        self.Skill1Points.SetPosition(92-8, 106-22)
        self.Skill1Points.SetFontColor(1, 0.6, 0.3)
        self.Skill1Points.SetFontName("Tahoma:12")
        self.Skill1Points.SetOutline()
        self.Skill1Points.Show()

        self.Skill2Points = uimg.TextLine()
        self.Skill2Points.SetDefaultFontName()
        self.Skill2Points.SetParent(self.SkillsBG)
        self.Skill2Points.SetPosition(202+8, 106-22)
        self.Skill2Points.SetFontColor(1, 0.6, 0.3)
        self.Skill2Points.SetFontName("Tahoma:12")
        self.Skill2Points.SetOutline()
        self.Skill2Points.Show()

        self.Skill3Points = uimg.TextLine()
        self.Skill3Points.SetDefaultFontName()
        self.Skill3Points.SetParent(self.SkillsBG)
        self.Skill3Points.SetPosition(312+24, 106-22)
        self.Skill3Points.SetFontColor(1, 0.6, 0.3)
        self.Skill3Points.SetFontName("Tahoma:12")
        self.Skill3Points.SetOutline()
        self.Skill3Points.Show()

        self.Skill4Points = uimg.TextLine()
        self.Skill4Points.SetDefaultFontName()
        self.Skill4Points.SetParent(self.SkillsBG)
        self.Skill4Points.SetPosition(92-8, 196-29)
        self.Skill4Points.SetFontColor(1, 0.6, 0.3)
        self.Skill4Points.SetFontName("Tahoma:12")
        self.Skill4Points.SetOutline()
        self.Skill4Points.Show()

        self.Skill5Points = uimg.TextLine()
        self.Skill5Points.SetDefaultFontName()
        self.Skill5Points.SetParent(self.SkillsBG)
        self.Skill5Points.SetPosition(202+8, 196-29)
        self.Skill5Points.SetFontColor(1, 0.6, 0.3)
        self.Skill5Points.SetFontName("Tahoma:12")
        self.Skill5Points.SetOutline()
        self.Skill5Points.Show()

        self.Skill6Points = uimg.TextLine()
        self.Skill6Points.SetDefaultFontName()
        self.Skill6Points.SetParent(self.SkillsBG)
        self.Skill6Points.SetPosition(312+24, 196-29)
        self.Skill6Points.SetFontColor(1, 0.6, 0.3)
        self.Skill6Points.SetFontName("Tahoma:12")
        self.Skill6Points.SetOutline()
        self.Skill6Points.Show()

        self.Skill1PlusButton = uimg.Button()
        self.Skill1PlusButton.SetParent(self.SkillsBG)
        self.Skill1PlusButton.SetPosition(92-11, 125-25)
        self.Skill1PlusButton.SetUpVisual("illumina/skill_system/btn_plus_01.tga")
        self.Skill1PlusButton.SetOverVisual("illumina/skill_system/btn_plus_02.tga")
        self.Skill1PlusButton.SetDownVisual("illumina/skill_system/btn_plus_03.tga")
        self.Skill1PlusButton.SetText("|cffe6d0a2Ulepsz")
        self.Skill1PlusButton.SetEvent(lambda arg=1: self.SkillPlus(arg))
        self.Skill1PlusButton.Show()

        self.Skill2PlusButton = uimg.Button()
        self.Skill2PlusButton.SetParent(self.SkillsBG)
        self.Skill2PlusButton.SetPosition(202+5, 125-25)
        self.Skill2PlusButton.SetUpVisual("illumina/skill_system/btn_plus_01.tga")
        self.Skill2PlusButton.SetOverVisual("illumina/skill_system/btn_plus_02.tga")
        self.Skill2PlusButton.SetDownVisual("illumina/skill_system/btn_plus_03.tga")
        self.Skill2PlusButton.SetText("|cffe6d0a2Ulepsz")
        self.Skill2PlusButton.SetEvent(lambda arg=2: self.SkillPlus(arg))
        self.Skill2PlusButton.Show()

        self.Skill3PlusButton = uimg.Button()
        self.Skill3PlusButton.SetParent(self.SkillsBG)
        self.Skill3PlusButton.SetPosition(312+21, 125-25)
        self.Skill3PlusButton.SetUpVisual("illumina/skill_system/btn_plus_01.tga")
        self.Skill3PlusButton.SetOverVisual("illumina/skill_system/btn_plus_02.tga")
        self.Skill3PlusButton.SetDownVisual("illumina/skill_system/btn_plus_03.tga")
        self.Skill3PlusButton.SetText("|cffe6d0a2Ulepsz")
        self.Skill3PlusButton.SetEvent(lambda arg=3: self.SkillPlus(arg))
        self.Skill3PlusButton.Show()

        self.Skill4PlusButton = uimg.Button()
        self.Skill4PlusButton.SetParent(self.SkillsBG)
        self.Skill4PlusButton.SetPosition(92-11, 215-32)
        self.Skill4PlusButton.SetUpVisual("illumina/skill_system/btn_plus_01.tga")
        self.Skill4PlusButton.SetOverVisual("illumina/skill_system/btn_plus_02.tga")
        self.Skill4PlusButton.SetDownVisual("illumina/skill_system/btn_plus_03.tga")
        self.Skill4PlusButton.SetText("|cffe6d0a2Ulepsz")
        self.Skill4PlusButton.SetEvent(lambda arg=4: self.SkillPlus(arg))
        self.Skill4PlusButton.Show()

        self.Skill5PlusButton = uimg.Button()
        self.Skill5PlusButton.SetParent(self.SkillsBG)
        self.Skill5PlusButton.SetPosition(202+5, 215-32)
        self.Skill5PlusButton.SetUpVisual("illumina/skill_system/btn_plus_01.tga")
        self.Skill5PlusButton.SetOverVisual("illumina/skill_system/btn_plus_02.tga")
        self.Skill5PlusButton.SetDownVisual("illumina/skill_system/btn_plus_03.tga")
        self.Skill5PlusButton.SetText("|cffe6d0a2Ulepsz")
        self.Skill5PlusButton.SetEvent(lambda arg=5: self.SkillPlus(arg))
        self.Skill5PlusButton.Show()

        self.Skill6PlusButton = uimg.Button()
        self.Skill6PlusButton.SetParent(self.SkillsBG)
        self.Skill6PlusButton.SetPosition(312+21, 215-32)
        self.Skill6PlusButton.SetUpVisual("illumina/skill_system/btn_plus_01.tga")
        self.Skill6PlusButton.SetOverVisual("illumina/skill_system/btn_plus_02.tga")
        self.Skill6PlusButton.SetDownVisual("illumina/skill_system/btn_plus_03.tga")
        self.Skill6PlusButton.SetText("|cffe6d0a2Ulepsz")
        self.Skill6PlusButton.SetEvent(lambda arg=6: self.SkillPlus(arg))
        self.Skill6PlusButton.Show()

        self.InfoSkillsWindow()
        self.SkillActivatedWnd()

    def CloseInfoSkillsWindow(self):
        self.InfoSkillsBG.Hide()
        self.SkillInfo = 0
        self.SkillsBG.SetSize(387, 290)

    def InfoSkillsWindow(self):
        self.InfoSkillsBG = uimg.AniImageBox()
        self.InfoSkillsBG.SetParent(self.SkillsBG)
        self.InfoSkillsBG.AppendImage("illumina/skill_system/background_info.tga")
        self.InfoSkillsBG.SetSize(204, 253)
        self.InfoSkillsBG.SetPosition(387+19, 25-9)
        self.InfoSkillsBG.AddFlag("float")
        self.InfoSkillsBG.Hide()

        self.InfoSkillsClose = uimg.Button()
        self.InfoSkillsClose.SetParent(self.InfoSkillsBG)
        self.InfoSkillsClose.SetPosition(183-15, 16)
        self.InfoSkillsClose.SetUpVisual("illumina/skill_system/close_01.tga")
        self.InfoSkillsClose.SetOverVisual("illumina/skill_system/close_02.tga")
        self.InfoSkillsClose.SetDownVisual("illumina/skill_system/close_03.tga")
        self.InfoSkillsClose.SetEvent(uimg.__mem_func__(self.CloseInfoSkillsWindow))
        self.InfoSkillsClose.Show()

        self.ActivationSkill = uimg.Button()
        self.ActivationSkill.SetParent(self.InfoSkillsBG)
        self.ActivationSkill.SetPosition(37, 173+40)
        self.ActivationSkill.SetUpVisual("illumina/inne/btn_kod2_01.tga")
        self.ActivationSkill.SetOverVisual("illumina/inne/btn_kod2_02.tga")
        self.ActivationSkill.SetDownVisual("illumina/inne/btn_kod2_03.tga")
        #self.ActivationSkill.SetText("|cffe6d0a2Aktywuj")
        self.ActivationSkill.SetEvent(uimg.__mem_func__(self.SkillActivation))
        self.ActivationSkill.Show()

        self.SkillNameInfo = uimg.TextLine()
        self.SkillNameInfo.SetDefaultFontName()
        self.SkillNameInfo.SetParent(self.InfoSkillsBG)
        self.SkillNameInfo.SetPosition(16-3, 25+24)
        self.SkillNameInfo.SetFontColor(0.95, 0.9, 0.75)
        self.SkillNameInfo.SetFontName("Tahoma:12")
        self.SkillNameInfo.SetText("")
        self.SkillNameInfo.SetOutline()
        self.SkillNameInfo.Show()

        self.SkillDescInfo = uimg.TextLine()
        self.SkillDescInfo.SetDefaultFontName()
        self.SkillDescInfo.SetParent(self.InfoSkillsBG)
        self.SkillDescInfo.SetPosition(16-3, 43+20)
        self.SkillDescInfo.SetFontColor(1, 0.7, 0)
        self.SkillDescInfo.SetFontName("Tahoma:12")
        self.SkillDescInfo.SetMultiLine()
        self.SkillDescInfo.SetLimitWidth(162)
        self.SkillDescInfo.SetText("")
        self.SkillDescInfo.Show()

        self.SkillValInfo = uimg.TextLine()
        self.SkillValInfo.SetDefaultFontName()
        self.SkillValInfo.SetParent(self.InfoSkillsBG)
        self.SkillValInfo.SetPosition(16-3, 114+20)
        self.SkillValInfo.SetFontColor(0.15, 0.85, 0)
        self.SkillValInfo.SetFontName("Tahoma:12")
        self.SkillValInfo.SetOutline()
        self.SkillValInfo.Show()

        self.SkillNextValInfo = uimg.TextLine()
        self.SkillNextValInfo.SetDefaultFontName()
        self.SkillNextValInfo.SetParent(self.InfoSkillsBG)
        self.SkillNextValInfo.SetPosition(16-3, 128+20)
        self.SkillNextValInfo.SetFontColor(0.9, 0.2, 0.2)
        self.SkillNextValInfo.SetFontName("Tahoma:12")
        self.SkillNextValInfo.SetOutline()
        self.SkillNextValInfo.Show()

        self.SkillTimeInfo = uimg.TextLine()
        self.SkillTimeInfo.SetDefaultFontName()
        self.SkillTimeInfo.SetParent(self.InfoSkillsBG)
        self.SkillTimeInfo.SetPosition(16-3, 143+19)
        self.SkillTimeInfo.SetFontColor(1, 0.7, 0)
        self.SkillTimeInfo.SetFontName("Tahoma:12")
        self.SkillTimeInfo.SetOutline()
        self.SkillTimeInfo.Show()

        self.SkillMPinfo = uimg.TextLine()
        self.SkillMPinfo.SetDefaultFontName()
        self.SkillMPinfo.SetParent(self.InfoSkillsBG)
        self.SkillMPinfo.SetPosition(16-3, 114+62)
        self.SkillMPinfo.SetFontColor(1, 0.7, 0)
        self.SkillMPinfo.SetFontName("Tahoma:12")
        self.SkillMPinfo.SetOutline()
        self.SkillMPinfo.Show()

        self.SkillTitleBok = uimg.TextLine()
        self.SkillTitleBok.SetDefaultFontName()
        self.SkillTitleBok.SetParent(self.InfoSkillsBG)
        self.SkillTitleBok.SetPosition(70, 13+9)
        self.SkillTitleBok.SetText("|cffe6d0a2Informacje")
        self.SkillTitleBok.SetOutline()
        self.SkillTitleBok.Show()

    def InfoSkill(self, value):
        self.CloseInfoSkillsWindow()
        SkillInfo = int(value)
        self.SkillInfo = SkillInfo
        self.SkillsBG.SetSize(387 + 203, 290)
        self.InfoSkillsBG.Show()

        self.SkillNameInfo.SetText(skills_language.SkillName[SkillInfo])
        self.SkillDescInfo.SetText(skills_language.SkillDesc[SkillInfo])
        self.SkillValInfo.SetText(skills_language.SkillActLevel + str(self.SkillValue[SkillInfo]))
        self.SkillMPinfo.SetText("Wymagana Energia: " + str(self.SkillMP[SkillInfo]))
        self.SkillTimeInfo.SetText(skills_language.SkillDuration + str(self.SkillDuration[SkillInfo]) + " sec")
        if self.level_skill[SkillInfo] == 0:
            self.ActivationSkill.SetUpVisual("illumina/skill_system/btn_avtiv_no.tga")
            self.ActivationSkill.SetOverVisual("illumina/skill_system/btn_avtiv_no.tga")
            self.ActivationSkill.SetDownVisual("illumina/skill_system/btn_avtiv_no.tga")
        else:
            self.ActivationSkill.SetUpVisual("illumina/skill_system/btn_avtiv_01.tga")
            self.ActivationSkill.SetOverVisual("illumina/skill_system/btn_avtiv_02.tga")
            self.ActivationSkill.SetDownVisual("illumina/skill_system/btn_avtiv_03.tga")
        if self.level_skill[SkillInfo]!= 17:
            self.SkillNextValInfo.SetText(skills_language.SkillNextLevel + str(self.SkillNextValue[SkillInfo]))
        #self.ButonActivareMagie.SetEvent(uimg.__mem_func__(self.activareMagie1))

    def __SkillsLevels(self, value1, value2, value3, value4, value5, value6):
        self.level_skill = []
        self.level_skill.append(0)
        self.level_skill.append(int(value1))
        self.level_skill.append(int(value2))
        self.level_skill.append(int(value3))
        self.level_skill.append(int(value4))
        self.level_skill.append(int(value5))
        self.level_skill.append(int(value6))

        self.Skill1Level.SetText(skills_language.SkillLevel + value1)
        self.Skill2Level.SetText(skills_language.SkillLevel + value2)
        self.Skill3Level.SetText(skills_language.SkillLevel + value3)
        self.Skill4Level.SetText(skills_language.SkillLevel + value4)
        self.Skill5Level.SetText(skills_language.SkillLevel + value5)
        self.Skill6Level.SetText(skills_language.SkillLevel + value6)

    def __SkillsPoints(self, value1, value2, value3, value4, value5, value6):
        if self.level_skill[1] == 17:
            self.Skill1Points.SetText(skills_language.PointsMaxLevel)
            self.Skill1PlusButton.Hide()
        else:
            self.Skill1Points.SetText(value1 + " " + skills_language.PointsLevel)
        if self.level_skill[2] == 17:
            self.Skill2Points.SetText(skills_language.PointsMaxLevel)
            self.Skill2PlusButton.Hide()
        else:
            self.Skill2Points.SetText(value2 + " " + skills_language.PointsLevel)
        if self.level_skill[3] == 17:
            self.Skill3Points.SetText(skills_language.PointsMaxLevel)
            self.Skill3PlusButton.Hide()
        else:
            self.Skill3Points.SetText(value3 + " " + skills_language.PointsLevel)
        if self.level_skill[4] == 17:
            self.Skill4Points.SetText(skills_language.PointsMaxLevel)
            self.Skill4PlusButton.Hide()
        else:
            self.Skill4Points.SetText(value4 + " " + skills_language.PointsLevel)
        if self.level_skill[5] == 17:
            self.Skill5Points.SetText(skills_language.PointsMaxLevel)
            self.Skill5PlusButton.Hide()
        else:
            self.Skill5Points.SetText(value5 + " " + skills_language.PointsLevel)
        if self.level_skill[6] == 17:
            self.Skill6Points.SetText(skills_language.PointsMaxLevel)
            self.Skill6PlusButton.Hide()
        else:
            self.Skill6Points.SetText(value6 + " " + skills_language.PointsLevel)

    def __QuestSkills(self, value):
        constInfo.QUESTSKILLS = int(value)

    def __SkillsValue(self, value1, value2, value3, value4, value5, value6):
        self.SkillValue = []
        self.SkillValue.append(0)
        self.SkillValue.append(int(value1))
        self.SkillValue.append(int(value2))
        self.SkillValue.append(int(value3))
        self.SkillValue.append(int(value4))
        self.SkillValue.append(int(value5))
        self.SkillValue.append(int(value6))

    def __SkillsNextValue(self, value1, value2, value3, value4, value5, value6):
        self.SkillNextValue = []
        self.SkillNextValue.append(0)
        self.SkillNextValue.append(int(value1))
        self.SkillNextValue.append(int(value2))
        self.SkillNextValue.append(int(value3))
        self.SkillNextValue.append(int(value4))
        self.SkillNextValue.append(int(value5))
        self.SkillNextValue.append(int(value6))

    def __SkillsDuration(self, value1, value2, value3, value4, value5, value6):
        self.SkillDuration = []
        self.SkillDuration.append(0)
        self.SkillDuration.append(int(value1))
        self.SkillDuration.append(int(value2))
        self.SkillDuration.append(int(value3))
        self.SkillDuration.append(int(value4))
        self.SkillDuration.append(int(value5))
        self.SkillDuration.append(int(value6))

    def __SkillsMP(self, value1, value2, value3, value4, value5, value6):
        self.SkillMP = []
        self.SkillMP.append(0)
        self.SkillMP.append(int(value1))
        self.SkillMP.append(int(value2))
        self.SkillMP.append(int(value3))
        self.SkillMP.append(int(value4))
        self.SkillMP.append(int(value5))
        self.SkillMP.append(int(value6))

        if self.SkillInfo != 0:
            self.InfoSkill(self.SkillInfo)

    def __GetInputStatus(self, value):
        constInfo.GETINPUTSTUS = int(value)

    def __GetInput(self):
        net.SendQuestInputStringPacket("1")

    def SkillPlus(self, value):
        questskills = int(constInfo.QUESTSKILLS)
        event.QuestButtonClick(questskills)
        net.SendQuestInputStringPacket("skill" + str(value) + "_plus")

    def SkillActivatedWnd(self):
        self.SkillActivatedBG = uimg.AniImageBox()
        self.SkillActivatedBG.AppendImage("illumina/skill_system/background_activ_skill.tga")
        self.SkillActivatedBG.SetPosition(wndMgr.GetScreenWidth() - 160+15, 170)
        self.SkillActivatedBG.AddFlag("float")
        self.SkillActivatedBG.Hide()

        self.SkillActivatedBar = uimg.AniImageBox()
        self.SkillActivatedBar.AppendImage("illumina/skill_system/pasek_ladowania_small.tga")
        self.SkillActivatedBar.SetParent(self.SkillActivatedBG)
        self.SkillActivatedBar.SetPosition(56-7, 27+7)
        self.SkillActivatedBar.SetPercentage(100, 100)
        self.SkillActivatedBar.Show()

        self.SkillActivatedName = uimg.TextLine()
        self.SkillActivatedName.SetDefaultFontName()
        self.SkillActivatedName.SetParent(self.SkillActivatedBG)
        self.SkillActivatedName.SetPosition(50, 14)
        self.SkillActivatedName.SetFontColor(0.95, 0.9, 0.75)
        self.SkillActivatedName.SetFontName("Tahoma:12")
        self.SkillActivatedName.SetText("")
        self.SkillActivatedName.SetOutline()
        self.SkillActivatedName.Show()

    def __SkillActivated(self, value1, value2):
        self.SkillActivatedIcon = uimg.AniImageBox()
        self.SkillActivatedIcon.SetParent(self.SkillActivatedBG)
        self.SkillActivatedIcon.AppendImage("illumina/skill_system/skille/skil" + value1 + "_small.tga")
        self.SkillActivatedIcon.SetPosition(5+5, 4+6)
        self.SkillActivatedIcon.AddFlag("float")
        self.SkillActivatedIcon.Show()

        skill = int(value1)
        self.SkillActivatedName.SetText(skills_language.SkillName[skill])

        self.SkillFullTime = int(value2)
        self.SkillEndTime = int(value2) + time.clock()

        self.SkillActivatedBG.Show()
        self.SkillActivatedInfo = 1

        self.SkillActivated = skill
        self.SkillEffectUpdate = time.clock()

    def UpdateSkillEffect(self):
        net.SendChatPacket("(skill" + str(self.SkillActivated) + "_effect)")

    def UpdateSkillTimeBar(self):
        self.SkillTimeLeft = self.SkillEndTime - time.clock()
        if self.SkillTimeLeft <= 0:
            self.SkillActivatedBG.Hide()
            self.SkillActivatedInfo = 0
        else:
            self.SkillActivatedBar.SetPercentage(self.SkillTimeLeft * 100 / self.SkillFullTime, 100)

    def __SetSkillsBar(self, value):
        self.SkillsBar.SetPercentage(int(value), 100)
        self.SkillBarStatus.SetText("Energia: " + value + "/100")

    def SkillActivation(self):
        questskills = int(constInfo.QUESTSKILLS)
        event.QuestButtonClick(questskills)
        net.SendQuestInputStringPacket("skill" + str(self.SkillInfo) + "_activation")

    #### nowe skile za PO ###

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

            isUpgradeable = False
            isMetin = False
            item.SelectItem(itemVnum)
            if item.GetItemType(1,2,3,4,5,6) == item.ITEM_TYPE_WEAPON or item.GetItemType(1,2,3,4,5,6) == item.ITEM_TYPE_ARMOR:
                isUpgradeable = True
            elif item.GetItemType(1,2,3,4,5,6) == item.ITEM_TYPE_METIN:
                isMetin = True

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

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

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

    def PokazOknoSkill(self, qid):
        constInfo.Okienko = int(qid)

    def PokazOknoSkill2(self):
        if self.SkillsWindowIsOpen == 0:
            self.SkillsBG.Show()
            self.SkillsWindowIsOpen = 1
        else:
            self.SkillsBG.Hide()
            self.SkillsWindowIsOpen = 0

    def Gui_Wybor_Boss_Nagroda(self, i1, i2, i3, c1, c2, c3):
        self.NagrodaBoss.UstawItemy(i1, i2, i3, c1, c2, c3)
        self.NagrodaBoss.Open()

    def Odbierz_Nagrode_Boss(self, qid):
        constInfo.Nagroda_Za_Bossa_Odbierz = int(qid)

    def __Acce_okno(self):
        if FALSE == player.IsObserverMode():
            if FALSE == self.Acce_okno.IsShow():
                self.Acce_okno.Show()
                self.Acce_okno.SetTop()
            else:
                self.Acce_okno.Hide()

    def WczytajBiologa(self, etap, oddane, szansa, czas):
        self.interface.wndBiolog.WczytajBiologa(etap, oddane, szansa, czas)

    def OddajBiologowi(self, qid):
        constInfo.OddajBiolog = int(qid)


        ####SHOP SYSTEM#####
    def NewShop(self):
        if self.uiNewShop:
            self.uiNewShop.Show()

    def ShopClear(self):
        if self.uiNewShop:
            self.uiNewShop.HideAll()
        constInfo.MyShops=[]
    def ShopCostClear(self):
        constInfo.shop_cost=[]
    def ShopCost(self,id,time,time_val,price):
        constInfo.shop_cost.append({"id":int(id),"time":int(time),"time_val":int(time_val),"price":int(price)})
    def ShopAdd(self,shop_id,shop_vid,szSign,gold,sold,count,days,date_close):
        chat.AppendChat(chat.CHAT_TYPE_INFO, " id "+ shop_id + " vid " + shop_vid + " name " + szSign + " gold " + gold + " sold " + sold + " days " + days + " time " + date_close + " count " + count)
        if self.uiNewShop:
            shop={
                "id":shop_id,
                "vid":shop_vid,
                "name":szSign.replace("\\"," ").replace("_","#"),
                "gold":gold,
                "sold":sold,
                "items":int(count)-int(sold),
                "days":days,
                "time":date_close
            }
            self.uiNewShop.Load(shop)
        #   self.uiNewShop.Load(2)
            constInfo.MyShops.append(shop)
    def ShopItemClear(self):
        if self.uiNewShop:
            self.uiNewShop.ClearItems()
    def ShopItem(self,data):
        d=data.split("#")
        id=d[0]
        vnum=d[1]
        count=d[2]
        slot=d[3]
        price=d[4]
        s=d[5]
        a=d[6]
        sockets=[]
        for key in s.split("|"):
            sockets.append(int(key))

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

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

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