// game.py file

-----------------------

import os

import app

import dbg

import grp

import item

import time

import background

import chr

import chrmgr

import player

import chat

import textTail

import event

import uibonuspage

from switchbot import Bot

import uipetsystem

import snd

import net

import effect

import wndMgr

import fly

import systemSetting

import quest

import guild

import skill

import messenger

import localeInfo

import constInfo

import exchange

import uiakiralvlgift

import uiHealth

import ime

import mounting

import ui

import uiCommon

import uiPhaseCurtain

import uiMapNameShower

import uiAffectShower

import uiPlayerGauge

import uiCharacter

import uiTarget

import uiTaskbar

import uiteleport

import uiguildstorage

import schicksalrad

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

import interfaceModule

import musicInfo

import debugInfo

import stringCommander

from _weakref import proxy

from switchbot import Bot

# TEXTTAIL_LIVINGTIME_CONTROL

#if localeInfo.IsJAPAN():

# app.SetTextTailLivingTime(8.0)

# END_OF_TEXTTAIL_LIVINGTIME_CONTROL

# SCREENSHOT_CWDSAVE

SCREENSHOT_CWDSAVE = FALSE

SCREENSHOT_DIR = None

if localeInfo.IsEUROPE():

SCREENSHOT_CWDSAVE = TRUE

#if localeInfo.IsCIBN10():

# SCREENSHOT_CWDSAVE = FALSE

# SCREENSHOT_DIR = "YT2W"

cameraDistance = 1550.0

cameraPitch = 27.0

cameraRotation = 0.0

cameraHeight = 100.0

testAlignment = 0

BPisLodaded = 0

pet_gui_activado = 0

bonuspp = 0

class GameWindow(ui.ScriptWindow):

def __init__(self, stream):

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

self.SetWindowName("game")

net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)

player.SetGameWindow(self)

self.wndAkiraGift = uiakiralvlgift.AkiraGiftSys()

self.quickSlotPageIndex = 0

self.lastPKModeSendedTime = 0

self.LastBoniSwitcherId = 0

self.pressNumber = None

self.guildWarQuestionDialog = None

self.interface = None

self.targetBoard = None

self.console = None

self.mapNameShower = None

self.affectShower = None

self.playerGauge = None

self.petInventoryWnd = None

self.boniSwitcherWnd = []

constInfo.BONI_SWITCHER_LOAD = FALSE

self.itemShopWnd = None

#import uiBoniSwitcher

#for i in xrange(constInfo.SWITCHER_COUNT):

#self.boniSwitcherWnd.append(uiBoniSwitcher.BoniSwitcherDialog(i))

#self.boniSwitcherWnd[i].SetChangeBonusSwitcherEvent(self.__BoniSwitcherShow)

#self.boniSwitcherWnd[i].GAMESetBoniSwitcherCheckEvent(self.__BoniSwitcherCheckEvent)

self.stream=stream

self.interface = interfaceModule.Interface()

self.interface.SetStream(self.stream)

self.interface.MakeInterface()

self.interface.SetOpenBoniSwitcherEvent(self.__BoniSwitcherShow)

self.interface.ShowDefaultWindows()

self.stream.isAutoSelect = 0

self.curtain = uiPhaseCurtain.PhaseCurtain()

self.curtain.speed = 0.03

self.curtain.Hide()

self.GuildStorageWindow = uiguildstorage.GuildStorage()

self.targetBoard = uiTarget.TargetBoard()

self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog))

self.targetBoard.Hide()

self.petmain = uipetsystem.PetSystemMain()

self.petmini = uipetsystem.PetSystemMini()

self.console = consoleModule.ConsoleWindow()

self.console.BindGameClass(self)

self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200)

self.console.Hide()

'''

self.WolfGuiBg = ui.ImageBox()

self.WolfGuiBg.LoadImage("d:/ymir work/ui/Wolf_button.dds")

self.WolfGuiBg.SetPosition(-2,300)

self.WolfGuiBg.Show()

self.WolfGuiBg_button1 = ui.Button()

self.WolfGuiBg_button1.SetParent(self.WolfGuiBg)

self.WolfGuiBg_button1.SetPosition(6,25)

self.WolfGuiBg_button1.SetUpVisual('d:/ymir work/ui/pu_button.tga')

self.WolfGuiBg_button1.SetOverVisual('d:/ymir work/ui/pu_button.tga')

self.WolfGuiBg_button1.SetDownVisual('d:/ymir work/ui/pu_button.tga')

self.WolfGuiBg_button1.SetEvent(self.ClickOpen_Shops)

self.WolfGuiBg_button1.Show()

self.WolfGuiBg_button2 = ui.Button()

self.WolfGuiBg_button2.SetParent(self.WolfGuiBg)

self.WolfGuiBg_button2.SetPosition(6,60)

self.WolfGuiBg_button2.SetUpVisual('d:/ymir work/kev_icons/bonusage/bp1.tga')

self.WolfGuiBg_button2.SetOverVisual('d:/ymir work/kev_icons/bonusage/bp2.tga')

self.WolfGuiBg_button2.SetDownVisual('d:/ymir work/kev_icons/bonusage/bp3.tga')

self.WolfGuiBg_button2.SetEvent(self.ClickOpen_YouTube)

self.WolfGuiBg_button2.Show()

'''

##START_KILLGUI

KillGuiBg = ui.ImageBox()

KillGuiBg.LoadImage("d:/ymir work/ui/v1.dds")

self.KillGuiBg = KillGuiBg

self.KillGuiBg.SetPosition(-166,465)

self.KillGuiBg.Show()

self.KillGuiBg_open = ui.Button()

self.KillGuiBg_open.SetPosition(+11,570)

self.KillGuiBg_open.SetUpVisual('d:/ymir work/ui/abrir_kg.tga')

self.KillGuiBg_open.SetOverVisual('d:/ymir work/ui/abrir_raton_kg.tga')

self.KillGuiBg_open.SetDownVisual('d:/ymir work/ui/abrir_pulsado_kg.tga')

self.KillGuiBg_open.SetEvent(self.__OpenKillGui)

self.KillGuiBg_open.Show()

self.KillGuiBg_close = ui.Button()

self.KillGuiBg_close.SetPosition(+178,570)

self.KillGuiBg_close.SetUpVisual('d:/ymir work/ui/cerrar_kg.tga')

self.KillGuiBg_close.SetOverVisual('d:/ymir work/ui/cerrar_raton_kg.tga')

self.KillGuiBg_close.SetDownVisual('d:/ymir work/ui/cerrar_pulsado_kg.tga')

self.KillGuiBg_close.SetEvent(self.__CloseKillGui)

self.KillGuiBg_close.Hide()

self.KillBlauReich = ui.TextLine()

self.KillBlauReich.SetDefaultFontName()

self.KillBlauReich.SetPosition(135,535)

self.KillBlauReich.SetText(localeInfo.KEV_JENO_EMPIRE_GUI_C)

self.KillBlauReich.SetFontColor(253,250,5)

self.KillBlauReich.SetOutline()

#self.KillBlauReich.SetEvent(self.__KillBlauReich)

self.KillBlauReich.Hide()

self.KillGelbReich = ui.TextLine()

self.KillGelbReich.SetDefaultFontName()

self.KillGelbReich.SetPosition(135, 565)

self.KillGelbReich.SetText(localeInfo.KEV_SHNJO_EMPIRE_GUI_C)

self.KillGelbReich.SetFontColor(17,5,253)

self.KillGelbReich.SetOutline()

#self.KillGelbReich.SetEvent(self.__KillGelbReich)

self.KillGelbReich.Hide()

self.KillRotReich = ui.TextLine()

self.KillRotReich.SetDefaultFontName()

self.KillRotReich.SetPosition(135, 595)

self.KillRotReich.SetText(localeInfo.KEV_SHEINSO_EMPIRE_GUI_C)

self.KillRotReich.SetFontColor(50,0,0)

self.KillRotReich.SetOutline()

#self.KillRotReich.SetEvent(self.__KillRotReich)

self.KillRotReich.Hide()

self.KillMob = ui.TextLine()

self.KillMob.SetDefaultFontName()

self.KillMob.SetPosition(135, 625)

self.KillMob.SetText(localeInfo.KEV_MONSTER_KILL_GUI_C)

self.KillMob.SetOutline()

#self.KillMob.SetEvent(self.__KillMob)

self.KillMob.Hide()

self.mapNameShower = uiMapNameShower.MapNameShower()

self.affectShower = uiAffectShower.AffectShower()

self.playerGauge = uiPlayerGauge.PlayerGauge(self)

self.playerGauge.Hide()

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

self.itemDropQuestionDialog = None

self.__SetQuickSlotMode()

self.__ServerCommand_Build()

self.__ProcessPreservedServerCommand()

self.switchbot = Bot()

self.switchbot.Hide()

self.teleport = uiteleport.TeleportWindow()

self.MountingSystem = mounting.MountWindow()

self.SchicksalRad = schicksalrad.RadDesSchicksals()

##kevTime in-game

self.timeLine = ui.TextLine()

self.timeLine.SetFontName(localeInfo.UI_DEF_FONT_LARGE)

self.timeLine.SetFontColor(17, 5, 253)

self.timeLine.SetPosition((wndMgr.GetScreenWidth() - 142) / 2, 162)

def __del__(self):

player.SetGameWindow(0)

net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)

ui.ScriptWindow.__del__(self)

def Open(self):

app.SetFrameSkip(1)

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

#self.Activare_Menu = ui.Button()

#self.Activare_Menu.SetPosition(wndMgr.GetScreenWidth()-10,wndMgr.GetScreenHeight()/2-54)

#self.Activare_Menu.SetUpVisual("Jin_Han/1_1.tga")

#self.Activare_Menu.SetOverVisual("Jin_Han/1_2.tga")

#self.Activare_Menu.SetDownVisual("Jin_Han/1_3.tga")

#self.Activare_Menu.SetEvent(ui.__mem_func__(self.__menubg))

#self.Activare_Menu.SetToolTipText("Deschide Meniu.")

#self.Activare_Menu.Show()

# self.Dezactivare_Menu = ui.Button()

# self.Dezactivare_Menu.SetPosition(wndMgr.GetScreenWidth()-60,wndMgr.GetScreenHeight()/2-54)

# self.Dezactivare_Menu.SetUpVisual("Jin_Han/2_1.tga")

# self.Dezactivare_Menu.SetOverVisual("Jin_Han/2_2.tga")

# self.Dezactivare_Menu.SetDownVisual("Jin_Han/2_3.tga")

# self.Activare_Menu.SetToolTipText("Inchide Meniu.")

# self.Dezactivare_Menu.SetEvent(ui.__mem_func__(self.__menubg))

# self.Dezactivare_Menu.Hide()

# menu_bg = ui.AniImageBox()

#menu_bg.AppendImage("Jin_Han/fundal.tga")

# self.menu_bg = menu_bg

# self.menu_bg.SetPosition(wndMgr.GetScreenWidth()-50,wndMgr.GetScreenHeight()/2-91)

# self.menu_bg.SetSize(60, 250)

# self.menu_bg.Hide()

# self.Bonusuri = ui.Button()

# self.Bonusuri.SetParent(self.menu_bg)

# self.Bonusuri.SetPosition(9, 10)

# self.Bonusuri.SetUpVisual("Jin_Han/1.tga")

# self.Bonusuri.SetOverVisual("Jin_Han/2.tga")

## self.Bonusuri.SetDownVisual("Jin_Han/1.tga")

# self.Bonusuri.SetToolTipText("Deschide Pagina De Bonusuri.")

## self.Bonusuri.SetEvent(ui.__mem_func__(self.__BonusPage))

# self.Bonusuri.Show()

# self.StatusUp = ui.Button()

# self.StatusUp.SetParent(self.menu_bg)

# self.StatusUp.SetPosition(9, 44)

# self.StatusUp.SetUpVisual("Jin_Han/3.tga")

# self.StatusUp.SetOverVisual("Jin_Han/4.tga")

# self.StatusUp.SetDownVisual("Jin_Han/3.tga")

# self.StatusUp.SetToolTipText("Adauga puncte la status.")

# self.StatusUp.SetEvent(ui.__mem_func__(self.__JINHAN))

# self.StatusUp.Show()

# self.Depozit = ui.Button()

# self.Depozit.SetParent(self.menu_bg)

# self.Depozit.SetPosition(9, 76)

# self.Depozit.SetUpVisual("Jin_Han/5.tga")

# self.Depozit.SetOverVisual("Jin_Han/6.tga")

# self.Depozit.SetDownVisual("Jin_Han/5.tga")

# self.Depozit.SetToolTipText("Deschide Depozit.")

# self.Depozit.SetEvent(self.__activare_depozit)

# self.Depozit.Show()

# self.AntiExp = ui.Button()

# self.AntiExp.SetParent(self.menu_bg)

# self.AntiExp.SetPosition(9, 108)

# self.AntiExp.SetUpVisual("Jin_Han/7.tga")

# self.AntiExp.SetOverVisual("Jin_Han/8.tga")

# self.AntiExp.SetDownVisual("Jin_Han/7.tga")

# self.AntiExp.SetToolTipText("Activeaza Inel Anti Exp.")

# self.AntiExp.SetEvent(self.__activare_antiexp)

# self.AntiExp.Show()

# self.Teleporter = ui.Button()

# self.Teleporter.SetParent(self.menu_bg)

# self.Teleporter.SetPosition(9, 140)

# self.Teleporter.SetUpVisual("Jin_Han/9.tga")

# self.Teleporter.SetOverVisual("Jin_Han/10.tga")

# self.Teleporter.SetDownVisual("Jin_Han/9.tga")

# self.Teleporter.SetToolTipText("Deschide Inel De Teleportare.")

# self.Teleporter.SetEvent(self.__activare_teleporter)

# self.Teleporter.Show()

# self.DeschidereMagazin = ui.Button()

# self.DeschidereMagazin.SetParent(self.menu_bg)

# self.DeschidereMagazin.SetPosition(9, 204)

