import os

import pythonApi

app = __import__(pythonApi.GetModuleName("app"))

chrmgr = __import__(pythonApi.GetModuleName("chrmgr"))

import dbg

import grp

import item

import background

chr = __import__(pythonApi.GetModuleName("chr"))

pack = __import__(pythonApi.GetModuleName("pack"))

player = __import__(pythonApi.GetModuleName("player"))

import snd

import chat

import textTail

import snd

net = __import__(pythonApi.GetModuleName("net"))

import effect

import wndMgr

import fly

import systemSetting

import quest

import guild

import skill

import messenger

import localeInfo

import constInfo

import uiruhtasi

import exchange

import ime

import uiSearchShop

import uiScriptLocale

import ui

import uiCommon

import uiPhaseCurtain

import uiMapNameShower

import uiAffectShower

import uiPlayerGauge

import uiCharacter

import uiTarget

import uipetsystem,uiDungeonInfo

import time

# PRIVATE_SHOP_PRICE_LIST

import uiPrivateShopBuilder

# END_OF_PRIVATE_SHOP_PRICE_LIST

import background

import mouseModule

import consoleModule

import localeInfo

import playerSettingModule

import interfaceModule

import day

import musicInfo

import debugInfo

import stringCommander

import uigamemasterpanel

import nonplayer

import uisupportsystem

if app.ENABLE_CHANGE_LOOK_SYSTEM:

import uichangelook

if app.ENABLE_COSTUME_AURA:

import UiRefineAura

#fixme -- add module in userinterface/pythonApplicationModule

#if app.ENABLE_SUPPORT_SYSTEM:

import uisupportsystem

from _weakref import proxy

# 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

if app.ENABLE_BIOLOG_SYSTEM:

import uiprofessionalbiolog

SUB_RACE_FLAG_TO_ELEMENT = {

1 << 11 : 1,

1 << 12 : 2,

1 << 13 : 3,

1 << 14 : 4,

1 << 15 : 5,

1 << 16 : 6,

}

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)

day.nacht = 0

day.tag = 0

import dailygift

self.wnddailygift = dailygift.DailyGift()

self.uiNewShopCreate = None

self.uiNewShop = None

self.ruhtasi = uiruhtasi.RuhTasi()

self.ruhtasi.Hide()

self.uiSearchShopBtn = ui.Button()

self.uiSearchShopBtn.SetUpVisual("news/search.tga")

self.uiSearchShopBtn.SetOverVisual("news/search.tga")

self.uiSearchShopBtn.SetDownVisual("news/search.tga")

self.uiSearchShopBtn.SetText("")

self.uiSearchShopBtn.SetToolTipText(uiScriptLocale.SHOP_SEARCH_TITLE)

self.uiSearchShopBtn.SetPosition(int((wndMgr.GetScreenWidth()*0.80)), 0)

self.uiSearchShopBtn.SetEvent(self.OnClickSearch)

self.uiSearchShopBtn.Show()

self.uiSearchShop=uiSearchShop.ShopSearch()

self.uiSearchShop.SetPosition(100,100)

self.uiSearchShop.AddFlag('movable')

self.uiSearchShop.AddFlag('float')

self.uiSearchShop.Close()

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, 60)

self.Medallas_gui.Hide()

self.muertes = ui.TextLine()

self.muertes.SetWindowHorizontalAlignLeft()

self.muertes.SetWindowVerticalAlignTop()

self.muertes.SetDefaultFontName()

self.muertes.SetPosition(24, 71)

self.muertes.SetText("0")

self.muertes.SetOutline()

self.muertes.Hide()

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, 60)

self.primera_muerte.Hide()

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, 60)

self.doble_muerte.Hide()

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, 60)

self.triple_muerte.Hide()

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, 60)

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, 60)

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, 60)

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, 60)

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, 60)

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, 60)

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, 60)

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, 60)

#Fin menu

self.quickSlotPageIndex = 0

self.lastPKModeSendedTime = 0

self.pressNumber = None

if (app.WJ_COMBAT_ZONE):

import uicombatzone

self.wndCombatZone = uicombatzone.CombatZoneWindow()

self.guildWarQuestionDialog = None

self.interface = None

self.targetBoard = None

self.console = None

self.mapNameShower = None

self.affectShower = None

self.playerGauge = None

if app.ENABLE_COSTUME_AURA:

self.RefineAura = UiRefineAura.RefineAura()

self.stream=stream

self.interface = interfaceModule.Interface()

self.interface.MakeInterface()

self.interface.ShowDefaultWindows()

self.curtain = uiPhaseCurtain.PhaseCurtain()

self.curtain.speed = 0.03

self.curtain.Hide()

if app.ENABLE_CHANGE_LOOK_SYSTEM:

self.ChangeLookWindow = uichangelook.ChangeLookWindow()

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

# if app.ENABLE_SUPPORT_SYSTEM:

self.supportpg = uisupportsystem.SupportMainGui()

self.supportpg = uisupportsystem.SupportMainGui()

self.supportpg.Close()

self.mapNameShower = uiMapNameShower.MapNameShower()

self.affectShower = uiAffectShower.AffectShower()

if app.ENABLE_TITLE_SYSTEM:

import title_system

self.wndTitleSystem = title_system.Title_System()

import uimaintenance

self.wndMaintenance = uimaintenance.MaintenanceClass()

self.playerGauge = uiPlayerGauge.PlayerGauge(self)

self.playerGauge.Hide()

#wj 2014.1.2. ESCإ°¸¦ ´©¸¦ ½أ ؟ى¼±ہûہ¸·خ DropQuestionDialog¸¦ ²ôµµ·د ¸¸µé¾ْ´ظ. ادءِ¸¸ أ³ہ½؟، itemDropQuestionDialog°، ¼±¾ًµا¾î ہضءِ ¾ت¾ئ ERROR°، ¹ك»‎اد؟© init؟،¼­ ¼±¾ً°ْ µ؟½أ؟، أت±âب­ ½أإ´.

self.itemDropQuestionDialog = None

self.__SetQuickSlotMode()

self.__ServerCommand_Build()

self.__ProcessPreservedServerCommand()

def __del__(self):

player.SetGameWindow(0)

net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)

ui.ScriptWindow.__del__(self)

def Open(self):

app.SetFrameSkip(1)

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

self.quickSlotPageIndex = 0

self.PickingCharacterIndex = -1

self.PickingItemIndex = -1

self.consoleEnable = False

self.isShowDebugInfo = False

self.ShowNameFlag = False

self.litere_event = ui.Button()

self.litere_event.SetParent(self)

self.litere_event.SetPosition(wndMgr.GetScreenWidth()-300,50)

self.litere_event.SetUpVisual("d:/ymir work/eventlitere/status_letters.tga")

self.litere_event.SetOverVisual("d:/ymir work/eventlitere/status_letters.tga")

self.litere_event.SetDownVisual("d:/ymir work/eventlitere/status_letters.tga")

self.litere_event.SetToolTipText("Abrir evento")

self.litere_event.SetEvent(lambda : net.SendChatPacket("/letters_open"))

self.enableXMasBoom = False

self.startTimeXMasBoom = 0.0

self.indexXMasBoom = 0

global cameraDistance, cameraPitch, cameraRotation, cameraHeight

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

if str(background.GetCurrentMapName()) == "metin2_12zi_stage" and app.ENABLE_12ZI:

constInfo.SET_CAMERA_MAX_DISTANCE_12ZI()

else:

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)

Espacio = ui.AniImageBox()

Espacio.AddFlag("movable")

Espacio.AddFlag("float")

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.SetParent(Espacio)

self.contador_usuarios_guerra.SetDefaultFontName()

self.contador_usuarios_guerra.SetPosition(10, 0)

self.contador_usuarios_guerra.SetText("0")

self.contador_usuarios_guerra.SetOutline()

self.muertos_guerra = ui.TextLine()

self.muertos_guerra.SetParent(Espacio)

self.muertos_guerra.SetDefaultFontName()

self.muertos_guerra.SetPosition(10, 10)

self.muertos_guerra.SetText("0")

self.muertos_guerra.SetOutline()

self.caido_guerra = ui.TextLine()

self.caido_guerra.SetParent(Espacio)

self.caido_guerra.SetDefaultFontName()

self.caido_guerra.SetPosition(10, 20)

self.caido_guerra.SetText("0")

self.caido_guerra.SetOutline()

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

import uiNewShop

self.uiNewShop = uiNewShop.ShopDialog()

self.uiNewShop.Close()

self.uiNewShopCreate = uiNewShop.ShopDialogCreate()

self.uiNewShopCreate.Hide()

# PRIVATE_SHOP_PRICE_LIST

uiPrivateShopBuilder.Clear()

# END_OF_PRIVATE_SHOP_PRICE_LIST

# UNKNOWN_UPDATE

exchange.InitTrading()

# END_OF_UNKNOWN_UPDATE

#if debugInfo.IsDebugMode():

# self.ToggleDebugInfo()

self.ToggleFPSInfo()

## Sound

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

snd.SetSoundVolume(systemSetting.GetSoundVolume())

netFieldMusicFileName = net.GetFieldMusicFileName()

if netFieldMusicFileName:

snd.FadeInMusic("BGM/" + netFieldMusicFileName)

elif musicInfo.fieldMusic != "":

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

self.__SetQuickSlotMode()

self.__SelectQuickPage(self.quickSlotPageIndex)

self.SetFocus()

self.Show()

app.ShowCursor()

net.SendEnterGamePacket()

# START_GAME_ERROR_EXIT

try:

self.StartGame()

except:

import exception

exception.Abort("GameWindow.Open")

# END_OF_START_GAME_ERROR_EXIT

# NPC°، إ¥؛ê½أ½؛إغہ¸·خ ¸¸µé ¼ِ ہض´آ ¾ئہجإغµéہا ¸ٌ·دہ» ؤ³½ج

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

self.cubeInformation = {}

self.currentCubeNPC = 0

if app.ENABLE_FOG_FIX:

if systemSetting.IsFogMode():

background.SetEnvironmentFog(True)

else:

background.SetEnvironmentFog(False)

def Close(self):

self.__ocultar_usuarios()

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

self.Hide()

if self.uiNewShop:

self.uiNewShop.Hide()

self.uiNewShopCreate.Hide()

uiPrivateShopBuilder.Clear()

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

if app.ENABLE_COSTUME_AURA:

self.RefineAura.Hide()

chat.Close()

snd.StopAllSound()

grp.InitScreenEffect()

chr.Destroy()

textTail.Clear()

quest.Clear()

background.Destroy()

guild.Destroy()

messenger.Destroy()

skill.ClearSkillData()

wndMgr.Unlock()

mouseModule.mouseController.DeattachObject()

if self.guildWarQuestionDialog:

self.guildWarQuestionDialog.Close()

self.guildNameBoard = None

self.partyRequestQuestionDialog = None

self.partyInviteQuestionDialog = None

self.guildInviteQuestionDialog = None

self.guildWarQuestionDialog = None

self.messengerAddFriendQuestion = None

# UNKNOWN_UPDATE

self.itemDropQuestionDialog = None

# END_OF_UNKNOWN_UPDATE

# QUEST_CONFIRM

self.confirmDialog = None

# END_OF_QUEST_CONFIRM

if self.uiSearchShop:

self.uiSearchShop.Close()

