- Katılım
- 25 Ocak 2020
- Konular
- 41
- Mesajlar
- 229
- Online süresi
- 14g 70322s
- Reaksiyon Skoru
- 31
- Altın Konu
- 0
- Başarım Puanı
- 75
- TM Yaşı
- 6 Yıl 2 Ay 26 Gün
- MmoLira
- 282
- DevLira
- 3
Metin2 EP, Valorant VP dahil tüm oyun ürünlerini en uygun fiyatlarla bulabilir, Item ve Karakterlerinizi hızlıca satabilirsiniz. HEMEN TIKLA!
S.a beyler tunganın paylaştıgı hızlı biyolog sistemini kurdumda böle bi sysser alıyorum yardımcı olucak varmı
0419 22:50:11458 :: Traceback (most recent call last):
0419 22:50:11458 :: File "networkModule.py", line 240, in SetGamePhase
0419 22:50:11459 :: File "game.py", line 197, in __init__
0419 22:50:11459 :: File "game.py", line 2855, in __ServerCommand_Build
0419 22:50:11459 :: AttributeError
0419 22:50:11459 :: :
0419 22:50:11459 :: 'GameWindow' object has no attribute 'BiyologLvBildirim'
0419 22:50:11458 :: Traceback (most recent call last):
0419 22:50:11458 :: File "networkModule.py", line 240, in SetGamePhase
0419 22:50:11459 :: File "game.py", line 197, in __init__
0419 22:50:11459 :: File "game.py", line 2855, in __ServerCommand_Build
0419 22:50:11459 :: AttributeError
0419 22:50:11459 :: :
0419 22:50:11459 :: 'GameWindow' object has no attribute 'BiyologLvBildirim'
game.py:
import os
import app
import dbg
import grp
import item
import background
import chr
import chrmgr
import player
import chat
import translate
import textTail
import event
import uibonuspage
from switchbot import Bot
import uipetsystem
import snd
import net
import effect
import wndMgr
import fly
import systemSetting
import quest
import guild
import skill
import messenger
import uimarbleshop
import localeInfo
import constInfo
import exchange
import uiHealth
import ime
import constInfo2
import mounting
import ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
import uiTaskbar
import uiteleport
import uiguildstorage
import schicksalrad
# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LIST
import time
# 5Lv Oto Bec Sistemi
import savbec
import surabec
import ninjabec
import samanbec
import lycanbec
import BKTrade
import serverInfo
import mouseModule
import consoleModule
import localeInfo
import gameInfo
import uinpcekran
import uikygnitemsil
import playerSettingModule
import interfaceModule
import musicInfo
import debugInfo
import stringCommander
import uiPrivateShopSearch
from _weakref import proxy
# TEXTTAIL_LIVINGTIME_CONTROL
#if localeInfo.IsJAPAN():
# app.SetTextTailLivingTime(8.0)
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL
# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = None
svsidedia = None
svsidedi_cp = ""
from svsideoi import SvsideDialog
import binascii
import guildwarkillcounter
import uiGuild
if localeInfo.IsEUROPE():
SCREENSHOT_CWDSAVE = TRUE
if localeInfo.IsCIBN10():
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = "YT2W"
if app.WJ_OFFLINESHOP_SYSTEM:
import uiOfflineShopBuilder
import uiOfflineShop
cameraDistance = 1550.0
cameraPitch = 27.0
cameraRotation = 0.0
cameraHeight = 100.0
testAlignment = 0
BPisLodaded = 0
pet_gui_activado = 0
bonuspp = 0
class GameWindow(ui.ScriptWindow):
def __init__(self, stream):
ui.ScriptWindow.__init__(self, "GAME")
self.SetWindowName("game")
net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
player.SetGameWindow(self)
global svsidedia
if svsidedia == None:
svsidedia = SvsideDialog()
svsidedia.Board.Hide()
self.quickSlotPageIndex = 0
self.lastPKModeSendedTime = 0
self.LastBoniSwitcherId = 0
self.pressNumber = None
self.guildWarQuestionDialog = None
self.interface = None
self.targetBoard = None
self.console = None
self.mapNameShower = None
self.affectShower = None
self.playerGauge = None
self.endTime = 0
self.PrivateShopSearch = None
self.petInventoryWnd = None
self.boniSwitcherWnd = []
constInfo.BONI_SWITCHER_LOAD = FALSE
self.itemShopWnd = None
#import uiBoniSwitcher
#for i in xrange(constInfo.SWITCHER_COUNT):
#self.boniSwitcherWnd.append(uiBoniSwitcher.BoniSwitcherDialog(i))
#self.boniSwitcherWnd[i].SetChangeBonusSwitcherEvent(self.__BoniSwitcherShow)
#self.boniSwitcherWnd[i].GAMESetBoniSwitcherCheckEvent(self.__BoniSwitcherCheckEvent)
self.stream=stream
self.interface = interfaceModule.Interface()
self.interface.SetStream(self.stream)
self.interface.MakeInterface()
self.interface.SetOpenBoniSwitcherEvent(self.__BoniSwitcherShow)
self.interface.ShowDefaultWindows()
self.stream.isAutoSelect = 0
self.curtain = uiPhaseCurtain.PhaseCurtain()
self.curtain.speed = 0.03
self.curtain.Hide()
self.BKTradeSys = BKTrade.BKTrade()
self.BKTradeSys.Close()
self.GuildStorageWindow = uiguildstorage.GuildStorage()
self.targetBoard = uiTarget.TargetBoard()
self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog))
self.targetBoard.Hide()
self.petmain = uipetsystem.PetSystemMain()
self.petmini = uipetsystem.PetSystemMini()
self.console = consoleModule.ConsoleWindow()
self.console.BindGameClass(self)
self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200)
self.console.Hide()
self.mapNameShower = uiMapNameShower.MapNameShower()
self.LoncaGecmisi = uiGuild.LoncaGecmisUI()
self.LoncaGecmisi.Hide()
self.affectShower = uiAffectShower.AffectShower()
self.wndMarbleShop = uimarbleshop.MarbleShopWindow()
self.playerGauge = uiPlayerGauge.PlayerGauge(self)
self.playerGauge.Hide()
self.guildScoreCounter = guildwarkillcounter.MessageQueue()
#wj 2014.1.2. ESCÅ°¸¦ ´©¸¦ ½Ã ¿ì¼±ÀûÀ¸·Î DropQuestionDialog¸¦ ²ôµµ·Ï ¸¸µé¾ú´Ù. ÇÏÁö¸¸ óÀ½¿¡ itemDropQuestionDialog°¡ ¼±¾ğµÇ¾î ÀÖÁö ¾Ê¾Æ ERROR°¡ ¹ß»ıÇÏ¿© init¿¡¼ ¼±¾ğ°ú µ¿½Ã¿¡ ÃʱâÈ ½ÃÅ´.
self.itemDropQuestionDialog = None
self.__SetQuickSlotMode()
self.__ServerCommand_Build()
self.__ProcessPreservedServerCommand()
self.teleport = uiteleport.TeleportWindow()
self.MountingSystem = mounting.MountWindow()
self.SchicksalRad = schicksalrad.RadDesSchicksals()
def __del__(self):
player.SetGameWindow(0)
net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)
ui.ScriptWindow.__del__(self)
def Open(self):
app.SetFrameSkip(1)
self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())
#self.Activare_Menu = ui.Button()
#self.Activare_Menu.SetPosition(wndMgr.GetScreenWidth()-10,wndMgr.GetScreenHeight()/2-54)
#self.Activare_Menu.SetUpVisual("Jin_Han/1_1.tga")
#self.Activare_Menu.SetOverVisual("Jin_Han/1_2.tga")
#self.Activare_Menu.SetDownVisual("Jin_Han/1_3.tga")
#self.Activare_Menu.SetEvent(ui.__mem_func__(self.__menubg))
#self.Activare_Menu.SetToolTipText("Deschide Meniu.")
#self.Activare_Menu.Show()
# self.Dezactivare_Menu = ui.Button()
# self.Dezactivare_Menu.SetPosition(wndMgr.GetScreenWidth()-60,wndMgr.GetScreenHeight()/2-54)
# self.Dezactivare_Menu.SetUpVisual("Jin_Han/2_1.tga")
# self.Dezactivare_Menu.SetOverVisual("Jin_Han/2_2.tga")
# self.Dezactivare_Menu.SetDownVisual("Jin_Han/2_3.tga")
# self.Activare_Menu.SetToolTipText("Inchide Meniu.")
# self.Dezactivare_Menu.SetEvent(ui.__mem_func__(self.__menubg))
# self.Dezactivare_Menu.Hide()
# menu_bg = ui.AniImageBox()
#menu_bg.AppendImage("Jin_Han/fundal.tga")
# self.menu_bg = menu_bg
# self.menu_bg.SetPosition(wndMgr.GetScreenWidth()-50,wndMgr.GetScreenHeight()/2-91)
# self.menu_bg.SetSize(60, 250)
# self.menu_bg.Hide()
# self.Bonusuri = ui.Button()
# self.Bonusuri.SetParent(self.menu_bg)
# self.Bonusuri.SetPosition(9, 10)
# self.Bonusuri.SetUpVisual("Jin_Han/1.tga")
# self.Bonusuri.SetOverVisual("Jin_Han/2.tga")
## self.Bonusuri.SetDownVisual("Jin_Han/1.tga")
# self.Bonusuri.SetToolTipText("Deschide Pagina De Bonusuri.")
## self.Bonusuri.SetEvent(ui.__mem_func__(self.__BonusPage))
# self.Bonusuri.Show()
# self.StatusUp = ui.Button()
# self.StatusUp.SetParent(self.menu_bg)
# self.StatusUp.SetPosition(9, 44)
# self.StatusUp.SetUpVisual("Jin_Han/3.tga")
# self.StatusUp.SetOverVisual("Jin_Han/4.tga")
# self.StatusUp.SetDownVisual("Jin_Han/3.tga")
# self.StatusUp.SetToolTipText("Adauga puncte la status.")
# self.StatusUp.SetEvent(ui.__mem_func__(self.__JINHAN))
# self.StatusUp.Show()
# self.Depozit = ui.Button()
# self.Depozit.SetParent(self.menu_bg)
# self.Depozit.SetPosition(9, 76)
# self.Depozit.SetUpVisual("Jin_Han/5.tga")
# self.Depozit.SetOverVisual("Jin_Han/6.tga")
# self.Depozit.SetDownVisual("Jin_Han/5.tga")
# self.Depozit.SetToolTipText("Deschide Depozit.")
# self.Depozit.SetEvent(self.__activare_depozit)
# self.Depozit.Show()
# self.AntiExp = ui.Button()
# self.AntiExp.SetParent(self.menu_bg)
# self.AntiExp.SetPosition(9, 108)
# self.AntiExp.SetUpVisual("Jin_Han/7.tga")
# self.AntiExp.SetOverVisual("Jin_Han/8.tga")
# self.AntiExp.SetDownVisual("Jin_Han/7.tga")
# self.AntiExp.SetToolTipText("Activeaza Inel Anti Exp.")
# self.AntiExp.SetEvent(self.__activare_antiexp)
# self.AntiExp.Show()
# self.Teleporter = ui.Button()
# self.Teleporter.SetParent(self.menu_bg)
# self.Teleporter.SetPosition(9, 140)
# self.Teleporter.SetUpVisual("Jin_Han/9.tga")
# self.Teleporter.SetOverVisual("Jin_Han/10.tga")
# self.Teleporter.SetDownVisual("Jin_Han/9.tga")
# self.Teleporter.SetToolTipText("Deschide Inel De Teleportare.")
# self.Teleporter.SetEvent(self.__activare_teleporter)
# self.Teleporter.Show()
# self.DeschidereMagazin = ui.Button()
# self.DeschidereMagazin.SetParent(self.menu_bg)
# self.DeschidereMagazin.SetPosition(9, 204)
# self.DeschidereMagazin.SetUpVisual("Jin_Han/sopen.tga")
# self.DeschidereMagazin.SetOverVisual("Jin_Han/sopen1.tga")
# self.DeschidereMagazin.SetDownVisual("Jin_Han/sopen2.tga")
# self.DeschidereMagazin.SetToolTipText("Deschidere Offline Shop.")
# self.DeschidereMagazin.SetEvent(self.__DeschidereMagazin)
# self.DeschidereMagazin.Show()
# self.Switch = ui.Button()
# self.Switch.SetParent(self.menu_bg)
# self.Switch.SetPosition(9, 172)
# self.Switch.SetUpVisual("Jin_Han/s1.tga")
# self.Switch.SetOverVisual("Jin_Han/s1.tga")
# self.Switch.SetDownVisual("Jin_Han/s2.tga")
# self.Switch.SetToolTipText("Switchbot.")
# self.Switch.SetEvent(ui.__mem_func__(self.__toggleSwitchbot))
# self.Switch.Show()
#meniuasd
## self.Activare_Menu2 = ui.Button()
# self.Activare_Menu2.SetPosition(wndMgr.GetScreenWidth()-270,wndMgr.GetScreenHeight()/1-47)
# self.Activare_Menu2.SetUpVisual("Jin_Han/p1_1.tga")
# self.Activare_Menu2.SetOverVisual("Jin_Han/p1_2.tga")
# self.Activare_Menu2.SetDownVisual("Jin_Han/p1_3.tga")
# self.Activare_Menu2.SetEvent(ui.__mem_func__(self.__menubg2))
# self.Activare_Menu2.SetToolTipText("Deschide Meniu Cu Urmatoarele Atribute: Offline Shop/Info Shop/Retrage Yang/Inchide Shop/Switchbot")
# self.Activare_Menu2.Show()
# self.Dezactivare_Menu2 = ui.Button()
# self.Dezactivare_Menu2.SetPosition(wndMgr.GetScreenWidth()-270,wndMgr.GetScreenHeight()/1-230)
# self.Dezactivare_Menu2.SetUpVisual("Jin_Han/p1_4.tga")
# self.Dezactivare_Menu2.SetOverVisual("Jin_Han/p1_5.tga")
# self.Dezactivare_Menu2.SetDownVisual("Jin_Han/p1_6.tga")
# self.Dezactivare_Menu2.SetToolTipText("Inchidere Meniu")
# self.Dezactivare_Menu2.SetEvent(ui.__mem_func__(self.__menubg2))
# self.Dezactivare_Menu2.Hide()
# menu_bg2 = ui.AniImageBox()
# menu_bg2.AppendImage("Jin_Han/fundal.tga")
# self.menu_bg2 = menu_bg2
# self.menu_bg2.SetPosition(wndMgr.GetScreenWidth()-240,wndMgr.GetScreenHeight()/1-220)
# self.menu_bg2.SetSize(50, 150)
# self.menu_bg2.Hide()
# self.RetrageYang = ui.Button()
# self.RetrageYang.SetParent(self.menu_bg2)
# self.RetrageYang.SetPosition(9, 10)
# self.RetrageYang.SetUpVisual("Jin_Han/smoney.tga")
# self.RetrageYang.SetOverVisual("Jin_Han/smoney1.tga")
# self.RetrageYang.SetDownVisual("Jin_Han/smoney2.tga")
# self.RetrageYang.SetToolTipText("Retrage Yang/Innformatii Shop/Inchide Shop.")
# self.RetrageYang.SetEvent(ui.__mem_func__(self.__RetrageYang))
# self.RetrageYang.Show()
# self.DeschidereMagazin = ui.Button()
# self.DeschidereMagazin.SetParent(self.menu_bg2)
# self.DeschidereMagazin.SetPosition(9, 42)
# self.DeschidereMagazin.SetUpVisual("Jin_Han/sopen.tga")
# self.DeschidereMagazin.SetOverVisual("Jin_Han/sopen1.tga")
# self.DeschidereMagazin.SetDownVisual("Jin_Han/sopen2.tga")
# self.DeschidereMagazin.SetToolTipText("Deschidere Offline Shop.")
# self.DeschidereMagazin.SetEvent(self.__DeschidereMagazin)
# self.DeschidereMagazin.Show()
# self.Switch = ui.Button()
# self.Switch.SetParent(self.menu_bg2)
# self.Switch.SetPosition(9, 74)
# self.Switch.SetUpVisual("Jin_Han/s1.tga")
# self.Switch.SetOverVisual("Jin_Han/s1.tga")
# self.Switch.SetDownVisual("Jin_Han/s2.tga")
# self.Switch.SetToolTipText("Switchbot.")
# self.Switch.SetEvent(ui.__mem_func__(self.__toggleSwitchbot))
# self.Switch.Show()
Espacio = ui.AniImageBox()
Espacio.SetWindowHorizontalAlignLeft()
Espacio.SetWindowVerticalAlignTop()
Espacio.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")
self.Espacio = Espacio
self.Espacio.SetPosition(10, 80)
self.contador_usuarios_guerra = ui.TextLine()
self.contador_usuarios_guerra.SetWindowHorizontalAlignLeft()
self.contador_usuarios_guerra.SetWindowVerticalAlignTop()
self.contador_usuarios_guerra.SetDefaultFontName()
self.contador_usuarios_guerra.SetPosition(24+8, 37+2 +40)
self.contador_usuarios_guerra.SetText("0")
self.contador_usuarios_guerra.SetOutline()
self.muertos_guerra = ui.TextLine()
self.muertos_guerra.SetWindowHorizontalAlignLeft()
self.muertos_guerra.SetWindowVerticalAlignTop()
self.muertos_guerra.SetDefaultFontName()
self.muertos_guerra.SetPosition(24+8, 47+2+40)
self.muertos_guerra.SetText("0")
self.muertos_guerra.SetOutline()
self.caido_guerra = ui.TextLine()
self.caido_guerra.SetWindowHorizontalAlignLeft()
self.caido_guerra.SetWindowVerticalAlignTop()
self.caido_guerra.SetDefaultFontName()
self.caido_guerra.SetPosition(24+8, 57+2+40)
self.caido_guerra.SetText("0")
self.caido_guerra.SetOutline()
self.usuarios_guerra = ui.TextLine()
self.usuarios_guerra.SetWindowHorizontalAlignLeft()
self.usuarios_guerra.SetWindowVerticalAlignTop()
self.usuarios_guerra.SetDefaultFontName()
self.usuarios_guerra.SetPosition(10+8, 37+2+40)
self.usuarios_guerra.SetText("U:")
self.usuarios_guerra.SetOutline()
self.ranking_guerra = ui.TextLine()
self.ranking_guerra.SetWindowHorizontalAlignLeft()
self.ranking_guerra.SetWindowVerticalAlignTop()
self.ranking_guerra.SetDefaultFontName()
self.ranking_guerra.SetPosition(10+8, 47+2+40)
self.ranking_guerra.SetText("R:")
self.ranking_guerra.SetOutline()
self.ranking_caido = ui.TextLine()
self.ranking_caido.SetWindowHorizontalAlignLeft()
self.ranking_caido.SetWindowVerticalAlignTop()
self.ranking_caido.SetDefaultFontName()
self.ranking_caido.SetPosition(10 +8, 57 +2+40)
self.ranking_caido.SetText("M:")
self.ranking_caido.SetOutline()
Medallas_gui = ui.AniImageBox()
Medallas_gui.SetWindowHorizontalAlignLeft()
Medallas_gui.SetWindowVerticalAlignTop()
Medallas_gui.AppendImage("d:/ymir work/ui/pattern/medallas/espacio.dds")
self.Medallas_gui = Medallas_gui
self.Medallas_gui.SetPosition(10, 40)
self.muertes = ui.TextLine()
self.muertes.SetWindowHorizontalAlignLeft()
self.muertes.SetWindowVerticalAlignTop()
self.muertes.SetDefaultFontName()
self.muertes.SetPosition(24, 51)
self.muertes.SetText("0")
self.muertes.SetOutline()
self.primera_muerte = ui.AniImageBox()
self.primera_muerte.SetWindowHorizontalAlignLeft()
self.primera_muerte.SetWindowVerticalAlignTop()
self.primera_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/1.dds")
self.primera_muerte.SetPosition(43, 40)
self.doble_muerte = ui.AniImageBox()
self.doble_muerte.SetWindowHorizontalAlignLeft()
self.doble_muerte.SetWindowVerticalAlignTop()
self.doble_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/2.dds")
self.doble_muerte.SetPosition(43 + 33, 40)
self.triple_muerte = ui.AniImageBox()
self.triple_muerte.SetWindowHorizontalAlignLeft()
self.triple_muerte.SetWindowVerticalAlignTop()
self.triple_muerte.AppendImage("d:/ymir work/ui/pattern/medallas/3.dds")
self.triple_muerte.SetPosition(43 + 33 + 33, 40)
self.exterminio = ui.AniImageBox()
self.exterminio.SetWindowHorizontalAlignLeft()
self.exterminio.SetWindowVerticalAlignTop()
self.exterminio.AppendImage("d:/ymir work/ui/pattern/medallas/4.dds")
self.exterminio.SetPosition(43+ 33+ 33 + 33, 40)
self.muertacular = ui.AniImageBox()
self.muertacular.SetWindowHorizontalAlignLeft()
self.muertacular.SetWindowVerticalAlignTop()
self.muertacular.AppendImage("d:/ymir work/ui/pattern/medallas/5.dds")
self.muertacular.SetPosition(43+ 33+ 33+ 33 + 33, 40)
self.bestialidad = ui.AniImageBox()
self.bestialidad.SetWindowHorizontalAlignLeft()
self.bestialidad.SetWindowVerticalAlignTop()
self.bestialidad.AppendImage("d:/ymir work/ui/pattern/medallas/6.dds")
self.bestialidad.SetPosition(43+ 33+ 33+ 33+ 33 + 33, 40)
self.salvajada = ui.AniImageBox()
self.salvajada.SetWindowHorizontalAlignLeft()
self.salvajada.SetWindowVerticalAlignTop()
self.salvajada.AppendImage("d:/ymir work/ui/pattern/medallas/7.dds")
self.salvajada.SetPosition(43+ 33+ 33+ 33+ 33+ 33 + 33, 40)
self.catastrofe = ui.AniImageBox()
self.catastrofe.SetWindowHorizontalAlignLeft()
self.catastrofe.SetWindowVerticalAlignTop()
self.catastrofe.AppendImage("d:/ymir work/ui/pattern/medallas/8.dds")
self.catastrofe.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)
self.apocalipsis = ui.AniImageBox()
self.apocalipsis.SetWindowHorizontalAlignLeft()
self.apocalipsis.SetWindowVerticalAlignTop()
self.apocalipsis.AppendImage("d:/ymir work/ui/pattern/medallas/9.dds")
self.apocalipsis.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)
self.lluvia_muertos = ui.AniImageBox()
self.lluvia_muertos.SetWindowHorizontalAlignLeft()
self.lluvia_muertos.SetWindowVerticalAlignTop()
self.lluvia_muertos.AppendImage("d:/ymir work/ui/pattern/medallas/10.dds")
self.lluvia_muertos.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)
self.super_increible = ui.AniImageBox()
self.super_increible.SetWindowHorizontalAlignLeft()
self.super_increible.SetWindowVerticalAlignTop()
self.super_increible.AppendImage("d:/ymir work/ui/pattern/medallas/11.dds")
self.super_increible.SetPosition(43+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33+ 33 + 33, 40)
#Fin menu
self.quickSlotPageIndex = 0
self.switchbot = Bot()
self.switchbot.Hide()
self.PickingCharacterIndex = -1
self.PickingItemIndex = -1
self.consoleEnable = FALSE
self.isShowDebugInfo = FALSE
self.ShowNameFlag = FALSE
self.enableXMasBoom = FALSE
self.startTimeXMasBoom = 0.0
self.indexXMasBoom = 0
global cameraDistance, cameraPitch, cameraRotation, cameraHeight
app.SetCamera(cameraDistance, cameraPitch, cameraRotation, cameraHeight)
constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()
constInfo.SET_DEFAULT_CHRNAME_COLOR()
constInfo.SET_DEFAULT_FOG_LEVEL()
constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENABLE()
constInfo.SET_DEFAULT_USE_ITEM_WEAPON_TABLE_ATTACK_BONUS()
constInfo.SET_DEFAULT_USE_SKILL_EFFECT_ENABLE()
# TWO_HANDED_WEAPON_ATTACK_SPEED_UP
constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP
import event
event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)
textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)
if constInfo.PVPMODE_TEST_ENABLE:
self.testPKMode = ui.TextLine()
self.testPKMode.SetFontName(localeInfo.UI_DEF_FONT)
self.testPKMode.SetPosition(0, 15)
self.testPKMode.SetWindowHorizontalAlignCenter()
self.testPKMode.SetHorizontalAlignCenter()
self.testPKMode.SetFeather()
self.testPKMode.SetOutline()
self.testPKMode.Show()
self.testAlignment = ui.TextLine()
self.testAlignment.SetFontName(localeInfo.UI_DEF_FONT)
self.testAlignment.SetPosition(0, 35)
self.testAlignment.SetWindowHorizontalAlignCenter()
self.testAlignment.SetHorizontalAlignCenter()
self.testAlignment.SetFeather()
self.testAlignment.SetOutline()
self.testAlignment.Show()
self.__BuildKeyDict()
self.__BuildDebugInfo()
# PRIVATE_SHOP_PRICE_LIST
uiPrivateShopBuilder.Clear()
# END_OF_PRIVATE_SHOP_PRICE_LIST
if app.WJ_OFFLINESHOP_SYSTEM:
uiOfflineShopBuilder.Clear()
# UNKNOWN_UPDATE
exchange.InitTrading()
# END_OF_UNKNOWN_UPDATE
## Sound
snd.SetMusicVolume(systemSetting.GetMusicVolume()*net.GetFieldMusicVolume())
snd.SetSoundVolume(systemSetting.GetSoundVolume())
netFieldMusicFileName = net.GetFieldMusicFileName()
if netFieldMusicFileName:
snd.FadeInMusic("BGM/" + netFieldMusicFileName)
elif musicInfo.fieldMusic != "":
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
self.__SetQuickSlotMode()
self.__SelectQuickPage(self.quickSlotPageIndex)
self.SetFocus()
self.Show()
app.ShowCursor()
net.SendEnterGamePacket()
if app.WJ_SECURITY_SYSTEM:
if constInfo.open_security == 0:
net.SendChatPacket("/open_security")
constInfo.open_security = 1
if app.PARTY_MATCH:
constInfo.KILITLE = 0
# START_GAME_ERROR_EXIT
try:
self.StartGame()
except:
import exception
exception.Abort("GameWindow.Open")
# END_OF_START_GAME_ERROR_EXIT
# NPC°¡ Å¥ºê½Ã½ºÅÛÀ¸·Î ¸¸µé ¼ö ÀÖ´Â ¾ÆÀÌÅÛµéÀÇ ¸ñ·ÏÀ» ij½Ì
# ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
self.cubeInformation = {}
self.currentCubeNPC = 0
self.acceInformation = {}
self.currentAcceNPC = 0
for i in xrange(10):
if systemSetting.IsSnowTexturesMode():
if background.GetCurrentMapName():
snow_maps = [
"metin2_map_a1",
"metin2_map_b1",
"metin2_map_c1"
]
snow_maps_textures = {
"metin2_map_a1" : "textureset\metin2_a1_snow.txt",
"metin2_map_b1" : "textureset\metin2_b1_snow.txt",
"metin2_map_c1" : "textureset\metin2_c1_snow.txt", }
if str(background.GetCurrentMapName()) in snow_maps:
background.TextureChange(snow_maps_textures[str(background.GetCurrentMapName())])
def Close(self):
self.Hide()
global cameraDistance, cameraPitch, cameraRotation, cameraHeight
(cameraDistance, cameraPitch, cameraRotation, cameraHeight) = app.GetCamera()
if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)
self.onPressKeyDict = None
self.onClickKeyDict = None
uiPrivateShopBuilder.Clear()
chat.Close()
# self.menu_bg.Hide()
# self.Dezactivare_Menu.Hide()
# self.Activare_Menu.Hide()
# self.menu_bg2.Hide()
# self.Dezactivare_Menu2.Hide()
# self.Activare_Menu2.Hide()
snd.StopAllSound()
grp.InitScreenEffect()
chr.Destroy()
textTail.Clear()
quest.Clear()
background.Destroy()
guild.Destroy()
messenger.Destroy()
skill.ClearSkillData()
wndMgr.Unlock()
mouseModule.mouseController.DeattachObject()
if self.guildWarQuestionDialog:
self.guildWarQuestionDialog.Close()
self.guildNameBoard = None
self.partyRequestQuestionDialog = None
self.warPlayerCheckQuestionDialog = None
self.partyInviteQuestionDialog = None
self.guildInviteQuestionDialog = None
self.guildWarQuestionDialog = None
self.messengerAddFriendQuestion = None
# UNKNOWN_UPDATE
self.itemDropQuestionDialog = None
# END_OF_UNKNOWN_UPDATE
# QUEST_CONFIRM
self.confirmDialog = None
# END_OF_QUEST_CONFIRM
self.PrintCoord = None
self.FrameRate = None
self.Pitch = None
self.Splat = None
self.TextureNum = None
self.ObjectNum = None
self.ViewDistance = None
self.PrintMousePos = None
self.ClearDictionary()
self.petmain.Close()
self.petmini.Close()
self.playerGauge = None
self.mapNameShower = None
self.LoncaGecmisi = None
self.affectShower = None
#uiPrivateShopBuilder.Clear()
if self.SchicksalRad.IsShow():
self.SchicksalRad.Open()
if self.MountingSystem.IsShow():
self.MountingSystem.Open()
if self.console:
self.console.BindGameClass(0)
self.console.Close()
self.console=None
if self.targetBoard:
self.targetBoard.Destroy()
self.targetBoard = None
if self.wndMarbleShop:
self.wndMarbleShop.Hide()
if self.itemShopWnd:
self.itemShopWnd.Destroy()
self.itemShopWnd = None
if self.interface:
self.interface.HideAllWindows()
self.interface.Close()
self.interface=None
for i in xrange(len(self.boniSwitcherWnd)):
if self.boniSwitcherWnd[i]:
self.boniSwitcherWnd[i].Destroy()
self.boniSwitcherWnd[i] = None
if self.petInventoryWnd:
self.petInventoryWnd.Destroy()
self.petInventoryWnd = None
player.ClearSkillDict()
player.ResetCameraRotation()
self.KillFocus()
app.HideCursor()
print "---------------------------------------------------------------------------- CLOSE GAME WINDOW"
def __BuildKeyDict(self):
onPressKeyDict = {}
##PressKey ´Â ´©¸£°í ÀÖ´Â µ¿¾È °è¼Ó Àû¿ëµÇ´Â Å°ÀÌ´Ù.
## ¼ıÀÚ ´ÜÃàÅ° Äü½½·Ô¿¡ ÀÌ¿ëµÈ´Ù.(ÀÌÈÄ ¼ıÀڵ鵵 Äü ½½·Ô¿ë ¿¹¾à)
## F12 ´Â Ŭ¶ó µğ¹ö±×¿ë Å°À̹ǷΠ¾²Áö ¾Ê´Â °Ô ÁÁ´Ù.
onPressKeyDict[app.DIK_1] = lambda : self.__PressNumKey(1)
onPressKeyDict[app.DIK_2] = lambda : self.__PressNumKey(2)
onPressKeyDict[app.DIK_3] = lambda : self.__PressNumKey(3)
onPressKeyDict[app.DIK_4] = lambda : self.__PressNumKey(4)
onPressKeyDict[app.DIK_5] = lambda : self.__PressNumKey(5)
onPressKeyDict[app.DIK_6] = lambda : self.__PressNumKey(6)
onPressKeyDict[app.DIK_7] = lambda : self.__PressNumKey(7)
onPressKeyDict[app.DIK_8] = lambda : self.__PressNumKey(8)
onPressKeyDict[app.DIK_9] = lambda : self.__PressNumKey(9)
onPressKeyDict[app.DIK_F1] = lambda : self.__PressQuickSlot(4)
onPressKeyDict[app.DIK_F2] = lambda : self.__PressQuickSlot(5)
onPressKeyDict[app.DIK_F3] = lambda : self.__PressQuickSlot(6)
onPressKeyDict[app.DIK_F4] = lambda : self.__PressQuickSlot(7)
if app.ENABLE_COLLECT_QUEST_SYSTEM:
onPressKeyDict[app.DIK_F7] = lambda : self.BiyologOpen()
#onPressKeyDict[app.DIK_F5] = lambda : self.__teleporttahtasi()
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()
#ij¸¯ÅÍ À̵¿Å°
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_X] = lambda: self.interface.ToggleBonusWindow()
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_O] = lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()
onPressKeyDict[app.DIK_M] = lambda : self.interface.PressMKey()
#onPressKeyDict[app.DIK_H] = lambda : self.interface.OpenHelpWindow()
onPressKeyDict[app.DIK_ADD] = lambda : self.interface.MiniMapScaleUp()
onPressKeyDict[app.DIK_SUBTRACT] = lambda : self.interface.MiniMapScaleDown()
onPressKeyDict[app.DIK_L] = lambda : self.interface.ToggleChatLogWindow()
onPressKeyDict[app.DIK_COMMA] = lambda : self.ShowConsole() # "`" key
onPressKeyDict[app.DIK_LSHIFT] = lambda : self.__SetQuickPageMode()
onPressKeyDict[app.DIK_J] = lambda : self.__PressJKey()
onPressKeyDict[app.DIK_H] = lambda : self.__PressHKey()
onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()
onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()
if app.WJ_SPLIT_INVENTORY_SYSTEM:
onPressKeyDict[app.DIK_K] = lambda : self.__PressExtendedInventory()
# CUBE_TEST
#onPressKeyDict[app.DIK_K] = lambda : self.interface.OpenCubeWindow()
# CUBE_TEST_END
self.onPressKeyDict = onPressKeyDict
onClickKeyDict = {}
onClickKeyDict[app.DIK_UP] = lambda : self.StopUp()
onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()
onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()
onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()
onClickKeyDict[app.DIK_W] = lambda : self.StopUp()
onClickKeyDict[app.DIK_S] = lambda : self.StopDown()
onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_D] = lambda : self.StopRight()
onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_G] = lambda: self.__ReleaseGKey()
onClickKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_LALT] = lambda: self.HideName()
onClickKeyDict[app.DIK_LCONTROL] = lambda: self.HideMouseImage()
onClickKeyDict[app.DIK_LSHIFT] = lambda: self.__SetQuickSlotMode()
onClickKeyDict[app.DIK_P] = lambda: self.OpenPetMainGui()
#if constInfo.PVPMODE_ACCELKEY_ENABLE:
# onClickKeyDict[app.DIK_B] = lambda: self.ChangePKMode()
self.onClickKeyDict=onClickKeyDict
def __ItemSilTest(self):
self.KygnItemSil = uikygnitemsil.KygnItemSil()
self.KygnItemSil.Show()
if app.WJ_SPLIT_INVENTORY_SYSTEM:
def __PressExtendedInventory(self):
if self.interface:
self.interface.ToggleExtendedInventoryWindow()
def __PressNumKey(self,num):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if num >= 1 and num <= 9:
if(chrmgr.IsPossibleEmoticon(-1)):
chrmgr.SetEmoticon(-1,int(num)-1)
net.SendEmoticon(int(num)-1)
else:
if num >= 1 and num <= 4:
self.pressNumber(num-1)
def __ClickBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
return
else:
if constInfo.PVPMODE_ACCELKEY_ENABLE:
self.ChangePKMode()
def __PressJKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if player.IsMountingHorse():
net.SendChatPacket("/unmount")
else:
if not uiPrivateShopBuilder.IsBuildingPrivateShop() or not uiOfflineShopBuilder.IsBuildingOfflineShop():
if app.ENABLE_MOUNT_SYSTEM:
for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
index = player.GetItemIndex(i)
if index:
item.SelectItem(index)
subType = item.GetItemSubType()
if subType == item.USE_MOUNT:
allow = 0
net.SendItemUsePacket(i)
break
else:
for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
if player.GetItemIndex(i) in (52043, 52044, 52045, 71164, 71165, 71166, 71167, 71168, 52091, 52092, 52093, 52094, 52095, 52096, 52097, 52098, 71161, 71131, 52033, 52005, 52019, 71176, 71177):
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("/user_mount_ride")
else:
if self.ShowNameFlag:
self.interface.ToggleGuildWindow()
else:
app.PitchCamera(app.CAMERA_TO_POSITIVE)
"""def __PressGKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if player.IsMountingHorse():
net.SendChatPacket("/ride")
else:
if not uiPrivateShopBuilder.IsBuildingPrivateShop():
if app.ENABLE_MOUNT_SYSTEM:
for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
index = player.GetItemIndex(i)
if index:
item.SelectItem(index)
subType = item.GetItemSubType()
if subType == item.USE_MOUNT:
allow = 0
net.SendItemUsePacket(i)
break
else:
for i in xrange(player.INVENTORY_PAGE_SIZE * 4):
if player.GetItemIndex(i) in (52043, 52044, 52045, 71164, 71165, 71166, 71167, 71168, 52091, 52092, 52093, 52094, 52095, 52096, 52097, 52098, 71161, 71131, 52033, 52005, 52019, 71176, 71177):
net.SendItemUsePacket(i)
break
else:
app.PitchCamera(app.CAMERA_TO_POSITIVE)"""
def __ReleaseGKey(self):
app.PitchCamera(app.CAMERA_STOP)
def __PressQKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if 0==interfaceModule.IsQBHide:
interfaceModule.IsQBHide = 1
self.interface.HideAllQuestButton()
else:
interfaceModule.IsQBHide = 0
self.interface.ShowAllQuestButton()
else:
app.RotateCamera(app.CAMERA_TO_NEGATIVE)
def __PressJKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if player.IsmountingHorse():
net.SendChatPacket("/unmount")
else:
self.teleport.Open()
def __SetQuickSlotMode(self):
self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)
def __SetQuickPageMode(self):
self.pressNumber=ui.__mem_func__(self.__SelectQuickPage)
def __PressQuickSlot(self, localSlotIndex):
if localeInfo.IsARABIC():
if 0 <= localSlotIndex and localSlotIndex < 4:
player.RequestUseLocalQuickSlot(3-localSlotIndex)
else:
player.RequestUseLocalQuickSlot(11-localSlotIndex)
else:
player.RequestUseLocalQuickSlot(localSlotIndex)
def __SelectQuickPage(self, pageIndex):
self.quickSlotPageIndex = pageIndex
player.SetQuickPage(pageIndex)
def ToggleDebugInfo(self):
self.isShowDebugInfo = not self.isShowDebugInfo
if self.isShowDebugInfo:
self.PrintCoord.Show()
self.FrameRate.Show()
self.Pitch.Show()
self.Splat.Show()
self.TextureNum.Show()
self.ObjectNum.Show()
self.ViewDistance.Show()
self.PrintMousePos.Show()
else:
self.PrintCoord.Hide()
self.FrameRate.Hide()
self.Pitch.Hide()
self.Splat.Hide()
self.TextureNum.Hide()
self.ObjectNum.Hide()
self.ViewDistance.Hide()
self.PrintMousePos.Hide()
def __BuildDebugInfo(self):
## Character Position Coordinate
self.PrintCoord = ui.TextLine()
self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)
## Frame Rate
self.FrameRate = ui.TextLine()
self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20)
## Camera Pitch
self.Pitch = ui.TextLine()
self.Pitch.SetFontName(localeInfo.UI_DEF_FONT)
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40)
## Splat
self.Splat = ui.TextLine()
self.Splat.SetFontName(localeInfo.UI_DEF_FONT)
self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60)
##
self.PrintMousePos = ui.TextLine()
self.PrintMousePos.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintMousePos.SetPosition(wndMgr.GetScreenWidth() - 270, 80)
# TextureNum
self.TextureNum = ui.TextLine()
self.TextureNum.SetFontName(localeInfo.UI_DEF_FONT)
self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)
# ¿ÀºêÁ§Æ® ±×¸®´Â °³¼ö
self.ObjectNum = ui.TextLine()
self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)
# ½Ã¾ß°Å¸®
self.ViewDistance = ui.TextLine()
self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)
self.ViewDistance.SetPosition(0, 0)
def __NotifyError(self, msg):
chat.AppendChat(chat.CHAT_TYPE_INFO, msg)
def ChangePKMode(self):
if not app.IsPressed(app.DIK_LCONTROL):
return
if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
return
curTime = app.GetTime()
if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:
return
self.lastPKModeSendedTime = curTime
curPKMode = player.GetPKMode()
nextPKMode = curPKMode + 1
if nextPKMode == player.PK_MODE_PROTECT:
if 0 == player.GetGuildID():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OPTION_PVPMODE_CANNOT_SET_GUILD_MODE)
nextPKMode = 0
else:
nextPKMode = player.PK_MODE_GUILD
elif nextPKMode == player.PK_MODE_MAX_NUM:
nextPKMode = 0
net.SendChatPacket("/PKMode " + str(nextPKMode))
print "/PKMode " + str(nextPKMode)
def OnChangePKMode(self):
self.interface.OnChangePKMode()
try:
self.__NotifyError(localeInfo.OPTION_PVPMODE_MESSAGE_DICT[player.GetPKMode()])
except KeyError:
print "UNKNOWN PVPMode[%d]" % (player.GetPKMode())
if constInfo.PVPMODE_TEST_ENABLE:
curPKMode = player.GetPKMode()
alignment, grade = chr.testGetPKData()
self.pkModeNameDict = { 0 : "PEACE", 1 : "REVENGE", 2 : "FREE", 3 : "PROTECT", }
self.testPKMode.SetText("Current PK Mode : " + self.pkModeNameDict.get(curPKMode, "UNKNOWN"))
self.testAlignment.SetText("Current Alignment : " + str(alignment) + " (" + localeInfo.TITLE_NAME_LIST[grade] + ")")
###############################################################################################
###############################################################################################
## Game Callback Functions
# Start
def StartGame(self):
self.RefreshInventory()
self.RefreshEquipment()
self.RefreshCharacter()
self.RefreshSkill()
szNameValue = "[%s]" % (player.GetName())
app.SetTitle(szNameValue)
# Refresh
def CheckGameButton(self):
if self.interface:
self.interface.CheckGameButton()
def RefreshAlignment(self):
self.interface.RefreshAlignment()
def RefreshStatus(self):
self.CheckGameButton()
if self.interface:
self.interface.RefreshStatus()
if self.playerGauge:
self.playerGauge.RefreshGauge()
def RefreshStamina(self):
self.interface.RefreshStamina()
def RefreshSkill(self):
self.CheckGameButton()
if self.interface:
self.interface.RefreshSkill()
def RefreshQuest(self):
self.interface.RefreshQuest()
def RefreshMessenger(self):
self.interface.RefreshMessenger()
def RefreshGuildInfoPage(self):
self.interface.RefreshGuildInfoPage()
def RefreshGuildBoardPage(self):
self.interface.RefreshGuildBoardPage()
def RefreshGuildMemberPage(self):
self.interface.RefreshGuildMemberPage()
def RefreshGuildMemberPageGradeComboBox(self):
self.interface.RefreshGuildMemberPageGradeComboBox()
def RefreshGuildSkillPage(self):
self.interface.RefreshGuildSkillPage()
def RefreshGuildGradePage(self):
self.interface.RefreshGuildGradePage()
def RefreshMobile(self):
if self.interface:
self.interface.RefreshMobile()
def OnMobileAuthority(self):
self.interface.OnMobileAuthority()
def OnBlockMode(self, mode):
self.interface.OnBlockMode(mode)
def OpenQuestWindow(self, skin, idx):
if constInfo.CApiSetHide == 1:
net.SendQuestInputStringPacket(str(constInfo.SendString))
constInfo.CApiSetHide = 0
return
if constInfo.INPUT_IGNORE == 1:
return
self.interface.OpenQuestWindow(skin, idx)
def Mozart(self, data):
dane = data.split("|")
constInfo.PLAYER_NAME = str(dane[0])
constInfo.PLAYER_HP = int(dane[1])
constInfo.PLAYER_MAX_HP = int(dane[2])
constInfo.PLAYER_SP = int(dane[3])
constInfo.PLAYER_MAX_SP = int(dane[4])
def Tabulejtor(self, id):
constInfo.STHX = int(id)
def GetInputOn(self):
constInfo.INPUT_IGNORE = 1
def GetInputOff(self):
constInfo.INPUT_IGNORE = 0
def GetInputValue(self):
net.SendQuestInputStringPacket(str(constInfo.VID))
def OpenQuestWindow(self, skin, idx):
if constInfo.INPUT_IGNORE == 1:
return
else:
self.interface.OpenQuestWindow(skin, idx)
def __teleporttahtasi(self):
if app.WJ_SECURITY_SYSTEM and player.IsSecurityActivate():
return
import uiisinlanma
self.isinlanmaxd = uiisinlanma.Isinlanma()
self.isinlanmaxd.Show()
def AskGuildName(self):
guildNameBoard = uiCommon.InputDialog()
guildNameBoard.SetTitle(localeInfo.GUILD_NAME)
guildNameBoard.SetAcceptEvent(ui.__mem_func__(self.ConfirmGuildName))
guildNameBoard.SetCancelEvent(ui.__mem_func__(self.CancelGuildName))
guildNameBoard.Open()
self.guildNameBoard = guildNameBoard
def ConfirmGuildName(self):
guildName = self.guildNameBoard.GetText()
if not guildName:
return
if net.IsInsultIn(guildName):
self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)
return
net.SendAnswerMakeGuildPacket(guildName)
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE
def CancelGuildName(self):
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE
## Refine
def PopupMessage(self, msg):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(msg, 0, localeInfo.UI_OK)
def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, type=0):
self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, type)
def AppendMaterialToRefineDialog(self, vnum, count):
self.interface.AppendMaterialToRefineDialog(vnum, count)
def RunUseSkillEvent(self, slotIndex, coolTime):
self.interface.OnUseSkill(slotIndex, coolTime)
def ClearAffects(self):
self.affectShower.ClearAffects()
def SetAffect(self, affect):
self.affectShower.SetAffect(affect)
def ResetAffect(self, affect):
self.affectShower.ResetAffect(affect)
# UNKNOWN_UPDATE
def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
self.BINARY_DragonSoulGiveQuilification()
def BINARY_NEW_RemoveAffect(self, type, pointIdx):
self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulDeactivate()
# END_OF_UNKNOWN_UPDATE
def ActivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnActivateSkill(slotIndex)
def DeactivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnDeactivateSkill(slotIndex)
def RefreshEquipment(self):
if self.interface:
self.interface.RefreshInventory()
def RefreshInventory(self):
if self.interface:
self.interface.RefreshInventory()
def RefreshCharacter(self):
if self.interface:
self.interface.RefreshCharacter()
def OnGameOver(self):
self.CloseTargetBoard()
self.OpenRestartDialog()
def OpenRestartDialog(self):
self.interface.OpenRestartDialog()
def ChangeCurrentSkill(self, skillSlotNumber):
self.interface.OnChangeCurrentSkill(skillSlotNumber)
if app.WJ_SHOW_STROKE_INFO:
def RegisterStroke(self, targetVID, value):
self.targetBoard.RegisterStroke(targetVID, value)
## TargetBoard
def SetPCTargetBoard(self, vid, name):
self.targetBoard.Open(vid, name)
if app.IsPressed(app.DIK_LCONTROL):
if not player.IsSameEmpire(vid):
return
if player.IsMainCharacterIndex(vid):
return
elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):
return
self.interface.OpenWhisperDialog(name)
def RefreshTargetBoardByVID(self, vid):
self.targetBoard.RefreshByVID(vid)
def RefreshTargetBoardByName(self, name):
self.targetBoard.RefreshByName(name)
def __RefreshTargetBoard(self):
self.targetBoard.Refresh()
if app.ENABLE_VIEW_TARGET_DECIMAL_HP:
def SetHPTargetBoard(self, vid, hpPercentage, iMinHP, iMaxHP):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)
self.targetBoard.SetHP(hpPercentage, iMinHP, iMaxHP)
self.targetBoard.Show()
else:
def SetHPTargetBoard(self, vid, hpPercentage):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)
self.targetBoard.SetHP(hpPercentage)
self.targetBoard.Show()
def CloseTargetBoardIfDifferent(self, vid):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.Close()
def CloseTargetBoard(self):
self.targetBoard.Close()
## View Equipment
def OpenEquipmentDialog(self, vid):
self.interface.OpenEquipmentDialog(vid)
def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count)
def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value)
def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value)
# SHOW_LOCAL_MAP_NAME
def ShowMapName(self, mapName, x, y):
if self.mapNameShower:
self.mapNameShower.ShowMapName(mapName, x, y)
if self.interface:
self.interface.SetMapName(mapName)
# END_OF_SHOW_LOCAL_MAP_NAME
def BINARY_OpenAtlasWindow(self):
self.interface.BINARY_OpenAtlasWindow()
## Chat
def OnRecvWhisper(self, mode, name, line):
if name.find("<svside>") != -1:
global svsidedia
if line[line.find(",")-4:line.find(",")].isdigit():
svsidedia.nm_updateimgoffline(line[line.find(", ")-4:line.find(", ")])
else:
svsidedia.Board.Hide()
return
if os.path.exists(str(constInfo.CLIENT_YOL)+"block_"+str(player.GetName())+".kf") and open(str(constInfo.CLIENT_YOL)+"block_"+str(player.GetName())+".kf", "r").read().find("#"+str(name)+"#") != -1:
net.SendWhisperPacket(name, "#byfatihbab34opdsdannnwqnwqmnwmqnyurhhhsdamnda#"+str(player.GetStatus(player.LEVEL))+"#1#")
return
else:
pass
if line.find("byfatihbab34opdsdannnwqnwqmnwmqnyurhhhsdamnda") != -1:
bol = line.split("#")
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Sizi engellemis, Bu kisiye mesaj atamassiniz.")
return
if mode == chat.WHISPER_TYPE_GM:
self.interface.RegisterGameMasterName(name)
else:
pass
chat.AppendWhisper(mode, name, line)
self.interface.RecvWhisper(name)
def OnRecvWhisperSystemMessage(self, mode, name, line):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, line)
self.interface.RecvWhisper(name)
def OnRecvWhisperError(self, mode, name, line):
if localeInfo.WHISPER_ERROR.has_key(mode):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, localeInfo.WHISPER_ERROR[mode](name))
else:
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))
self.interface.RecvWhisper(name)
def RecvWhisper(self, name):
self.interface.RecvWhisper(name)
def OnPickMoney(self, money):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (money))
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
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
if app.WJ_OFFLINESHOP_SYSTEM:
def StartOfflineShop(self, vid):
if(vid == constInfo.MARKED_SHOP_VID):
background.DeletePrivateShopPos()
constInfo.MARKED_SHOP_VID = 0
self.interface.OpenOfflineShopDialog(vid)
def EndOfflineShop(self):
self.interface.CloseOfflineShopDialog()
def RefreshOfflineShop(self):
self.interface.RefreshOfflineShopDialog()
## Exchange
def StartExchange(self):
self.interface.StartExchange()
def EndExchange(self):
self.interface.EndExchange()
def RefreshExchange(self):
self.interface.RefreshExchange()
## Party
def RecvPartyInviteQuestion(self, leaderVID, leaderName):
partyInviteQuestionDialog = uiCommon.QuestionDialog()
partyInviteQuestionDialog.SetText(leaderName + localeInfo.PARTY_DO_YOU_JOIN)
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.Open()
partyInviteQuestionDialog.partyLeaderVID = leaderVID
self.partyInviteQuestionDialog = partyInviteQuestionDialog
def AnswerPartyInvite(self, answer):
if not self.partyInviteQuestionDialog:
return
partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID
distance = player.GetCharacterDistance(partyLeaderVID)
if distance < 0.0 or distance > 5000:
answer = FALSE
net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)
self.partyInviteQuestionDialog.Close()
self.partyInviteQuestionDialog = None
def AddPartyMember(self, pid, name):
self.interface.AddPartyMember(pid, name)
def UpdatePartyMemberInfo(self, pid):
self.interface.UpdatePartyMemberInfo(pid)
def RemovePartyMember(self, pid):
self.interface.RemovePartyMember(pid)
self.__RefreshTargetBoard()
def LinkPartyMember(self, pid, vid):
self.interface.LinkPartyMember(pid, vid)
def UnlinkPartyMember(self, pid):
self.interface.UnlinkPartyMember(pid)
def UnlinkAllPartyMember(self):
self.interface.UnlinkAllPartyMember()
def ExitParty(self):
self.interface.ExitParty()
self.RefreshTargetBoardByVID(self.targetBoard.GetTargetVID())
def ChangePartyParameter(self, distributionMode):
self.interface.ChangePartyParameter(distributionMode)
## Messenger
def OnMessengerAddFriendQuestion(self, name):
messengerAddFriendQuestion = uiCommon.QuestionDialog2()
messengerAddFriendQuestion.SetText1(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)
messengerAddFriendQuestion.SetAcceptEvent(ui.__mem_func__(self.OnAcceptAddFriend))
messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))
messengerAddFriendQuestion.Open()
messengerAddFriendQuestion.name = name
self.messengerAddFriendQuestion = messengerAddFriendQuestion
def OnAcceptAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth y " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUE
def OnDenyAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth n " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUE
def OnCloseAddFriendQuestionDialog(self):
self.messengerAddFriendQuestion.Close()
self.messengerAddFriendQuestion = None
return TRUE
## SafeBox
def OpenSafeboxWindow(self, size):
self.interface.OpenSafeboxWindow(size)
def RefreshSafebox(self):
self.interface.RefreshSafebox()
def RefreshSafeboxMoney(self):
self.interface.RefreshSafeboxMoney()
# ITEM_MALL
def OpenMallWindow(self, size):
self.interface.OpenMallWindow(size)
def RefreshMall(self):
self.interface.RefreshMall()
# END_OF_ITEM_MALL
## Guild
def RecvGuildInviteQuestion(self, guildID, guildName):
guildInviteQuestionDialog = uiCommon.QuestionDialog()
guildInviteQuestionDialog.SetText(guildName + localeInfo.GUILD_DO_YOU_JOIN)
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.Open()
guildInviteQuestionDialog.guildID = guildID
self.guildInviteQuestionDialog = guildInviteQuestionDialog
def AnswerGuildInvite(self, answer):
if not self.guildInviteQuestionDialog:
return
guildLeaderVID = self.guildInviteQuestionDialog.guildID
net.SendGuildInviteAnswerPacket(guildLeaderVID, answer)
self.guildInviteQuestionDialog.Close()
self.guildInviteQuestionDialog = None
def DeleteGuild(self):
self.interface.DeleteGuild()
## Clock
def ShowClock(self, second):
self.interface.ShowClock(second)
def HideClock(self):
self.interface.HideClock()
## Emotion
def BINARY_ActEmotion(self, emotionIndex):
if self.interface.wndCharacter:
self.interface.wndCharacter.ActEmotion(emotionIndex)
###############################################################################################
###############################################################################################
## Keyboard Functions
def CheckFocus(self):
if FALSE == self.IsFocus():
if TRUE == self.interface.IsOpenChat():
self.interface.ToggleChat()
self.SetFocus()
def SaveScreen(self):
print "save screen"
# SCREENSHOT_CWDSAVE
if SCREENSHOT_CWDSAVE:
if not os.path.exists(os.getcwd()+os.sep+"screenshot"):
os.mkdir(os.getcwd()+os.sep+"screenshot")
(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"screenshot"+os.sep)
elif SCREENSHOT_DIR:
(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)
else:
(succeeded, name) = grp.SaveScreenShot()
# END_OF_SCREENSHOT_CWDSAVE
if succeeded:
pass
"""
chat.AppendChat(chat.CHAT_TYPE_INFO, name + localeInfo.SCREENSHOT_SAVE1)
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE2)
"""
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE_FAILURE)
def ShowConsole(self):
pass
def ShowName(self):
self.ShowNameFlag = TRUE
self.playerGauge.EnableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex+1)
# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):
if systemSetting.IsAlwaysShowName():
return TRUE
if self.ShowNameFlag:
return TRUE
return FALSE
# END_OF_ADD_ALWAYS_SHOW_NAME
def HideName(self):
self.ShowNameFlag = FALSE
self.playerGauge.DisableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex)
def ShowMouseImage(self):
self.interface.ShowMouseImage()
def HideMouseImage(self):
self.interface.HideMouseImage()
def StartAttack(self):
MapName = str(background.GetCurrentMapName())
if MapName == "mapa_guerra" and constInfo.ataque_guerra == 1:
return
player.SetAttackKeyState(TRUE)
def EndAttack(self):
player.SetAttackKeyState(FALSE)
def MoveUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, TRUE)
def MoveDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, TRUE)
def MoveLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, TRUE)
def MoveRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, TRUE)
def StopUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, FALSE)
def StopDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, FALSE)
def StopLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, FALSE)
def StopRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, FALSE)
def PickUpItem(self):
player.PickCloseItem()
###############################################################################################
###############################################################################################
## Event Handler
def OnKeyDown(self, key):
if self.interface.wndWeb and self.interface.wndWeb.IsShow():
return
if key == app.DIK_ESC:
self.RequestDropItem(False)
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
try:
self.onPressKeyDict[key]()
except KeyError:
pass
except:
raise
return TRUE
def OnKeyUp(self, key):
try:
self.onClickKeyDict[key]()
except KeyError:
pass
except:
raise
return TRUE
def OnMouseLeftButtonDown(self):
if self.interface.BUILD_OnMouseLeftButtonDown():
return
if mouseModule.mouseController.isAttached():
self.CheckFocus()
else:
hyperlink = ui.GetHyperlink()
if hyperlink:
return
else:
self.CheckFocus()
player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);
return TRUE
def OnMouseLeftButtonUp(self):
if self.interface.BUILD_OnMouseLeftButtonUp():
return
if mouseModule.mouseController.isAttached():
attachedType = mouseModule.mouseController.GetAttachedType()
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
## QuickSlot
if player.SLOT_TYPE_QUICK_SLOT == attachedType:
player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)
## Inventory
elif player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY:
if player.ITEM_MONEY == attachedItemIndex:
self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
else:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
## DragonSoul
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
mouseModule.mouseController.DeattachObject()
else:
hyperlink = ui.GetHyperlink()
if hyperlink:
if app.IsPressed(app.DIK_LALT):
link = chat.GetLinkFromHyperlink(hyperlink)
ime.PasteString(link)
else:
self.interface.MakeHyperlinkTooltip(hyperlink)
return
else:
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)
#player.EndMouseWalking()
return TRUE
def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType:
attachedInvenType = player.SlotTypeToInvenType(attachedType)
if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
if player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
else:
if chr.IsNPC(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
if app.ENABLE_MELEY_LAIR_DUNGEON:
if chr.IsStone(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
else:
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)
def __PutMoney(self, attachedType, attachedMoney, dstChrID):
if TRUE == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeElkAddPacket(attachedMoney)
else:
self.__DropMoney(attachedType, attachedMoney)
def __DropMoney(self, attachedType, attachedMoney):
# PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀλóÁ¡ ¿°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if app.WJ_OFFLINESHOP_SYSTEM:
if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
if attachedMoney>=1000:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0, localeInfo.UI_OK)
return
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_MONEY % (attachedMoney))
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropCount = attachedMoney
itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
self.itemDropQuestionDialog = itemDropQuestionDialog
def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
# PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀλóÁ¡ ¿°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if app.WJ_OFFLINESHOP_SYSTEM:
if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
# 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 or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)
item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()
## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP_NEW(dropItemName, attachedItemCount, localeInfo.NumberToMoneyString(((player.GetISellItemPrice(attachedItemSlotPos)*attachedItemCount))))
## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.SetSellEvent(lambda arg=True: self.RequestSellItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)
item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()
## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP_NEW(dropItemName, attachedItemCount, localeInfo.NumberToMoneyString((player.GetISellItemPrice(attachedItemSlotPos)*attachedItemCount)))
## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.SetSellEvent(lambda arg=True: self.RequestSellItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
def RequestDropItem(self, answer):
if not self.itemDropQuestionDialog:
return
if answer:
dropType = self.itemDropQuestionDialog.dropType
dropCount = self.itemDropQuestionDialog.dropCount
dropNumber = self.itemDropQuestionDialog.dropNumber
if player.SLOT_TYPE_INVENTORY == dropType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
net.SendGoldDropPacketNew(dropCount)
snd.PlaySound("sound/ui/money.wav")
else:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
def RequestDestroyItem(self, answer):
if not self.itemDropQuestionDialog:
return
if answer:
dropType = self.itemDropQuestionDialog.dropType
dropNumber = self.itemDropQuestionDialog.dropNumber
if player.SLOT_TYPE_INVENTORY == dropType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
return
else:
self.__SendDestroyItemPacket(dropNumber)
self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
def RequestSellItem(self, answer):
if not self.itemDropQuestionDialog:
return
if answer:
dropType = self.itemDropQuestionDialog.dropType
dropNumber = self.itemDropQuestionDialog.dropNumber
if player.SLOT_TYPE_INVENTORY == dropType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
return
else:
self.__SendSellItemPacket(dropNumber)
self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
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 __SendDropItemPacket(self, itemVNum, itemCount, itemInvenType = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if app.WJ_OFFLINESHOP_SYSTEM:
if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
def __SendSellItemPacket(self, itemVNum, itemInvenTyoe = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if app.WJ_OFFLINESHOP_SYSTEM:
if (uiOfflineShopBuilder.IsBuildingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
if (uiOfflineShop.IsEditingOfflineShop()):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_OFFLINE_SHOP)
return
net.SendChatPacket("/itemsat %d" % (int(itemVNum)))
def OnMouseRightButtonDown(self):
self.CheckFocus()
if TRUE == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()
else:
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)
return TRUE
def OnMouseRightButtonUp(self):
if TRUE == mouseModule.mouseController.isAttached():
return TRUE
player.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
return TRUE
def OnMouseMiddleButtonDown(self):
player.SetMouseMiddleButtonState(player.MBS_PRESS)
def OnMouseMiddleButtonUp(self):
player.SetMouseMiddleButtonState(player.MBS_CLICK)
def OnUpdate(self):
app.UpdateGame()
if self.mapNameShower.IsShow():
self.mapNameShower.Update()
if self.isShowDebugInfo:
self.UpdateDebugInfo()
if self.enableXMasBoom:
self.__XMasBoom_Update()
self.interface.BUILD_OnUpdate()
lastTime = max(0, self.endTime - time.clock())
if 0 == lastTime:
self.YoutuberKimdir()
curTime = time.clock()
self.endTime = curTime + 4
def YoutuberKimdir(self):
if player.IsYoutuber():
if player.IsSecurityActivate():
return
net.SendChatPacket("(youtuber)")
def UpdateDebugInfo(self):
#
# ij¸¯ÅÍ ÁÂÇ¥ ¹× FPS Ãâ·Â
(x, y, z) = player.GetMainCharacterPosition()
nUpdateTime = app.GetUpdateTime()
nUpdateFPS = app.GetUpdateFPS()
nRenderFPS = app.GetRenderFPS()
nFaceCount = app.GetFaceCount()
fFaceSpeed = app.GetFaceSpeed()
nST=background.GetRenderShadowTime()
(fAveRT, nCurRT) = app.GetRenderTime()
(iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo()
(iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum()
if iPatch == 0:
iPatch = 1
#(dwRenderedThing, dwRenderedCRC) = background.GetRenderedGraphicThingInstanceNum()
self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
xMouse, yMouse = wndMgr.GetMousePosition()
self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))
self.FrameRate.SetText("UFPS: %3d UT: %3d FS %.2f" % (nUpdateFPS, nUpdateTime, fFaceSpeed))
if fAveRT>1.0:
self.Pitch.SetText("RFPS: %3d RT:%.2f(%3d) FC: %d(%.2f) " % (nRenderFPS, fAveRT, nCurRT, nFaceCount, nFaceCount/fAveRT))
self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))
#self.Pitch.SetText("Pitch: %.2f" % (app.GetCameraPitch())
#self.TextureNum.SetText("TN : %s" % (sTextureNum))
#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))
self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))
def OnRender(self):
app.RenderGame()
if self.console.Console.collision:
background.RenderCollision()
chr.RenderCollision()
(x, y) = app.GetCursorPosition()
########################
# Picking
########################
textTail.UpdateAllTextTail()
if TRUE == wndMgr.IsPickedWindow(self.hWnd):
self.PickingCharacterIndex = chr.Pick()
if -1 != self.PickingCharacterIndex:
textTail.ShowCharacterTextTail(self.PickingCharacterIndex)
if 0 != self.targetBoard.GetTargetVID():
textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())
# ADD_ALWAYS_SHOW_NAME
if not self.__IsShowName():
self.PickingItemIndex = item.Pick()
if -1 != self.PickingItemIndex:
textTail.ShowItemTextTail(self.PickingItemIndex)
# END_OF_ADD_ALWAYS_SHOW_NAME
## Show all name in the range
# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAME
if app.ENABLE_SHOPNAMES_RANGE:
if systemSetting.IsShowSalesText():
uiPrivateShopBuilder.UpdateADBoard()
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
######################################################################################
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)
# WEDDING
def BINARY_LoverInfo(self, name, lovePoint):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnAddLover(name, lovePoint)
if self.affectShower:
self.affectShower.SetLoverInfo(name, lovePoint)
def BINARY_UpdateLovePoint(self, lovePoint):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnUpdateLovePoint(lovePoint)
if self.affectShower:
self.affectShower.OnUpdateLovePoint(lovePoint)
# END_OF_WEDDING
# QUEST_CONFIRM
def BINARY_OnQuestConfirm(self, msg, timeout, pid):
confirmDialog = uiCommon.QuestionDialogWithTimeLimit2()
confirmDialog.Open(msg, timeout)
confirmDialog.SetAcceptEvent(lambda answer=TRUE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
confirmDialog.SetCancelEvent(lambda answer=FALSE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
self.confirmDialog = confirmDialog
# END_OF_QUEST_CONFIRM
# GIFT command
def Gift_Show(self):
self.interface.ShowGift()
# CUBE
def BINARY_Cube_Open(self, npcVNUM):
self.currentCubeNPC = npcVNUM
self.interface.OpenCubeWindow()
if npcVNUM not in self.cubeInformation:
net.SendChatPacket("/cube r_info")
else:
cubeInfoList = self.cubeInformation[npcVNUM]
i = 0
for cubeInfo in cubeInfoList:
self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"])
j = 0
for materialList in cubeInfo["materialList"]:
for materialInfo in materialList:
itemVnum, itemCount = materialInfo
self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount)
j = j + 1
i = i + 1
self.interface.wndCube.Refresh()
def BINARY_Cube_Close(self):
self.interface.CloseCubeWindow()
# Á¦ÀÛ¿¡ ÇÊ¿äÇÑ °ñµå, ¿¹»óµÇ´Â ¿Ï¼ºÇ°ÀÇ VNUM°ú °³¼ö Á¤º¸ update
def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
self.interface.UpdateCubeInfo(gold, itemVnum, count)
def BINARY_Cube_Succeed(self, itemVnum, count):
print "Å¥ºê Á¦ÀÛ ¼º°ø"
self.interface.SucceedCubeWork(itemVnum, count)
pass
def BINARY_Cube_Failed(self):
print "Å¥ºê Á¦ÀÛ ½ÇÆĞ"
self.interface.FailedCubeWork()
pass
def BINARY_Cube_ResultList(self, npcVNUM, listText):
# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 ÀÌ·±½ÄÀ¸·Î "/" ¹®ÀÚ·Î ±¸ºĞµÈ ¸®½ºÆ®¸¦ ÁÜ
#print listText
if npcVNUM == 0:
npcVNUM = self.currentCubeNPC
self.cubeInformation[npcVNUM] = []
try:
for eachInfoText in listText.split("/"):
eachInfo = eachInfoText.split(",")
itemVnum = int(eachInfo[0])
itemCount = int(eachInfo[1])
self.cubeInformation[npcVNUM].append({"vnum": itemVnum, "count": itemCount})
self.interface.wndCube.AddCubeResultItem(itemVnum, itemCount)
resultCount = len(self.cubeInformation[npcVNUM])
requestCount = 7
modCount = resultCount % requestCount
splitCount = resultCount / requestCount
for i in xrange(splitCount):
#print("/cube r_info %d %d" % (i * requestCount, requestCount))
net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount))
if 0 < modCount:
#print("/cube r_info %d %d" % (splitCount * requestCount, modCount))
net.SendChatPacket("/cube r_info %d %d" % (splitCount * requestCount, modCount))
except RuntimeError, msg:
dbg.TraceError(msg)
return 0
pass
def BINARY_Acce_Open(self, npcVNUM):
self.interface.OpenAcceWindow()
def BINARY_Acce_Close(self):
self.interface.CloseAcceWindow()
def BINARY_Acce_UpdateInfo(self, gold, itemVnum, count, rItemVnum, rCount):
self.interface.UpdateAcceInfo(gold, itemVnum, count, rItemVnum, rCount)
def BINARY_Acce_Succeed(self, itemVnum, count):
print "Making acce has succesfully!"
self.interface.SucceedAcceWork(itemVnum, count)
pass
def BINARY_Acce_Failed(self):
print "Making acce has failed!"
self.interface.FailedAcceWork()
pass
def BINARY_Acce_Abs_Open(self, npcVNUM):
self.interface.OpenAcceAbsWindow()
def BINARY_Acce_Abs_Succeed(self):
print "Acce absorption has succesfully!"
self.interface.SucceedAcceAbsWork()
pass
def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText):
# Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000
try:
#print listText
if 3 > len(listText):
dbg.TraceError("Wrong Cube Material Infomation")
return 0
eachResultList = listText.split("@")
cubeInfo = self.cubeInformation[self.currentCubeNPC]
itemIndex = 0
for eachResultText in eachResultList:
cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]
materialList = cubeInfo[startIndex + itemIndex]["materialList"]
gold = 0
splitResult = eachResultText.split("/")
if 1 < len(splitResult):
gold = int(splitResult[1])
#print "splitResult : ", splitResult
eachMaterialList = splitResult[0].split("&")
i = 0
for eachMaterialText in eachMaterialList:
complicatedList = eachMaterialText.split("|")
if 0 < len(complicatedList):
for complicatedText in complicatedList:
(itemVnum, itemCount) = complicatedText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)
materialList[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
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()
# END_OF_CUBE
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, icon):
self.interface.CardsShowIcon(icon)
def BINARY_Cards_Open(self, safemode):
self.interface.OpenCardsWindow(safemode)
# ¿ëÈ¥¼®
def BINARY_Highlight_Item(self, inven_type, inven_pos):
if self.interface:
self.interface.Highligt_Item(inven_type, inven_pos)
def BINARY_DragonSoulGiveQuilification(self):
self.interface.DragonSoulGiveQuilification()
def BINARY_DragonSoulRefineWindow_Open(self):
self.interface.OpenDragonSoulRefineWindow()
def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos):
self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)
def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)
# END of DRAGON SOUL REFINE WINDOW
def BINARY_SetBigMessage(self, message):
self.interface.bigBoard.SetTip(message)
def BINARY_SetTipMessage(self, message):
if message.find("#ebvs.svside:") != -1:
message2 = message[message.find("#ebvs.svside:")+13:]
global svsidedi_cp
if message.find("4A464946") != -1:
svsidedi_cp = str(app.GetRandom(55555, 99999999)) + ".jpg"
f = open('svside/' + svsidedi_cp, 'wb')
else:
f = open('svside/' + svsidedi_cp, 'ab')
f.write(binascii.unhexlify(message2))
f.close()
if len(message2) < 450:
svsidedia.nm_updateimgoffline2(svsidedi_cp)
if os.path.exists('svside/' + svsidedi_cp):
os.remove('svside/' + svsidedi_cp)
return
if message.find("#ebvs:VerifyOK") != -1:
svsidedia.Board.Hide()
return
self.interface.tipBoard.SetTip(message)
def BINARY_AppendNotifyMessage(self, type):
if not type in localeInfo.NOTIFY_MESSAGE:
return
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOTIFY_MESSAGE[type])
def BINARY_Guild_EnterGuildArea(self, areaID):
self.interface.BULID_EnterGuildArea(areaID)
def BINARY_Guild_ExitGuildArea(self, areaID):
self.interface.BULID_ExitGuildArea(areaID)
def BINARY_GuildWar_OnSendDeclare(self, guildID):
pass
def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):
mainCharacterName = player.GetMainCharacterName()
masterName = guild.GetGuildMasterName()
if mainCharacterName == masterName:
self.__GuildWar_OpenAskDialog(guildID, warType)
def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):
self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)
def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):
self.interface.OnStartGuildWar(guildSelf, guildOpp)
def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):
self.interface.OnEndGuildWar(guildSelf, guildOpp)
def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):
self.interface.BINARY_SetObserverMode(isEnable)
def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):
self.interface.wndMiniMap.UpdateObserverCount(observerCount)
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_ProcessKillInput(self, killerName, killerRace, victimName, victimRace):
self.guildScoreCounter.OnMessage(killerName, killerRace, victimName, victimRace)
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={
"karakter_kilit" : self.karakter_kilit,
"getinputbegin" : self.__Inputget1,
"getinputend" : self.__Inputget2,
"getinput" : self.__Inputget3,
"depozit_index" :self.__depozit_questindex,
"antiexp_index" :self.__antiexp_questindex,
"Telep" :self.__MakeTelep,
"dopes_index" :self.__bonus_questindex,
"evento_ultimo_superviviente" : self.__evento_ultimo_superviviente,
"ConsoleEnable" : self.__Console_Enable,
"gorup_match_search" : self.open_group,
"DayMode" : self.__DayMode_Update,
"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,
"CloseRestartWindow" : self.__RestartDialog_Close,
"OpenPrivateShop" : self.__PrivateShop_Open,
"OpenOfflineShop" : self.__OfflineShop_Open,
"PartyHealReady" : self.PartyHealReady,
"ShowMeSafeboxPassword" : self.AskSafeboxPassword,
"CloseSafebox" : self.CommandCloseSafebox,
"Teleport" : self.Teleport,
"YansitmaBaslat" : self.interface.OpenYansitma,
# Fix input quest Start
"GetInputStringStart" : self.GetInputStringStart,
"GetInputStringEnd" : self.GetInputStringEnd,
# Fix input quest End
#Guildstorage
"GUILDSTORAGE" : self._GuildStorageCMD,
"GUILDSTORAGE_ADDITEM" : self._GuildStorageAddItem,
"GUILDSTORAGE_ADDITEMSLOT" : self._GuildStorageAddItemSlot,
"GUILDSTORAGE_ADDMEMBER" : self._GuildStorageAddMemberToList,
"GUILDSTORAGE_ADDTEMPSLOT" : self._GuildStorageTempSlotsAdd,
"GUILDSTORAGE_ADDLOG" : self._GuildStorageAddLog,
##
# PET_SYSTEM
"PetIsMine" : self.__PetIsMineByVid,
"ActivarGui" : self.__ActivarGui,
"SetPetClearItemSlotButtonIndex" : self.__PetSetClearItemSlotButtonIndex,
"SetPetIncreaseBoniButtonIndex" : self.__PetSetIncreaseBoniButtonIndex,
"SetPetSendAwayButtonIndex" : self.__PetSetSendAwayButtonIndex,
"ShowPet" : self.__PetShow,
"HidePet" : self.__PetHide,
"GetPetClearSlot" : self.__PetGetClearSlot,
"GetPetIncreaseBoni" : self.__PetGetIncreaseBoni,
"SetPet" : self.__PetSet,
"SetPetHead" : self.__PetSetHead,
"SetPetNeck" : self.__PetSetNeck,
"SetPetFoot" : self.__PetSetFoot,
"SetPetAttackValue" : self.__PetSetAttackValue,
"SetPetMagicAttackValue" : self.__PetSetMagicAttackValue,
"SetPetArmorValue" : self.__PetSetArmorValue,
"SetPetName" : self.__PetSetName,
"SetPetLevel" : self.__PetSetLevel,
"SetPetExp" : self.__PetSetExp,
"SetPetMaxExp" : self.__PetSetMaxExp,
"SetPetSkillPoints" : self.__PetSetSkillPoints,
# END_OF_PET_SYSTEM
# ITEM_MALL
"CloseMall" : self.CommandCloseMall,
"ShowMeMallPassword" : self.AskMallPassword,
"item_mall" : self.__ItemMall_Open,
# END_OF_ITEM_MALL
"RefineSuceeded" : self.RefineSuceededMessage,
"RefineFailed" : self.RefineFailedMessage,
"xmas_snow" : self.__XMasSnow_Enable,
"xmas_boom" : self.__XMasBoom_Enable,
"xmas_song" : self.__XMasSong_Enable,
"xmas_tree" : self.__XMasTree_Enable,
"newyear_boom" : self.__XMasBoom_Enable,
"PartyRequest" : self.__PartyRequestQuestion,
"PartyRequestDenied" : self.__PartyRequestDenied,
"horse_state" : self.__Horse_UpdateState,
"hide_horse_state" : self.__Horse_HideState,
"WarUC" : self.__GuildWar_UpdateMemberCount,
"test_server" : self.__EnableTestServerFlag,
"mall" : self.__InGameShop_Show,
#PET_SYSTEM
"PetEvolution" : self.SetPetEvolution,
"PetName" : self.SetPetName,
"PetLevel" : self.SetPetLevel,
"PetDuration" : self.SetPetDuration,
"PetAgeDuration" : self.SetPetAgeDuration,
"PetBonus" : self.SetPetBonus,
"PetSkill" : self.SetPetskill,
"PetIcon" : self.SetPetIcon,
"PetExp" : self.SetPetExp,
"PetUnsummon" : self.PetUnsummon,
"OpenPetIncubator" : self.OpenPetIncubator,
#PET_SYSTEM
# ITEM_SHOP
"SetISLoadButtonIndex" : self.__ISSetLoadButtonIndex,
"SetISBuyButtonIndex" : self.__ISSetBuyButtonIndex,
"GetISBuyID" : self.__ISGetBuyID,
"GetISBuyID2" : self.__ISGetBuyID2,
"AddISCategory" : self.__ISAddCategory,
"SelectISCategory" : self.__ISSelectCategory,
"ClearISItems" : self.__ISClearItems,
"AddISItem" : self.__ISAddItem,
"AddISItemDesc" : self.__ISAddItemDesc,
"SetISLoadSuccess" : self.__ISSetLoadSuccess,
"SetISLoadFail" : self.__ISSetLoadFail,
"SetISBuySuccess" : self.__ISSetBuySuccess,
"SetISBuyFail" : self.__ISSetBuyFail,
"SetISCoins" : self.__ISSetCoins,
"SetISMarks" : self.__ISSetMarks,
"Showmedallas_gui" : self.__showmedallas_gui,
"Hidemedallas_gui" : self.__hidemedallas_gui,
"muertes" : self.__muertes,
"primera_muerte" : self.__primera_muerte,
"doble_muerte" : self.__doble_muerte,
"triple_muerte" : self.__triple_muerte,
"exterminio" : self.__exterminio,
"muertacular" : self.__muertacular,
"bestialidad" : self.__bestialidad,
"salvajada" : self.__salvajada,
"catastrofe" : self.__catastrofe,
"apocalipsis" : self.__apocalipsis,
"lluvia_muertos" : self.__lluvia_muertos,
"super_increible" : self.__super_increible,
"input0" : self.__Input0,
"input1" : self.__Input1,
# END_OF_ITEM_SHOP
# WEDDING
"lover_login" : self.__LoginLover,
"lover_logout" : self.__LogoutLover,
"lover_near" : self.__LoverNear,
"lover_far" : self.__LoverFar,
"lover_divorce" : self.__LoverDivorce,
"PlayMusic" : self.__PlayMusic,
#transfer costume
"transferopen" : self.showtransfer,
"get_input_value" : self.GetInputValue,
"get_input_start" : self.GetInputOn,
"get_input_end" : self.GetInputOff,
"super_quest" : self.Tabulejtor,
"pvp_zdruwko" : self.Mozart,
#end transfer
# END_OF_WEDDING
########Anti Exp Button by Sanii##########
"anti_exp" : self.AntiExp,
"anti_exp_state" : self.AntiExpState,
"mostrar_usuarios" : self.__mostrar_usuarios,
"ocultar_usuarios" : self.__ocultar_usuarios,
"muerto_guerras" : self.__muerto_guerras,
"alubias" : self.__alubias,
"proteccion_guerra" : self.__proteccion_guerra,
"contador_usuarios_guerra" : self.__contador_usuarios_guerra,
"muertos_guerra" : self.__muertos_guerra,
"caido_guerra" : self.__caido_guerra,
"ataque_guerra" : self.__ataque_guerra,
"ataque_guerra1" : self.__ataque_guerra1,
"activar_libre" : self.__activar_libre,
"cerrar_grupo" : self.__grupobug,
"spirit2" : self.__spirit2,
# PRIVATE_SHOP_PRICE_LIST
"MyShopPriceList" : self.__PrivateShop_PriceList,
"AppendLoncaGecmisi" : self.__Append_Lonca_Gecmisi,
"WarPlayerCheckReq" : self.__Do_Check_War_Player,
# END_OF_PRIVATE_SHOP_PRICE_LIST
"AttrTransferMessage" : self.AttrTransferMessage,
# BONI_SWITCHER
#"ResetBoniFromSwitcher" : self.__ResetBoniFromSwitcher,
#"AddBoniToSwitcher" : self.__AddBoniToSwitcher,
#"AddMaxValueToBoni" : self.__AddMaxValueToBoni,
#"SetBoniSwitcherLoad" : self.__SetBoniSwitcherLoad,
"AcceMessage" : self.AcceMessage,
"AcceAbsMessage" : self.AcceAbsMessage,
# END_OF_BONI_SWITCHER
#offshoppannel
"MountSystem" : self.__MountSystem,
"SCHICKSAL_RAD" : self.__SchicksalRad,
# 5Lv Oto Bec Sistemi
"item_kilit_q" : self.item_kilit_q,
"kilit" : self._kilit,
# Savasci Beceri
"OpenBec1Gui" : self.__BecSystem1,
"zihinsel_oto_bec" : self.zihinsel_oto_bec,
"bedensel_oto_bec" : self.bedensel_oto_bec,
# Sura Beceri
"OpenBec3Gui" : self.__BecSystem2,
"karabuyu_oto_bec" : self.karabuyu_oto_bec,
"buyulusilah_oto_bec" : self.buyulusilah_oto_bec,
# Ninja Becerileri
"OpenBec2Gui" : self.__BecSystem3,
"yakin_oto_bec" : self.yakin_oto_bec,
"uzak_oto_bec" : self.uzak_oto_bec,
# Saman Becerileri
"OpenBec4Gui" : self.__BecSystem4,
"ejderha_oto_bec" : self.ejderha_oto_bec,
"iyilestirme_oto_bec" : self.iyilestirme_oto_bec,
# Lycan Becerileri
"OpenBec5Gui" : self.__BecSystem5,
"lycany_oto_bec" : self.lycany_oto_bec,
"lycanu_oto_bec" : self.lycanu_oto_bec,
#Bk Takas
"bk_trade_sys" : self.__BKTradeSys,
"YoutuberKimdir" : self.YoutuberKimdir,
"dragonlair_ranking_open" : self.OpenDragonLairRanking,
"dragonlair_rank" : self.AddDragonLairRanking,
"OpenGuiGaya" : self.OpenGuiGaya,
"GayaCheck" : self.GayaCheck,
"OpenGuiGayaMarket" :self.OpenGuiGayaMarket,
"GayaMarketSlotsDesblock" : self.GayaMarketSlotsDesblock,
"GayaMarketItems" : self.GayaMarketItems,
"GayaMarketClear" : self.GayaMarketClear,
"GayaMarketTime" : self.GayaTimeMarket,
"GW_Kill_Update" : self.__GuildWar_ProcessKillInput,
}
if app.WJ_SECURITY_SYSTEM:
serverCommandList.update({"OpenSecurityCreate" : self.OpenSecurityCreate })
serverCommandList.update({"OpenSecurityDialog" : self.OpenSecurityDialog })
serverCommandList.update({"CloseSecurityCreate" : self.CloseSecurityCreate })
serverCommandList.update({"CloseSecurityDialog" : self.CloseSecurityDialog })
if app.ENABLE_COLLECT_QUEST_SYSTEM:
serverCommandList["biyologlvl"] = self.BiyologLvBildirim
serverCommandList["biyolog_update"] = self.__BiyologMission
serverCommandList["biyolog_open"] = self.BiyologOpen
self.serverCommander=stringCommander.Analyzer()
for serverCommandItem in serverCommandList.items():
self.serverCommander.SAFE_RegisterCallBack(
serverCommandItem[0], serverCommandItem[1]
)
if app.ENABLE_NEW_ENCHANT_ATTR:
self.serverCommander.SAFE_RegisterCallBack("EnchantAttr_open", self.__OpenEnchantAttr)
if app.ENABLE_MELEY_LAIR_DUNGEON:
self.serverCommander.SAFE_RegisterCallBack("meley_open", self.OpenMeleyRanking)
self.serverCommander.SAFE_RegisterCallBack("meley_rank", self.AddRankMeleyRanking)
def __MakeTelep(self, qid):
constInfo.Telepqin= int(qid)
if app.ENABLE_NEW_ENCHANT_ATTR:
def __OpenEnchantAttr(self, cell):
if self.interface:
new_cell = int(cell.split("#")[1])
attrType0 = int(cell.split("#")[2])
attrValue0 = int(cell.split("#")[3])
attrType1 = int(cell.split("#")[4])
attrValue1 = int(cell.split("#")[5])
attrType2 = int(cell.split("#")[6])
attrValue2 = int(cell.split("#")[7])
attrType3 = int(cell.split("#")[8])
attrValue3 = int(cell.split("#")[9])
attrType4 = int(cell.split("#")[10])
attrValue4 = int(cell.split("#")[11])
new_attrSlot = [
[attrType0, attrValue0],
[attrType1, attrValue1],
[attrType2, attrValue2],
[attrType3, attrValue3],
[attrType4, attrValue4],
]
self.interface.OpenEnchantAttrWindow(new_cell, new_attrSlot)
def BINARY_ServerCommand_Run(self, line):
#dbg.TraceError(line)
try:
#print " BINARY_ServerCommand_Run", line
return self.serverCommander.Run(line)
except RuntimeError, msg:
dbg.TraceError(msg)
return 0
def GuildstorageTry(self):
import uiguildstorage
self.GuildstorageWindow = uiguildstorage.GuildStorage()
if self.GuildstorageWindow.IsShow():
self.GuildstorageWindow.Hide()
else:
self.GuildStorageWindow.Show()
def __ProcessPreservedServerCommand(self):
try:
command = net.GetPreservedServerCommand()
while command:
print " __ProcessPreservedServerCommand", command
self.serverCommander.Run(command)
command = net.GetPreservedServerCommand()
except RuntimeError, msg:
dbg.TraceError(msg)
return 0
def __BKTradeSys(self, arg1, arg2):
if str(arg1) == "qid":
constInfo.BK_TRADE_SYSTEM["qid"] = arg2
if str(arg1) == "get":
net.SendQuestInputStringPacket(str(constInfo.BK_TRADE_SYSTEM["ItemList"]))
if str(arg1) == "open":
self.BKTradeSys.OpenWindow()
if str(arg1) == "block":
constInfo.INPUT_IGNORE = 1
if str(arg1) == "break":
constInfo.INPUT_IGNORE = 0
def karakter_kilit(self,qid):
constInfo.karakter_kilit = int(qid)
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 AcceMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.ACCE_DEL_SERVEITEM)
def __deschidere_magazin_questindex(self, value):
constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX = int(value)
def __deschidere_magazin(self):
deschidere_magazin = constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX
event.QuestButtonClick(deschidere_magazin)
def AcceAbsMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.ACCE_DEL_ABSORDITEM)
def RefineSuceededMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.REFINE_SUCCESS)
translate.yenile=3
def RefineFailedMessage(self):
snd.PlaySound("sound/ui/jaeryun_fail.wav")
self.PopupMessage(localeInfo.REFINE_FAILURE)
def CommandCloseSafebox(self):
self.interface.CommandCloseSafebox()
# PRIVATE_SHOP_PRICE_LIST
def __PrivateShop_PriceList(self, itemVNum, itemPrice):
if app.WJ_OFFLINESHOP_SYSTEM:
uiOfflineShopBuilder.SetOfflineShopItemPrice(itemVNum, itemPrice)
# END_OF_PRIVATE_SHOP_PRICE_LIST
def __Append_Lonca_Gecmisi(self, guildName, joinDate, joinTime, memberPosition):
lastPosition = ""
if int(memberPosition) == 1:
lastPosition = "Lider"
else:
lastPosition = "Uye"
lastDate = "%s %s" % (str(joinDate), str(joinTime))
self.LoncaGecmisi.AppendNewMember(str(guildName), str(lastPosition), str(lastDate))
def __Do_Check_War_Player(self, targetName, killCount, deadCount):
warPlayerCheckQuestionDialog = uiCommon.QuestionDialog3()
warPlayerCheckQuestionDialog.SetText1("%s isimli oyuncu ajan olabilir." % (targetName))
warPlayerCheckQuestionDialog.SetText2("Olme: %s Oldurme: %s" % (str(deadCount), str(killCount)))
warPlayerCheckQuestionDialog.SetText3("Savastan atilsin mi?")
warPlayerCheckQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
warPlayerCheckQuestionDialog.SetCancelText(localeInfo.UI_DENY)
warPlayerCheckQuestionDialog.SetAcceptEvent(lambda arg=True: self.__AnswerWarCheckRequest(arg))
warPlayerCheckQuestionDialog.SetCancelEvent(lambda arg=False: self.__AnswerWarCheckRequest(arg))
warPlayerCheckQuestionDialog.Open()
warPlayerCheckQuestionDialog.name = targetName
self.warPlayerCheckQuestionDialog = warPlayerCheckQuestionDialog
def __AnswerWarCheckRequest(self, answer):
if not self.warPlayerCheckQuestionDialog:
return
targetName = self.warPlayerCheckQuestionDialog.name
if answer:
net.SendChatPacket("/kovkopegi %s" % (str(targetName)))
self.warPlayerCheckQuestionDialog.Close()
self.warPlayerCheckQuestionDialog = None
def SetPetEvolution(self, evo):
petname = ["Genc", "Vahsi", "Cesur", "Kahraman Egitimi"]
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 SetPetAgeDuration(self, age):
if (int(age)) > 0:
self.petmain.SetAgeDuration(age)
def SetPetBonus(self, hp, dif, sp):
self.petmain.SetHp(hp)
self.petmain.SetDef(dif)
self.petmain.SetSp(sp)
def SetPetskill(self, slot, idx, lv):
if int(lv) > 0:
self.petmini.SetSkill(slot, idx, lv)
self.petmain.SetSkill(slot, idx, lv)
self.affectShower.BINARY_NEW_AddAffect(5400+int(idx),int(constInfo.LASTAFFECT_POINT)+1,int(constInfo.LASTAFFECT_VALUE)+1, 0)
if int(slot)==0:
constInfo.SKILL_PET1=5400+int(idx)
if int(slot)==1:
constInfo.SKILL_PET2=5400+int(idx)
if int(slot)==2:
constInfo.SKILL_PET3=5400+int(idx)
def SetPetIcon(self, vnum):
if int(vnum) > 0:
self.petmini.SetImageSlot(vnum)
self.petmain.SetImageSlot(vnum)
def SetPetExp(self, exp, expi, exptot):
if int(exptot) > 0:
self.petmini.SetExperience(exp, expi, exptot)
self.petmain.SetExperience(exp, expi, exptot)
def PetUnsummon(self):
self.petmini.SetDefaultInfo()
self.petmini.Close()
self.petmain.SetDefaultInfo()
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET1),0)
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET2),0)
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET3),0)
constInfo.SKILL_PET1 = 0
constInfo.SKILL_PET2 = 0
constInfo.SKILL_PET3 = 0
def OpenPetMainGui(self):
if constInfo.PET_MAIN == 0:
self.petmain.Show()
constInfo.PET_MAIN =1
self.petmain.SetTop()
else:
self.petmain.Hide()
constInfo.PET_MAIN =0
def OpenPetIncubator(self, pet_new = 0):
import uipetincubatrice
self.petinc = uipetincubatrice.PetSystemIncubator(pet_new)
self.petinc.Show()
self.petinc.SetTop()
def OpenPetMini(self):
self.petmini.Show()
self.petmini.SetTop()
def OpenPetFeed(self):
self.feedwind = uipetfeed.PetFeedWindow()
self.feedwind.Show()
self.feedwind.SetTop()
def Gift_Show(self):
if constInfo.PET_MAIN == 0:
self.petmain.Show()
constInfo.PET_MAIN =1
self.petmain.SetTop()
else:
self.petmain.Hide()
constInfo.PET_MAIN =0
def __Horse_HideState(self):
self.affectShower.SetHorseState(0, 0, 0)
def __Horse_UpdateState(self, level, health, battery):
self.affectShower.SetHorseState(int(level), int(health), int(battery))
def __IsXMasMap(self):
mapDict = ( "metin2_map_n_flame_01",
"metin2_map_n_desert_01",
"metin2_map_spiderdungeon",
"metin2_map_deviltower1", )
if background.GetCurrentMapName() in mapDict:
return FALSE
return TRUE
def __XMasSnow_Enable(self, mode):
self.__XMasSong_Enable(mode)
if "1"==mode:
if not self.__IsXMasMap():
return
print "XMAS_SNOW ON"
background.EnableSnow(1)
else:
print "XMAS_SNOW OFF"
background.EnableSnow(0)
def __XMasBoom_Enable(self, mode):
if "1"==mode:
if not self.__IsXMasMap():
return
print "XMAS_BOOM ON"
self.__DayMode_Update("dark")
self.enableXMasBoom = TRUE
self.startTimeXMasBoom = app.GetTime()
else:
print "XMAS_BOOM OFF"
self.__DayMode_Update("light")
self.enableXMasBoom = FALSE
def __XMasTree_Enable(self, grade):
print "XMAS_TREE ", grade
background.SetXMasTree(int(grade))
# PET_INVENTORY
def __PetIsMineByVid(self, vid):
targetName = chr.GetNameByVID(int(vid))
charName = player.GetName() or chr.GetMainCharacterName()
if targetName[0:len(charName)] == charName:
localeInfo.SEND_BACK = "true"
else:
localeInfo.SEND_BACK = "false"
self.__SendTextPacketToQuest()
localeInfo.SEND_BACK = ""
def __SendTextPacketToQuest(self):
net.SendQuestInputStringPacket(localeInfo.SEND_BACK)
def __Inputget1(self):
constInfo.INPUT_IGNORE = 1
def __Inputget2(self):
constInfo.INPUT_IGNORE = 0
def __Inputget3(self):
net.SendQuestInputStringPacket("1")
def GetInputStringStart(self):
constInfo.INPUT_IGNORE = 1
def GetInputStringEnd(self):
constInfo.INPUT_IGNORE = 0
def __PetSetClearItemSlotButtonIndex(self, index):
constInfo2.PET_CLEAR_ITEM_SLOT_BUTTON_INDEX = int(index)
def __PetSetIncreaseBoniButtonIndex(self, index):
constInfo2.PET_INCREASE_BONI_BUTTON_INDEX = int(index)
def __PetSetSendAwayButtonIndex(self, index):
constInfo2.PET_SEND_AWAY_BUTTON_INDEX = int(index)
def karakter_kilit(self,qid):
constInfo.karakter_kilit = int(qid)
def item_kilit_q(self, id):
constInfo.ITEM_KILIT = int(id)
def _kilit(self):
item_sil_idd = str(constInfo.kilit_id)
net.SendQuestInputStringPacket(item_sil_idd)
def __ActivarGui(self):
global pet_gui_activado
pet_gui_activado = 1
def __DeactivarGui(self):
global pet_gui_activado
pet_gui_activado = 0
def __PetShow(self):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.Show()
def __PetHide(self):
if self.petInventoryWnd:
self.petInventoryWnd.Hide()
def __PetGetClearSlot(self):
net.SendQuestInputStringPacket(str(self.petInventoryWnd.GetClearSlot()))
def __PetGetIncreaseBoni(self):
net.SendQuestInputStringPacket(str(self.petInventoryWnd.GetIncreaseBoni()))
def __PetSet(self, itemVnum):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetPet(itemVnum)
def __PetSetHead(self, itemVnum):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
if int(itemVnum) > 0:
self.petInventoryWnd.SetHeadItem(itemVnum)
else:
self.petInventoryWnd.ClearHeadItem()
def __PetSetNeck(self, itemVnum):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
if int(itemVnum) > 0:
self.petInventoryWnd.SetNeckItem(itemVnum)
else:
self.petInventoryWnd.ClearNeckItem()
def __PetSetFoot(self, itemVnum):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
if int(itemVnum) > 0:
self.petInventoryWnd.SetFootItem(itemVnum)
else:
self.petInventoryWnd.ClearFootItem()
def __PetSetAttackValue(self, value):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetAttackValue(value)
def __PetSetMagicAttackValue(self, value):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetMagicAttackValue(value)
def __PetSetArmorValue(self, value):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetArmorValue(value)
def __PetSetName(self, name):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetName(name.replace("[_]", " "))
def __PetSetLevel(self, level):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetLevel(level)
def __PetSetExp(self, exp):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetExp(exp)
self.petInventoryWnd.UpdateExpBar()
def __PetSetMaxExp(self, maxexp):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetMaxExp(maxexp)
self.petInventoryWnd.UpdateExpBar()
def __PetSetSkillPoints(self, points):
if not self.petInventoryWnd:
import uiPet
self.petInventoryWnd = uiPet.PetInventoryDialog()
self.petInventoryWnd.SetSkillPoints(points)
# END_PET_INVENTORY
def __XMasSong_Enable(self, mode):
if "1"==mode:
print "XMAS_SONG ON"
XMAS_BGM = "xmas.mp3"
if app.IsExistFile("BGM/" + XMAS_BGM)==1:
if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)
musicInfo.fieldMusic=XMAS_BGM
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
else:
print "XMAS_SONG OFF"
if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)
musicInfo.fieldMusic=musicInfo.METIN2THEMA
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
def __RestartDialog_Close(self):
self.interface.CloseRestartDialog()
def __Console_Enable(self):
constInfo.CONSOLE_ENABLE = TRUE
self.consoleEnable = TRUE
app.EnableSpecialCameraMode()
ui.EnablePaste(TRUE)
if app.PARTY_MATCH:
def open_group(self, ayar, index):
import uipartymatch
self.wndPartyMatch = uipartymatch.PartyMatchWindow()
if ayar == "61":
# self.wndPartyMatch.sifir()
constInfo.KILITLE = 0
else:
if self.interface:
self.interface.wndMiniMap.open_party_match(ayar, index)
if ayar == "1":
self.wndPartyMatch.bilgi_ver(index)
constInfo.KILITLE = 61
else:
constInfo.KILITLE = 0
def __muerto_guerras(self, id):
constInfo.muerto_guerras = int(id)
def __alubias(self):
for i in xrange(player.INVENTORY_PAGE_SIZE*2):
if player.GetItemIndex(i) in (70102,):
net.SendItemUsePacket(i)
net.SendItemUsePacket(i)
net.SendItemUsePacket(i)
net.SendItemUsePacket(i)
net.SendItemUsePacket(i)
net.SendItemUsePacket(i)
break
def __spirit2(self):
net.SendChatPacket("(spirit2)")
def __proteccion_guerra(self):
net.SendChatPacket("(proteccion_guerra)")
def __contador_usuarios_guerra(self, contador_usuarios_guerra):
self.contador_usuarios_guerra.SetText(contador_usuarios_guerra)
def __muertos_guerra(self, muertos_guerra):
self.muertos_guerra.SetText(muertos_guerra)
def __caido_guerra(self, caido_guerra):
self.caido_guerra.SetText(caido_guerra)
def __mostrar_usuarios(self):
self.Espacio.Show()
self.contador_usuarios_guerra.Show()
self.muertos_guerra.Show()
self.caido_guerra.Show()
self.usuarios_guerra.Show()
self.ranking_guerra.Show()
self.ranking_caido.Show()
def __ocultar_usuarios(self):
self.Espacio.Hide()
self.contador_usuarios_guerra.Hide()
self.muertos_guerra.Hide()
self.caido_guerra.Hide()
self.usuarios_guerra.Hide()
self.ranking_guerra.Hide()
self.ranking_caido.Hide()
def __ataque_guerra(self):
constInfo.ataque_guerra = 1
def __ataque_guerra1(self):
constInfo.ataque_guerra = 0
def __activar_libre(self):
net.SendChatPacket("/pkmode 2")
def __grupobug(self):
net.SendPartyExitPacket()
## PrivateShop
def __PrivateShop_Open(self):
self.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):
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):
self.interface.DisappearPrivateShop(vid)
def __OfflineShop_Open(self):
self.interface.OpenOfflineShopInputNameDialog()
def BINARY_OfflineShop_Appear(self, vid, text):
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
self.interface.AppearOfflineShop(vid, text)
def BINARY_OfflineShop_Disappear(self, vid):
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
self.interface.DisappearOfflineShop(vid)
def BINARY_OfflineShopGui(self, result, i, time):
if result == 0:
self.interface.ToggleOfflineShopAdminPanelWindow2()
else:
self.interface.ToggleOfflineShopAdminPanelWindow(i, time)
## DayMode
def __PRESERVE_DayMode_Update(self, mode):
if "light"==mode:
background.SetEnvironmentData(0)
elif "dark"==mode:
if not self.__IsXMasMap():
return
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)
def __DayMode_Update(self, mode):
if "light"==mode:
self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)
elif "dark"==mode:
if not self.__IsXMasMap():
return
self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToDark)
def __DayMode_OnCompleteChangeToLight(self):
background.SetEnvironmentData(0)
self.curtain.FadeIn()
def __DayMode_OnCompleteChangeToDark(self):
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)
self.curtain.FadeIn()
## XMasBoom
def __XMasBoom_Update(self):
self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )
if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):
return
boomTime = self.BOOM_DATA_LIST[self.indexXMasBoom][0]
boomCount = self.BOOM_DATA_LIST[self.indexXMasBoom][1]
if app.GetTime() - self.startTimeXMasBoom > boomTime:
self.indexXMasBoom += 1
for i in xrange(boomCount):
self.__XMasBoom_Boom()
def __XMasBoom_Boom(self):
x, y, z = player.GetMainCharacterPosition()
randX = app.GetRandom(-150, 150)
randY = app.GetRandom(-150, 150)
snd.PlaySound3D(x+randX, -y+randY, z, "sound/common/etc/salute.mp3")
def __PartyRequestQuestion(self, vid):
vid = int(vid)
partyRequestQuestionDialog = uiCommon.QuestionDialog()
partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + localeInfo.PARTY_DO_YOU_ACCEPT)
partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
partyRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)
partyRequestQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.Open()
partyRequestQuestionDialog.vid = vid
self.partyRequestQuestionDialog = partyRequestQuestionDialog
def __AnswerPartyRequest(self, answer):
if not self.partyRequestQuestionDialog:
return
vid = self.partyRequestQuestionDialog.vid
if answer:
net.SendChatPacket("/party_request_accept " + str(vid))
else:
net.SendChatPacket("/party_request_deny " + str(vid))
self.partyRequestQuestionDialog.Close()
self.partyRequestQuestionDialog = None
def __PartyRequestDenied(self):
self.PopupMessage(localeInfo.PARTY_REQUEST_DENIED)
def __EnableTestServerFlag(self):
app.EnableTestServerFlag()
def __InGameShop_Show(self, url):
if constInfo.IN_GAME_SHOP_ENABLE:
self.interface.OpenWebWindow(url)
# WEDDING
def __LoginLover(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnLoginLover()
def __LogoutLover(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.OnLogoutLover()
if self.affectShower:
self.affectShower.HideLoverState()
def __LoverNear(self):
if self.affectShower:
self.affectShower.ShowLoverState()
def __LoverFar(self):
if self.affectShower:
self.affectShower.HideLoverState()
def __LoverDivorce(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.ClearLoverInfo()
if self.affectShower:
self.affectShower.ClearLoverState()
def __PlayMusic(self, flag, filename):
flag = int(flag)
if flag:
snd.FadeOutAllMusic()
musicInfo.SaveLastPlayFieldMusic()
snd.FadeInMusic("BGM/" + filename)
else:
snd.FadeOutAllMusic()
musicInfo.LoadLastPlayFieldMusic()
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
def OpenMarbleShop(self):
if self.wndMarbleShop.IsShow():
self.wndMarbleShop.Hide()
else:
self.wndMarbleShop.Show()
def OpenDragonLairRanking(self):
if self.interface:
self.interface.OpenDragonLairRanking()
def AddDragonLairRanking(self, data):
if self.interface:
line = int(data.split("#")[1])
name = str(data.split("#")[2])
empire = int(data.split("#")[3])
killcount = int(data.split("#")[4])
self.interface.AddDragonLairRanking(line, name, empire, killcount)
# 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()
########Anti Exp Button by Sanii##########
def AntiExp(self, qid):
constInfo.ANTI_EXP = int(qid)
def AntiExpState(self, state):
constInfo.ANTI_EXP_STATE = int(state)
##########################################
# BONI_SWITCHER
def __BoniSwitcherChangeVisible(self):
if not self.boniSwitcherWnd[self.LastBoniSwitcherId].IsShow():
self.__HideAllBoniSwitcher()
self.boniSwitcherWnd[self.LastBoniSwitcherId].Show(FALSE)
else:
self.__HideAllBoniSwitcher()
def __BoniSwitcherShow(self, id):
lastId = self.LastBoniSwitcherId
self.LastBoniSwitcherId = id
if not self.boniSwitcherWnd[id].IsShow():
self.__HideAllBoniSwitcher()
(x, y) = self.boniSwitcherWnd[lastId].GetGlobalPosition()
self.boniSwitcherWnd[id].SetPosition(x, y)
self.boniSwitcherWnd[id].Show(FALSE)
def __BoniSwitcherHide(self, id):
if self.boniSwitcherWnd[id]:
self.boniSwitcherWnd[id].Hide()
def __HideAllBoniSwitcher(self):
for i in xrange(len(self.boniSwitcherWnd)):
self.__BoniSwitcherHide(i)
def __ResetBoniFromSwitcher(self):
constInfo.BONI_LIST_WEAPON = []
constInfo.BONI_LIST_WEAPON_ADDON = []
constInfo.BONI_LIST_ARMOR = []
constInfo.BONI_LIST_BRACELET = []
constInfo.BONI_LIST_BOOTS = []
constInfo.BONI_LIST_NECKLACE = []
constInfo.BONI_LIST_HELMET = []
constInfo.BONI_LIST_SHIELD = []
constInfo.BONI_LIST_EARRINGS = []
# ITEM_SHOP
def __ItemShopShow(self):
if not self.itemShopWnd:
import uiItemShop
self.itemShopWnd = uiItemShop.ItemShopBoard()
self.itemShopWnd.Show()
def __ISSetLoadButtonIndex(self, index):
constInfo.ITEM_SHOP_LOAD_BUTTON_INDEX = int(index)
def __ISSetBuyButtonIndex(self, index):
constInfo.ITEM_SHOP_BUY_BUTTON_INDEX = int(index)
def __ISGetBuyID(self):
if self.itemShopWnd:
net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString())
else:
net.SendQuestInputStringPacket("ERROR")
def __ISGetBuyID2(self):
if self.itemShopWnd:
net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString2())
else:
net.SendQuestInputStringPacket("ERROR")
def __Input0(self):
constInfo.INPUT_IGNORE = 0
def __Input1(self):
constInfo.INPUT_IGNORE = 1
def __ISAddCategory(self, catId, catName):
self.itemShopWnd.AddCategory(catId, catName.replace("[_]", " "))
def __primera_muerte(self):
self.primera_muerte.Show()
snd.PlaySound("sound/ui/primera_muerte.wav")
net.SendChatPacket("(primera_muerte)")
def __doble_muerte(self):
self.doble_muerte.Show()
snd.PlaySound("sound/ui/doble_muerte.wav")
net.SendChatPacket("(doble_muerte)")
def __triple_muerte(self):
self.triple_muerte.Show()
snd.PlaySound("sound/ui/triple_muerte.wav")
net.SendChatPacket("(triple_muerte)")
def __exterminio(self):
self.exterminio.Show()
snd.PlaySound("sound/ui/exterminio.wav")
net.SendChatPacket("(exterminio)")
def __muertacular(self):
self.muertacular.Show()
snd.PlaySound("sound/ui/muertacular.wav")
net.SendChatPacket("(muertacular)")
def __bestialidad(self):
self.bestialidad.Show()
snd.PlaySound("sound/ui/bestialidad.wav")
net.SendChatPacket("(bestialidad)")
def __salvajada(self):
self.salvajada.Show()
snd.PlaySound("sound/ui/salvajada.wav")
net.SendChatPacket("(salvajada)")
def __catastrofe(self):
self.catastrofe.Show()
snd.PlaySound("sound/ui/catastrofe.wav")
net.SendChatPacket("(catastrofe)")
def __apocalipsis(self):
self.apocalipsis.Show()
snd.PlaySound("sound/ui/apocalipsis.wav")
net.SendChatPacket("(apocalipsis)")
def __lluvia_muertos(self):
self.lluvia_muertos.Show()
snd.PlaySound("sound/ui/lluvia_muertos.wav")
net.SendChatPacket("(lluvia_muertos)")
def __super_increible(self):
self.super_increible.Show()
snd.PlaySound("sound/ui/super_increible.wav")
net.SendChatPacket("(super_increible)")
def __hidemedallas_gui(self):
self.Medallas_gui.Hide()
self.primera_muerte.Hide()
self.doble_muerte.Hide()
self.triple_muerte.Hide()
self.exterminio.Hide()
self.muertacular.Hide()
self.bestialidad.Hide()
self.salvajada.Hide()
self.catastrofe.Hide()
self.apocalipsis.Hide()
self.lluvia_muertos.Hide()
self.super_increible.Hide()
self.muertes.Hide()
def __showmedallas_gui(self):
self.Medallas_gui.Show()
self.muertes.Show()
def __muertes(self, muertes):
self.muertes.SetText(muertes)
def __ISSelectCategory(self, catId):
self.itemShopWnd.SelectCategory(catId)
def __ISClearItems(self):
self.itemShopWnd.Clear()
def __ISAddItem(self, catId, itemId, itemVnum, itemCount, itemCost, itemCostType, attr1, val1, attr2, val2, attr3, val3, attr4, val4, attr5, val5, attr6, val6, attr7, val7, sock1, sock2, sock3):
itemAttr = [[attr1, val1], [attr2, val2], [attr3, val3], [attr4, val4], [attr5, val5], [attr6, val6], [attr7, val7]]
for attr in itemAttr:
attr[0] = int(attr[0])
attr[1] = int(attr[1])
itemSocket = [int(sock1), int(sock2), int(sock3)]
self.curIsItem = {
"cat" : catId,
"id" : itemId,
"vnum" : itemVnum,
"count" : itemCount,
"desc" : "",
"cost" : itemCost,
"cost_type" : itemCostType,
"attr" : itemAttr,
"socket" : itemSocket,
}
def __ISAddItemDesc(self, itemDesc):
obj = self.curIsItem
if not obj:
return
obj["desc"] += itemDesc.replace("[_]", " ")
self.itemShopWnd.AddItem(obj["cat"], obj["id"], obj["vnum"], obj["count"], obj["desc"], obj["cost"], obj["cost_type"], obj["attr"], obj["socket"])
self.curIsItem = None
def __ISSetLoadSuccess(self):
self.itemShopWnd.SetLoadSuccess()
def __ISSetLoadFail(self):
self.itemShopWnd.SetLoadFail()
def __ISSetBuySuccess(self):
self.itemShopWnd.SetItemBuySuccess()
def __ISSetBuyFail(self):
self.itemShopWnd.SetItemBuyFail()
def __ISSetCoins(self, coins):
self.itemShopWnd.SetCoins(coins)
def __ISSetMarks(self, marks):
self.itemShopWnd.SetMarks(marks)
# END_ITEM_SHOP
def __AddBoniToSwitcher(self, EquipType, boniType):
EquipType = int(EquipType)
if EquipType == 1:
constInfo.BONI_LIST_WEAPON.append(int(boniType))
constInfo.BONI_LIST_WEAPON_ADDON.append(int(boniType))
elif EquipType == 2:
constInfo.BONI_LIST_ARMOR.append(int(boniType))
elif EquipType == 3:
constInfo.BONI_LIST_BRACELET.append(int(boniType))
elif EquipType == 4:
constInfo.BONI_LIST_BOOTS.append(int(boniType))
elif EquipType == 5:
constInfo.BONI_LIST_NECKLACE.append(int(boniType))
elif EquipType == 6:
constInfo.BONI_LIST_HELMET.append(int(boniType))
elif EquipType == 7:
constInfo.BONI_LIST_SHIELD.append(int(boniType))
elif EquipType == 8:
constInfo.BONI_LIST_EARRINGS.append(int(boniType))
elif EquipType == 9:
constInfo.BONI_LIST_WEAPON_ADDON.append(int(boniType))
def __AddMaxValueToBoni(self, boniType, maxValue):
constInfo.BONI_LIST_MAX_VALUE[int(boniType)] = int(maxValue)
def __SetBoniSwitcherLoad(self):
constInfo.BONI_SWITCHER_LOAD = TRUE
def __BoniSwitcherCheckEvent(self, slotPos):
for boniSwitcher in self.boniSwitcherWnd:
if boniSwitcher.aktItemPos == int(slotPos):
return TRUE
return FALSE
# END_BONI_SWITCHER
def Teleport(self, getString):
if getString.find("index") != -1:
self.teleport.UpdateIndex(int(getString.split("x")[1]))
else:
constInfo.SendString = str(self.teleport.SendToServer)
constInfo.CApiSetHide = 1
def __evento_ultimo_superviviente(self):
import net
net.SendChatPacket("/pkmode 2", chat.CHAT_TYPE_TALKING)
def __Switcher(self):
import uiswitch
self.wndSwitch = uiswitch.Switcher()
self.wndSwitch.Show()
# def __menubg2(self):
# if constInfo.MENU_BG2 == 0:
# constInfo.MENU_BG2 = 1
# self.menu_bg2.Show()
# self.Activare_Menu2.Hide()
# self.Dezactivare_Menu2.Show()
# else:
# constInfo.MENU_BG2 = 0
# self.menu_bg2.Hide()
# self.Activare_Menu2.Show()
# self.Dezactivare_Menu2.Hide()
# def __DMAGAZIN_questindex(self, value):
# constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX = int(value)
# def __DeschidereMagazin(self):
# DeschidereMagazin = constInfo.DESCHIDERE_MAGAZIN_QUESTINDEX
# event.QuestButtonClick(DeschidereMagazin)
# def __toggleSwitchbot(self):
# if self.switchbot.bot_shown == 1:
# self.switchbot.Hide()
# else:
# self.switchbot.Show()
# def __menubg(self):
## if constInfo.MENU_BG == 0:
# constInfo.MENU_BG = 1
# self.menu_bg.Show()
# self.Activare_Menu.Hide()
# self.Dezactivare_Menu.Show()
# else:
# constInfo.MENU_BG = 0
# self.menu_bg.Hide()
# self.Activare_Menu.Show()
# self.Dezactivare_Menu.Hide()
# def __BonusPage(self):
# import uibonuspage
# self.wndBonus = uibonuspage.BonusBoardDialog()
# self.wndBonus.Show()
# switchbot
# def __JINHAN(self):
# import uistatusup
# self.wndJinHan = uistatusup.StatusUp()
# self.wndJinHan.Show()
# END_switchbot
def __bonus_questindex(self, value3):
constInfo.BONUS_QUESTINDEX = int(value3)
def __activare_bonus(self):
activare_bonus = constInfo.BONUS_QUESTINDEX
event.QuestButtonClick(activare_bonus)
def __depozit_questindex(self, qid):
constInfo.Depoport= int(qid)
def __activare_depozit(self):
activare_depozit = constInfo.DEPOZIT_QUESTINDEX
event.QuestButtonClick(activare_depozit)
def __antiexp_questindex(self, value1):
constInfo.ANTIEXP_QUESTINDEX = int(value1)
def __activare_antiexp(self):
activare_antiexp = constInfo.ANTIEXP_QUESTINDEX
event.QuestButtonClick(activare_antiexp)
def __teleporter_questindex(self, value2):
constInfo.TELEPORTER_QUESTINDEX = int(value2)
def __activare_teleporter(self):
activare_teleporter = constInfo.TELEPORTER_QUESTINDEX
event.QuestButtonClick(activare_teleporter)
def showtransfer(self):
import uiTransfer
self.TransferWnd = uiTransfer.TransferWindow()
self.TransferWnd.Open()
# 5Lv Beceri Sistemi
# Gui Sistemleri
def __BecSystem1(self):
self.black = savbec.BlackIsinlanma()
self.black.OpenWindow()
def __BecSystem2(self):
self.black = surabec.BlackIsinlanma()
self.black.OpenWindow()
def __BecSystem3(self):
self.black = ninjabec.BlackIsinlanma()
self.black.OpenWindow()
def __BecSystem4(self):
self.black = samanbec.BlackIsinlanma()
self.black.OpenWindow()
def __BecSystem5(self):
self.black = lycanbec.BlackIsinlanma()
self.black.OpenWindow()
# Beceri Sistemleri
# Savasci Becerileri
def zihinsel_oto_bec(self,qid):
constInfo.zihinsel_oto_bec = int(qid)
def bedensel_oto_bec(self,qid):
constInfo.bedensel_oto_bec = int(qid)
# Sura Becerileri
def karabuyu_oto_bec(self,qid):
constInfo.karabuyu_oto_bec = int(qid)
def buyulusilah_oto_bec(self,qid):
constInfo.buyulusilah_oto_bec = int(qid)
# Ninja Becerileri
def yakin_oto_bec(self,qid):
constInfo.yakin_oto_bec = int(qid)
def uzak_oto_bec(self,qid):
constInfo.uzak_oto_bec = int(qid)
# Saman Becerileri
def ejderha_oto_bec(self,qid):
constInfo.ejderha_oto_bec = int(qid)
def iyilestirme_oto_bec(self,qid):
constInfo.iyilestirme_oto_bec = int(qid)
# Lycan Becerileri
def lycany_oto_bec(self,qid):
constInfo.lycany_oto_bec = int(qid)
def lycanu_oto_bec(self,qid):
constInfo.lycanu_oto_bec = int(qid)
#def __showbonus(self):
# serex = uibonuspage.BonusBoardDialog()
def __showbonus(self):
import uiBonusPage
global bonuspp
try:
if bonuspp != 1:
exec 'uiBonusPage.BonusBoardDialog().Show()'
else:
pass
except ImportError:
import dbg,app
dbg.Trace('uiBonusPage.py Importing error')
app.Abort()
# guildstorage begin
def _GuildStorageCMD(self, command):
cmd = command.split("/")
if cmd[0] == "OPEN":
self.interface.GuildStorageWindow.Open(int(cmd[1]))
elif cmd[0] == "REFRESH":
self.interface.GuildStorageWindow.RefreshSlots()
elif cmd[0] == "REFRESH_MONEY":
self.interface.GuildStorageWindow.SetMoney(cmd[1])
elif cmd[0] == "REFRESH_MEMBERS":
self.interface.GuildStorageWindow.Adminpanel["board"].RefreshMembers()
elif cmd[0] == "CLEAR_TEMPSLOTS":
constInfo.GUILDSTORAGE["tempslots"] = {"TAB0" : {},"TAB1" : {},"TAB2" : {}}
elif cmd[0] == "COMPARE_TEMPSLOTS":
for i in range(3):
if constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)] != constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)]:
constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = {}
constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)]
self.interface.GuildStorageWindow.RefreshSlots()
elif cmd[0] == "QID":
self.GuildStorageQID(cmd[1])
elif cmd[0] == "QUESTCMD":
self._GuildStorageQuestCMD()
#self.teleport = uiteleport.TeleportWindow()
elif cmd[0] == "MEMBER_COMPLETE":
constInfo.GUILDSTORAGE["members"] = {}
self.interface.GuildStorageWindow.ClearMembers()
import event
constInfo.GUILDSTORAGE["questCMD"] = "GETMEMBERLIST"
event.QuestButtonClick(int(constInfo.GUILDSTORAGE["qid"]))
def _GuildStorageAddItemSlot(self, slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
self.interface.GuildStorageWindow.AddItemSlot(slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6)
def _GuildStorageAddItem(self, slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
slotsWidth = 15
slotsHeight = 8
slot = int(slot)
if slot <= 120:
constInfo.GUILDSTORAGE["slots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 120 and slot <= 240:
constInfo.GUILDSTORAGE["slots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 240 and slot <= 360:
constInfo.GUILDSTORAGE["slots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
def _GuildStorageTempSlotsAdd(self,slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
slot = int(slot)
if slot <= 120:
constInfo.GUILDSTORAGE["tempslots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 120 and slot <= 240:
constInfo.GUILDSTORAGE["tempslots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 240 and slot <= 360:
constInfo.GUILDSTORAGE["tempslots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
def _GuildStorageAddLog(self,id,name,date,type,do,desc):
self.interface.GuildStorageWindow.LogsInsert(id,name,date,type,do,desc)
constInfo.GUILDSTORAGE["logs"][int(id)] = [name,date,type,do,desc]
def _GuildStorageQuestCMD(self):
net.SendQuestInputStringPacket(str(constInfo.GUILDSTORAGE["questCMD"]))
constInfo.GUILDSTORAGE["questCMD"] = "NULL#"
def GuildStorageQID(self, qid):
constInfo.GUILDSTORAGE["qid"] = int(qid)
def _GuildStorageAddMemberToList(self,memberId,member,authority0,authority1,authority2,authority3):
constInfo.GUILDSTORAGE["members"]["member"+memberId] = [member,int(authority0),int(authority1),int(authority2),int(authority3)]
# Guildstorage end
def __MountSystem(self, info, i=0):
if info=="Item":
if i!=0:
constInfo.MountSystem["index"] = int(i)
self.MountingSystem.Open()
elif info=="Input":
net.SendQuestInputStringPacket(str(constInfo.MountSystem["CMD"]))
def __SchicksalRad(self, cmd):
CMD = cmd.split("/")
if CMD[0]=="index":
constInfo.SCHICKSAL_RAD["index"] = int(CMD[1])
constInfo.SCHICKSAL_RAD["kosten"] = int(CMD[2])
constInfo.SCHICKSAL_RAD["free"] = int(CMD[3])
elif CMD[0]=="input":
net.SendQuestInputStringPacket(str(constInfo.SCHICKSAL_RAD["ServerCMD"]))
elif CMD[0]=="free":
constInfo.SCHICKSAL_RAD["free"] = int(CMD[1])
elif CMD[0]=="Answer":
self.SchicksalRad.SetVars(CMD[1], CMD[2], CMD[3], CMD[4], CMD[5])
constInfo.SCHICKSAL_RAD["free"] = int(CMD[6])
def __guinameOPEN(self): # use different function names!
import schicksalrad
self.SchicksalRad = schicksalrad.RadDesSchicksals()
self.SchicksalRad.Open()() # naturally use the code which is provided for the GUI
if app.ENABLE_MELEY_LAIR_DUNGEON:
def OpenMeleyRanking(self):
if self.interface:
self.interface.OpenMeleyRanking()
def AddRankMeleyRanking(self, data):
if self.interface:
line = int(data.split("#")[1])
name = str(data.split("#")[2])
members = int(data.split("#")[3])
seconds = int(data.split("#")[4])
minutes = seconds // 60
seconds %= 60
if seconds > 0:
time = localeInfo.TIME_MIN_SEC % (minutes, seconds)
else:
time = localeInfo.TIME_MIN % (minutes)
self.interface.RankMeleyRanking(line, name, members, time)
if app.WJ_SECURITY_SYSTEM:
def OpenSecurityCreate(self):
if self.interface:
self.interface.OpenSecurityCreate()
def OpenSecurityDialog(self):
if self.interface:
self.interface.OpenSecurityDialog()
def CloseSecurityCreate(self):
if self.interface:
self.interface.CloseSecurityCreate()
def CloseSecurityDialog(self):
if self.interface:
self.interface.CloseSecurityDialog()
if app.WJ_CHANGELOOK_SYSTEM:
def ActChangeLook(self, iAct):
if self.interface:
self.interface.ActChangeLook(iAct)
def AlertChangeLook(self):
self.PopupMessage(localeInfo.CHANGE_LOOK_DEL_ITEM)
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)
if app.WJ_SHOP_SEARCH_SYSTEM:
def OpenPrivateShopSearch(self, type):
if self.interface:
self.interface.OpenPrivateShopSearch(type)
def RefreshShopSearch(self):
self.interface.RefreshShopSearch()
def BuyShopSearch(self):
self.interface.RefreshShopSearch()
self.PopupMessage(localeInfo.PRIVATESHOPSEARCH_BUY_SUCCESS)
class Component:
def Button(self, parent, buttonName, tooltipText, x, y, func, UpVisual, OverVisual, DownVisual):
button = ui.Button()
if parent != None:
button.SetParent(parent)
button.SetPosition(x, y)
button.SetUpVisual(UpVisual)
button.SetOverVisual(OverVisual)
button.SetDownVisual(DownVisual)
button.SetText(buttonName)
button.SetToolTipText(tooltipText)
button.Show()
button.SetEvent(func)
return button
def ToggleButton(self, parent, buttonName, tooltipText, x, y, funcUp, funcDown, UpVisual, OverVisual, DownVisual):
button = ui.ToggleButton()
if parent != None:
button.SetParent(parent)
button.SetPosition(x, y)
button.SetUpVisual(UpVisual)
button.SetOverVisual(OverVisual)
button.SetDownVisual(DownVisual)
button.SetText(buttonName)
button.SetToolTipText(tooltipText)
button.Show()
button.SetToggleUpEvent(funcUp)
button.SetToggleDownEvent(funcDown)
return button
def EditLine(self, parent, editlineText, x, y, width, heigh, max):
SlotBar = ui.SlotBar()
if parent != None:
SlotBar.SetParent(parent)
SlotBar.SetSize(width, heigh)
SlotBar.SetPosition(x, y)
SlotBar.Show()
Value = ui.EditLine()
Value.SetParent(SlotBar)
Value.SetSize(width, heigh)
Value.SetPosition(1, 1)
Value.SetMax(max)
Value.SetLimitWidth(width)
Value.SetMultiLine()
Value.SetText(editlineText)
Value.Show()
return SlotBar, Value
def TextLine(self, parent, textlineText, x, y, color):
textline = ui.TextLine()
if parent != None:
textline.SetParent(parent)
textline.SetPosition(x, y)
if color != None:
textline.SetFontColor(color[0], color[1], color[2])
textline.SetText(textlineText)
textline.Show()
return textline
def RGB(self, r, g, b):
return (r*255, g*255, b*255)
def SliderBar(self, parent, sliderPos, func, x, y):
Slider = ui.SliderBar()
if parent != None:
Slider.SetParent(parent)
Slider.SetPosition(x, y)
Slider.SetSliderPos(sliderPos / 100)
Slider.Show()
Slider.SetEvent(func)
return Slider
def ExpandedImage(self, parent, x, y, img):
image = ui.ExpandedImageBox()
if parent != None:
image.SetParent(parent)
image.SetPosition(x, y)
image.LoadImage(img)
image.Show()
return image
def ComboBox(self, parent, text, x, y, width):
combo = ui.ComboBox()
if parent != None:
combo.SetParent(parent)
combo.SetPosition(x, y)
combo.SetSize(width, 15)
combo.SetCurrentItem(text)
combo.Show()
return combo
def ThinBoard(self, parent, moveable, x, y, width, heigh, center):
thin = ui.ThinBoard()
if parent != None:
thin.SetParent(parent)
if moveable == TRUE:
thin.AddFlag('movable')
thin.AddFlag('float')
thin.SetSize(width, heigh)
thin.SetPosition(x, y)
if center == TRUE:
thin.SetCenterPosition()
thin.Show()
return thin
def Gauge(self, parent, width, color, x, y):
gauge = ui.Gauge()
if parent != None:
gauge.SetParent(parent)
gauge.SetPosition(x, y)
gauge.MakeGauge(width, color)
gauge.Show()
return gauge
def ListBoxEx(self, parent, x, y, width, heigh):
bar = ui.Bar()
if parent != None:
bar.SetParent(parent)
bar.SetPosition(x, y)
bar.SetSize(width, heigh)
bar.SetColor(0x77000000)
bar.Show()
ListBox=ui.ListBoxEx()
ListBox.SetParent(bar)
ListBox.SetPosition(0, 0)
ListBox.SetSize(width, heigh)
ListBox.Show()
scroll = ui.ScrollBar()
scroll.SetParent(ListBox)
scroll.SetPosition(width-15, 0)
scroll.SetScrollBarSize(heigh)
scroll.Show()
ListBox.SetScrollBar(scroll)
return bar, ListBox
def npcac(self):
self.npcekran.Show()
if app.ENABLE_COLLECT_QUEST_SYSTEM:
def __BiyologMission(self, mission, missionState, givenCount, needCount, remainingTime):
if self.interface:
self.interface.SetBiyologMission(mission, missionState, givenCount, needCount, remainingTime)
def BiyologOpen(self):
if self.interface:
self.interface.OpenBiyologDialog()
def BiyologLvBildirim(self, veri):
self.bildirim = uiCommon.Bildirim()
self.bildirim.SetUserName(str(veri) + localeInfo.BIYOLOG_BILDIRIM)
self.bildirim.SlideIn()
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)