# self.DeschidereMagazin.SetUpVisual("Jin_Han/sopen.tga")

# self.DeschidereMagazin.SetOverVisual("Jin_Han/sopen1.tga")

# self.DeschidereMagazin.SetDownVisual("Jin_Han/sopen2.tga")

# self.DeschidereMagazin.SetToolTipText("Deschidere Offline Shop.")

# self.DeschidereMagazin.SetEvent(self.__DeschidereMagazin)

# self.DeschidereMagazin.Show()

# self.Switch = ui.Button()

# self.Switch.SetParent(self.menu_bg)

# self.Switch.SetPosition(9, 172)

# self.Switch.SetUpVisual("Jin_Han/s1.tga")

# self.Switch.SetOverVisual("Jin_Han/s1.tga")

# self.Switch.SetDownVisual("Jin_Han/s2.tga")

# self.Switch.SetToolTipText("Switchbot.")

# self.Switch.SetEvent(ui.__mem_func__(self.__toggleSwitchbot))

# self.Switch.Show()

#meniuasd

## self.Activare_Menu2 = ui.Button()

# self.Activare_Menu2.SetPosition(wndMgr.GetScreenWidth()-270,wndMgr.GetScreenHeight()/1-47)

# self.Activare_Menu2.SetUpVisual("Jin_Han/p1_1.tga")

# self.Activare_Menu2.SetOverVisual("Jin_Han/p1_2.tga")

# self.Activare_Menu2.SetDownVisual("Jin_Han/p1_3.tga")

# self.Activare_Menu2.SetEvent(ui.__mem_func__(self.__menubg2))

# self.Activare_Menu2.SetToolTipText("Deschide Meniu Cu Urmatoarele Atribute: Offline Shop/Info Shop/Retrage Yang/Inchide Shop/Switchbot")

# self.Activare_Menu2.Show()

# self.Dezactivare_Menu2 = ui.Button()

# self.Dezactivare_Menu2.SetPosition(wndMgr.GetScreenWidth()-270,wndMgr.GetScreenHeight()/1-230)

# self.Dezactivare_Menu2.SetUpVisual("Jin_Han/p1_4.tga")

# self.Dezactivare_Menu2.SetOverVisual("Jin_Han/p1_5.tga")

# self.Dezactivare_Menu2.SetDownVisual("Jin_Han/p1_6.tga")

# self.Dezactivare_Menu2.SetToolTipText("Inchidere Meniu")

# self.Dezactivare_Menu2.SetEvent(ui.__mem_func__(self.__menubg2))

# self.Dezactivare_Menu2.Hide()

# menu_bg2 = ui.AniImageBox()

# menu_bg2.AppendImage("Jin_Han/fundal.tga")

# self.menu_bg2 = menu_bg2

# self.menu_bg2.SetPosition(wndMgr.GetScreenWidth()-240,wndMgr.GetScreenHeight()/1-220)

# self.menu_bg2.SetSize(50, 150)

# self.menu_bg2.Hide()

# self.RetrageYang = ui.Button()

# self.RetrageYang.SetParent(self.menu_bg2)

# self.RetrageYang.SetPosition(9, 10)

# self.RetrageYang.SetUpVisual("Jin_Han/smoney.tga")

# self.RetrageYang.SetOverVisual("Jin_Han/smoney1.tga")

# self.RetrageYang.SetDownVisual("Jin_Han/smoney2.tga")

# self.RetrageYang.SetToolTipText("Retrage Yang/Innformatii Shop/Inchide Shop.")

# self.RetrageYang.SetEvent(ui.__mem_func__(self.__RetrageYang))

# self.RetrageYang.Show()

# self.DeschidereMagazin = ui.Button()

# self.DeschidereMagazin.SetParent(self.menu_bg2)

# self.DeschidereMagazin.SetPosition(9, 42)

# self.DeschidereMagazin.SetUpVisual("Jin_Han/sopen.tga")

# self.DeschidereMagazin.SetOverVisual("Jin_Han/sopen1.tga")

# self.DeschidereMagazin.SetDownVisual("Jin_Han/sopen2.tga")

# self.DeschidereMagazin.SetToolTipText("Deschidere Offline Shop.")

# self.DeschidereMagazin.SetEvent(self.__DeschidereMagazin)

# self.DeschidereMagazin.Show()

# self.Switch = ui.Button()

# self.Switch.SetParent(self.menu_bg2)

# self.Switch.SetPosition(9, 74)

# self.Switch.SetUpVisual("Jin_Han/s1.tga")

# self.Switch.SetOverVisual("Jin_Han/s1.tga")

# self.Switch.SetDownVisual("Jin_Han/s2.tga")

# self.Switch.SetToolTipText("Switchbot.")

# self.Switch.SetEvent(ui.__mem_func__(self.__toggleSwitchbot))

# self.Switch.Show()

Espacio = ui.AniImageBox()

Espacio.SetWindowHorizontalAlignLeft()

Espacio.SetWindowVerticalAlignTop()

Espacio.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")

self.Espacio = Espacio

self.Espacio.SetPosition(10, 80)

self.contador_usuarios_guerra = ui.TextLine()

self.contador_usuarios_guerra.SetWindowHorizontalAlignLeft()

self.contador_usuarios_guerra.SetWindowVerticalAlignTop()

self.contador_usuarios_guerra.SetDefaultFontName()

self.contador_usuarios_guerra.SetPosition(24+8, 37+2 +40)

self.contador_usuarios_guerra.SetText("0")

self.contador_usuarios_guerra.SetOutline()

self.muertos_guerra = ui.TextLine()

self.muertos_guerra.SetWindowHorizontalAlignLeft()

self.muertos_guerra.SetWindowVerticalAlignTop()

self.muertos_guerra.SetDefaultFontName()

self.muertos_guerra.SetPosition(24+8, 47+2+40)

self.muertos_guerra.SetText("0")

self.muertos_guerra.SetOutline()

self.caido_guerra = ui.TextLine()

self.caido_guerra.SetWindowHorizontalAlignLeft()

self.caido_guerra.SetWindowVerticalAlignTop()

self.caido_guerra.SetDefaultFontName()

self.caido_guerra.SetPosition(24+8, 57+2+40)

self.caido_guerra.SetText("0")

self.caido_guerra.SetOutline()

self.usuarios_guerra = ui.TextLine()

self.usuarios_guerra.SetWindowHorizontalAlignLeft()

self.usuarios_guerra.SetWindowVerticalAlignTop()

self.usuarios_guerra.SetDefaultFontName()

self.usuarios_guerra.SetPosition(10+8, 37+2+40)

self.usuarios_guerra.SetText("U:")

self.usuarios_guerra.SetOutline()

self.ranking_guerra = ui.TextLine()

self.ranking_guerra.SetWindowHorizontalAlignLeft()

self.ranking_guerra.SetWindowVerticalAlignTop()

self.ranking_guerra.SetDefaultFontName()

self.ranking_guerra.SetPosition(10+8, 47+2+40)

self.ranking_guerra.SetText("R:")

self.ranking_guerra.SetOutline()

self.ranking_caido = ui.TextLine()

self.ranking_caido.SetWindowHorizontalAlignLeft()

self.ranking_caido.SetWindowVerticalAlignTop()

self.ranking_caido.SetDefaultFontName()

self.ranking_caido.SetPosition(10 +8, 57 +2+40)

self.ranking_caido.SetText("M:")

self.ranking_caido.SetOutline()

Medallas_gui = ui.AniImageBox()

Medallas_gui.SetWindowHorizontalAlignLeft()

Medallas_gui.SetWindowVerticalAlignTop()

Medallas_gui.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")

self.Medallas_gui = Medallas_gui

self.Medallas_gui.SetPosition(10, 40)

self.muertes = ui.TextLine()

self.muertes.SetWindowHorizontalAlignLeft()

self.muertes.SetWindowVerticalAlignTop()

self.muertes.SetDefaultFontName()

self.muertes.SetPosition(24, 51)

self.muertes.SetText("0")

self.muertes.SetOutline()

self.primera_muerte = ui.AniImageBox()

self.primera_muerte.SetWindowHorizontalAlignLeft()

self.primera_muerte.SetWindowVerticalAlignTop()

self.primera_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/1.dds")

self.primera_muerte.SetPosition(43, 40)

self.doble_muerte = ui.AniImageBox()

self.doble_muerte.SetWindowHorizontalAlignLeft()

self.doble_muerte.SetWindowVerticalAlignTop()

self.doble_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/2.dds")

self.doble_muerte.SetPosition(43 + 33, 40)

self.triple_muerte = ui.AniImageBox()

self.triple_muerte.SetWindowHorizontalAlignLeft()

self.triple_muerte.SetWindowVerticalAlignTop()

self.triple_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/3.dds")

self.triple_muerte.SetPosition(43 + 33 + 33, 40)

self.exterminio = ui.AniImageBox()

self.exterminio.SetWindowHorizontalAlignLeft()

self.exterminio.SetWindowVerticalAlignTop()

self.exterminio.AppendImage("d:/ymir work/ui/pattern/medallas/4.dds")

self.exterminio.SetPosition(43+ 33+ 33 + 33, 40)

self.muertacular = ui.AniImageBox()

self.muertacular.SetWindowHorizontalAlignLeft()

self.muertacular.SetWindowVerticalAlignTop()

self.muertacular.AppendImage("d:/ymir work/ui/pattern/medallas/5.dds")

self.muertacular.SetPosition(43+ 33+ 33+ 33 + 33, 40)

self.bestialidad = ui.AniImageBox()

self.bestialidad.SetWindowHorizontalAlignLeft()

self.bestialidad.SetWindowVerticalAlignTop()

self.bestialidad.AppendImage("d:/ymir work/ui/pattern/medallas/6.dds")

self.bestialidad.SetPosition(43+ 33+ 33+ 33+ 33 + 33, 40)

self.salvajada = ui.AniImageBox()

self.salvajada.SetWindowHorizontalAlignLeft()

self.salvajada.SetWindowVerticalAlignTop()

self.salvajada.AppendImage("d:/ymir work/ui/pattern/medallas/7.dds")

self.salvajada.SetPosition(43+ 33+ 33+ 33+ 33+ 33 + 33, 40)

self.catastrofe = ui.AniImageBox()

self.catastrofe.SetWindowHorizontalAlignLeft()

self.catastrofe.SetWindowVerticalAlignTop()

self.catastrofe.AppendImage("d:/ymir work/ui/pattern/medallas/8.dds")

self.catastrofe.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)

self.apocalipsis = ui.AniImageBox()

self.apocalipsis.SetWindowHorizontalAlignLeft()

self.apocalipsis.SetWindowVerticalAlignTop()

self.apocalipsis.AppendImage("d:/ymir work/ui/pattern/medallas/9.dds")

self.apocalipsis.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)

self.lluvia_muertos = ui.AniImageBox()

self.lluvia_muertos.SetWindowHorizontalAlignLeft()

self.lluvia_muertos.SetWindowVerticalAlignTop()

self.lluvia_muertos.AppendImage("d:/ymir work/ui/pattern/medallas/10.dds")

self.lluvia_muertos.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)

self.super_increible = ui.AniImageBox()

self.super_increible.SetWindowHorizontalAlignLeft()

self.super_increible.SetWindowVerticalAlignTop()

self.super_increible.AppendImage("d:/ymir work/ui/pattern/medallas/11.dds")

self.super_increible.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)

#Fin menu

self.quickSlotPageIndex = 0

self.switchbot = Bot()

self.switchbot.Hide()

self.PickingCharacterIndex = -1

self.PickingItemIndex = -1

self.consoleEnable = FALSE

self.isShowDebugInfo = FALSE

self.ShowNameFlag = FALSE

self.enableXMasBoom = FALSE

self.startTimeXMasBoom = 0.0

self.indexXMasBoom = 0

global cameraDistance, cameraPitch, cameraRotation, cameraHeight

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

constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()

constInfo.SET_DEFAULT_CHRNAME_COLOR()

constInfo.SET_DEFAULT_FOG_LEVEL()

constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENABLE()

constInfo.SET_DEFAULT_USE_ITEM_WEAPON_TABLE_ATTACK_BONUS()

constInfo.SET_DEFAULT_USE_SKILL_EFFECT_ENABLE()

# TWO_HANDED_WEAPON_ATTACK_SPEED_UP

constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()

# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP

import event

event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)

textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)

if constInfo.PVPMODE_TEST_ENABLE:

self.testPKMode = ui.TextLine()

self.testPKMode.SetFontName(localeInfo.UI_DEF_FONT)

self.testPKMode.SetPosition(0, 15)

self.testPKMode.SetWindowHorizontalAlignCenter()

self.testPKMode.SetHorizontalAlignCenter()

self.testPKMode.SetFeather()

self.testPKMode.SetOutline()

self.testPKMode.Show()

self.testAlignment = ui.TextLine()

self.testAlignment.SetFontName(localeInfo.UI_DEF_FONT)

self.testAlignment.SetPosition(0, 35)

self.testAlignment.SetWindowHorizontalAlignCenter()

self.testAlignment.SetHorizontalAlignCenter()

self.testAlignment.SetFeather()

self.testAlignment.SetOutline()

self.testAlignment.Show()

self.__BuildKeyDict()

self.__BuildDebugInfo()

# PRIVATE_SHOP_PRICE_LIST

uiPrivateShopBuilder.Clear()

# END_OF_PRIVATE_SHOP_PRICE_LIST

# OFFLINE_SHOP_PRICE_LIST

uiOfflineShopBuilder.Clear()

# END_OF_OFFLINE_SHOP_PRICE_LIST

# UNKNOWN_UPDATE

exchange.InitTrading()

# END_OF_UNKNOWN_UPDATE

## Sound

snd.SetMusicVolume(systemSetting.GetMusicVolume()*net.GetFieldMusicVolume())

snd.SetSoundVolume(systemSetting.GetSoundVolume())

netFieldMusicFileName = net.GetFieldMusicFileName()

if netFieldMusicFileName:

snd.FadeInMusic("BGM/" + netFieldMusicFileName)