self.uiSearchShop=0

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

#if app.ENABLE_SUPPORT_SYSTEM:

self.supportpg.Close()

self.petmain.Close()

self.petmini.Close()

self.playerGauge = None

self.mapNameShower = None

self.affectShower = None

if self.console:

self.console.BindGameClass(0)

self.console.Close()

self.console=None

if self.ruhtasi:

self.ruhtasi.Destroy()

self.ruhtasi = None

if self.wndMaintenance.IsShow():

self.wndMaintenance.Hide()

if self.targetBoard:

self.targetBoard.Destroy()

self.targetBoard = None

if (app.WJ_COMBAT_ZONE):

if self.wndCombatZone:

self.wndCombatZone.Close()

if app.ENABLE_TITLE_SYSTEM:

self.wndTitleSystem.Close()

if self.interface:

self.interface.HideAllWindows()

self.interface.Close()

self.interface=None

player.ClearSkillDict()

player.ResetCameraRotation()

self.KillFocus()

app.HideCursor()

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

def ruhcac(self):

self.ruhtasi.Show()

def __BuildKeyDict(self):

onPressKeyDict = {}

##PressKey ´آ ´©¸£°ي ہض´آ µ؟¾ب °è¼س ہû؟ëµا´آ إ°ہج´ظ.

## ¼‎ہع ´ـأàإ° ؤü½½·ش؟، ہج؟ëµب´ظ.(ہجبؤ ¼‎ہعµéµµ ؤü ½½·ش؟ë ؟¹¾à)

## F12 ´آ إ¬¶َ µً¹ِ±×؟ë إ°ہج¹ا·خ ¾²ءِ ¾ت´آ °ش ءء´ظ.

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

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

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

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

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

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

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

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

onPressKeyDict[app.DIK_F5] = lambda : self.GameMasterPanel()

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

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

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

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

self.onClickKeyDict=onClickKeyDict

def __PressNumKey(self,num):

MapName = str(background.GetCurrentMapName())

if MapName == "mapa_guerra":

if constInfo.ataque_guerra == 1:

return

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

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

if player.GetItemIndex(i) in (71114, 71116, 71118, 71120):

net.SendItemUsePacket(i)

break

def __PressHKey(self):

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

net.SendChatPacket("/user_horse_ride")

else:

self.interface.OpenHelpWindow()

def __PressBKey(self):

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

net.SendChatPacket("/user_horse_back")

else:

state = "EMOTICON"

self.interface.ToggleCharacterWindow(state)

def __PressFKey(self):

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

net.SendChatPacket("/user_horse_feed")

else:

app.ZoomCamera(app.CAMERA_TO_POSITIVE)

def __PressGKey(self):

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

net.SendChatPacket("/ride")

else:

if self.ShowNameFlag:

self.interface.ToggleGuildWindow()

else:

app.PitchCamera(app.CAMERA_TO_POSITIVE)

def __ReleaseGKey(self):

app.PitchCamera(app.CAMERA_STOP)

def __PressQKey(self):

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

if 0==interfaceModule.IsQBHide:

interfaceModule.IsQBHide = 1

self.interface.HideAllQuestButton()

else:

interfaceModule.IsQBHide = 0

self.interface.ShowAllQuestButton()

else:

app.RotateCamera(app.CAMERA_TO_NEGATIVE)

def __SetQuickSlotMode(self):

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

def __SetQuickPageMode(self):

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

def __PressQuickSlot(self, localSlotIndex):

player.RequestUseLocalQuickSlot(localSlotIndex)

def __SelectQuickPage(self, pageIndex):

self.quickSlotPageIndex = pageIndex

player.SetQuickPage(pageIndex)

def ToggleFPSInfo(self):

self.FrameRate.Show()

def ToggleDebugInfo(self):

self.isShowDebugInfo = not self.isShowDebugInfo

if self.isShowDebugInfo:

self.PrintCoord.Show()

self.FrameRate.Show()

self.Pitch.Show()

self.Splat.Show()

self.TextureNum.Show()

self.ObjectNum.Show()

self.ViewDistance.Show()

self.PrintMousePos.Show()

else:

self.PrintCoord.Hide()

self.FrameRate.Hide()

self.Pitch.Hide()

self.Splat.Hide()

self.TextureNum.Hide()

self.ObjectNum.Hide()

self.ViewDistance.Hide()

self.PrintMousePos.Hide()

def __BuildDebugInfo(self):

## Character Position Coordinate

self.PrintCoord = ui.TextLine()

self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)

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

## Frame Rate

#self.FrameRate = ui.TextLine()

#self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)

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

self.FrameRate = ui.TextLine()

self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)

self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 85, 180) #Change -200 for x coordinate, 20 for y coordinate

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

if app.WJ_SHOW_ALL_CHANNEL:

def BINARY_OnChannelPacket(self, channel):

dict = {'name' : ' الفترة التجربية '}

if channel == 99:

net.SetServerInfo((localeInfo.TEXT_CHANNEL_EVENTOS % (dict['name'], str("Especial"))).strip())

if self.interface:

self.interface.wndMiniMap.serverInfo.SetText(net.GetServerInfo())

else:

net.SetServerInfo((localeInfo.TEXT_CHANNEL % (dict['name'], channel)).strip())

if self.interface:

self.interface.wndMiniMap.serverInfo.SetText(net.GetServerInfo())

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 not constInfo.INPUT_IGNORE:

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

if app.RENEWAL_DEAD_PACKET:

def OnGameOver(self, d_time):

self.CloseTargetBoard()

self.OpenRestartDialog(d_time)

else:

def OnGameOver(self):

self.CloseTargetBoard()

self.OpenRestartDialog()

if app.RENEWAL_DEAD_PACKET:

def OpenRestartDialog(self, d_time):

self.interface.OpenRestartDialog(d_time)

else:

def OpenRestartDialog(self):

self.interface.OpenRestartDialog()

if app.ENABLE_12ZI:

def OpenUI12zi(self, yellowmark, greenmark, yellowreward, greenreward, goldreward):

self.interface.OpenUI12zi(int(yellowmark,16), int(greenmark,16), int(yellowreward), int(greenreward), int(goldreward))

def Refresh12ziTimer(self, currentFloor, jumpCount, limitTime, elapseTime):

self.interface.Refresh12ziTimer(currentFloor, jumpCount, limitTime, elapseTime)

def Show12ziJumpButton(self):

self.interface.Show12ziJumpButton()

def Hide12ziTimer(self):

self.interface.Hide12ziTimer()

def OpenReviveDialog(self, vid, itemcount):

self.targetBoard.OpenReviveDialog(vid, itemcount);

def RefreshShopItemToolTip(self):

self.interface.RefreshShopItemToolTip()

def NotEnoughPrism(self, itemcount):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOT_ENOUGH_PRISM % (itemcount))

def ChangeCurrentSkill(self, skillSlotNumber):

self.interface.OnChangeCurrentSkill(skillSlotNumber)

if app.WJ_SHOW_STROKE_INFO:

def RegisterStroke(self, targetVID, value):

self.targetBoard.RegisterStroke(targetVID, value)

## TargetBoard

def SetPCTargetBoard(self, vid, name):

MapName = str(background.GetCurrentMapName())

if MapName == "mapa_guerra":

if player.IsSameEmpire(vid):

mouseModule.mouseController.DeattachObject()

return

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

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

self.targetBoard.ResetTargetBoard()

self.targetBoard.SetEnemyVID(vid)

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

dwRaceFlag = nonplayer.GetMonsterRaceFlag(vnum)

elementId = self.GetElementByRaceFlag(dwRaceFlag)

self.targetBoard.SetElementImage(elementId)

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

if app.ENABLE_TARGET_AFFECT:

def ClearTargetAffects(self):

self.targetBoard.ClearAffects()

def AddTargetBoardAffect(self, affect, duration):

self.targetBoard.AddAffect(affect, duration)

def RemoveTargetBoardAffect(self, affect):

self.targetBoard.RemoveAffect(affect)

def CloseTargetBoardIfDifferent(self, vid):

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

self.targetBoard.Close()

def CloseTargetBoard(self):

self.targetBoard.Close()

def HAS_FLAG(self, value, flag):

return (value & flag) == flag

def GetElementByRaceFlag(self, raceFlag):

if raceFlag == 0:

return 0

for i in xrange(17):

curFlag = 1 << i

if self.HAS_FLAG(raceFlag, curFlag):

if SUB_RACE_FLAG_TO_ELEMENT.has_key(curFlag):

return SUB_RACE_FLAG_TO_ELEMENT[curFlag]

return 0

## View Equipment

def OpenEquipmentDialog(self, vid):

self.interface.OpenEquipmentDialog(vid)

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

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

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

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

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

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

# SHOW_LOCAL_MAP_NAME

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

if self.mapNameShower:

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

if self.interface:

self.interface.SetMapName(mapName)

# END_OF_SHOW_LOCAL_MAP_NAME

def BINARY_OpenAtlasWindow(self):

self.interface.BINARY_OpenAtlasWindow()

## Chat

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

if mode == chat.WHISPER_TYPE_GM:

self.interface.RegisterGameMasterName(name)

chat.AppendWhisper(mode, name, line)

self.interface.RecvWhisper(name)

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

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

self.interface.RecvWhisper(name)

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

if localeInfo.WHISPER_ERROR.has_key(mode):

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

else:

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

self.interface.RecvWhisper(name)

def RecvWhisper(self, name):

self.interface.RecvWhisper(name)

def OnPickMoney(self, money):

self.interface.OnPickMoneyNew(money)

if app.ENABLE_12ZI:

def SetBeadCount(self, value):

self.interface.SetBeadCount(value)

def NextBeadUpdateTime(self, value):

self.interface.NextBeadUpdateTime(value)

if app.ENABLE_CHEQUE_SYSTEM:

def OnPickCheque(self, cheque):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHEQUE_SYSTEM_PICK_WON % (cheque))

def OnShopError(self, type):

try:

self.PopupMessage(localeInfo.SHOP_ERROR_DICT[type])

except KeyError:

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

def OnSafeBoxError(self):

self.PopupMessage(localeInfo.SAFEBOX_ERROR)

def OnFishingSuccess(self, isFish, fishName):

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

# ADD_FISHING_MESSAGE

def OnFishingNotifyUnknown(self):

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

def OnFishingWrongPlace(self):

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

# END_OF_ADD_FISHING_MESSAGE

def OnFishingNotify(self, isFish, fishName):

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

def OnFishingFailure(self):

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

def OnCannotPickItem(self):

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

# MINING

def OnCannotMining(self):

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

# END_OF_MINING

def OnCannotUseSkill(self, vid, type):

if localeInfo.USE_SKILL_ERROR_TAIL_DICT.has_key(type):

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

if localeInfo.USE_SKILL_ERROR_CHAT_DICT.has_key(type):

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

def OnCannotShotError(self, vid, type):

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

## PointReset

def StartPointReset(self):

self.interface.OpenPointResetDialog()

## Shop

if (app.WJ_COMBAT_ZONE):

def StartShop(self, vid, points, curLimit, maxLimit):

self.interface.OpenShopDialog(vid, points, curLimit, maxLimit)

else:

def StartShop(self, vid):

self.interface.OpenShopDialog(vid)

def EndShop(self):

self.interface.CloseShopDialog()

def RefreshShop(self):

self.interface.RefreshShopDialog()

def SetShopSellingPrice(self, Price):

pass

## Exchange

def StartExchange(self):

self.interface.StartExchange()

def EndExchange(self):

self.interface.EndExchange()

def RefreshExchange(self):

self.interface.RefreshExchange()

## Party

def RecvPartyInviteQuestion(self, leaderVID, leaderName):

partyInviteQuestionDialog = uiCommon.QuestionDialog()

partyInviteQuestionDialog.SetText(leaderName + localeInfo.PARTY_DO_YOU_JOIN)

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

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

partyInviteQuestionDialog.Open()

partyInviteQuestionDialog.partyLeaderVID = leaderVID

self.partyInviteQuestionDialog = partyInviteQuestionDialog

def AnswerPartyInvite(self, answer):

if not self.partyInviteQuestionDialog:

return

partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID

distance = player.GetCharacterDistance(partyLeaderVID)

if distance < 0.0 or distance > 5000:

answer = False

net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)

self.partyInviteQuestionDialog.Close()

self.partyInviteQuestionDialog = None

if app.BL_PARTY_UPDATE:

def AddPartyMember(self, pid, name, mapIdx, channel):

self.interface.AddPartyMember(pid, name, mapIdx, channel)

else:

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

if app.BL_PARTY_UPDATE:

def LinkPartyMember(self, pid, vid, mapIdx, channel):

self.interface.LinkPartyMember(pid, vid, mapIdx, channel)

else:

def LinkPartyMember(self, pid, vid):

self.interface.LinkPartyMember(pid, vid)

def UnlinkPartyMember(self, pid):

self.interface.UnlinkPartyMember(pid)

def UnlinkAllPartyMember(self):

self.interface.UnlinkAllPartyMember()

def ExitParty(self):

self.interface.ExitParty()

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

def ChangePartyParameter(self, distributionMode):

self.interface.ChangePartyParameter(distributionMode)

## Messenger

def OnMessengerAddFriendQuestion(self, name):

messengerAddFriendQuestion = uiCommon.QuestionDialog2()

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

messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)

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

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

messengerAddFriendQuestion.Open()

messengerAddFriendQuestion.name = name

self.messengerAddFriendQuestion = messengerAddFriendQuestion

def OnAcceptAddFriend(self):

name = self.messengerAddFriendQuestion.name

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

self.OnCloseAddFriendQuestionDialog()

return True

def OnDenyAddFriend(self):

name = self.messengerAddFriendQuestion.name

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

self.OnCloseAddFriendQuestionDialog()

return True

def OnCloseAddFriendQuestionDialog(self):

self.messengerAddFriendQuestion.Close()

self.messengerAddFriendQuestion = None

return True

## SafeBox

def OpenSafeboxWindow(self, size):

self.interface.OpenSafeboxWindow(size)

def RefreshSafebox(self):

self.interface.RefreshSafebox()

def RefreshSafeboxMoney(self):

self.interface.RefreshSafeboxMoney()

# ITEM_MALL

def OpenMallWindow(self, size):

self.interface.OpenMallWindow(size)

def RefreshMall(self):

self.interface.RefreshMall()

# END_OF_ITEM_MALL

## Guild

def RecvGuildInviteQuestion(self, guildID, guildName):

guildInviteQuestionDialog = uiCommon.QuestionDialog()

guildInviteQuestionDialog.SetText(guildName + localeInfo.GUILD_DO_YOU_JOIN)

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

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

guildInviteQuestionDialog.Open()

guildInviteQuestionDialog.guildID = guildID

self.guildInviteQuestionDialog = guildInviteQuestionDialog

def AnswerGuildInvite(self, answer):

if not self.guildInviteQuestionDialog:

return

guildLeaderVID = self.guildInviteQuestionDialog.guildID

net.SendGuildInviteAnswerPacket(guildLeaderVID, answer)

self.guildInviteQuestionDialog.Close()

self.guildInviteQuestionDialog = None

def DeleteGuild(self):

self.interface.DeleteGuild()

## Clock

def ShowClock(self, second):

self.interface.ShowClock(second)

def HideClock(self):

self.interface.HideClock()

## Emotion

def BINARY_ActEmotion(self, emotionIndex):

if self.interface.wndCharacter:

self.interface.wndCharacter.ActEmotion(emotionIndex)

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

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

## Keyboard Functions

def CheckFocus(self):

if False == self.IsFocus():

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

self.interface.ToggleChat()

self.SetFocus()

def SaveScreen(self):

print "save screen"

# SCREENSHOT_CWDSAVE

if SCREENSHOT_CWDSAVE:

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

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

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

elif SCREENSHOT_DIR:

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

else:

(succeeded, name) = grp.SaveScreenShot()

# END_OF_SCREENSHOT_CWDSAVE

if succeeded:

pass

"""

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

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

"""

else:

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

def ShowConsole(self):

if debugInfo.IsDebugMode() or True == self.consoleEnable:

player.EndKeyWalkingImmediately()

self.console.OpenWindow()

def ShowName(self):

self.ShowNameFlag = True

self.playerGauge.EnableShowAlways()

player.SetQuickPage(self.quickSlotPageIndex+1)

# ADD_ALWAYS_SHOW_NAME

def __IsShowName(self):

if systemSetting.IsAlwaysShowName():

return True

if self.ShowNameFlag:

return True

return False

# END_OF_ADD_ALWAYS_SHOW_NAME

def HideName(self):

self.ShowNameFlag = False

self.playerGauge.DisableShowAlways()

player.SetQuickPage(self.quickSlotPageIndex)

def GameMasterPanel(self):

import uigamemasterpanel

if chr.IsGameMaster(player.GetMainCharacterIndex()):

self.GMPaneL = uigamemasterpanel.GMPaneL()

self.GMPaneL.Show()

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 BINARY_Update_Maintenance(self, iTime, iDuration, iReason):

sTime = int(iTime)

sDuration = int(iDuration)

sReason = str(iReason)

if sTime != 0 and sDuration != 0:

self.wndMaintenance.OpenMaintenance(int(iTime), int(iDuration), str(iReason))

def MoveUp(self):

player.SetSingleDIKKeyState(app.DIK_UP, True)

def MoveDown(self):

player.SetSingleDIKKeyState(app.DIK_DOWN, True)

def MoveLeft(self):

player.SetSingleDIKKeyState(app.DIK_LEFT, True)

def MoveRight(self):

player.SetSingleDIKKeyState(app.DIK_RIGHT, True)

def StopUp(self):

player.SetSingleDIKKeyState(app.DIK_UP, False)

def StopDown(self):

player.SetSingleDIKKeyState(app.DIK_DOWN, False)

def StopLeft(self):

player.SetSingleDIKKeyState(app.DIK_LEFT, False)

def StopRight(self):

player.SetSingleDIKKeyState(app.DIK_RIGHT, False)

def PickUpItem(self):

#player.PickCloseItem()

player.PickCloseItemVector()

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

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

## Event Handler

def OnKeyDown(self, key):

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

return

if key == app.DIK_ESC:

self.RequestDropItem(False)

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

try:

self.onPressKeyDict[key]()

except KeyError:

pass

except:

raise

return True

def OnKeyUp(self, key):

try:

self.onClickKeyDict[key]()

except KeyError:

pass

except:

raise

return True

def OnMouseLeftButtonDown(self):

if self.interface.BUILD_OnMouseLeftButtonDown():

return

if mouseModule.mouseController.isAttached():

self.CheckFocus()

else:

hyperlink = ui.GetHyperlink()

if hyperlink:

return

else:

self.CheckFocus()

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

return True

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():

return

if mouseModule.mouseController.isAttached():

attachedType = mouseModule.mouseController.GetAttachedType()

attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()

## QuickSlot

if player.SLOT_TYPE_QUICK_SLOT == attachedType:

player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)

## Inventory

elif player.SLOT_TYPE_INVENTORY == attachedType:

if player.ITEM_MONEY == attachedItemIndex:

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

else:

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

## DragonSoul

elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:

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

if app.ENABLE_SPECIAL_STORAGE:

if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\

player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\

player.SLOT_TYPE_STONE_INVENTORY == attachedType or\

player.SLOT_TYPE_CHEST_INVENTORY == attachedType or\

player.SLOT_TYPE_BONUS_INVENTORY == attachedType or\

player.SLOT_TYPE_VARIUS_INVENTORY == attachedType:

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

mouseModule.mouseController.DeattachObject()

else:

hyperlink = ui.GetHyperlink()

if hyperlink:

if app.IsPressed(app.DIK_LALT):

link = chat.GetLinkFromHyperlink(hyperlink)

ime.PasteString(link)

else:

self.interface.MakeHyperlinkTooltip(hyperlink)

return

else:

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

#player.EndMouseWalking()

return True

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

if app.ENABLE_SPECIAL_STORAGE:

if player.SLOT_TYPE_INVENTORY == attachedType or\

player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType or\

player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\

player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\

player.SLOT_TYPE_STONE_INVENTORY == attachedType or\

player.SLOT_TYPE_CHEST_INVENTORY == attachedType or\

player.SLOT_TYPE_BONUS_INVENTORY == attachedType or\

player.SLOT_TYPE_VARIUS_INVENTORY == attachedType:

attachedInvenType = player.SlotTypeToInvenType(attachedType)

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

if player.IsEquipmentSlot(attachedItemSlotPos) and\

player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType and\

player.SLOT_TYPE_UPGRADE_INVENTORY != attachedType and\

player.SLOT_TYPE_BOOK_INVENTORY != attachedType and\

player.SLOT_TYPE_STONE_INVENTORY != attachedType and\

player.SLOT_TYPE_CHEST_INVENTORY != attachedType and\

player.SLOT_TYPE_BONUS_INVENTORY != attachedType and\

player.SLOT_TYPE_VARIUS_INVENTORY != attachedType:

self.stream.popupWindow.Close()

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

else:

if chr.IsNPC(dstChrID):

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

else:

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)

else:

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

else:

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

attachedInvenType = player.SlotTypeToInvenType(attachedType)

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

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

self.stream.popupWindow.Close()

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

else:

if chr.IsNPC(dstChrID):

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

else:

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)

else:

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

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

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

net.SendExchangeStartPacket(dstChrID)

net.SendExchangeElkAddPacket(attachedMoney)

else:

self.__DropMoney(attachedType, attachedMoney)

def __DropMoney(self, attachedType, attachedMoney):

# PRIVATESHOP_DISABLE_ITEM_DROP - °³ہخ»َء، ؟­°ي ہض´آ µ؟¾ب ¾ئہجإغ ¹ِ¸² ¹وءِ

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

if attachedMoney>=1000:

self.stream.popupWindow.Close()

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

return

# itemDropQuestionDialog = uiCommon.QuestionDialog()

itemDropQuestionDialog = uiCommon.ItemQuestionDialog()

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.window_type = "inv"

itemDropQuestionDialog.Open(1, "", attachedMoney)

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropCount = attachedMoney

itemDropQuestionDialog.dropNumber = player.ITEM_MONEY

self.itemDropQuestionDialog = itemDropQuestionDialog

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

# PRIVATESHOP_DISABLE_ITEM_DROP - °³ہخ»َء، ؟­°ي ہض´آ µ؟¾ب ¾ئہجإغ ¹ِ¸² ¹وءِ

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

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