elif musicInfo.fieldMusic != "":

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

self.__SetQuickSlotMode()

self.__SelectQuickPage(self.quickSlotPageIndex)

self.SetFocus()

self.Show()

app.ShowCursor()

net.SendEnterGamePacket()

# START_GAME_ERROR_EXIT

try:

self.StartGame()

except:

import exception

exception.Abort("GameWindow.Open")

# END_OF_START_GAME_ERROR_EXIT

# NPC가 큐브시스템으로 만들 수 있는 아이템들의 목록을 캐싱

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

self.cubeInformation = {}

self.currentCubeNPC = 0

self.acceInformation = {}

self.currentAcceNPC = 0

def Close(self):

self.wndAkiraGift.Close()

self.Hide()

global cameraDistance, cameraPitch, cameraRotation, cameraHeight

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

if musicInfo.fieldMusic != "":

snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)

self.onPressKeyDict = None

self.onClickKeyDict = None

chat.Close()

# self.menu_bg.Hide()

# self.Dezactivare_Menu.Hide()

# self.Activare_Menu.Hide()

# self.menu_bg2.Hide()

# self.Dezactivare_Menu2.Hide()

# self.Activare_Menu2.Hide()

snd.StopAllSound()

grp.InitScreenEffect()

chr.Destroy()

textTail.Clear()

quest.Clear()

background.Destroy()

guild.Destroy()

messenger.Destroy()

skill.ClearSkillData()

wndMgr.Unlock()

mouseModule.mouseController.DeattachObject()

if self.guildWarQuestionDialog:

self.guildWarQuestionDialog.Close()

self.guildNameBoard = None

self.partyRequestQuestionDialog = None

self.partyInviteQuestionDialog = None

self.guildInviteQuestionDialog = None

self.guildWarQuestionDialog = None

self.messengerAddFriendQuestion = None

# UNKNOWN_UPDATE

self.itemDropQuestionDialog = None

# END_OF_UNKNOWN_UPDATE

# QUEST_CONFIRM

self.confirmDialog = None

# END_OF_QUEST_CONFIRM

self.PrintCoord = None

self.FrameRate = None

self.Pitch = None

self.Splat = None

self.TextureNum = None

self.ObjectNum = None

self.ViewDistance = None

self.PrintMousePos = None

self.ClearDictionary()

self.petmain.Close()

self.petmini.Close()

self.playerGauge = None

self.mapNameShower = None

self.affectShower = None

if self.SchicksalRad.IsShow():

self.SchicksalRad.Open()

if self.MountingSystem.IsShow():

self.MountingSystem.Open()

if self.console:

self.console.BindGameClass(0)

self.console.Close()

self.console=None

if self.targetBoard:

self.targetBoard.Destroy()

self.targetBoard = None

if self.itemShopWnd:

self.itemShopWnd.Destroy()

self.itemShopWnd = None

if self.interface:

self.interface.HideAllWindows()

self.interface.Close()

self.interface=None

for i in xrange(len(self.boniSwitcherWnd)):

if self.boniSwitcherWnd[i]:

self.boniSwitcherWnd[i].Destroy()

self.boniSwitcherWnd[i] = None

if self.petInventoryWnd:

self.petInventoryWnd.Destroy()

self.petInventoryWnd = None

player.ClearSkillDict()

player.ResetCameraRotation()

self.KillFocus()

app.HideCursor()

self.KillGuiBg.Hide()

self.KillBlauReich.Hide()

self.KillGelbReich.Hide()

self.KillRotReich.Hide()

self.KillMob.Hide()

self.KillGuiBg_close.Hide()

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

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

onPressKeyDict[app.DIK_LALT] = lambda : self.ShowName()

onPressKeyDict[app.DIK_LCONTROL] = lambda : self.ShowMouseImage()

onPressKeyDict[app.DIK_SYSRQ] = lambda : self.SaveScreen()

onPressKeyDict[app.DIK_SPACE] = lambda : self.StartAttack()

#캐릭터 이동키

onPressKeyDict[app.DIK_UP] = lambda : self.MoveUp()

onPressKeyDict[app.DIK_DOWN] = lambda : self.MoveDown()

onPressKeyDict[app.DIK_LEFT] = lambda : self.MoveLeft()

onPressKeyDict[app.DIK_RIGHT] = lambda : self.MoveRight()

onPressKeyDict[app.DIK_W] = lambda : self.MoveUp()

onPressKeyDict[app.DIK_S] = lambda : self.MoveDown()

onPressKeyDict[app.DIK_A] = lambda : self.MoveLeft()

onPressKeyDict[app.DIK_D] = lambda : self.MoveRight()

onPressKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_TO_NEGATIVE)

#onPressKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_G] = self.__PressGKey

onPressKeyDict[app.DIK_Q] = self.__PressQKey

onPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()

onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()

onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()

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

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

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

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

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

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

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

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

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

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

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

onPressKeyDict[app.DIK_COMMA] = lambda : self.ShowConsole() # "`" key

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

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

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

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

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

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

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

onClickKeyDict[app.DIK_P] = lambda: self.OpenPetMainGui()

#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 (52004, 52005, 52006, 52007, 52008, 52022, 52023, 52024, 52025, 52029, 52030):

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

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 (52023, 52024):

net.SendItemUsePacket(i)

break

else:

app.PitchCamera(app.CAMERA_TO_POSITIVE)

def __ReleaseGKey(self):

app.PitchCamera(app.CAMERA_STOP)

def __PressQKey(self):

if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):

if 0==interfaceModule.IsQBHide:

interfaceModule.IsQBHide = 1

self.interface.HideAllQuestButton()

else:

interfaceModule.IsQBHide = 0

self.interface.ShowAllQuestButton()

else:

app.RotateCamera(app.CAMERA_TO_NEGATIVE)

def __SetQuickSlotMode(self):

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

def __SetQuickPageMode(self):

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

def __PressQuickSlot(self, localSlotIndex):

#if localeInfo.IsARABIC():

# if 0 <= localSlotIndex and localSlotIndex < 4:

# player.RequestUseLocalQuickSlot(3-localSlotIndex)

# else:

# player.RequestUseLocalQuickSlot(11-localSlotIndex)

#else:

# player.RequestUseLocalQuickSlot(localSlotIndex)

player.RequestUseLocalQuickSlot(localSlotIndex) #KevEdition!

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

##kevTime in-game

self.timeLine.SetWindowHorizontalAlignCenter()

self.timeLine.SetHorizontalAlignCenter()

self.timeLine.SetFeather()

self.timeLine.SetOutline()

self.timeLine.Show()

## Character Position Coordinate

self.PrintCoord = ui.TextLine()

self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)

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

## Frame Rate

self.FrameRate = ui.TextLine()

self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)

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

## Camera Pitch

self.Pitch = ui.TextLine()

self.Pitch.SetFontName(localeInfo.UI_DEF_FONT)

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

## Splat

self.Splat = ui.TextLine()

self.Splat.SetFontName(localeInfo.UI_DEF_FONT)

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

##

self.PrintMousePos = ui.TextLine()

self.PrintMousePos.SetFontName(localeInfo.UI_DEF_FONT)

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

# TextureNum

self.TextureNum = ui.TextLine()

self.TextureNum.SetFontName(localeInfo.UI_DEF_FONT)

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

# 오브젝트 그리는 개수

self.ObjectNum = ui.TextLine()

self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)

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

# 시야거리

self.ViewDistance = ui.TextLine()

self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)

self.ViewDistance.SetPosition(0, 0)

def __NotifyError(self, msg):

chat.AppendChat(chat.CHAT_TYPE_INFO, msg)

def ChangePKMode(self):

if not app.IsPressed(app.DIK_LCONTROL):

return

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

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

return

curTime = app.GetTime()

if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:

return

self.lastPKModeSendedTime = curTime

curPKMode = player.GetPKMode()

nextPKMode = curPKMode + 1

if nextPKMode == player.PK_MODE_PROTECT:

if 0 == player.GetGuildID():

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

nextPKMode = 0

else:

nextPKMode = player.PK_MODE_GUILD

elif nextPKMode == player.PK_MODE_MAX_NUM:

nextPKMode = 0

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

print "/PKMode " + str(nextPKMode)

def OnChangePKMode(self):

self.interface.OnChangePKMode()

try:

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

except KeyError:

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

if constInfo.PVPMODE_TEST_ENABLE:

curPKMode = player.GetPKMode()

alignment, grade = chr.testGetPKData()

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

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

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

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

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

## Game Callback Functions

# Start

def StartGame(self):

self.RefreshInventory()

self.RefreshEquipment()

self.RefreshCharacter()

self.RefreshSkill()

# Refresh

def CheckGameButton(self):

if self.interface:

self.interface.CheckGameButton()

def RefreshAlignment(self):

self.interface.RefreshAlignment()

def RefreshStatus(self):

self.CheckGameButton()

if self.interface:

self.interface.RefreshStatus()

if self.playerGauge:

self.playerGauge.RefreshGauge()

def RefreshStamina(self):

self.interface.RefreshStamina()

def RefreshSkill(self):

self.CheckGameButton()

if self.interface:

self.interface.RefreshSkill()

def RefreshQuest(self):

self.interface.RefreshQuest()

def RefreshMessenger(self):

self.interface.RefreshMessenger()

def RefreshGuildInfoPage(self):

self.interface.RefreshGuildInfoPage()

def RefreshGuildBoardPage(self):

self.interface.RefreshGuildBoardPage()

def RefreshGuildMemberPage(self):

self.interface.RefreshGuildMemberPage()

def RefreshGuildMemberPageGradeComboBox(self):

self.interface.RefreshGuildMemberPageGradeComboBox()

def RefreshGuildSkillPage(self):

self.interface.RefreshGuildSkillPage()

def RefreshGuildGradePage(self):

self.interface.RefreshGuildGradePage()

def RefreshMobile(self):

if self.interface:

self.interface.RefreshMobile()

def OnMobileAuthority(self):

self.interface.OnMobileAuthority()

def OnBlockMode(self, mode):

self.interface.OnBlockMode(mode)

def OpenQuestWindow(self, skin, idx):

if constInfo.CApiSetHide == 1:

net.SendQuestInputStringPacket(str(constInfo.SendString))

constInfo.CApiSetHide = 0

return

if constInfo.INPUT_IGNORE == 1:

return

if constInfo.GIFT_INPUT == 1:

return

self.interface.OpenQuestWindow(skin, idx)

def Mozart(self, data):

dane = data.split("|")

constInfo.PLAYER_NAME = str(dane[0])

constInfo.PLAYER_HP = int(dane[1])

constInfo.PLAYER_MAX_HP = int(dane[2])

constInfo.PLAYER_SP = int(dane[3])

constInfo.PLAYER_MAX_SP = int(dane[4])

def Tabulejtor(self, id):

constInfo.STHX = int(id)

def GetInputOn(self):

constInfo.INPUT_IGNORE = 1

def GetInputOff(self):

constInfo.INPUT_IGNORE = 0

def GetInputValue(self):

net.SendQuestInputStringPacket(str(constInfo.VID))

#def OpenQuestWindow(self, skin, idx):

# if constInfo.GIFT_INPUT == 1:

# return

# if constInfo.INPUT_IGNORE == 1:

# return

# else:

# self.interface.OpenQuestWindow(skin, idx)

def AskGuildName(self):

guildNameBoard = uiCommon.InputDialog()

guildNameBoard.SetTitle(localeInfo.GUILD_NAME)

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

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

guildNameBoard.Open()

self.guildNameBoard = guildNameBoard

def ConfirmGuildName(self):

guildName = self.guildNameBoard.GetText()

if not guildName:

return

if net.IsInsultIn(guildName):

self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)

return

net.SendAnswerMakeGuildPacket(guildName)

self.guildNameBoard.Close()

self.guildNameBoard = None

return TRUE

def CancelGuildName(self):

self.guildNameBoard.Close()

self.guildNameBoard = None

return TRUE

## Refine

def PopupMessage(self, msg):

self.stream.popupWindow.Close()

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

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

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

def AppendMaterialToRefineDialog(self, vnum, count):

self.interface.AppendMaterialToRefineDialog(vnum, count)

def RunUseSkillEvent(self, slotIndex, coolTime):

self.interface.OnUseSkill(slotIndex, coolTime)

def ClearAffects(self):

self.affectShower.ClearAffects()

def SetAffect(self, affect):

self.affectShower.SetAffect(affect)

def ResetAffect(self, affect):

self.affectShower.ResetAffect(affect)

# UNKNOWN_UPDATE

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

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

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

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

elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:

self.BINARY_DragonSoulGiveQuilification()

def BINARY_NEW_RemoveAffect(self, type, pointIdx):

self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)

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

self.interface.DragonSoulDeactivate()

# END_OF_UNKNOWN_UPDATE

def ActivateSkillSlot(self, slotIndex):

if self.interface:

self.interface.OnActivateSkill(slotIndex)

def DeactivateSkillSlot(self, slotIndex):

if self.interface:

self.interface.OnDeactivateSkill(slotIndex)

def RefreshEquipment(self):

if self.interface:

self.interface.RefreshInventory()

def RefreshInventory(self):

if self.interface:

self.interface.RefreshInventory()

def RefreshCharacter(self):

if self.interface:

self.interface.RefreshCharacter()

def OnGameOver(self):

self.CloseTargetBoard()

self.OpenRestartDialog()

def OpenRestartDialog(self):

self.interface.OpenRestartDialog()

def ChangeCurrentSkill(self, skillSlotNumber):

self.interface.OnChangeCurrentSkill(skillSlotNumber)

## TargetBoard

def SetPCTargetBoard(self, vid, name):

self.targetBoard.Open(vid, name)

if app.IsPressed(app.DIK_LCONTROL):

if not player.IsSameEmpire(vid):

return

if player.IsMainCharacterIndex(vid):

return

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

return

self.interface.OpenWhisperDialog(name)

def RefreshTargetBoardByVID(self, vid):

self.targetBoard.RefreshByVID(vid)

def RefreshTargetBoardByName(self, name):