self.stream.popupWindow.Close()

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

else:

if player.SLOT_TYPE_INVENTORY == attachedType:

dropItemIndex = player.GetItemIndex(attachedItemSlotPos)

item.SelectItem(dropItemIndex)

dropItemName = item.GetItemName()

## Question Text

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

# itemDropQuestionDialog = uiCommon.QuestionDialogItem()

itemDropQuestionDialog = uiCommon.ItemQuestionDialog()

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.window_type = "inv"

itemDropQuestionDialog.count = attachedItemCount

itemDropQuestionDialog.Open(dropItemIndex,attachedItemSlotPos)

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropNumber = attachedItemSlotPos

itemDropQuestionDialog.dropCount = attachedItemCount

self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:

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

item.SelectItem(dropItemIndex)

dropItemName = item.GetItemName()

## Question Text

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

# itemDropQuestionDialog = uiCommon.QuestionDialog()

itemDropQuestionDialog = uiCommon.ItemQuestionDialog()

itemDropQuestionDialog.SetText(questionText)

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

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

itemDropQuestionDialog.window_type = "dragon"

itemDropQuestionDialog.count = attachedItemCount

itemDropQuestionDialog.Open(dropItemIndex, attachedItemSlotPos)

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropNumber = attachedItemSlotPos

itemDropQuestionDialog.dropCount = attachedItemCount

self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

if app.ENABLE_SPECIAL_STORAGE:

if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\

player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\

player.SLOT_TYPE_STONE_INVENTORY == attachedType or\

player.SLOT_TYPE_CHEST_INVENTORY == attachedType or\

player.SLOT_TYPE_BONUS_INVENTORY == attachedType or\

player.SLOT_TYPE_VARIUS_INVENTORY == attachedType:

dropItemIndex = player.GetItemIndex(player.SlotTypeToInvenType(attachedType), attachedItemSlotPos)

item.SelectItem(dropItemIndex)

dropItemName = item.GetItemName()

## Question Text

questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)

## Dialog

# itemDropQuestionDialog = uiCommon.QuestionDialog()

itemDropQuestionDialog = uiCommon.ItemQuestionDialog()

itemDropQuestionDialog.SetText(questionText)

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

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

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

if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType:

itemDropQuestionDialog.window_type = "upp"

elif player.SLOT_TYPE_BOOK_INVENTORY == attachedType:

itemDropQuestionDialog.window_type = "book"

elif player.SLOT_TYPE_STONE_INVENTORY == attachedType:

itemDropQuestionDialog.window_type = "stone"

itemDropQuestionDialog.count = attachedItemCount

itemDropQuestionDialog.Open(dropItemIndex, attachedItemSlotPos)

itemDropQuestionDialog.dropType = attachedType

itemDropQuestionDialog.dropNumber = attachedItemSlotPos

itemDropQuestionDialog.dropCount = attachedItemCount

self.itemDropQuestionDialog = itemDropQuestionDialog

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

def RequestDropItem(self, answer):

if not self.itemDropQuestionDialog:

return

if answer:

dropType = self.itemDropQuestionDialog.dropType

dropCount = self.itemDropQuestionDialog.dropCount

dropNumber = self.itemDropQuestionDialog.dropNumber

if player.SLOT_TYPE_INVENTORY == dropType:

if dropNumber == player.ITEM_MONEY:

net.SendGoldDropPacketNew(dropCount)

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

else:

# PRIVATESHOP_DISABLE_ITEM_DROP

self.__SendDropItemPacket(dropNumber, dropCount)

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:

# PRIVATESHOP_DISABLE_ITEM_DROP

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

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

if app.ENABLE_SPECIAL_STORAGE:

if player.SLOT_TYPE_UPGRADE_INVENTORY == dropType or\

player.SLOT_TYPE_BOOK_INVENTORY == dropType or\

player.SLOT_TYPE_STONE_INVENTORY == dropType or\

player.SLOT_TYPE_CHEST_INVENTORY == dropType or\

player.SLOT_TYPE_BONUS_INVENTORY == dropType or\

player.SLOT_TYPE_VARIUS_INVENTORY == dropType:

self.__SendDropItemPacket(dropNumber, dropCount, player.SlotTypeToInvenType(dropType))

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

dropCount = self.itemDropQuestionDialog.dropCount

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

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

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)

# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP

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

if uiPrivateShopBuilder.IsBuildingPrivateShop():

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

return

net.SendItemDestroyPacket(itemVNum)

def OnMouseRightButtonDown(self):

self.CheckFocus()

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

mouseModule.mouseController.DeattachObject()

else:

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

return True

def OnMouseRightButtonUp(self):

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

return True

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

return True

def OnMouseMiddleButtonDown(self):

player.SetMouseMiddleButtonState(player.MBS_PRESS)

def OnMouseMiddleButtonUp(self):

player.SetMouseMiddleButtonState(player.MBS_CLICK)

def OnUpdate(self):

self.wnddailygift.OnUpdate()

app.UpdateGame()

if app.ENABLE_TITLE_SYSTEM:

self.wndTitleSystem.OnUpdate()

if self.mapNameShower.IsShow():

self.mapNameShower.Update()

if self.isShowDebugInfo:

self.UpdateDebugInfo()

if self.enableXMasBoom:

self.__XMasBoom_Update()

if constInfo.E_LITERE_STATUS == 1:

self.litere_event.Show()

else:

self.litere_event.Hide()

self.UpdateFPSInfo()

self.interface.BUILD_OnUpdate()

def UpdateFPSInfo(self):

nRenderFPS = app.GetRenderFPS()

self.FrameRate.SetText("FPS: %3d" % (nRenderFPS))

#self.FrameRate.SetPackedFontColor(ui.GenerateColor(255, 0, 0)) #delete this line if you want normal color (like in debug mode)

def UpdateDebugInfo(self):

#

# ؤ³¸¯إح ءآا¥ ¹× FPS أâ·آ

(x, y, z) = player.GetMainCharacterPosition()

nUpdateTime = app.GetUpdateTime()

nUpdateFPS = app.GetUpdateFPS()

nRenderFPS = app.GetRenderFPS()

nFaceCount = app.GetFaceCount()

fFaceSpeed = app.GetFaceSpeed()

nST=background.GetRenderShadowTime()

(fAveRT, nCurRT) = app.GetRenderTime()

(iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo()

(iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum()

if iPatch == 0:

iPatch = 1

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

self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))

xMouse, yMouse = wndMgr.GetMousePosition()

self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))

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

if fAveRT>1.0:

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

self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))

#self.Pitch.SetText("Pitch: %.2f" % (app.GetCameraPitch())

#self.TextureNum.SetText("TN : %s" % (sTextureNum))

#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))

self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))

def OnRender(self):

app.RenderGame()

if self.console.Console.collision:

background.RenderCollision()

chr.RenderCollision()

(x, y) = app.GetCursorPosition()

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

# Picking

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

textTail.UpdateAllTextTail()

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

self.PickingCharacterIndex = chr.Pick()

if -1 != self.PickingCharacterIndex:

textTail.ShowCharacterTextTail(self.PickingCharacterIndex)

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

textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())

# ADD_ALWAYS_SHOW_NAME

if not self.__IsShowName():

self.PickingItemIndex = item.Pick()

if -1 != self.PickingItemIndex:

textTail.ShowItemTextTail(self.PickingItemIndex)

# END_OF_ADD_ALWAYS_SHOW_NAME

## Show all name in the range

# ADD_ALWAYS_SHOW_NAME

if self.__IsShowName():

textTail.ShowAllTextTail()

self.PickingItemIndex = textTail.Pick(x, y)

# END_OF_ADD_ALWAYS_SHOW_NAME

if systemSetting.IsShowSalesText():

uiPrivateShopBuilder.UpdateADBoard()

textTail.UpdateShowingTextTail()

textTail.ArrangeTextTail()

if -1 != self.PickingItemIndex:

textTail.SelectItemName(self.PickingItemIndex)

grp.PopState()

grp.SetInterfaceRenderState()

textTail.Render()

textTail.HideAllTextTail()

def OnPressEscapeKey(self):

if app.TARGET == app.GetCursor():

app.SetCursor(app.NORMAL)

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

mouseModule.mouseController.DeattachObject()

else:

self.interface.OpenSystemDialog()

return True

def OnIMEReturn(self):

if app.IsPressed(app.DIK_LSHIFT):

self.interface.OpenWhisperDialogWithoutTarget()

else:

self.interface.ToggleChat()

return True

def OnPressExitKey(self):

self.interface.ToggleSystemDialog()

return True

## BINARY CALLBACK

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

# EXCHANGE

if app.WJ_ENABLE_TRADABLE_ICON:

def BINARY_AddItemToExchange(self, inven_type, inven_pos, display_pos):

if inven_type == player.INVENTORY:

self.interface.CantTradableItemExchange(display_pos, inven_pos)

# END_OF_EXCHANGE

# 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

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

# QUEST_CONFIRM

def BINARY_OnQuestConfirm(self, msg, timeout, pid):

confirmDialog = uiCommon.QuestionDialogWithTimeLimit()

confirmDialog.SetText1(msg)

confirmDialog.Open(timeout)

confirmDialog.SetAcceptEvent(lambda answer=True, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())

confirmDialog.SetCancelEvent(lambda answer=False, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())

self.confirmDialog = confirmDialog

# END_OF_QUEST_CONFIRM

# GIFT command

def Gift_Show(self):

self.interface.ShowGift()

# CUBE

def BINARY_Cube_Open(self, npcVNUM):

self.currentCubeNPC = npcVNUM

self.interface.OpenCubeWindow()

if npcVNUM not in self.cubeInformation:

net.SendChatPacket("/cube r_info")

else:

cubeInfoList = self.cubeInformation[npcVNUM]

i = 0

for cubeInfo in cubeInfoList:

self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"])

j = 0

for materialList in cubeInfo["materialList"]:

for materialInfo in materialList:

itemVnum, itemCount = materialInfo

self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount)

j = j + 1

i = i + 1

self.interface.wndCube.Refresh()

def BINARY_Cube_Close(self):

self.interface.CloseCubeWindow()

# ء¦ہغ؟، ات؟نار °ٌµه, ؟¹»َµا´آ ؟د¼؛ا°ہا VNUM°ْ °³¼ِ ء¤؛¸ update

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

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

def BINARY_Cube_Succeed(self, itemVnum, count):

print "إ¥؛ê ء¦ہغ ¼؛°ّ"

self.interface.SucceedCubeWork(itemVnum, count)

pass

def BINARY_Cube_Failed(self):

print "إ¥؛ê ء¦ہغ ½ائذ"

self.interface.FailedCubeWork()

pass

def BINARY_Cube_ResultList(self, npcVNUM, listText):

# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 ہج·±½ؤہ¸·خ "/" ¹®ہع·خ ±¸؛ذµب ¸®½؛ئ®¸¦ ءـ

#print listText

if npcVNUM == 0:

npcVNUM = self.currentCubeNPC

self.cubeInformation[npcVNUM] = []

try:

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

eachInfo = eachInfoText.split(",")

itemVnum = int(eachInfo[0])

itemCount = int(eachInfo[1])

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

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

resultCount = len(self.cubeInformation[npcVNUM])

requestCount = 7

modCount = resultCount % requestCount

splitCount = resultCount / requestCount

for i in xrange(splitCount):

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

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

if 0 < modCount:

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

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

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

pass

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

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

try:

#print listText

if 3 > len(listText):

dbg.TraceError("Wrong Cube Material Infomation")

return 0

eachResultList = listText.split("@")

cubeInfo = self.cubeInformation[self.currentCubeNPC]

itemIndex = 0

for eachResultText in eachResultList:

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

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

gold = 0

splitResult = eachResultText.split("/")

if 1 < len(splitResult):

gold = int(splitResult[1])

#print "splitResult : ", splitResult

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

i = 0

for eachMaterialText in eachMaterialList:

complicatedList = eachMaterialText.split("|")

if 0 < len(complicatedList):

for complicatedText in complicatedList:

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

itemVnum = int(itemVnum)

itemCount = int(itemCount)

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

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

else:

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

itemVnum = int(itemVnum)

itemCount = int(itemCount)

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

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

i = i + 1

itemIndex = itemIndex + 1

self.interface.wndCube.Refresh()

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

pass

# END_OF_CUBE

if app.ENABLE_ATTR_TRANSFER_SYSTEM:

def BINARY_AttrTransfer_Open(self):

self.interface.OpenAttrTransferWindow()

def BINARY_AttrTransfer_Close(self):

self.interface.CloseAttrTransferWindow()

def BINARY_AttrTransfer_Success(self):

self.interface.AttrTransferSuccess()

# ؟ëب¥¼®

def BINARY_Highlight_Item(self, inven_type, inven_pos):

# @fixme003 (+if self.interface:)

if self.interface:

self.interface.Highligt_Item(inven_type, inven_pos)

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

if app.ENABLE_12ZI:

def BINARY_SetMissionMessage(self, message):

if app.ENABLE_CHAT_MISSION_ALTERNATIVE:

self.interface.missionBoard.SetMission(message.replace("_", " "))

else:

self.interface.missionBoard.SetMission(message)

def BINARY_SetSubMissionMessage(self, message):

self.interface.missionBoard.SetSubMission(message)

def BINARY_CleanMissionMessage(self):

self.interface.missionBoard.CleanMission()

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 BINARY_UpdateUserCount(self, userCount):

self.interface.wndMiniMap.UpdateUserCount(userCount)

# PROFESSIONAL_BIOLOG_SYSTEM

if app.ENABLE_BIOLOG_SYSTEM:

def BINARY_Biolog_Update(self, pLeftTime, pCountActual, pCountNeed, pVnum):

uiprofessionalbiolog.BIOLOG_BINARY_LOADED["time"][0] = int(pLeftTime) + app.GetGlobalTimeStamp()

uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countActual"][0] = str(pCountActual)

uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countNeed"][0] = str(pCountNeed)

uiprofessionalbiolog.BIOLOG_BINARY_LOADED["vnum"][0] = int(pVnum)

def BINARY_Biolog_SendMessage(self, pMessage):

if str(pMessage) != "":

self.wndBiologMessage = uiCommon.PopupDialog()

self.wndBiologMessage.SetWidth(350)

self.wndBiologMessage.SetText((str(pMessage).replace("$"," ")))

self.wndBiologMessage.Show()

else:

chat.AppendChat(chat.CHAT_TYPE_INFO, "Error, i could not initialize message from server!")

def BINARY_Biolog_PopUp(self, iRewardType, iRewardItem, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2):

self.wndBiologSlider = uiprofessionalbiolog.Biolog_FinishSlider()

self.wndBiologSlider.BINARY_BiologPopUp_Load([str(iRewardType), int(iRewardItem), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2)])

self.wndBiologSlider.Show()

def BINARY_Biolog_SelectReward(self, iTypeWindow, iRewardType, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2, iBonusName_3, iBonusValue_3):

self.wndBiologSelectReward = uiprofessionalbiolog.Biolog_SelectReward()

self.wndBiologSelectReward.Open_SelectRewardType([int(iTypeWindow), str(iRewardType), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2), str(iBonusName_3), int(iBonusValue_3)])

self.wndBiologSelectReward.SetTitle((str(iRewardType).replace("$"," ")))

self.wndBiologSelectReward.SetCenterPosition()

self.wndBiologSelectReward.SetTop()

self.wndBiologSelectReward.Show()

# END_OF_PROFESSIONAL_BIOLOG_SYSTEM

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

guildID1 = int(guildID1)

guildID2 = int(guildID2)

memberCount1 = int(memberCount1)

memberCount2 = int(memberCount2)

observerCount = int(observerCount)

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

self.interface.wndMiniMap.UpdateObserverCount(observerCount)

def __GuildWar_OpenAskDialog(self, guildID, warType):

guildName = guild.GetGuildName(guildID)

# REMOVED_GUILD_BUG_FIX

if "Noname" == guildName:

return

# END_OF_REMOVED_GUILD_BUG_FIX

import uiGuild

questionDialog = uiGuild.AcceptGuildWarDialog()

questionDialog.SAFE_SetAcceptEvent(self.__GuildWar_OnAccept)

questionDialog.SAFE_SetCancelEvent(self.__GuildWar_OnDecline)

questionDialog.Open(guildName, warType)

self.guildWarQuestionDialog = questionDialog

def __GuildWar_CloseAskDialog(self):

self.guildWarQuestionDialog.Close()

self.guildWarQuestionDialog = None