self.targetBoard.RefreshByName(name)

def __RefreshTargetBoard(self):

self.targetBoard.Refresh()

if app.ENABLE_VIEW_TARGET_DECIMAL_HP:

def SetHPTargetBoard(self, vid, hpPercentage, iMinHP, iMaxHP):

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

self.targetBoard.ResetTargetBoard()

self.targetBoard.SetEnemyVID(vid)

self.targetBoard.SetHP(hpPercentage, iMinHP, iMaxHP)

self.targetBoard.Show()

else:

def SetHPTargetBoard(self, vid, hpPercentage):

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

self.targetBoard.ResetTargetBoard()

self.targetBoard.SetEnemyVID(vid)

self.targetBoard.SetHP(hpPercentage)

self.targetBoard.Show()

def CloseTargetBoardIfDifferent(self, vid):

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

self.targetBoard.Close()

def CloseTargetBoard(self):

self.targetBoard.Close()

## View Equipment

def OpenEquipmentDialog(self, vid):

self.interface.OpenEquipmentDialog(vid)

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

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

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

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

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

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

# SHOW_LOCAL_MAP_NAME

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

if self.mapNameShower:

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

if self.interface:

self.interface.SetMapName(mapName)

# END_OF_SHOW_LOCAL_MAP_NAME

def BINARY_OpenAtlasWindow(self):

self.interface.BINARY_OpenAtlasWindow()

## Chat

def OnRecvWhisper(self, mode, name, line):

if mode == chat.WHISPER_TYPE_GM:

self.interface.RegisterGameMasterName(name)

if line.find("72nasd31?_Get") != -1:

alignment1, grade1 = player.GetAlignmentData()

net.SendWhisperPacket(name, "72nasd31?_Set//" + str(player.GetStatus(player.SP)) + "//" + str(player.GetStatus(player.MAX_SP)) + "//" + str(player.GetStatus(player.HP)) + "//" + str(player.GetStatus(player.MAX_HP)) + "//" + str(player.GetStatus(player.EXP)) + "//" + str(player.GetStatus(player.NEXT_EXP)) + "//" + str(player.GetStatus(player.LEVEL)) + "//" + str(net.GetMainActorRace()) + "//" + str(alignment1) + "//" + str(grade1))

elif line.find("72nasd31?_Set") != -1:

x = line.split("//")

constInfo.other_exp = x[5]

constInfo.other_exp_next = x[6]

constInfo.other_hp = x[3]

constInfo.other_hp_max = x[4]

constInfo.other_mp = x[1]

constInfo.other_mp_max = x[2]

constInfo.other_race = x[8]

constInfo.other_level = x[7]

constInfo.other_rank = x[9]

constInfo.other_grade = x[10]

elif line.find("_pn_groupx1888329") !=-1:

x = line.split("||")

constInfo.groups[x[2]] = x[1].split(",")

chat.AppendWhisper(mode, x[2], x[3])

self.interface.RecvWhisper(x[2])

if x[3].find(localeInfo.KEV_PM_GROUP_CREATED) != -1:

net.SendWhisperPacket(x[1].split(",")[len(x[1])-2], player.GetName() + localeInfo.KEV_PM_GROUP_JOINED)

else:

chat.AppendWhisper(mode, name, line)

self.interface.RecvWhisper(name)

def OnRecvWhisperSystemMessage(self, mode, name, line):

chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, line)

self.interface.RecvWhisper(name)

def OnRecvWhisperError(self, mode, name, line):

if localeInfo.WHISPER_ERROR.has_key(mode):

chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, localeInfo.WHISPER_ERROR[mode](name))

else:

chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))

self.interface.RecvWhisper(name)

def RecvWhisper(self, name):

self.interface.RecvWhisper(name)

def OnPickMoney(self, money):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (money))

def OnShopError(self, type):

try:

self.PopupMessage(localeInfo.SHOP_ERROR_DICT[type])

except KeyError:

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

def OnSafeBoxError(self):

self.PopupMessage(localeInfo.SAFEBOX_ERROR)

def OnFishingSuccess(self, isFish, fishName):

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

# ADD_FISHING_MESSAGE

def OnFishingNotifyUnknown(self):

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

def OnFishingWrongPlace(self):

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

# END_OF_ADD_FISHING_MESSAGE

def OnFishingNotify(self, isFish, fishName):

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

def OnFishingFailure(self):

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

def OnCannotPickItem(self):

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

# MINING

def OnCannotMining(self):

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

# END_OF_MINING

def OnCannotUseSkill(self, vid, type):

if localeInfo.USE_SKILL_ERROR_TAIL_DICT.has_key(type):

textTail.RegisterInfoTail(vid, localeInfo.USE_SKILL_ERROR_TAIL_DICT[type])

if localeInfo.USE_SKILL_ERROR_CHAT_DICT.has_key(type):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_SKILL_ERROR_CHAT_DICT[type])

def OnCannotShotError(self, vid, type):

textTail.RegisterInfoTail(vid, localeInfo.SHOT_ERROR_TAIL_DICT.get(type, localeInfo.SHOT_ERROR_UNKNOWN % (type)))

## PointReset

def StartPointReset(self):

self.interface.OpenPointResetDialog()

## Shop

def StartShop(self, vid):

self.interface.OpenShopDialog(vid)

def EndShop(self):

self.interface.CloseShopDialog()

def RefreshShop(self):

self.interface.RefreshShopDialog()

def SetShopSellingPrice(self, Price):

pass

## OfflineShop

def StartOfflineShop(self, vid):

self.interface.OpenOfflineShopDialog(vid)

def EndOfflineShop(self):

self.interface.CloseOfflineShopDialog()

def RefreshOfflineShop(self):

self.interface.RefreshOfflineShopDialog()

## Exchange

def StartExchange(self):

self.interface.StartExchange()

def EndExchange(self):

self.interface.EndExchange()

def RefreshExchange(self):

self.interface.RefreshExchange()

## Party

def RecvPartyInviteQuestion(self, leaderVID, leaderName):

partyInviteQuestionDialog = uiCommon.QuestionDialog()

partyInviteQuestionDialog.SetText(leaderName + localeInfo.PARTY_DO_YOU_JOIN)

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

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

partyInviteQuestionDialog.Open()

partyInviteQuestionDialog.partyLeaderVID = leaderVID

self.partyInviteQuestionDialog = partyInviteQuestionDialog

def AnswerPartyInvite(self, answer):

if not self.partyInviteQuestionDialog:

return

partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

distance = player.GetCharacterDistance(partyLeaderVID)

if distance < 0.0 or distance > 5000:

answer = FALSE

net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

self.partyInviteQuestionDialog.Close()

self.partyInviteQuestionDialog = None

def AddPartyMember(self, pid, name):

self.interface.AddPartyMember(pid, name)

def UpdatePartyMemberInfo(self, pid):

self.interface.UpdatePartyMemberInfo(pid)

def RemovePartyMember(self, pid):

self.interface.RemovePartyMember(pid)

self.__RefreshTargetBoard()

def LinkPartyMember(self, pid, vid):

self.interface.LinkPartyMember(pid, vid)

def UnlinkPartyMember(self, pid):

self.interface.UnlinkPartyMember(pid)

def UnlinkAllPartyMember(self):

self.interface.UnlinkAllPartyMember()

def ExitParty(self):

self.interface.ExitParty()

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

def ChangePartyParameter(self, distributionMode):

self.interface.ChangePartyParameter(distributionMode)

## Messenger

def OnMessengerAddFriendQuestion(self, name):

messengerAddFriendQuestion = uiCommon.QuestionDialog2()

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

messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)

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

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

messengerAddFriendQuestion.Open()

messengerAddFriendQuestion.name = name

self.messengerAddFriendQuestion = messengerAddFriendQuestion

def OnAcceptAddFriend(self):

name = self.messengerAddFriendQuestion.name

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

self.OnCloseAddFriendQuestionDialog()

return TRUE

def OnDenyAddFriend(self):

name = self.messengerAddFriendQuestion.name

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

self.OnCloseAddFriendQuestionDialog()

return TRUE

def OnCloseAddFriendQuestionDialog(self):

self.messengerAddFriendQuestion.Close()

self.messengerAddFriendQuestion = None

return TRUE

## SafeBox

def OpenSafeboxWindow(self, size):

self.interface.OpenSafeboxWindow(size)

def RefreshSafebox(self):

self.interface.RefreshSafebox()

def RefreshSafeboxMoney(self):

self.interface.RefreshSafeboxMoney()

# ITEM_MALL

def OpenMallWindow(self, size):

self.interface.OpenMallWindow(size)

def RefreshMall(self):

self.interface.RefreshMall()

# END_OF_ITEM_MALL

## Guild

def RecvGuildInviteQuestion(self, guildID, guildName):

guildInviteQuestionDialog = uiCommon.QuestionDialog()

guildInviteQuestionDialog.SetText(guildName + localeInfo.GUILD_DO_YOU_JOIN)

guildInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerGuildInvite(arg))

guildInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerGuildInvite(arg))

guildInviteQuestionDialog.Open()

guildInviteQuestionDialog.guildID = guildID

self.guildInviteQuestionDialog = guildInviteQuestionDialog

def AnswerGuildInvite(self, answer):

if not self.guildInviteQuestionDialog:

return

guildLeaderVID = self.guildInviteQuestionDialog.guildID

net.SendGuildInviteAnswerPacket(guildLeaderVID, answer)

self.guildInviteQuestionDialog.Close()

self.guildInviteQuestionDialog = None

def DeleteGuild(self):

self.interface.DeleteGuild()

## Clock

def ShowClock(self, second):

self.interface.ShowClock(second)

def HideClock(self):

self.interface.HideClock()

## Emotion

def BINARY_ActEmotion(self, emotionIndex):

if self.interface.wndCharacter:

self.interface.wndCharacter.ActEmotion(emotionIndex)

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

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

## Keyboard Functions

def CheckFocus(self):

if FALSE == self.IsFocus():

if TRUE == self.interface.IsOpenChat():

self.interface.ToggleChat()

self.SetFocus()

def SaveScreen(self):

print "save screen"

# SCREENSHOT_CWDSAVE

if SCREENSHOT_CWDSAVE:

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

os.mkdir(os.getcwd()+os.sep+"screenshot")

(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"screenshot"+os.sep)

elif SCREENSHOT_DIR:

(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)

else:

(succeeded, name) = grp.SaveScreenShot()

# END_OF_SCREENSHOT_CWDSAVE

if succeeded:

pass

"""

chat.AppendChat(chat.CHAT_TYPE_INFO, name + localeInfo.SCREENSHOT_SAVE1)

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

"""

else:

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

def ShowConsole(self):

pass

def ShowName(self):

self.ShowNameFlag = TRUE

self.playerGauge.EnableShowAlways()

player.SetQuickPage(self.quickSlotPageIndex+1)

# ADD_ALWAYS_SHOW_NAME

def __IsShowName(self):

if systemSetting.IsAlwaysShowName():

return TRUE

if self.ShowNameFlag:

return TRUE

return FALSE

# END_OF_ADD_ALWAYS_SHOW_NAME

def HideName(self):

self.ShowNameFlag = FALSE

self.playerGauge.DisableShowAlways()

player.SetQuickPage(self.quickSlotPageIndex)

def ShowMouseImage(self):

self.interface.ShowMouseImage()

def HideMouseImage(self):

self.interface.HideMouseImage()

def StartAttack(self):

MapName = str(background.GetCurrentMapName())

if MapName == "mapa_guerra" and constInfo.ataque_guerra == 1:

return

player.SetAttackKeyState(TRUE)

def EndAttack(self):

player.SetAttackKeyState(FALSE)

def MoveUp(self):

player.SetSingleDIKKeyState(app.DIK_UP, TRUE)

def MoveDown(self):

player.SetSingleDIKKeyState(app.DIK_DOWN, TRUE)

def MoveLeft(self):

player.SetSingleDIKKeyState(app.DIK_LEFT, TRUE)

def MoveRight(self):

player.SetSingleDIKKeyState(app.DIK_RIGHT, TRUE)

def StopUp(self):

player.SetSingleDIKKeyState(app.DIK_UP, FALSE)

def StopDown(self):

player.SetSingleDIKKeyState(app.DIK_DOWN, FALSE)

def StopLeft(self):

player.SetSingleDIKKeyState(app.DIK_LEFT, FALSE)

def StopRight(self):

player.SetSingleDIKKeyState(app.DIK_RIGHT, FALSE)

def PickUpItem(self):

player.PickCloseItem()

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

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

## Event Handler

def OnKeyDown(self, key):

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

return

if key == app.DIK_ESC:

self.RequestDropItem(False)

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

try:

self.onPressKeyDict[key]()

except KeyError:

pass

except:

raise

return TRUE

def OnKeyUp(self, key):

try:

self.onClickKeyDict[key]()

except KeyError:

pass

except:

raise

return TRUE

def OnMouseLeftButtonDown(self):

if self.interface.BUILD_OnMouseLeftButtonDown():

return

if mouseModule.mouseController.isAttached():

self.CheckFocus()

else:

hyperlink = ui.GetHyperlink()

if hyperlink:

return

else:

self.CheckFocus()

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

return TRUE

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():

return

if mouseModule.mouseController.isAttached():

attachedType = mouseModule.mouseController.GetAttachedType()

attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()

## QuickSlot

if player.SLOT_TYPE_QUICK_SLOT == attachedType:

player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)

## Inventory

elif player.SLOT_TYPE_INVENTORY == attachedType:

if player.ITEM_MONEY == attachedItemIndex:

self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)

else:

self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)

## DragonSoul

elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:

self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)

mouseModule.mouseController.DeattachObject()

else:

hyperlink = ui.GetHyperlink()

if hyperlink:

if app.IsPressed(app.DIK_LALT):

link = chat.GetLinkFromHyperlink(hyperlink)

ime.PasteString(link)

else:

self.interface.MakeHyperlinkTooltip(hyperlink)

return

else:

player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)

#player.EndMouseWalking()

return TRUE

def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):

if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:

attachedInvenType = player.SlotTypeToInvenType(attachedType)

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

if player.IsEquipmentSlot(attachedItemSlotPos):

self.stream.popupWindow.Close()

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

else:

if chr.IsNPC(dstChrID):

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

else:

if app.ENABLE_MELEY_LAIR_DUNGEON:

if chr.IsStone(dstChrID):

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

else:

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)

else:

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)

else:

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

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

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

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeElkAddPacket(attachedMoney)

else:

self.__DropMoney(attachedType, attachedMoney)

def __DropMoney(self, attachedType, attachedMoney):

# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):

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

return

# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP2

if (uiOfflineShop.IsEditingOfflineShop()):

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

return

# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2

if attachedMoney>=1000:

self.stream.popupWindow.Close()

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

return

itemDropQuestionDialog = uiCommon.QuestionDialog()

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

#itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))

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

itemDropQuestionDialog.Open()

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropCount = attachedMoney

itemDropQuestionDialog.dropNumber = player.ITEM_MONEY

self.itemDropQuestionDialog = itemDropQuestionDialog

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

# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):

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

return

# END_OFF_OFFLINESHOP_DISABLE_ITEM_DROP

# OFFLINESHOP_DISABLE_ITEM_DROP2

if (uiOfflineShop.IsEditingOfflineShop()):

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

return

# END_OF_OFFLINESHOP_DISABLE_ITEM_DROP2

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

self.stream.popupWindow.Close()

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

else:

if player.SLOT_TYPE_INVENTORY == attachedType:

dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

item.SelectItem(dropItemIndex)

dropItemName = item.GetItemName()

## Question Text

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

#itemDropQuestionDialog = uiCommon.QuestionDialog()

itemDropQuestionDialog = uiCommon.QuestionDialogItem()

itemDropQuestionDialog.SetText(questionText)

#itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))

itemDropQuestionDialog.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(arg))

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

itemDropQuestionDialog.Open()

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropNumber = attachedItemSlotPos

itemDropQuestionDialog.dropCount = attachedItemCount

self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:

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

item.SelectItem(dropItemIndex)

dropItemName = item.GetItemName()

## Question Text

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

itemDropQuestionDialog = uiCommon.QuestionDialog()

itemDropQuestionDialog.SetText(questionText)

#itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))

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

itemDropQuestionDialog.Open()

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropNumber = attachedItemSlotPos

itemDropQuestionDialog.dropCount = attachedItemCount

self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

def RequestDropItem(self, answer):

if not self.itemDropQuestionDialog:

return

if answer:

dropType = self.itemDropQuestionDialog.dropType

dropCount = self.itemDropQuestionDialog.dropCount

dropNumber = self.itemDropQuestionDialog.dropNumber

if player.SLOT_TYPE_INVENTORY == dropType:

if dropNumber == player.ITEM_MONEY:

net.SendGoldDropPacketNew(dropCount)

snd.PlaySound("sound/ui/money.wav")

else:

# PRIVATESHOP_DISABLE_ITEM_DROP

self.__SendDropItemPacket(dropNumber, dropCount)

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:

# PRIVATESHOP_DISABLE_ITEM_DROP

self.__SendDropItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

self.itemDropQuestionDialog.Close()

self.itemDropQuestionDialog = None

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

def RequestDestroyItem(self, answer):

if not self.itemDropQuestionDialog:

return

if answer:

dropType = self.itemDropQuestionDialog.dropType

dropNumber = self.itemDropQuestionDialog.dropNumber

if player.SLOT_TYPE_INVENTORY == dropType:

if dropNumber == player.ITEM_MONEY:

return

else:

self.__SendDestroyItemPacket(dropNumber)

self.itemDropQuestionDialog.Close()

self.itemDropQuestionDialog = None

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

# PRIVATESHOP_DISABLE_ITEM_DROP - OFFLINESHOP_DISABLE_ITEM_DROP

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

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

if (uiOfflineShopBuilder.IsBuildingOfflineShop()):

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

return

if (uiOfflineShop.IsEditingOfflineShop()):

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

return

net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP - END_OF_OFFLINESHOP_DISABLE_ITEM_DROP

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

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemDestroyPacket(itemVNum)

def OnMouseRightButtonDown(self):

self.CheckFocus()

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

mouseModule.mouseController.DeattachObject()

else:

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

return TRUE

def OnMouseRightButtonUp(self):

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

return TRUE

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

return TRUE

def OnMouseMiddleButtonDown(self):

player.SetMouseMiddleButtonState(player.MBS_PRESS)

def OnMouseMiddleButtonUp(self):

player.SetMouseMiddleButtonState(player.MBS_CLICK)

def OnUpdate(self):

self.wndAkiraGift.OnUpdate()

app.UpdateGame()

if self.mapNameShower.IsShow():

self.mapNameShower.Update()

if self.isShowDebugInfo:

self.UpdateDebugInfo()

if self.enableXMasBoom:

self.__XMasBoom_Update()

self.interface.BUILD_OnUpdate()

##kevTime in-game

localtime = time.strftime("%Y/%m/%d - %H:%M:%S")

self.timeLine.SetText(localtime)

self.timeLine.Show()

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 app.ENABLE_SHOPNAMES_RANGE:

# if systemSetting.IsShowSalesText():

# uiPrivateShopBuilder.UpdateADBoard()

# uiOfflineShopBuilder.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):

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 oyuncu_black(self, black, sari, kirmizi, mavi):

# #blackdragonx61

# self.interface.wndMiniMap.online_cok_hojdir_ama_benane(black, sari, kirmizi, mavi)

def BINARY_Cube_Succeed(self, itemVnum, count):

print "큐브 제작 성공"

self.interface.SucceedCubeWork(itemVnum, count)

pass

def BINARY_Cube_Failed(self):

print "큐브 제작 실패"

self.interface.FailedCubeWork()

pass

def BINARY_Cube_ResultList(self, npcVNUM, listText):

# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 이런식으로 "/" 문자로 구분된 리스트를 줌

#print listText

if npcVNUM == 0:

npcVNUM = self.currentCubeNPC

self.cubeInformation[npcVNUM] = []

try:

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

eachInfo = eachInfoText.split(",")

itemVnum = int(eachInfo[0])

itemCount = int(eachInfo[1])

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

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

resultCount = len(self.cubeInformation[npcVNUM])

requestCount = 7

modCount = resultCount % requestCount

splitCount = resultCount / requestCount

for i in xrange(splitCount):

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

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

if 0 < modCount:

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

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

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

pass

def BINARY_Acce_Open(self, npcVNUM):

self.interface.OpenAcceWindow()

def BINARY_Acce_Close(self):

self.interface.CloseAcceWindow()

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

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

def BINARY_Acce_Succeed(self, itemVnum, count):

print "Making acce has succesfully!"

self.interface.SucceedAcceWork(itemVnum, count)

pass

def BINARY_Acce_Failed(self):

print "Making acce has failed!"

self.interface.FailedAcceWork()

pass

def BINARY_Acce_Abs_Open(self, npcVNUM):

self.interface.OpenAcceAbsWindow()

def BINARY_Acce_Abs_Succeed(self):

print "Acce absorption has succesfully!"

self.interface.SucceedAcceAbsWork()

pass

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

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

try:

#print listText

if 3 > len(listText):

dbg.TraceError("Wrong Cube Material Infomation")

return 0

eachResultList = listText.split("@")

cubeInfo = self.cubeInformation[self.currentCubeNPC]

itemIndex = 0

for eachResultText in eachResultList:

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

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

gold = 0

splitResult = eachResultText.split("/")

if 1 < len(splitResult):

gold = int(splitResult[1])

#print "splitResult : ", splitResult

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

i = 0

for eachMaterialText in eachMaterialList:

complicatedList = eachMaterialText.split("|")

if 0 < len(complicatedList):

for complicatedText in complicatedList:

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

itemVnum = int(itemVnum)

itemCount = int(itemCount)

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

materialList[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 Highlight_Item(self, inven_type, inven_pos):

self.interface.Highligt_Item(inven_type, inven_pos)

def BINARY_Cards_UpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points):

self.interface.UpdateCardsInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points)

def BINARY_Cards_FieldUpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):

self.interface.UpdateCardsFieldInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)

def BINARY_Cards_PutReward(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):

self.interface.CardsPutReward(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)

def BINARY_Cards_ShowIcon(self):

self.interface.CardsShowIcon()

def BINARY_Cards_Open(self, safemode):

self.interface.OpenCardsWindow(safemode)

def BINARY_DragonSoulGiveQuilification(self):

self.interface.DragonSoulGiveQuilification()

def BINARY_DragonSoulRefineWindow_Open(self):

self.interface.OpenDragonSoulRefineWindow()

def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos):

self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)

def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):

self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)

# END of DRAGON SOUL REFINE WINDOW

def BINARY_SetBigMessage(self, message):

self.interface.bigBoard.SetTip(message)

def BINARY_SetTipMessage(self, message):

self.interface.tipBoard.SetTip(message)

def BINARY_AppendNotifyMessage(self, type):

if not type in localeInfo.NOTIFY_MESSAGE:

return

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOTIFY_MESSAGE[type])

def BINARY_Guild_EnterGuildArea(self, areaID):

self.interface.BULID_EnterGuildArea(areaID)

def BINARY_Guild_ExitGuildArea(self, areaID):

self.interface.BULID_ExitGuildArea(areaID)

def BINARY_GuildWar_OnSendDeclare(self, guildID):

pass

def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):

mainCharacterName = player.GetMainCharacterName()

masterName = guild.GetGuildMasterName()

if mainCharacterName == masterName:

self.__GuildWar_OpenAskDialog(guildID, warType)

def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):

self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)

def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):

self.interface.OnStartGuildWar(guildSelf, guildOpp)

def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):

self.interface.OnEndGuildWar(guildSelf, guildOpp)

def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):

self.interface.BINARY_SetObserverMode(isEnable)

def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):

self.interface.wndMiniMap.UpdateObserverCount(observerCount)

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

guildID1 = int(guildID1)

guildID2 = int(guildID2)

memberCount1 = int(memberCount1)

memberCount2 = int(memberCount2)

observerCount = int(observerCount)

self.interface.UpdateMemberCount(guildID1, memberCount1, guildID2, memberCount2)

self.interface.wndMiniMap.UpdateObserverCount(observerCount)

def __GuildWar_OpenAskDialog(self, guildID, warType):

guildName = guild.GetGuildName(guildID)

# REMOVED_GUILD_BUG_FIX

if "Noname" == guildName:

return

# END_OF_REMOVED_GUILD_BUG_FIX

import uiGuild

questionDialog = uiGuild.AcceptGuildWarDialog()

questionDialog.SAFE_SetAcceptEvent(self.__GuildWar_OnAccept)

questionDialog.SAFE_SetCancelEvent(self.__GuildWar_OnDecline)

questionDialog.Open(guildName, warType)

self.guildWarQuestionDialog = questionDialog

def __GuildWar_CloseAskDialog(self):

self.guildWarQuestionDialog.Close()

self.guildWarQuestionDialog = None