def __GuildWar_OnAccept(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/war " + guildName)

self.__GuildWar_CloseAskDialog()

return 1

def __GuildWar_OnDecline(self):

guildName = self.guildWarQuestionDialog.GetGuildName()

net.SendChatPacket("/nowar " + guildName)

self.__GuildWar_CloseAskDialog()

return 1

## BINARY CALLBACK

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

def __ServerCommand_Build(self):

serverCommandList={

"ConsoleEnable" : self.__Console_Enable,

"DayMode" : self.__DayMode_Update,

"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,

"CloseRestartWindow" : self.__RestartDialog_Close,

"OpenPrivateShop" : self.__PrivateShop_Open,

"ruhtasiekranac" : self.ruhcac,

"PartyHealReady" : self.PartyHealReady,

"ShowMeSafeboxPassword" : self.AskSafeboxPassword,

"CloseSafebox" : self.CommandCloseSafebox,

'PARTY_E' : self._PartyEmotionsCMD,

# ITEM_MALL

"CloseMall" : self.CommandCloseMall,

"ShowMeMallPassword" : self.AskMallPassword,

"item_mall" : self.__ItemMall_Open,

"envanter" : self.envanter_kilitle_quest,

# END_OF_ITEM_MALL

"requestWarpToCharcater" : self.__RequestWarpToCharacter,

##NEW SHOP

"OpenItemshop" : self.OpenItemShop,

"shop" : self.NewShop,

"shop_clear" : self.ShopClear,

"shop_add" : self.ShopAdd,

"shop_item" : self.ShopItem,

"shop_cost" : self.ShopCost,

"shop_cost_clear" : self.ShopCostClear,

"shop_item_clear" : self.ShopItemClear,

#####GIFT SYSTEM

"gift_clear" : self.gift_clear,

"gift_item" : self.gift_item,

"gift_info" : self.gift_show,

"gift_load" : self.gift_load,

"decoracion" : self.__OpenDecoration,

###

"RefineSuceeded" : self.RefineSuceededMessage,

"RefineFailed" : self.RefineFailedMessage,

"xmas_snow" : self.__XMasSnow_Enable,

"xmas_boom" : self.__XMasBoom_Enable,

"xmas_song" : self.__XMasSong_Enable,

"xmas_tree" : self.__XMasTree_Enable,

"newyear_boom" : self.__XMasBoom_Enable,

"PartyRequest" : self.__PartyRequestQuestion,

"PartyRequestDenied" : self.__PartyRequestDenied,

"horse_state" : self.__Horse_UpdateState,

"hide_horse_state" : self.__Horse_HideState,

"WarUC" : self.__GuildWar_UpdateMemberCount,

"test_server" : self.__EnableTestServerFlag,

"mall" : self.__InGameShop_Show,

# PROFESSIONAL_BIOLOG_SYSTEM

"BINARY_Biolog_Update" : self.BINARY_Biolog_Update,

"BINARY_Biolog_SendMessage" : self.BINARY_Biolog_SendMessage,

"BINARY_Biolog_PopUp" : self.BINARY_Biolog_PopUp,

"BINARY_Biolog_SelectReward" : self.BINARY_Biolog_SelectReward,

# END_OF_PROFESSIONAL_BIOLOG_SYSTEM

"IShop_BanneData" : self.IShop_BanneData,

"IShop_BestSellersItems" : self.IShop_BestSellersItems,

"IShop_Items" : self.IShop_Items,

"IShop_Category" : self.IShop_Category,

"IShop_tombola" : self.IShop_tombola,

"IShop_Update" : self.IShop_Update,

"IShop_tombola_winner" : self.IShop_tombola_winner,

"Ishop_Hisotry" : self.Ishop_Hisotry,

"Showmedallas_gui" : self.__showmedallas_gui,

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

"BINARY_Update_Maintenance" : self.BINARY_Update_Maintenance,

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

#Shop Decoration

"OpenDecoration" :self.__OpenDecoration,

#Shop Decoration

# WEDDING

"lover_login" : self.__LoginLover,

"lover_logout" : self.__LogoutLover,

"lover_near" : self.__LoverNear,

"lover_far" : self.__LoverFar,

"lover_divorce" : self.__LoverDivorce,

"PlayMusic" : self.__PlayMusic,

#WARNME - remove manually if disable shaman system

# if app.ENABLE_SUPPORT_SYSTEM:

"SupportLv" : self.SetSupportLevel,

"SupportName" : self.SetSupportName,

"SupportLeave" : self.SupportLeave,

"SupporInt" : self.SupportInt,

"SupportExp" : self.SetSupportExp,

"SupportIcon" : self.SetSupportIcon,

"SupportSpeciality" : self.SetSupportSpeciality,

#WARNME_END

########################### GAYA SYSTEM #################################

"OpenGuiGaya" : self.OpenGuiGaya,

"GayaCheck" : self.GayaCheck,

"OpenGuiGayaMarket" :self.OpenGuiGayaMarket,

"GayaMarketSlotsDesblock" : self.GayaMarketSlotsDesblock,

"GayaMarketItems" : self.GayaMarketItems,

"GayaMarketClear" : self.GayaMarketClear,

"GayaMarketTime" : self.GayaTimeMarket,

####################### END GAYA SYSTEM ######################################

# END_OF_WEDDING

"evento_letras" :self.send_status,

"letters_drop" :self.SDropLitere,

"OpenLetterWindow" :self.interface.ShowBoardEvent,

"teleport_quest" : self.__TeleportQuestManager,

"antiexp_index" : self.__BlockExpQuestManager,

"offshop_index" : self.__OffShopQuestManager,

"mostrar_usuarios" : self.__mostrar_usuarios,

"ocultar_usuarios" : self.__ocultar_usuarios,

"muerto_guerras" : self.__muerto_guerras,

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

"ManagerGiftSystem" : self.ManagerGiftSystem,

# PRIVATE_SHOP_PRICE_LIST

"MyShopPriceList" : self.__PrivateShop_PriceList,

# END_OF_PRIVATE_SHOP_PRICE_LIST

"attrtransfermessage" : self.AttrTransferMessage,

# ChangeCH

"Update" : self.Update,

# EndChangeCH

"openregalo" : self.__regalo,

}

if app.ENABLE_DUNGEON_INFO_SYSTEM:

serverCommandList.update({

"DungeonInfo" : self.DungeonInfo,

"CleanDungeonInfo" : self.CleanDungeonInfo,

"CleanDungeonRanking" : self.CleanDungeonRanking,

"GetDungeonInfo" : self.GetDungeonInfo,

"UpdateDungeonInfo" : self.UpdateDungeonInfo,

"OpenDungeonRanking" : self.OpenDungeonRanking,

"OpenDungeon" : self.opendungeon,

"UpdateDungeonRanking" : self.UpdateDungeonRanking,

"TiempoDungeonInfo" : self.TiempoDungeonInfoTorre,

"TiempoDungeonInfoCata" : self.TiempoDungeonInfoCata,

"TiempoDungeonInfoNemere" : self.TiempoDungeonInfoNemere,

"TiempoDungeonInfoPuertas" : self.TiempoDungeonInfoPuertas,

"TiempoDungeonInfoSlime" : self.TiempoDungeonInfoSlime,

"TiempoDungeonInfoArya" : self.TiempoDungeonInfoArya,

"TiempoDungeonInfoBosque" : self.TiempoDungeonInfoBosque,

"TiempoDungeonInfoOrco" : self.TiempoDungeonInfoOrco,

"TiempoDungeonInfoIsla" : self.TiempoDungeonInfoIsla,

"TiempoDungeonInfoBeran" : self.TiempoDungeonInfoBeran,

"TiempoDungeonInfoJotuns" : self.TiempoDungeonInfoJotuns,

"TiempoDungeonInfoHydra" : self.TiempoDungeonInfoHydra,

"TiempoDungeonInfoValentine" : self.TiempoDungeonInfoValentine,

"TiempoDungeonInfonavidad" : self.TiempoDungeonInfonavidad,

"TiempoDungeonInfoHallowen" : self.TiempoDungeonInfoHallowen,

})

if app.ENABLE_CHEQUE_SYSTEM:

serverCommandList.update({"MyShopPriceListNew" : self.__PrivateShop_PriceListNew,})

if app.ENABLE_HIDE_COSTUME_SYSTEM:

serverCommandList["COSTUME_HIDE_CLEAR"] = self.COSTUME_HIDE_CLEAR

serverCommandList["COSTUME_HIDE_LIST"] = self.COSTUME_HIDE_LIST

serverCommandList["COSTUME_HIDE_LOAD"] = self.COSTUME_HIDE_LOAD

if app.ENABLE_COSTUME_AURA:

serverCommandList["ClearDirRefine"] = self.ClearDirRefine

serverCommandList["SetDirRefine"] = self.SetDirRefine

serverCommandList["AuraRefineInformation"] = self.AuraRefineInformation

serverCommandList["OpenBoardRefine"] = self.OpenBoardRefine

if app.ENABLE_CHANGE_LOOK_SYSTEM:

serverCommandList.update({"ChangeLookWindow" : self.OpenChangeLookWindow})

if app.ENABLE_ATTR_6TH_7TH_SYSTEM:

serverCommandList["attr_6th_7th"] = self.attr_6th_7th

serverCommandList["Attr67Add"] = self.Attr67Add

if app.ENABLE_DEFENSE_WAVE:

serverCommandList["BINARY_Update_Mast_HP"] = self.BINARY_Update_Mast_HP

serverCommandList["BINARY_Update_Mast_Window"] = self.BINARY_Update_Mast_Window

if app.ENABLE_12ZI:

serverCommandList["NextFloorButton"] = self.Show12ziJumpButton

serverCommandList["OpenUI12zi"] = self.OpenUI12zi

if app.ENABLE_SOUL_SYSTEM:

serverCommandList["RefineSoulSuceeded"] = self.__RefineSoulSuceededMessage

serverCommandList["RefineSoulFailed"] = self.__RefineSoulFailedMessage

if app.ENABLE_TARGET_AFFECT:

serverCommandList["AddTargetBoardAffect"] = self.AddTargetBoardAffect

serverCommandList["RemoveTargetBoardAffect"] = self.RemoveTargetBoardAffect

if app.ENABLE_SPECIAL_STORAGE:

serverCommandList["auto_stack_storage"] = self.interface.AutoStackStorage

self.serverCommander=stringCommander.Analyzer()

for serverCommandItem in serverCommandList.items():

self.serverCommander.SAFE_RegisterCallBack(

serverCommandItem[0], serverCommandItem[1]

)

def BINARY_ServerCommand_Run(self, line):

#dbg.TraceError(line)

try:

#print " BINARY_ServerCommand_Run", line

return self.serverCommander.Run(line)

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

def __TeleportQuestManager(self, questindex):

constInfo.TELEPORT_QUEST = questindex

def __BlockExpQuestManager(self, questindex):

constInfo.BLOCKEXP_QUEST = questindex

def __OffShopQuestManager(self, questindex):

constInfo.OFFSHOP_QUEST = questindex

def __ProcessPreservedServerCommand(self):

try:

command = net.GetPreservedServerCommand()

while command:

print " __ProcessPreservedServerCommand", command

self.serverCommander.Run(command)

command = net.GetPreservedServerCommand()

except RuntimeError, msg:

dbg.TraceError(msg)

return 0

def PartyHealReady(self):

self.interface.PartyHealReady()

def AskSafeboxPassword(self):

self.interface.AskSafeboxPassword()

# ITEM_MALL

def AskMallPassword(self):

self.interface.AskMallPassword()

def __ItemMall_Open(self):

self.interface.OpenItemMall();

def CommandCloseMall(self):

self.interface.CommandCloseMall()

# END_OF_ITEM_MALL

def AttrTransferMessage(self):

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

self.PopupMessage(localeInfo.COMB_ALERT)

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)

if app.ENABLE_SOUL_SYSTEM:

def __RefineSoulSuceededMessage(self):

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

self.PopupMessage(localeInfo.SOUL_REFINE_SUCCESS)

def __RefineSoulFailedMessage(self):

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

self.PopupMessage(localeInfo.SOUL_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 = [" شاب ", " بري ", " شجاع ", " بطولي "]

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

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

if app.ENABLE_CHEQUE_SYSTEM:

def __PrivateShop_PriceListNew(self, itemVNum, itemPrice, itemCheque):

uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice)

uiPrivateShopBuilder.SetPrivateShopItemCheque(itemVNum, itemCheque)

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

"chamber_of_wisdom_dungeon", )

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)

#Shop Decoration

def __OpenDecoration(self):

self.interface.OpenShopDecoration()

#Shop Decoration

def __XMasBoom_Enable(self, mode):

if "1"==mode:

if not self.__IsXMasMap():

return

print "XMAS_BOOM ON"

self.__DayMode_Update("dark")

self.enableXMasBoom = True

self.startTimeXMasBoom = app.GetTime()

else:

print "XMAS_BOOM OFF"

self.__DayMode_Update("light")

self.enableXMasBoom = False

def __XMasTree_Enable(self, grade):

print "XMAS_TREE ", grade

background.SetXMasTree(int(grade))

def __XMasSong_Enable(self, mode):

if "1"==mode:

print "XMAS_SONG ON"

XMAS_BGM = "xmas.mp3"

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

if musicInfo.fieldMusic != "":

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

musicInfo.fieldMusic=XMAS_BGM

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

else:

print "XMAS_SONG OFF"

if musicInfo.fieldMusic != "":

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

musicInfo.fieldMusic=musicInfo.METIN2THEMA

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

def __RestartDialog_Close(self):

self.interface.CloseRestartDialog()

def __Console_Enable(self):

constInfo.CONSOLE_ENABLE = True

self.consoleEnable = True

app.EnableSpecialCameraMode()

ui.EnablePaste(True)

## PrivateShop

def __PrivateShop_Open(self):

#self.interface.OpenPrivateShopInputNameDialog()

if app.WJ_ENABLE_TRADABLE_ICON:

self.uiNewShopCreate.privateShopBuilder.BindInterface(self.interface)

self.uiNewShopCreate.privateShopBuilder.SetInven(self.interface.wndInventory)

self.uiNewShopCreate.privateShopBuilder.wndInventory.BindWindow(self.interface.privateShopBuilder)

self.uiNewShop.Show()

def BINARY_PrivateShop_Appear(self, vid, text):

if chr.GetInstanceType(vid) in [chr.INSTANCE_TYPE_PLAYER, chr.INSTANCE_TYPE_NPC]:

self.interface.AppearPrivateShop(vid, text)

def BINARY_PrivateShop_Disappear(self, vid):

self.interface.DisappearPrivateShop(vid)

## DayMode

def __PRESERVE_DayMode_Update(self, mode):

if "light"==mode:

background.SetEnvironmentData(0)

elif "dark"==mode:

if not self.__IsXMasMap():

return

background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)

background.SetEnvironmentData(1)

def __DayMode_Update(self, mode):

if "light"==mode:

self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)

elif "dark"==mode:

if not self.__IsXMasMap():

return

self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToDark)

def __DayMode_OnCompleteChangeToLight(self):

background.SetEnvironmentData(0)

self.curtain.FadeIn()

def __DayMode_OnCompleteChangeToDark(self):

background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)

background.SetEnvironmentData(1)

self.curtain.FadeIn()

## XMasBoom

def __XMasBoom_Update(self):

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

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

return

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

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

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

self.indexXMasBoom += 1

for i in xrange(boomCount):

self.__XMasBoom_Boom()

def __XMasBoom_Boom(self):

x, y, z = player.GetMainCharacterPosition()

randX = app.GetRandom(-150, 150)

randY = app.GetRandom(-150, 150)

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

def __PartyRequestQuestion(self, vid):

vid = int(vid)

partyRequestQuestionDialog = uiCommon.QuestionDialog()

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

partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)

partyRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)

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

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

partyRequestQuestionDialog.Open()

partyRequestQuestionDialog.vid = vid

self.partyRequestQuestionDialog = partyRequestQuestionDialog

def __AnswerPartyRequest(self, answer):

if not self.partyRequestQuestionDialog:

return

vid = self.partyRequestQuestionDialog.vid

if answer:

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

else:

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

self.partyRequestQuestionDialog.Close()

self.partyRequestQuestionDialog = None

def __PartyRequestDenied(self):

self.PopupMessage(localeInfo.PARTY_REQUEST_DENIED)

if (app.WJ_COMBAT_ZONE):

def BINARY_CombatZone_Manager(self, tokens, arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0):

if tokens == "OpenWindow":

self.wndCombatZone.Open(arg1, arg2, arg3, arg4)

elif tokens == "RegisterRank":

self.wndCombatZone.RegisterRanking()

elif tokens == "StartFlashing":

if self.interface:

#self.interface.wndMiniMap.btnCombatZone.FlashEx()

pass

elif tokens == "RefreshShop":

if self.interface:

self.interface.dlgShop.SetCombatZonePoints(arg1)

self.interface.dlgShop.SetLimitCombatZonePoints(arg2, arg3)

def __EnableTestServerFlag(self):

app.EnableTestServerFlag()