def __GuildWar_OnAccept(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/war " + guildName)

self.__GuildWar_CloseAskDialog()

return 1

def __GuildWar_OnDecline(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/nowar " + guildName)

self.__GuildWar_CloseAskDialog()

return 1

## BINARY CALLBACK

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

def __ServerCommand_Build(self):

serverCommandList={

"mattius" : self._mattiusefekt,

"getinputbegin" : self.__Inputget1,

"getinputend" : self.__Inputget2,

"getinput" : self.__Inputget3,

"depozit_index" :self.__depozit_questindex,

"antiexp_index" :self.__antiexp_questindex,

"Telep" :self.__MakeTelep,

"dopes_index" :self.__bonus_questindex,

"evento_ultimo_superviviente" : self.__evento_ultimo_superviviente,

"ConsoleEnable" : self.__Console_Enable,

"DayMode" : self.__DayMode_Update,

"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,

"CloseRestartWindow" : self.__RestartDialog_Close,

"OpenPrivateShop" : self.__PrivateShop_Open,

"OpenOfflineShop" : self.__OfflineShop_Open,

"PartyHealReady" : self.PartyHealReady,

"ShowMeSafeboxPassword" : self.AskSafeboxPassword,

"CloseSafebox" : self.CommandCloseSafebox,

##Report_System

"ReportLogin" : self.ReportLogin,

"Report" : self.Report,

"getinputbegin" : self.__Inputget1,

"getinputend" : self.__Inputget2,

##End_Report_System

"Teamler_on" : self.__Team_On,

"Teamler_off" : self.__Team_Off,

"F_Teamler_on" : self.__FTeam_On,

"F_Teamler_off" : self.__FTeam_Off,

"Teleport" : self.Teleport,

##KILLGUI

"ShowKillGui" : self.__showkillgui,

"HideKillGui" : self.__hidekillgui,

"KillBlauReich" : self.__KillBlauReich,

"KillGelbReich" : self.__KillGelbReich,

"KillRotReich" : self.__KillRotReich,

"KillMob" : self.__KillMob,

##END_KILLGUI

"antiexp" : self.__antiexp,

#"puttonshops" : self.__puttonshops,

# Fix input quest Start

"GetInputStringStart" : self.GetInputStringStart,

"GetInputStringEnd" : self.GetInputStringEnd,

# Fix input quest End

#Guildstorage

"GUILDSTORAGE" : self._GuildStorageCMD,

"GUILDSTORAGE_ADDITEM" : self._GuildStorageAddItem,

"GUILDSTORAGE_ADDITEMSLOT" : self._GuildStorageAddItemSlot,

"GUILDSTORAGE_ADDMEMBER" : self._GuildStorageAddMemberToList,

"GUILDSTORAGE_ADDTEMPSLOT" : self._GuildStorageTempSlotsAdd,

"GUILDSTORAGE_ADDLOG" : self._GuildStorageAddLog,

## Fatihbab34 systema

#HP

"ticlevel" : self.Den7,

"pvp_den7" : self.Denn7,

"pvp_den8" : self.Denn8,

#Degerler..

"get_input_value7" : self.GetInputValue7,

"get_input_start7" : self.GetInputOn7,

"get_input_end7" : self.GetInputOff7,

# PET_SYSTEM

"PetIsMine" : self.__PetIsMineByVid,

"ActivarGui" : self.__ActivarGui,

"SetPetClearItemSlotButtonIndex" : self.__PetSetClearItemSlotButtonIndex,

"SetPetIncreaseBoniButtonIndex" : self.__PetSetIncreaseBoniButtonIndex,

"SetPetSendAwayButtonIndex" : self.__PetSetSendAwayButtonIndex,

"ShowPet" : self.__PetShow,

"HidePet" : self.__PetHide,

"GetPetClearSlot" : self.__PetGetClearSlot,

"GetPetIncreaseBoni" : self.__PetGetIncreaseBoni,

"SetPet" : self.__PetSet,

"SetPetHead" : self.__PetSetHead,

"SetPetNeck" : self.__PetSetNeck,

"SetPetFoot" : self.__PetSetFoot,

"SetPetAttackValue" : self.__PetSetAttackValue,

"SetPetMagicAttackValue" : self.__PetSetMagicAttackValue,

"SetPetArmorValue" : self.__PetSetArmorValue,

"SetPetName" : self.__PetSetName,

"SetPetLevel" : self.__PetSetLevel,

"SetPetExp" : self.__PetSetExp,

"SetPetMaxExp" : self.__PetSetMaxExp,

"SetPetSkillPoints" : self.__PetSetSkillPoints,

# END_OF_PET_SYSTEM

# ITEM_MALL

"CloseMall" : self.CommandCloseMall,

"ShowMeMallPassword" : self.AskMallPassword,

"item_mall" : self.__ItemMall_Open,

# END_OF_ITEM_MALL

"RefineSuceeded" : self.RefineSuceededMessage,

"RefineFailed" : self.RefineFailedMessage,

"xmas_snow" : self.__XMasSnow_Enable,

"xmas_boom" : self.__XMasBoom_Enable,

"xmas_song" : self.__XMasSong_Enable,

"xmas_tree" : self.__XMasTree_Enable,

"newyear_boom" : self.__XMasBoom_Enable,

"PartyRequest" : self.__PartyRequestQuestion,

"PartyRequestDenied" : self.__PartyRequestDenied,

"horse_state" : self.__Horse_UpdateState,

"hide_horse_state" : self.__Horse_HideState,

"WarUC" : self.__GuildWar_UpdateMemberCount,

"test_server" : self.__EnableTestServerFlag,

"mall" : self.__InGameShop_Show,

#PET_SYSTEM

"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,

#PET_SYSTEM

# ITEM_SHOP

"SetISLoadButtonIndex" : self.__ISSetLoadButtonIndex,

"SetISBuyButtonIndex" : self.__ISSetBuyButtonIndex,

"GetISBuyID" : self.__ISGetBuyID,

"GetISBuyID2" : self.__ISGetBuyID2,

"AddISCategory" : self.__ISAddCategory,

"SelectISCategory" : self.__ISSelectCategory,

"ClearISItems" : self.__ISClearItems,

"AddISItem" : self.__ISAddItem,

"AddISItemDesc" : self.__ISAddItemDesc,

"SetISLoadSuccess" : self.__ISSetLoadSuccess,

"SetISLoadFail" : self.__ISSetLoadFail,

"SetISBuySuccess" : self.__ISSetBuySuccess,

"SetISBuyFail" : self.__ISSetBuyFail,

"SetISCoins" : self.__ISSetCoins,

"SetISMarks" : self.__ISSetMarks,

"Showmedallas_gui" : self.__showmedallas_gui,

"Hidemedallas_gui" : self.__hidemedallas_gui,

"muertes" : self.__muertes,

"primera_muerte" : self.__primera_muerte,

"doble_muerte" : self.__doble_muerte,

"triple_muerte" : self.__triple_muerte,

"exterminio" : self.__exterminio,

"muertacular" : self.__muertacular,

"bestialidad" : self.__bestialidad,

"salvajada" : self.__salvajada,

"catastrofe" : self.__catastrofe,

"apocalipsis" : self.__apocalipsis,

"lluvia_muertos" : self.__lluvia_muertos,

"super_increible" : self.__super_increible,

"input0" : self.__Input0,

"input1" : self.__Input1,

# END_OF_ITEM_SHOP

# WEDDING

"lover_login" : self.__LoginLover,

"lover_logout" : self.__LogoutLover,

"lover_near" : self.__LoverNear,

"lover_far" : self.__LoverFar,

"lover_divorce" : self.__LoverDivorce,

"PlayMusic" : self.__PlayMusic,

#transfer costume

"transferopen" : self.showtransfer,

"get_input_value" : self.GetInputValue,

"get_input_start" : self.GetInputOn,

"get_input_end" : self.GetInputOff,

"super_quest" : self.Tabulejtor,

"pvp_zdruwko" : self.Mozart,

#end transfer

# END_OF_WEDDING

"AkiraGiftSys" : self.__AkiraGiftSystem,

########Anti Exp Button by Sanii##########

"anti_exp" : self.AntiExp,

"anti_exp_state" : self.AntiExpState,

"mostrar_usuarios" : self.__mostrar_usuarios,

"ocultar_usuarios" : self.__ocultar_usuarios,

"muerto_guerras" : self.__muerto_guerras,

"alubias" : self.__alubias,

"proteccion_guerra" : self.__proteccion_guerra,

"contador_usuarios_guerra" : self.__contador_usuarios_guerra,

"muertos_guerra" : self.__muertos_guerra,

"caido_guerra" : self.__caido_guerra,

"ataque_guerra" : self.__ataque_guerra,

"ataque_guerra1" : self.__ataque_guerra1,

"activar_libre" : self.__activar_libre,

"cerrar_grupo" : self.__grupobug,

"spirit2" : self.__spirit2,

# PRIVATE_SHOP_PRICE_LIST

"MyShopPriceList" : self.__PrivateShop_PriceList,

# END_OF_PRIVATE_SHOP_PRICE_LIST

# BONI_SWITCHER

#"ResetBoniFromSwitcher" : self.__ResetBoniFromSwitcher,

#"AddBoniToSwitcher" : self.__AddBoniToSwitcher,

#"AddMaxValueToBoni" : self.__AddMaxValueToBoni,

#"SetBoniSwitcherLoad" : self.__SetBoniSwitcherLoad,

"AcceMessage" : self.AcceMessage,

"AcceAbsMessage" : self.AcceAbsMessage,

# END_OF_BONI_SWITCHER

#offshoppannel

"MountSystem" : self.__MountSystem,

"SCHICKSAL_RAD" : self.__SchicksalRad,

}

self.serverCommander=stringCommander.Analyzer()

for serverCommandItem in serverCommandList.items():

self.serverCommander.SAFE_RegisterCallBack(

serverCommandItem[0], serverCommandItem[1]

)

if app.ENABLE_MELEY_LAIR_DUNGEON:

self.serverCommander.SAFE_RegisterCallBack("meley_open", self.OpenMeleyRanking)

self.serverCommander.SAFE_RegisterCallBack("meley_rank", self.AddRankMeleyRanking)

def __MakeTelep(self, qid):

constInfo.Telepqin= int(qid)

def BINARY_ServerCommand_Run(self, line):

#dbg.TraceError(line)

try:

#print " BINARY_ServerCommand_Run", line

return self.serverCommander.Run(line)

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

def GuildstorageTry(self):

import uiguildstorage

self.GuildstorageWindow = uiguildstorage.GuildStorage()

if self.GuildstorageWindow.IsShow():

self.GuildstorageWindow.Hide()

else:

self.GuildStorageWindow.Show()

def __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))

elif PythonIslem == "SIL_SLOT":

net.SendQuestInputStringPacket(str(constInfo.SIL_SLOT))

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]

# elif LuaToPython.find("EP_KARAKTER") != -1:

# bol = LuaToPython.split("#")

# constInfo.ACHIEVEMENT_POINTS = int(bol[1])

# elif LuaToPython.find("ticaret_log") != -1:

# bol = LuaToPython.split("#")

# bol2 = LuaToPython.split("|")

# constInfo.TICARET_LOG.insert(0, bol2[1])

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 ReportLogin(self, id):

constInfo.ReportLogin = int(id)

def Report(self):

net.SendQuestInputStringPacket(constInfo.ReportEntered)

def __Inputget1(self):

constInfo.INPUT = 1

def __Inputget2(self):

constInfo.INPUT = 0

def __AkiraGiftSystem(self, arg):

cmd = arg.split("|")

if cmd[0] == "Gift_Level":

self.wndAkiraGift.GiftLevel(str(cmd[1]))

elif cmd[0] == "Gift_Item_Name":

self.wndAkiraGift.GiftItemName(str(cmd[1]),str(cmd[2]),str(cmd[3]),str(cmd[4]),str(cmd[5]),str(cmd[6]))

elif cmd[0] == "Gift_Item_Count":

self.wndAkiraGift.GiftItemCount(str(cmd[1]),str(cmd[2]),str(cmd[3]),str(cmd[4]),str(cmd[5]),str(cmd[6]))

elif cmd[0] == "Quest":

constInfo.Akira_Gift_System["Quest"] = int(cmd[1])

elif cmd[0] == "Input":

constInfo.GIFT_INPUT = int(cmd[1])

elif cmd[0] == "Reload":

net.SendQuestInputStringPacket(str(constInfo.Akira_Gift_System["Accion"]))

constInfo.Akira_Gift_System["Accion"] = ""

elif cmd[0] == "Show":

self.wndAkiraGift.Show()

def PartyHealReady(self):

self.interface.PartyHealReady()

def AskSafeboxPassword(self):

self.interface.AskSafeboxPassword()

def _mattiusefekt(self):

net.SendChatPacket("(mattius)")

# ITEM_MALL

def AskMallPassword(self):

self.interface.AskMallPassword()

def __ItemMall_Open(self):

self.interface.OpenItemMall();

def CommandCloseMall(self):

self.interface.CommandCloseMall()

# END_OF_ITEM_MALL

def AcceMessage(self):

snd.PlaySound("sound/ui/make_soket.wav")

self.PopupMessage(localeInfo.ACCE_DEL_SERVEITEM)

def __deschidere_magazin_questindex(self, value):

constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX = int(value)

def __deschidere_magazin(self):

deschidere_magazin = constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX

event.QuestButtonClick(deschidere_magazin)

def AcceAbsMessage(self):

snd.PlaySound("sound/ui/make_soket.wav")

self.PopupMessage(localeInfo.ACCE_DEL_ABSORDITEM)

def RefineSuceededMessage(self):

snd.PlaySound("sound/ui/make_soket.wav")

self.PopupMessage(localeInfo.REFINE_SUCCESS)

def RefineFailedMessage(self):

snd.PlaySound("sound/ui/jaeryun_fail.wav")

self.PopupMessage(localeInfo.REFINE_FAILURE)

def CommandCloseSafebox(self):

self.interface.CommandCloseSafebox()

# PRIVATE_SHOP_PRICE_LIST

def __PrivateShop_PriceList(self, itemVNum, itemPrice):

uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice)

# END_OF_PRIVATE_SHOP_PRICE_LIST

def SetPetEvolution(self, evo):

petname = [localeInfo.KEV_PET_LV_A, localeInfo.KEV_PET_LV_B, localeInfo.KEV_PET_LV_C, localeInfo.KEV_PET_LV_D]

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

def __Horse_HideState(self):

self.affectShower.SetHorseState(0, 0, 0)

def __Horse_UpdateState(self, level, health, battery):

self.affectShower.SetHorseState(int(level), int(health), int(battery))

def __IsXMasMap(self):

mapDict = ( "metin2_map_n_flame_01",

"metin2_map_n_desert_01",

"metin2_map_spiderdungeon",

"metin2_map_deviltower1", )

if background.GetCurrentMapName() in mapDict:

return FALSE

return TRUE

def __XMasSnow_Enable(self, mode):

self.__XMasSong_Enable(mode)

if "1"==mode:

if not self.__IsXMasMap():

return

print "XMAS_SNOW ON"

background.EnableSnow(1)

else:

print "XMAS_SNOW OFF"

background.EnableSnow(0)

def __XMasBoom_Enable(self, mode):

if "1"==mode:

if not self.__IsXMasMap():

return

print "XMAS_BOOM ON"

self.__DayMode_Update("dark")

self.enableXMasBoom = TRUE

self.startTimeXMasBoom = app.GetTime()

else:

print "XMAS_BOOM OFF"

self.__DayMode_Update("light")

self.enableXMasBoom = FALSE

def __XMasTree_Enable(self, grade):

print "XMAS_TREE ", grade

background.SetXMasTree(int(grade))

# PET_INVENTORY

def __PetIsMineByVid(self, vid):

targetName = chr.GetNameByVID(int(vid))

charName = player.GetName() or chr.GetMainCharacterName()

if targetName[0:len(charName)] == charName:

localeInfo.SEND_BACK = "true"

else:

localeInfo.SEND_BACK = "false"

self.__SendTextPacketToQuest()

localeInfo.SEND_BACK = ""

def __SendTextPacketToQuest(self):

net.SendQuestInputStringPacket(localeInfo.SEND_BACK)

def __Inputget1(self):

constInfo.INPUT_IGNORE = 1

def __Inputget2(self):

constInfo.INPUT_IGNORE = 0

def __Inputget3(self):

net.SendQuestInputStringPacket("1")

def __PressXKey(self):

import event

#self.__DeactivarGui()

self.__PetHide()

event.QuestButtonClick(constInfo.PET_SEND_AWAY_BUTTON_INDEX)

def GetInputStringStart(self):

constInfo.INPUT_IGNORE = 1

def GetInputStringEnd(self):

constInfo.INPUT_IGNORE = 0

def __PetSetClearItemSlotButtonIndex(self, index):

constInfo.PET_CLEAR_ITEM_SLOT_BUTTON_INDEX = int(index)

def __PetSetIncreaseBoniButtonIndex(self, index):