def __InGameShop_Show(self, url):

if constInfo.IN_GAME_SHOP_ENABLE:

self.interface.OpenWebWindow(url)

# WEDDING

def __LoginLover(self):

if self.interface.wndMessenger:

self.interface.wndMessenger.OnLoginLover()

def __LogoutLover(self):

if self.interface.wndMessenger:

self.interface.wndMessenger.OnLogoutLover()

if self.affectShower:

self.affectShower.HideLoverState()

def __LoverNear(self):

if self.affectShower:

self.affectShower.ShowLoverState()

if app.ENABLE_ATTR_6TH_7TH_SYSTEM:

def attr_6th_7th(self):

self.interface.OpenAttr67AddDialog()

def Attr67Add(self):

self.wndPopupDialog = uiCommon.PopupDialog()

self.wndPopupDialog.SetText(localeInfo.ATTR_6TH_7TH_POSSIBILITY)

self.wndPopupDialog.Open()

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

if app.ENABLE_DEFENSE_WAVE:

def BINARY_Update_Mast_HP(self, hp):

self.interface.BINARY_Update_Mast_HP(int(hp))

def BINARY_Update_Mast_Window(self, i):

self.interface.BINARY_Update_Mast_Window(int(i))

def __Attr67AddWindow(self):

import uiattr67add

self.Attr67AddWindow = uiattr67add.Attr67AddWindow()

self.Attr67AddWindow.Show()

def __PlayMusic(self, flag, filename):

flag = int(flag)

if flag:

snd.FadeOutAllMusic()

musicInfo.SaveLastPlayFieldMusic()

snd.FadeInMusic("BGM/" + filename)

else:

snd.FadeOutAllMusic()

musicInfo.LoadLastPlayFieldMusic()

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

# END_OF_WEDDING

def GetInputStart(self):

constInfo.INPUT_IGNORE = 1

def GetInputStop(self):

constInfo.INPUT_IGNORE = 0

def _PartyEmotionsCMD(self, command):

cmd = command.split('/')

if cmd[0] == 'QID':

constInfo.PARTY_E['qid'] = int(cmd[1])

if app.ENABLE_SASH_SYSTEM:

def ActSash(self, iAct, bWindow):

if self.interface:

self.interface.ActSash(iAct, bWindow)

def AlertSash(self, bWindow):

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

if bWindow:

self.PopupMessage(localeInfo.SASH_DEL_SERVEITEM)

else:

self.PopupMessage(localeInfo.SASH_DEL_ABSORDITEM)

#ChangeCH

def Update(self, ch):

import serverInfo

net.SetServerInfo("%s, CH%s" % (serverInfo.SERVER_NAME, str(ch)))

constInfo.ch = int(ch)

#EndChangeCH

if app.ENABLE_SHOW_CHEST_DROP:

def BINARY_AddChestDropInfo(self, chestVnum, pageIndex, slotIndex, itemVnum, itemCount):

if self.interface:

self.interface.AddChestDropInfo(chestVnum, pageIndex, slotIndex, itemVnum, itemCount)

def BINARY_RefreshChestDropInfo(self, chestVnum):

if self.interface:

self.interface.RefreshChestDropInfo(chestVnum)

####SHOP SYSTEM#####

def NewShop(self):

if self.uiNewShop:

self.uiNewShop.Show()

def ShopClear(self):

if self.uiNewShop:

self.uiNewShop.HideAll()

constInfo.MyShops=[]

def ShopCostClear(self):

constInfo.shop_cost=[]

def ShopCost(self,id,time,time_val,price):

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

def ShopAdd(self,shop_id,shop_vid,szSign,gold,cheque,count,sold,days,date_close):

if self.uiNewShop:

shop={

"id":shop_id,

"vid":shop_vid,

"name":szSign.replace("\\"," ").replace("_","#"),

"gold":gold,

"cheque":cheque,

"sold":sold,

"items":int(count)-int(sold),

"days":days,

"time":date_close

}

self.uiNewShop.Load(shop)

constInfo.MyShops.append(shop)

def ShopItemClear(self):

if self.uiNewShop:

self.uiNewShop.ClearItems()

def ShopItem(self,data):

d=data.split("#")

id=d[0]

vnum=d[1]

dwVnum=d[2]

count=d[3]

slot=d[4]

price=d[5]

cheque=d[6]

s=d[7]

a=d[8]

sockets=[]

for key in s.split("|"):

sockets.append(int(key))

attrs=[]

for key in a.split("|"):

a=key.split(",")

attrs.append([int(a[0]),int(a[1])])

if self.uiNewShop:

self.uiNewShop.AddItem(slot,{"id":id,"vnum":vnum,"dwVnum":dwVnum,"count":count,"price":price,"cheque":cheque,"sockets":sockets,"attrs":attrs})

####GIFT SYSTEM#####

def gift_clear(self):

constInfo.gift_items={}

self.interface.ClearGift()

def gift_item(self, id, vnum, dwVnum, count, pos, date_add, give, reason, szSockets, szAttrs):

sockets=[]

for key in szSockets.split("|"):

sockets.append(int(key))

attrs=[]

for key in szAttrs.split("|"):

a=key.split(",")

attrs.append([int(a[0]),int(a[1])])

constInfo.gift_items[int(pos)]={"id":int(id),"vnum":int(vnum),"dwVnum":int(dwVnum),"count":int(count),"pos":int(pos),"date_add":int(date_add),"reason":reason.replace("_"," "),"give":give.replace("_"," "),"sockets":sockets,"attrs":attrs}

def gift_load(self):

self.interface.wndGiftBox.Refresh()

def gift_show(self,pages):

self.interface.wndGiftBox.pageNum=int(pages)

self.interface.OpenGift()

def OnClickSearch(self):

if not self.uiSearchShop.IsShow():

self.uiSearchShop.Show()

self.uiSearchShop.SetCenterPosition()

else:

self.uiSearchShop.Hide()

if app.ENABLE_HIDE_COSTUME_SYSTEM:

def COSTUME_HIDE_CLEAR(self):

self.interface.costume_hide_clear()

def COSTUME_HIDE_LIST(self,slot,index):

self.interface.costume_hide_list(slot,index)

def COSTUME_HIDE_LOAD(self):

self.interface.costume_hide_load()

def __muerto_guerras(self, id):

constInfo.muerto_guerras = int(id)

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("U:"+contador_usuarios_guerra)

def __muertos_guerra(self, muertos_guerra):

self.muertos_guerra.SetText("R:"+muertos_guerra)

def __caido_guerra(self, caido_guerra):

self.caido_guerra.SetText("M:"+caido_guerra)

def __mostrar_usuarios(self):

self.Espacio.Show()

self.contador_usuarios_guerra.Show()

self.muertos_guerra.Show()

self.caido_guerra.Show()

def __ocultar_usuarios(self):

self.Espacio.Hide()

self.contador_usuarios_guerra.Hide()

self.muertos_guerra.Hide()

self.caido_guerra.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()

if app.ENABLE_DUNGEON_INFO_SYSTEM:

def DungeonInfo(self, questindex):

constInfo.dungeonData["quest_index"] = questindex

def CleanDungeonInfo(self):

constInfo.dungeonInfo = []

def CleanDungeonRanking(self):

constInfo.dungeonRanking["ranking_list"] = []

def GetDungeonInfo(self, cmd):

cmd = cmd.split("#")

if cmd[0] == "INPUT":

constInfo.INPUT_IGNORE = int(cmd[1])

elif cmd[0] == "CMD":

net.SendQuestInputStringPacket(constInfo.dungeonData["quest_cmd"])

constInfo.dungeonData["quest_cmd"] = ""

else:

pass

def UpdateDungeonInfo(self, type, organization, levelLimit, partyMembers, mapName, mapIndex, mapCoordX, mapCoordY, cooldown, duration, entranceMapName, strengthBonusName, resistanceBonusName, itemVnum, BossVnum, finished, fastestTime, highestDamage):

type = int(type)

organization = int(organization)

levelLimit = int(levelLimit)

partyMembers = int(partyMembers)

mapName = str(mapName).replace("_", " ")

mapIndex = int(mapIndex)

mapCoordX = int(mapCoordX)

mapCoordY = int(mapCoordY)

cooldown = int(cooldown)

duration = int(duration)

entranceMapName = str(entranceMapName).replace("_", " ")

strengthBonusName = str(strengthBonusName).replace("_", " ")

resistanceBonusName = str(resistanceBonusName).replace("_", " ")

itemVnum = int(itemVnum)

BossVnum = int(BossVnum)

finished = int(finished)

fastestTime = int(fastestTime)

highestDamage = int(highestDamage)

constInfo.dungeonInfo.append(\

{

"type" : type,\

"organization" : organization,\

"level_limit" : levelLimit,\

"party_members" : partyMembers,\

"map" : mapName,\

"map_index" : mapIndex,\

"map_coord_x" : mapCoordX,\

"map_coord_y" : mapCoordY,\

"cooldown" : cooldown,\

"duration" : duration,\

"entrance_map" : entranceMapName,\

"strength_bonus" : strengthBonusName,\

"resistance_bonus" : resistanceBonusName,\

"item_vnum" : itemVnum,

"boss_vnum" : BossVnum,

"finished" : finished,

"fastest_time" : fastestTime,

"highest_damage" : highestDamage,

},

)

def UpdateDungeonRanking(self, data):

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

level = int(data.split("#")[2])

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

constInfo.dungeonRanking["ranking_list"].append([name, level, pointType],)

def TiempoDungeonInfoTorre(self, data):

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

tiempo_torre = int(data.split("#")[2])

constInfo.dungeontiempo["maptorre"] = int(index_torre)

constInfo.dungeontiempo["tiempo_torre"] = 0

def TiempoDungeonInfoCata(self, data):

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

tiempo_cata= int(data.split("#")[2])

constInfo.dungeontiempo["mapcata"] = int(index_cata)

constInfo.dungeontiempo["tiempo_cata"] = int(tiempo_cata)

def TiempoDungeonInfoNemere(self, data):

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

tiempo_nemere = int(data.split("#")[2])

constInfo.dungeontiempo["mapnemere"] = int(index_nemere)

constInfo.dungeontiempo["tiempo_nemere"] = int(tiempo_nemere)

def TiempoDungeonInfoPuertas(self, data):

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

tiempo_puertas = int(data.split("#")[2])

constInfo.dungeontiempo["mappuertas"] = int(index_puertas)

constInfo.dungeontiempo["tiempo_puertas"] = int(tiempo_puertas)

def TiempoDungeonInfoSlime(self, data):

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

tiempo_slime = int(data.split("#")[2])

constInfo.dungeontiempo["mapslime"] = int(index_slime)

constInfo.dungeontiempo["tiempo_slime"] = int(tiempo_slime)

def TiempoDungeonInfoArya(self, data):

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

tiempo_arya = int(data.split("#")[2])

constInfo.dungeontiempo["maparya"] = int(index_arya)

constInfo.dungeontiempo["tiempo_arya"] = int(tiempo_arya)

def TiempoDungeonInfoBosque(self, data):

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

tiempo_bosque = int(data.split("#")[2])

constInfo.dungeontiempo["mapbosque"] = int(index_bosque)

constInfo.dungeontiempo["tiempo_bosque"] = int(tiempo_bosque)

def TiempoDungeonInfoOrco(self, data):

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

tiempo_orco = int(data.split("#")[2])

constInfo.dungeontiempo["maporco"] = int(index_orco)

constInfo.dungeontiempo["tiempo_orco"] = int(tiempo_orco)

def TiempoDungeonInfoIsla(self, data):

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

tiempo_isla = int(data.split("#")[2])

constInfo.dungeontiempo["mapisla"] = int(index_isla)

constInfo.dungeontiempo["tiempo_isla"] = int(tiempo_isla)

def TiempoDungeonInfoBeran(self, data):

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

tiempo_beran = int(data.split("#")[2])

constInfo.dungeontiempo["mapberan"] = int(index_beran)

constInfo.dungeontiempo["tiempo_beran"] = int(tiempo_beran)

def TiempoDungeonInfoJotuns(self, data):

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

tiempo_jotuns = int(data.split("#")[2])

constInfo.dungeontiempo["mapochoa"] = int(index_jotuns)

constInfo.dungeontiempo["tiempo_ochoa"] = int(tiempo_jotuns)

def TiempoDungeonInfoHydra(self, data):

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

tiempo_hydra = int(data.split("#")[2])

constInfo.dungeontiempo["maphydra"] = int(index_hydra)

constInfo.dungeontiempo["tiempo_hydra"] = int(tiempo_hydra)

def TiempoDungeonInfoValentine(self, data):

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

tiempo_valentine = int(data.split("#")[2])

constInfo.dungeontiempo["mapvalentine"] = int(index_valentine)

constInfo.dungeontiempo["tiempo_valentine"] = int(tiempo_valentine)

def TiempoDungeonInfonavidad(self, data):

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

tiempo_navidad = int(data.split("#")[2])

constInfo.dungeontiempo["mapnavidad"] = int(index_navidad)

constInfo.dungeontiempo["tiempo_navidad"] = int(tiempo_navidad)

def TiempoDungeonInfoHallowen(self, data):

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

tiempo_hallowen = int(data.split("#")[2])

constInfo.dungeontiempo["maphallowen"] = int(index_hallowen)

constInfo.dungeontiempo["tiempo_hallowen"] = int(tiempo_hallowen)

def OpenDungeonRanking(self):

self.DungeonRank = uiDungeonInfo.DungeonRank()

self.DungeonRank.Open()

def opendungeon(self):

self.interface.ToggleDungeonInfoWindow()

def __regalo(self):

# self.interface.ToggleRegaloDiario()

self.ManagerGiftSystem("Show|")

def __RequestWarpToCharacter(self, name):

self.questionDialogWarp = uiCommon.QuestionDialogWithTimeLimit()

self.questionDialogWarp.SetText1(localeInfo.REQUEST_WARP_TO_CHARACTER % (name))

self.questionDialogWarp.SetTimeOverMsg(" عندما تكون متأكدًا ، حاول مرة أخرى ")

self.questionDialogWarp.SetTimeOverEvent(self.WarpCancelEvent, False)

self.questionDialogWarp.SetAcceptText(localeInfo.UI_ACCEPT)

self.questionDialogWarp.SetCancelText(localeInfo.UI_DENY)

self.questionDialogWarp.SetAcceptEvent(lambda arg = True: self.WarpAcceptEvent(name))

self.questionDialogWarp.SetCancelEvent(lambda arg = False: self.WarpCancelEvent(arg))

self.questionDialogWarp.Open(10)

self.questionDialogWarp.SetTop()

def WarpAcceptEvent(self, name):

net.SendMessengerSummonByNamePacket(name)

self.questionDialogWarp.Close()

def WarpCancelEvent(self, pregunta):

if pregunta == False:

self.questionDialogWarp.Close()

def __primera_muerte(self):

self.primera_muerte.Show()

snd.PlaySound("sound/ui/1_muerte.wav")

net.SendChatPacket("(1_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 SDropLitere(self, item_vnum, item_count, index, size):

constInfo.drop_letters[int(index)]={"iVnum":int(item_vnum),"iCount":int(item_count)}

constInfo.vnums_letters = int(size)

def send_status(self, status):

constInfo.E_LITERE_STATUS = int(status)

def day_night(self):

localtime = time.strftime("%H")

if day.nacht == 0:

if localtime == "01" or localtime == "02" or localtime == "03" or localtime == "04" or localtime == "05" or localtime == "06" or localtime == "07" or localtime == "00" or localtime == "23" or localtime == "22" or localtime == "21":

background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)

background.SetEnvironmentData(1)

day.tag = 0

day.nacht = 1

if day.tag == 0:

if localtime == "11" or localtime == "12" or localtime == "13" or localtime == "14" or localtime == "15" or localtime == "16" or localtime == "17":

background.SetEnvironmentData(0)

day.tag = 1

day.nacht = 0

if localtime == "08" or localtime == "09" or localtime == "10" or localtime == "18" or localtime == "19" or localtime == "20":

background.RegisterEnvironmentData(2, constInfo.ENVIRONMENT_EVENING)

background.SetEnvironmentData(2)

day.tag = 1

day.nacht = 0

if app.ENABLE_CHANGE_LOOK_SYSTEM:

def OpenChangeLookWindow(self):

self.ChangeLookWindow.Open()

# ITEM SHOP

def IShop_BanneData(self, src):

self.interface.IShop_BanneData(src)

def IShop_BestSellersItems(self, id, vnum):

self.interface.IShop_BestSellersItems(int(id), int(vnum))

def OpenItemShop(self):

self.interface.ShowN()

def IShop_Items(self, id, vnum, price, count, top, atrt0, atrv0, atrt1, atrv1, atrt2, atrv2, atrt3, atrv3, atrt4, atrv4, atrt5, atrv5, atrt6, atrv6, socket0, socket1, socket2, socket3, socket4, socket5, cat, desc):

self.interface.IShop_Items(int(id), int(vnum), int(price), int(count), int(top), int(atrt0), int(atrv0), int(atrt1), int(atrv1), int(atrt2), int(atrv2), int(atrt3), int(atrv3), int(atrt4), int(atrv4), int(atrt5), int(atrv5), int(atrt6), int(atrv6), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(cat), int(desc))

def IShop_Category(self, id, src):

self.interface.IShop_Category(id, src)

#chat.AppendChat(chat.CHAT_TYPE_INFO, str(id)+" - "+ str(src))

def IShop_tombola(self, id, vnum, count):

self.interface.IShop_tombola(int(id), int(vnum), 1)

def IShop_Update(self, coins, mds):

self.interface.IShop_Update(int(coins), int(mds))

def IShop_tombola_winner(self, pos):

self.interface.IShop_tombola_winner(int(pos))

def Ishop_Hisotry(self, id, vnum, cantidad, precio, origen):

self.interface.Ishop_Hisotry(int(id), int(vnum), int(cantidad), int(precio), str(origen))

# ITEM SHOP

if app.ENABLE_COSTUME_AURA:

def ClearDirRefine(self):

constInfo.ITEM_REFINE_DIR = {}

def SetDirRefine(self, i, vnum):

constInfo.ITEM_REFINE_DIR[i] = vnum

def AuraRefineInformation(self, result1, result2, item_vn_1, item_co_1, item_vn_2, item_co_2, item_vn_3, item_co_3, item_vn_4, item_co_4, price):

constInfo.REFINE_ITEM_RESULT_1 = result1

constInfo.REFINE_ITEM_RESULT_2 = result2

constInfo.ITEM_VNUM_1 = item_vn_1

constInfo.ITEM_COUNT_1 = item_co_1

constInfo.ITEM_VNUM_2 = item_vn_2

constInfo.ITEM_COUNT_2 = item_co_2

constInfo.ITEM_VNUM_3 = item_vn_3

constInfo.ITEM_COUNT_3 = item_co_3

constInfo.ITEM_VNUM_4 = item_vn_4

constInfo.ITEM_COUNT_4 = item_co_4

constInfo.PRICE_R = price

def OpenBoardRefine(self):

if (self.RefineAura.IsShow()):

self.RefineAura.Hide()

else:

self.RefineAura.Show()

if app.ENABLE_SWITCHBOT:

def RefreshSwitchbotWindow(self):

self.interface.RefreshSwitchbotWindow()

def RefreshSwitchbotItem(self, slot):

self.interface.RefreshSwitchbotItem(slot)

if app.ENABLE_CUBE_RENEWAL_WORLDARD:

def BINARY_CUBE_RENEWAL_OPEN(self):

if self.interface:

self.interface.BINARY_CUBE_RENEWAL_OPEN()

if app.ENVANTER_KILIT:

def envanter_kilitle_quest(self, value):

constInfo.ENVANTERRR_BLACK = int(value)

#if app.ENABLE_SUPPORT_SYSTEM:

def OpenSupportGui(self):

if constInfo.SUPPORTGUI == 0:

self.supportpg.Show()

self.supportpg.SetTop()

constInfo.SUPPORTGUI = 1

else:

self.supportpg.Close()

constInfo.SUPPORTGUI = 0

def SetSupportLevel(self, level):

self.supportpg.SetLevel(level)

constInfo.SUPPORTLEVEL = int(level)

def SetSupportName(self, name, name2):

self.supportpg.SetName(name, name2)

def SupportLeave(self):

self.supportpg.SetDefaultInfo()

self.supportpg.Close()

def SupportInt(self , ints):

self.supportpg.SetInt(ints)

def SetSupportExp(self, exp, exptot):

if int(exptot) > 0:

self.supportpg.SetExperience(exp, exptot)

self.supportpg.SetExperience(exp, exptot)

def SetSupportIcon(self, vnum):

if int(vnum) > 0:

self.supportpg.SetImageSlot(vnum)

self.supportpg.SetImageSlot(vnum)

def SetSupportSpeciality(self,speciality):

self.supportpg.SetSpeciality(speciality)

############################### GAYA SYSTEM ###############################

def OpenGuiGaya(self):

self.interface.OpenGuiGaya()

def GayaCheck(self):

self.interface.GayaCheck()

def OpenGuiGayaMarket(self):

self.interface.OpenGuiGayaMarket()

def GayaMarketItems(self,vnums,gaya,count):

self.interface.GayaMarketItems(vnums,gaya,count)

def GayaMarketSlotsDesblock(self,slot0,slot1,slot2,slot3,slot4,slot5):

self.interface.GayaMarketSlotsDesblock(slot0,slot1,slot2,slot3,slot4,slot5)

def GayaMarketClear(self):

self.interface.GayaMarketClear()

def GayaTimeMarket(self, time):

self.interface.GayaTime(time)

######################################## END GAYA SYSTEM ################################

def ManagerGiftSystem(self, cmd):

cmd = cmd.split("|")

if cmd[0] == "Show":

self.wnddailygift.Show()

elif cmd[0] == "DeleteRewards":

self.wnddailygift.DeleteRewards()

elif cmd[0] == "SetDailyReward":

self.wnddailygift.SetDailyReward(cmd[1]) # رقم المكافأة

elif cmd[0] == "SetTime":

self.wnddailygift.SetTime(cmd[1]) # الوقت بأعداد كبيرة

elif cmd[0] == "SetReward":

self.wnddailygift.SetReward(cmd[1], cmd[2]) #hacer un array con los items

elif cmd[0] == "SetRewardDone":

self.wnddailygift.SetRewardDone()