constInfo.PET_INCREASE_BONI_BUTTON_INDEX = int(index)

def __PetSetSendAwayButtonIndex(self, index):

constInfo.PET_SEND_AWAY_BUTTON_INDEX = int(index)

def __ActivarGui(self):

global pet_gui_activado

pet_gui_activado = 1

def __DeactivarGui(self):

global pet_gui_activado

pet_gui_activado = 0

def __PetShow(self):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.Show()

def __PetHide(self):

if self.petInventoryWnd:

self.petInventoryWnd.Hide()

def __PetGetClearSlot(self):

net.SendQuestInputStringPacket(str(self.petInventoryWnd.GetClearSlot()))

def __PetGetIncreaseBoni(self):

net.SendQuestInputStringPacket(str(self.petInventoryWnd.GetIncreaseBoni()))

def __PetSet(self, itemVnum):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetPet(itemVnum)

def __PetSetHead(self, itemVnum):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

if int(itemVnum) > 0:

self.petInventoryWnd.SetHeadItem(itemVnum)

else:

self.petInventoryWnd.ClearHeadItem()

def __PetSetNeck(self, itemVnum):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

if int(itemVnum) > 0:

self.petInventoryWnd.SetNeckItem(itemVnum)

else:

self.petInventoryWnd.ClearNeckItem()

def __PetSetFoot(self, itemVnum):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

if int(itemVnum) > 0:

self.petInventoryWnd.SetFootItem(itemVnum)

else:

self.petInventoryWnd.ClearFootItem()

def __PetSetAttackValue(self, value):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetAttackValue(value)

def __PetSetMagicAttackValue(self, value):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetMagicAttackValue(value)

def __PetSetArmorValue(self, value):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetArmorValue(value)

def __PetSetName(self, name):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetName(name.replace("[_]", " "))

def __PetSetLevel(self, level):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetLevel(level)

def __PetSetExp(self, exp):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetExp(exp)

self.petInventoryWnd.UpdateExpBar()

def __PetSetMaxExp(self, maxexp):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetMaxExp(maxexp)

self.petInventoryWnd.UpdateExpBar()

def __PetSetSkillPoints(self, points):

if not self.petInventoryWnd:

import uiPet

self.petInventoryWnd = uiPet.PetInventoryDialog()

self.petInventoryWnd.SetSkillPoints(points)

# END_PET_INVENTORY

def __XMasSong_Enable(self, mode):

if "1"==mode:

print "XMAS_SONG ON"

XMAS_BGM = "xmas.mp3"

if app.IsExistFile("BGM/" + XMAS_BGM)==1:

if musicInfo.fieldMusic != "":

snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)

musicInfo.fieldMusic=XMAS_BGM

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

else:

print "XMAS_SONG OFF"

if musicInfo.fieldMusic != "":

snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)

musicInfo.fieldMusic=musicInfo.METIN2THEMA

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

def __RestartDialog_Close(self):

self.interface.CloseRestartDialog()

def __Console_Enable(self):

constInfo.CONSOLE_ENABLE = TRUE

self.consoleEnable = TRUE

app.EnableSpecialCameraMode()

ui.EnablePaste(TRUE)

def __muerto_guerras(self, id):

constInfo.muerto_guerras = int(id)

def __alubias(self):

for i in xrange(player.INVENTORY_PAGE_SIZE*2):

if player.GetItemIndex(i) in (70102,):

net.SendItemUsePacket(i)

net.SendItemUsePacket(i)

net.SendItemUsePacket(i)

net.SendItemUsePacket(i)

net.SendItemUsePacket(i)

net.SendItemUsePacket(i)

break

def __spirit2(self):

net.SendChatPacket("(spirit2)")

def __proteccion_guerra(self):

net.SendChatPacket("(proteccion_guerra)")

def __contador_usuarios_guerra(self, contador_usuarios_guerra):

self.contador_usuarios_guerra.SetText(contador_usuarios_guerra)

def __muertos_guerra(self, muertos_guerra):

self.muertos_guerra.SetText(muertos_guerra)

def __caido_guerra(self, caido_guerra):

self.caido_guerra.SetText(caido_guerra)

def __mostrar_usuarios(self):

self.Espacio.Show()

self.contador_usuarios_guerra.Show()

self.muertos_guerra.Show()

self.caido_guerra.Show()

self.usuarios_guerra.Show()

self.ranking_guerra.Show()

self.ranking_caido.Show()

def __ocultar_usuarios(self):

self.Espacio.Hide()

self.contador_usuarios_guerra.Hide()

self.muertos_guerra.Hide()

self.caido_guerra.Hide()

self.usuarios_guerra.Hide()

self.ranking_guerra.Hide()

self.ranking_caido.Hide()

def __ataque_guerra(self):

constInfo.ataque_guerra = 1

def __ataque_guerra1(self):

constInfo.ataque_guerra = 0

def __activar_libre(self):

net.SendChatPacket("/pkmode 2")

def __grupobug(self):

net.SendPartyExitPacket()

## PrivateShop

def __PrivateShop_Open(self):

self.interface.OpenPrivateShopInputNameDialog()

def BINARY_PrivateShop_Appear(self, vid, text):

if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):

self.interface.AppearPrivateShop(vid, text)

def BINARY_PrivateShop_Disappear(self, vid):

if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):

self.interface.DisappearPrivateShop(vid)

# OfflineShop

def __OfflineShop_Open(self):

self.interface.OpenOfflineShopInputNameDialog()

def BINARY_OfflineShop_Appear(self, vid, text):

if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):

self.interface.AppearOfflineShop(vid, text)

def BINARY_OfflineShop_Disappear(self, vid):

if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):

self.interface.DisappearOfflineShop(vid)

## DayMode

def __PRESERVE_DayMode_Update(self, mode):

if "light"==mode:

background.SetEnvironmentData(0)

elif "dark"==mode:

if not self.__IsXMasMap():

return

background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)

background.SetEnvironmentData(1)

def __DayMode_Update(self, mode):

if "light"==mode:

self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)

elif "dark"==mode:

if not self.__IsXMasMap():

return

self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToDark)

def __DayMode_OnCompleteChangeToLight(self):

background.SetEnvironmentData(0)

self.curtain.FadeIn()

def __DayMode_OnCompleteChangeToDark(self):

background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)

background.SetEnvironmentData(1)

self.curtain.FadeIn()

## XMasBoom

def __XMasBoom_Update(self):

self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )

if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):

return

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

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

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

self.indexXMasBoom += 1

for i in xrange(boomCount):

self.__XMasBoom_Boom()

def __XMasBoom_Boom(self):

x, y, z = player.GetMainCharacterPosition()

randX = app.GetRandom(-150, 150)

randY = app.GetRandom(-150, 150)

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

def __PartyRequestQuestion(self, vid):

vid = int(vid)

partyRequestQuestionDialog = uiCommon.QuestionDialog()

partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + localeInfo.PARTY_DO_YOU_ACCEPT)

partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)

partyRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)

partyRequestQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.__AnswerPartyRequest(arg))

partyRequestQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.__AnswerPartyRequest(arg))

partyRequestQuestionDialog.Open()

partyRequestQuestionDialog.vid = vid

self.partyRequestQuestionDialog = partyRequestQuestionDialog

def __AnswerPartyRequest(self, answer):

if not self.partyRequestQuestionDialog:

return

vid = self.partyRequestQuestionDialog.vid

if answer:

net.SendChatPacket("/party_request_accept " + str(vid))

else:

net.SendChatPacket("/party_request_deny " + str(vid))

self.partyRequestQuestionDialog.Close()

self.partyRequestQuestionDialog = None

def __PartyRequestDenied(self):

self.PopupMessage(localeInfo.PARTY_REQUEST_DENIED)

def __EnableTestServerFlag(self):

app.EnableTestServerFlag()

def __InGameShop_Show(self, url):

if constInfo.IN_GAME_SHOP_ENABLE:

self.interface.OpenWebWindow(url)

def OpenTicaretLog(self):

self.silButton = ui.Button()

self.silButton.SetParent(self.Board)

self.silButton.SetPosition(80+120-56+72, 301)

self.silButton.SetUpVisual("d:/ymir work/ui/public/middle_button_01.sub")

self.silButton.SetOverVisual("d:/ymir work/ui/public/middle_button_02.sub")

self.silButton.SetDownVisual("d:/ymir work/ui/public/middle_button_03.sub")

self.silButton.SetText("Sil")

self.silButton.SetToolTipText("Bu logu sil")

self.silButton.Hide()

self.silButton.Down()

self.silButton.SetEvent(lambda : self.LogSil)

self.ListBox.ClearItem()

def __OnSelectListBox(self):

if self.silButton.IsDown():

self.silButton.SetUp()

self.silButton.SetUp()

# 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

# Monster Target System

if app.ENABLE_SEND_TARGET_INFO:

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

if not raceNum in constInfo.MONSTER_INFO_DATA:

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

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

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

isUpgradeable = False

isMetin = False

item.SelectItem(itemVnum)

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

isUpgradeable = True

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

isMetin = True

for curItem in curList:

if isUpgradeable:

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

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

curItem["vnum_list"].append(itemVnum)

return

elif isMetin:

if curItem.has_key("vnum_list"):

baseVnum = curItem["vnum_list"][0]

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

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

curItem["vnum_list"].append(itemVnum)

return

else:

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

return

if isUpgradeable or isMetin:

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

else:

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

def BINARY_RefreshTargetMonsterDropInfo(self, raceNum):

self.targetBoard.RefreshMonsterInfoBoard()

if app.ENABLE_MELEY_LAIR_DUNGEON:

def OpenMeleyRanking(self):

if self.interface:

self.interface.OpenMeleyRanking()

def AddRankMeleyRanking(self, data):

if self.interface:

line = int(data.split("#")[1])

name = str(data.split("#")[2])

members = int(data.split("#")[3])

seconds = int(data.split("#")[4])

minutes = seconds // 60

seconds %= 60

if seconds > 0:

time = localeInfo.TIME_MIN_SEC % (minutes, seconds)

else:

time = localeInfo.TIME_MIN % (minutes)

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

########Anti Exp Button by Sanii##########

def AntiExp(self, qid):

constInfo.ANTI_EXP = int(qid)

def AntiExpState(self, state):

constInfo.ANTI_EXP_STATE = int(state)

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

# BONI_SWITCHER

def __BoniSwitcherChangeVisible(self):

if not self.boniSwitcherWnd[self.LastBoniSwitcherId].IsShow():

self.__HideAllBoniSwitcher()

self.boniSwitcherWnd[self.LastBoniSwitcherId].Show(FALSE)

else:

self.__HideAllBoniSwitcher()

def __BoniSwitcherShow(self, id):

lastId = self.LastBoniSwitcherId

self.LastBoniSwitcherId = id

if not self.boniSwitcherWnd[id].IsShow():

self.__HideAllBoniSwitcher()

(x, y) = self.boniSwitcherWnd[lastId].GetGlobalPosition()

self.boniSwitcherWnd[id].SetPosition(x, y)

self.boniSwitcherWnd[id].Show(FALSE)

def __BoniSwitcherHide(self, id):

if self.boniSwitcherWnd[id]:

self.boniSwitcherWnd[id].Hide()

def __HideAllBoniSwitcher(self):

for i in xrange(len(self.boniSwitcherWnd)):

self.__BoniSwitcherHide(i)

def __ResetBoniFromSwitcher(self):

constInfo.BONI_LIST_WEAPON = []

constInfo.BONI_LIST_WEAPON_ADDON = []

constInfo.BONI_LIST_ARMOR = []

constInfo.BONI_LIST_BRACELET = []

constInfo.BONI_LIST_BOOTS = []

constInfo.BONI_LIST_NECKLACE = []

constInfo.BONI_LIST_HELMET = []

constInfo.BONI_LIST_SHIELD = []

constInfo.BONI_LIST_EARRINGS = []

# ITEM_SHOP

def __ItemShopShow(self):

if not self.itemShopWnd:

import uiItemShop

self.itemShopWnd = uiItemShop.ItemShopBoard()

self.itemShopWnd.Show()

def __ISSetLoadButtonIndex(self, index):

constInfo.ITEM_SHOP_LOAD_BUTTON_INDEX = int(index)

def __ISSetBuyButtonIndex(self, index):

constInfo.ITEM_SHOP_BUY_BUTTON_INDEX = int(index)

def __ISGetBuyID(self):

if self.itemShopWnd:

net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString())

else:

net.SendQuestInputStringPacket("ERROR")

def __ISGetBuyID2(self):

if self.itemShopWnd:

net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString2())

else:

net.SendQuestInputStringPacket("ERROR")

def __Input0(self):

constInfo.INPUT_IGNORE = 0

def __Input1(self):

constInfo.INPUT_IGNORE = 1

def __ISAddCategory(self, catId, catName):

self.itemShopWnd.AddCategory(catId, catName.replace("[_]", " "))

def __primera_muerte(self):

self.primera_muerte.Show()

snd.PlaySound("sound/ui/primera_muerte.wav")

net.SendChatPacket("(primera_muerte)")

def __doble_muerte(self):

self.doble_muerte.Show()

snd.PlaySound("sound/ui/doble_muerte.wav")

net.SendChatPacket("(doble_muerte)")

def __triple_muerte(self):

self.triple_muerte.Show()

snd.PlaySound("sound/ui/triple_muerte.wav")

net.SendChatPacket("(triple_muerte)")

def __exterminio(self):

self.exterminio.Show()

snd.PlaySound("sound/ui/exterminio.wav")

net.SendChatPacket("(exterminio)")

def __muertacular(self):

self.muertacular.Show()

snd.PlaySound("sound/ui/muertacular.wav")

net.SendChatPacket("(muertacular)")

def __bestialidad(self):

self.bestialidad.Show()

snd.PlaySound("sound/ui/bestialidad.wav")

net.SendChatPacket("(bestialidad)")

def __salvajada(self):

self.salvajada.Show()

snd.PlaySound("sound/ui/salvajada.wav")

net.SendChatPacket("(salvajada)")

def __catastrofe(self):

self.catastrofe.Show()

snd.PlaySound("sound/ui/catastrofe.wav")

net.SendChatPacket("(catastrofe)")

def __apocalipsis(self):

self.apocalipsis.Show()

snd.PlaySound("sound/ui/apocalipsis.wav")

net.SendChatPacket("(apocalipsis)")

def __lluvia_muertos(self):

self.lluvia_muertos.Show()

snd.PlaySound("sound/ui/lluvia_muertos.wav")

net.SendChatPacket("(lluvia_muertos)")

def __super_increible(self):

self.super_increible.Show()

snd.PlaySound("sound/ui/super_increible.wav")

net.SendChatPacket("(super_increible)")

def __hidemedallas_gui(self):

self.Medallas_gui.Hide()

self.primera_muerte.Hide()

self.doble_muerte.Hide()

self.triple_muerte.Hide()

self.exterminio.Hide()

self.muertacular.Hide()

self.bestialidad.Hide()

self.salvajada.Hide()

self.catastrofe.Hide()

self.apocalipsis.Hide()

self.lluvia_muertos.Hide()

self.super_increible.Hide()

self.muertes.Hide()

def __showmedallas_gui(self):

self.Medallas_gui.Show()

self.muertes.Show()

def __muertes(self, muertes):

self.muertes.SetText(muertes)

def __ISSelectCategory(self, catId):

self.itemShopWnd.SelectCategory(catId)

def __ISClearItems(self):

self.itemShopWnd.Clear()

def __ISAddItem(self, catId, itemId, itemVnum, itemCount, itemCost, itemCostType, attr1, val1, attr2, val2, attr3, val3, attr4, val4, attr5, val5, attr6, val6, attr7, val7, sock1, sock2, sock3):

itemAttr = [[attr1, val1], [attr2, val2], [attr3, val3], [attr4, val4], [attr5, val5], [attr6, val6], [attr7, val7]]

for attr in itemAttr:

attr[0] = int(attr[0])

attr[1] = int(attr[1])

itemSocket = [int(sock1), int(sock2), int(sock3)]

self.curIsItem = {

"cat" : catId,

"id" : itemId,

"vnum" : itemVnum,

"count" : itemCount,

"desc" : "",

"cost" : itemCost,

"cost_type" : itemCostType,

"attr" : itemAttr,

"socket" : itemSocket,

}

def __ISAddItemDesc(self, itemDesc):

obj = self.curIsItem

if not obj:

return

obj["desc"] += itemDesc.replace("[_]", " ")

self.itemShopWnd.AddItem(obj["cat"], obj["id"], obj["vnum"], obj["count"], obj["desc"], obj["cost"], obj["cost_type"], obj["attr"], obj["socket"])

self.curIsItem = None

def __ISSetLoadSuccess(self):

self.itemShopWnd.SetLoadSuccess()

def __ISSetLoadFail(self):

self.itemShopWnd.SetLoadFail()

def __ISSetBuySuccess(self):

self.itemShopWnd.SetItemBuySuccess()

def __ISSetBuyFail(self):

self.itemShopWnd.SetItemBuyFail()

def __ISSetCoins(self, coins):

self.itemShopWnd.SetCoins(coins)

def __ISSetMarks(self, marks):

self.itemShopWnd.SetMarks(marks)

# END_ITEM_SHOP

def __AddBoniToSwitcher(self, EquipType, boniType):

EquipType = int(EquipType)

if EquipType == 1:

constInfo.BONI_LIST_WEAPON.append(int(boniType))

constInfo.BONI_LIST_WEAPON_ADDON.append(int(boniType))

elif EquipType == 2:

constInfo.BONI_LIST_ARMOR.append(int(boniType))

elif EquipType == 3:

constInfo.BONI_LIST_BRACELET.append(int(boniType))

elif EquipType == 4:

constInfo.BONI_LIST_BOOTS.append(int(boniType))

elif EquipType == 5:

constInfo.BONI_LIST_NECKLACE.append(int(boniType))

elif EquipType == 6:

constInfo.BONI_LIST_HELMET.append(int(boniType))

elif EquipType == 7:

constInfo.BONI_LIST_SHIELD.append(int(boniType))

elif EquipType == 8:

constInfo.BONI_LIST_EARRINGS.append(int(boniType))

elif EquipType == 9:

constInfo.BONI_LIST_WEAPON_ADDON.append(int(boniType))

def __AddMaxValueToBoni(self, boniType, maxValue):

constInfo.BONI_LIST_MAX_VALUE[int(boniType)] = int(maxValue)

def __SetBoniSwitcherLoad(self):

constInfo.BONI_SWITCHER_LOAD = TRUE

def __BoniSwitcherCheckEvent(self, slotPos):

for boniSwitcher in self.boniSwitcherWnd:

if boniSwitcher.aktItemPos == int(slotPos):

return TRUE

return FALSE

# END_BONI_SWITCHER

def __antiexp(self, qid):

constInfo.antiexp = int(qid)

#def __puttonshops(self, qid):

#constInfo.puttonshops = int(qid)

def Teleport(self, getString):

if getString.find("index") != -1:

self.teleport.UpdateIndex(int(getString.split("x")[1]))

else:

constInfo.SendString = str(self.teleport.SendToServer)

constInfo.CApiSetHide = 1

def __evento_ultimo_superviviente(self):

import net

net.SendChatPacket("/pkmode 2", chat.CHAT_TYPE_TALKING)

def __Switcher(self):

import uiswitch

self.wndSwitch = uiswitch.Switcher()

self.wndSwitch.Show()

# def __menubg2(self):

# if constInfo.MENU_BG2 == 0:

# constInfo.MENU_BG2 = 1

# self.menu_bg2.Show()

# self.Activare_Menu2.Hide()

# self.Dezactivare_Menu2.Show()

# else:

# constInfo.MENU_BG2 = 0

# self.menu_bg2.Hide()

# self.Activare_Menu2.Show()

# self.Dezactivare_Menu2.Hide()

# def __DMAGAZIN_questindex(self, value):

# constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX = int(value)

# def __DeschidereMagazin(self):

# DeschidereMagazin = constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX

# event.QuestButtonClick(DeschidereMagazin)

def __toggleSwitchbot(self):

if self.switchbot.bot_shown == 1:

self.switchbot.Hide()

else:

self.switchbot.Show()

# def __menubg(self):

## if constInfo.MENU_BG == 0:

# constInfo.MENU_BG = 1

# self.menu_bg.Show()

# self.Activare_Menu.Hide()

# self.Dezactivare_Menu.Show()

# else:

# constInfo.MENU_BG = 0

# self.menu_bg.Hide()

# self.Activare_Menu.Show()

# self.Dezactivare_Menu.Hide()

# def __BonusPage(self):

# import uibonuspage

# self.wndBonus = uibonuspage.BonusBoardDialog()

# self.wndBonus.Show()

# switchbot

# def __JINHAN(self):

# import uistatusup

# self.wndJinHan = uistatusup.StatusUp()

# self.wndJinHan.Show()

# END_switchbot

def __bonus_questindex(self, value3):

constInfo.BONUS_QUESTINDEX = int(value3)

def __activare_bonus(self):

activare_bonus = constInfo.BONUS_QUESTINDEX

event.QuestButtonClick(activare_bonus)

def __depozit_questindex(self, qid):

constInfo.Depoport= int(qid)

def __activare_depozit(self):

activare_depozit = constInfo.DEPOZIT_QUESTINDEX

event.QuestButtonClick(activare_depozit)

def __antiexp_questindex(self, value1):

constInfo.ANTIEXP_QUESTINDEX = int(value1)

def __activare_antiexp(self):

activare_antiexp = constInfo.ANTIEXP_QUESTINDEX

event.QuestButtonClick(activare_antiexp)

def __teleporter_questindex(self, value2):

constInfo.TELEPORTER_QUESTINDEX = int(value2)

def __activare_teleporter(self):

activare_teleporter = constInfo.TELEPORTER_QUESTINDEX

event.QuestButtonClick(activare_teleporter)

def showtransfer(self):

import uiTransfer

self.TransferWnd = uiTransfer.TransferWindow()

self.TransferWnd.Open()

def Denn7(self, data):

dane = data.split("|")

constInfo.PLAYER_LEVEL = str(dane[0])

def Denn8(self, data):

dane = data.split("|")

constInfo.PLAYER_NAMEE = str(dane[0])

def Den7(self, id):

constInfo.STHX2 = int(id)

def GetInputOn7(self):

constInfo.INPUT_IGNORE = 1

def GetInputOff7(self):

constInfo.INPUT_IGNORE = 0

def GetInputValue7(self): # HP Sistemi de?er girilen sayi*

net.SendQuestInputStringPacket(str(constInfo.VID2))

#def OpenQuestWindow(self, skin, idx):

# if constInfo.INPUT_IGNORE == 1:

# return

# else:

# self.interface.OpenQuestWindow(skin, idx)

#def __showbonus(self):

# serex = uibonuspage.BonusBoardDialog()

def __showbonus(self):

import uiBonusPage

global bonuspp

try:

if bonuspp != 1:

exec 'uiBonusPage.BonusBoardDialog().Show()'

else:

pass

except ImportError:

import dbg,app

dbg.Trace('uiBonusPage.py Importing error')

app.Abort()

# guildstorage begin

def _GuildStorageCMD(self, command):

cmd = command.split("/")

if cmd[0] == "OPEN":

self.interface.GuildStorageWindow.Open(int(cmd[1]))

elif cmd[0] == "REFRESH":

self.interface.GuildStorageWindow.RefreshSlots()

elif cmd[0] == "REFRESH_MONEY":

self.interface.GuildStorageWindow.SetMoney(cmd[1])

elif cmd[0] == "REFRESH_MEMBERS":

self.interface.GuildStorageWindow.Adminpanel["board"].RefreshMembers()

elif cmd[0] == "CLEAR_TEMPSLOTS":

constInfo.GUILDSTORAGE["tempslots"] = {"TAB0" : {},"TAB1" : {},"TAB2" : {}}

elif cmd[0] == "COMPARE_TEMPSLOTS":

for i in range(3):

if constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)] != constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)]:

constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = {}

constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)]

self.interface.GuildStorageWindow.RefreshSlots()

elif cmd[0] == "QID":

self.GuildStorageQID(cmd[1])

elif cmd[0] == "QUESTCMD":

self._GuildStorageQuestCMD()

#self.teleport = uiteleport.TeleportWindow()

elif cmd[0] == "MEMBER_COMPLETE":

constInfo.GUILDSTORAGE["members"] = {}

self.interface.GuildStorageWindow.ClearMembers()

import event

constInfo.GUILDSTORAGE["questCMD"] = "GETMEMBERLIST"

event.QuestButtonClick(int(constInfo.GUILDSTORAGE["qid"]))

def _GuildStorageAddItemSlot(self, slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):

self.interface.GuildStorageWindow.AddItemSlot(slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6)

def _GuildStorageAddItem(self, slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):

slotsWidth = 15

slotsHeight = 8

slot = int(slot)

if slot <= 120:

constInfo.GUILDSTORAGE["slots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]

elif slot > 120 and slot <= 240:

constInfo.GUILDSTORAGE["slots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]

elif slot > 240 and slot <= 360:

constInfo.GUILDSTORAGE["slots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]

def _GuildStorageTempSlotsAdd(self,slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):

slot = int(slot)

if slot <= 120:

constInfo.GUILDSTORAGE["tempslots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]

elif slot > 120 and slot <= 240:

constInfo.GUILDSTORAGE["tempslots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]

elif slot > 240 and slot <= 360:

constInfo.GUILDSTORAGE["tempslots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]

def _GuildStorageAddLog(self,id,name,date,type,do,desc):

self.interface.GuildStorageWindow.LogsInsert(id,name,date,type,do,desc)

constInfo.GUILDSTORAGE["logs"][int(id)] = [name,date,type,do,desc]

def _GuildStorageQuestCMD(self):

net.SendQuestInputStringPacket(str(constInfo.GUILDSTORAGE["questCMD"]))

constInfo.GUILDSTORAGE["questCMD"] = "NULL#"

def GuildStorageQID(self, qid):

constInfo.GUILDSTORAGE["qid"] = int(qid)

def _GuildStorageAddMemberToList(self,memberId,member,authority0,authority1,authority2,authority3):

constInfo.GUILDSTORAGE["members"]["member"+memberId] = [member,int(authority0),int(authority1),int(authority2),int(authority3)]

# Guildstorage end

def __MountSystem(self, info, i=0):

if info=="Item":

if i!=0:

constInfo.MountSystem["index"] = int(i)

self.MountingSystem.Open()

elif info=="Input":

net.SendQuestInputStringPacket(str(constInfo.MountSystem["CMD"]))

def __SchicksalRad(self, cmd):

CMD = cmd.split("/")

if CMD[0]=="index":

constInfo.SCHICKSAL_RAD["index"] = int(CMD[1])

constInfo.SCHICKSAL_RAD["kosten"] = int(CMD[2])

constInfo.SCHICKSAL_RAD["free"] = int(CMD[3])

elif CMD[0]=="input":

net.SendQuestInputStringPacket(str(constInfo.SCHICKSAL_RAD["ServerCMD"]))

elif CMD[0]=="free":

constInfo.SCHICKSAL_RAD["free"] = int(CMD[1])

elif CMD[0]=="Answer":

self.SchicksalRad.SetVars(CMD[1], CMD[2], CMD[3], CMD[4], CMD[5])

constInfo.SCHICKSAL_RAD["free"] = int(CMD[6])

def __guinameOPEN(self): # use different function names!

import schicksalrad

self.SchicksalRad = schicksalrad.RadDesSchicksals()

self.SchicksalRad.Open()() # naturally use the code which is provided for the GUI

def __hidekillgui(self):

self.KillGuiBg.Hide()

self.KillBlauReich.Hide()

self.KillGelbReich.Hide()

self.KillRotReich.Hide()

self.KillMob.Hide()

def __showkillgui(self):