Files
AVA2/upstream/python-root/interfacemodule.py
T
shenandshen 281418f351 Fix cross-platform rendering and optimize frame performance
Correct selection orientation, game-entry lifecycle, mounted NPCs, labels and skill panels. Add the native GPU scene path, resident geometry, bounded texture and Python caches, and collision broad phase.

Pin the independently maintained Metin2 SDK through a submodule and document reproducible setup. Include rendering regressions and macOS packaging improvements.

Validation: client Debug build and 12 targeted client tests passed; SDK build and all 14 SDK tests passed.
2026-10-11 17:55:53 -07:00

3740 lines
110 KiB
Python

##
## Interface
##
import constInfo
import systemSetting
import wndMgr
import chat
import app
import player
import uiTaskBar
import uiCharacter
import uiInventory
import uiDragonSoul
import uiChat
import uiMessenger
import guild
import net
import item
import uiCards
import ui_mobile_hud
if app.RENEWAL_MISSION_BOOKS:
import uiMission
if app.ENABLE_TRACK_WINDOW:
import uiTrack
if app.ENABLE_ZODIAC_MISSION:
import ui12zi
if app.ENABLE_RENDER_TARGET:
import uiRenderTarget
if app.ENABLE_EXCHANGE_LOG:
import uiExchangeLog
if app.ENABLE_EVENT_MANAGER:
import uiEventCalendarNew
if app.ENABLE_AUTO_SELECT_SKILL:
import uiAutoSkill
if app.ENABLE_WIKI:
import uiWiki
import ui
import uiHelp
import uiWhisper
import uiPointReset
import uiShop
import uiExchange
import uiSystem
import uiRestart
import uiToolTip
import uiMiniMap
import uiParty
import uiSafebox
import uiGuild
import uiQuest
#import uiPrivateShopBuilder
import uiCommon
import uiRefine
import uiEquipmentDialog
import uiGameButton
import uiTip
import uiCube
if app.ENABLE_SWITCHBOT:
import uiSwitchbot
import miniMap
# ACCESSORY_REFINE_ADD_METIN_STONE
import uiselectitem
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
import uiScriptLocale
if app.ENABLE_BIYOLOG:
import uiBiyolog
if app.ENABLE_BATTLE_PASS:
import uiBattlePassEx
if app.ENABLE_OFFLINESHOP_SYSTEM:
import uiOfflineShopBuilder
import uiOfflineShop
import chr
import net
if app.ENABLE_NEW_PET_SYSTEM:
import uiPetSystemNew
import uiChangeName
import event
import localeInfo
# import uiItemShop
import uiTicket
import uiitemshop_v2
import dbg
if app.ENABLE_FISH_GAME:
import uiFishGame
if app.ENABLE_ITEMSHOP:
import uiItemShopNew
if app.ENABLE_SHOP_SEARCH_SYSTEM:
import uiPrivateShopSearch
if app.BL_67_ATTR:
import uiAttr67Add
if app.ENABLE_KINGDOMS_WAR:
import uikingdomswar
import uiSpecialInventory
if app.dracaryS_DUNGEON_LIB:
import uiDungeonTimer
IsQBHide = 0
if app.ENABLE_SASH_SYSTEM:
import uisash
if app.ENABLE_MANAGER_BANK_SYSTEM:
import uibankamanger
if app.ENABLE_SPECIAL_STORAGE:
import uiSpecialStorage
if app.ENABLE_SHOW_CHEST_DROP:
import uiChestDropInfo
if app.ENABLE_MINI_GAME_CATCH_KING:
import uiMiniGameCatchKing
import uicalendar
#import uiEventCalendar
if app.LINK_IN_CHAT:
import os
if app.ENABLE_DUNGEON_INFO:
import uiDungeonInfo
if app.ENABLE_DUNGEON_INFO:
import uitabledungeon
#import uidiscord
import uiguias
import grp
if app.ELEMENT_SPELL_WORLDARD:
import uielementspelladd
import uielementchange
if app.ENABLE_GEM_SYSTEM:
import uiGem
import uicz_estadisticas
import uiswitch
import uitablabonus
class Interface(object):
CHARACTER_STATUS_TAB = 1
CHARACTER_SKILL_TAB = 2
wndParty = None
if app.ENABLE_EXPANDED_MONEY_TASKBAR:
wndExpandedMoneyTaskBar = None
def __init__(self):
systemSetting.SetInterfaceHandler(self)
if app.ENABLE_GEM_SYSTEM:
self.wndGemShop = None
if app.ENABLE_TRACK_WINDOW:
self.wndTrackWindow = None
if app.ENABLE_EXCHANGE_LOG:
self.wndExchangeLog = None
if app.ENABLE_RENDER_TARGET:
self.wndRenderTarget = None
if app.RENEWAL_MISSION_BOOKS:
self.wndBookMission = None
self.windowOpenPosition = 0
if app.ENABLE_FISH_GAME:
self.wndFishGame=None
self.dlgWhisperWithoutTarget = None
self.inputDialog = None
self.tipBoard = None
self.bigBoard = None
self.wndGiftBox = None
if app.ENABLE_ZODIAC_MISSION:
self.wnd12ziReward = None
self.wnd12ziTimer = None
if app.ENABLE_WIKI:
self.wndWiki = None
if app.ENABLE_RARITY:
self.wndRarityQueque = None
if app.ENABLE_SHOW_CHEST_DROP:
self.wndChestDropInfo = None
if app.ENABLE_AUTO_SELECT_SKILL:
self.wndAutoSkill = None
if app.ENABLE_EVENT_MANAGER:
self.wndEventManager = None
self.wndEventIcon = None
if app.ENABLE_BATTLE_PASS:
self.wndBattlePassEx = None
if app.ENABLE_BIYOLOG:
self.wndBio = None
if app.ENABLE_DUNGEON_INFO:
self.wndDungeonInfo = None
self.questButtonList = []
if app.dracaryS_DUNGEON_LIB:
self.missionBoard = None
self.wndDungeonTimer=None
if app.ENABLE_ITEMSHOP:
self.wndItemShop=None
# ITEM_MALL
self.mallPageDlg = None
# END_OF_ITEM_MALL
if app.ENABLE_SHOP_SEARCH_SYSTEM:
self.wndPrivateShopSearch=None
if app.ENABLE_OFFLINESHOP_SYSTEM:
self.dlgOfflineShop=None
self.dlgOfflineShopPanel=None
self.offlineShopBuilder=None
self.dlgShopMessage=None
if app.ENABLE_DROP_ITEM_WORLDARD:
self.wndDropItem = None
self.wndTableBonus = None
if app.ENABLE_NEW_PET_SYSTEM:
self.wndPet=None
self.change_window=None
self.wndBattlePass = None
self.wndBattlePassButton = None
if app.ENABLE_CHANNEL_CHANGE:
self.wndChangeChannel = None
if app.ENABLE_MINI_GAME_CATCH_KING:
self.wndCatchKingGame = None
self.wndCatchKingIcon = None
if app.ENABLE_CUBE_RENEWAL_WORLDARD:
self.wndCubeRenewal = None
if app.ENABLE_SWITCHBOT:
self.wndSwitchbot = None
self.wndSwitchbotMenu = None
self.wndSwitchbotManual = None
self.wndWeb = None
self.wndTaskBar = None
self.wndCharacter = None
self.managerAccountBank = None
self.wndInventory = None
self.wndInventoryNew = None
self.wndInventoryGold = None
self.wndExpandedTaskBar = None
self.wndDragonSoul = None
self.wndDragonSoulRefine = None
self.wndChat = None
self.wndMessenger = None
self.wndMiniMap = None
self.wndGuild = None
self.wndGuildBuilding = None
if app.ENABLE_SPECIAL_STORAGE:
self.wndSpecialStorage = None
if app.LINK_IN_CHAT:
self.OpenLinkQuestionDialog = None
self.wndAlmacenMenu = None
self.listGMName = {}
self.wndQuestWindow = {}
self.wndQuestWindowNewKey = 0
self.guildScoreBoardDict = {}
self.equipmentDialogDict = {}
event.SetInterfaceWindow(self)
if app.WJ_ENABLE_TRADABLE_ICON:
self.onTopWindow = player.ON_TOP_WND_NONE
def __del__(self):
systemSetting.DestroyInterfaceHandler()
event.SetInterfaceWindow(None)
def OpenCombatZoneWindow(self):
if player.IsCombatZoneMap():
self.OnAskCombatZoneQuestionDialog()
else:
net.SendCombatZoneRequestActionPacket(net.COMBAT_ZONE_ACTION_OPEN_RANKING, net.COMBAT_ZONE_EMPTY_DATA)
def __OnClickGiftButton(self):
if self.wndGameButton:
if not self.wndGiftBox.IsShow():
self.wndGiftBox.Open()
else:
self.wndGiftBox.Close()
def ClearGift(self):
if self.wndGameButton:
self.wndGameButton.HideGiftButton()
if self.wndGiftBox:
self.wndGiftBox.Clear()
self.wndGiftBox.Refresh()
################################
## Make Windows & Dialogs
def __MakeUICurtain(self):
wndUICurtain = ui.Bar("TOP_MOST")
wndUICurtain.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())
wndUICurtain.SetColor(0x77000000)
wndUICurtain.Hide()
self.wndUICurtain = wndUICurtain
def __MakeMessengerWindow(self):
self.wndMessenger = uiMessenger.MessengerWindow()
from _weakref import proxy
self.wndMessenger.SetWhisperButtonEvent(lambda n,i=proxy(self):i.OpenWhisperDialog(n))
self.wndMessenger.SetGuildButtonEvent(ui.__mem_func__(self.ToggleGuildWindow))
def __MakeGuildWindow(self):
self.wndGuild = uiGuild.GuildWindow()
def __MakeChatWindow(self):
wndChat = uiChat.ChatWindow()
wndChat.SetSize(wndChat.CHAT_WINDOW_WIDTH, 0)
wndChat.SetPosition(wndMgr.GetScreenWidth()/2 - wndChat.CHAT_WINDOW_WIDTH/2, wndMgr.GetScreenHeight() - wndChat.EDIT_LINE_HEIGHT - 37)
wndChat.SetHeight(200)
wndChat.Refresh()
wndChat.Show()
self.wndChat = wndChat
self.wndChat.BindInterface(self)
self.wndChat.SetSendWhisperEvent(ui.__mem_func__(self.OpenWhisperDialogWithoutTarget))
self.wndChat.SetOpenChatLogEvent(ui.__mem_func__(self.ToggleChatLogWindow))
def __MakeTaskBar(self):
import uiGift
wndGiftBox=uiGift.GiftDialog()
wndGiftBox.Hide()
self.wndGiftBox=wndGiftBox
self.wndMobileHUD = None
if getattr(app, "ENABLE_MOBILE_HUD", 0):
self.wndMobileHUD = ui_mobile_hud.MobileHUD(self)
self.wndMobileHUD.Show()
wndTaskBar = uiTaskBar.TaskBar()
wndTaskBar.LoadWindow()
self.wndTaskBar = wndTaskBar
#self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_GOLD, ui.__mem_func__(self.ToggleGoldWindow))
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_CHARACTER, ui.__mem_func__(self.ToggleCharacterWindowStatusPage))
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_INVENTORY, ui.__mem_func__(self.ToggleInventoryWindow))
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_MESSENGER, ui.__mem_func__(self.ToggleMessenger))
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_SYSTEM, ui.__mem_func__(self.ToggleSystemDialog))
#if app.ENABLE_EVENT_MANAGER:
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_CALENDAR, ui.__mem_func__(self.OpenEventCalendar))
#else:
#self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_CALENDAR, ui.__mem_func__(self.CalendarDialog))
if uiTaskBar.TaskBar.IS_EXPANDED:
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_EXPAND, ui.__mem_func__(self.ToggleExpandedButton))
self.wndExpandedTaskBar = uiTaskBar.ExpandedTaskBar()
self.wndExpandedTaskBar.LoadWindow()
self.wndExpandedTaskBar.SetToggleButtonEvent(uiTaskBar.ExpandedTaskBar.BUTTON_DRAGON_SOUL, ui.__mem_func__(self.ToggleDragonSoulWindow))
self.wndExpandedTaskBar.SetToggleButtonEvent(uiTaskBar.ExpandedTaskBar.BUTTON_SWITCHBOT, ui.__mem_func__(self.ToggleSwitchbotWindow))
self.wndExpandedTaskBar.SetToggleButtonEvent(uiTaskBar.ExpandedTaskBar.BUTTON_SHOPSEARCH, ui.__mem_func__(self.OpenPrivateShopSearch))
self.wndExpandedTaskBar.SetToggleButtonEvent(uiTaskBar.ExpandedTaskBar.BUTTON_WIKI, ui.__mem_func__(self.OpenWikiWindow))
self.wndExpandedTaskBar.Show()
self.wndExpandedTaskBar.SetTop()
else:
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_CHAT, ui.__mem_func__(self.ToggleChat))
self.wndEnergyBar = None
if app.ENABLE_ENERGY_SYSTEM:
wndEnergyBar = uiTaskBar.EnergyBar()
wndEnergyBar.LoadWindow()
self.wndEnergyBar = wndEnergyBar
if app.ENABLE_EXPANDED_MONEY_TASKBAR:
self.wndTaskBar.SetToggleButtonEvent(uiTaskBar.TaskBar.BUTTON_EXPAND_MONEY, ui.__mem_func__(self.ToggleExpandedMoneyButton))
self.wndExpandedMoneyTaskBar = uiTaskBar.ExpandedMoneyTaskBar()
self.wndExpandedMoneyTaskBar.LoadWindow()
if self.wndInventory:
self.wndInventory.SetExpandedMoneyBar(self.wndExpandedMoneyTaskBar)
def __MakeParty(self):
wndParty = uiParty.PartyWindow()
wndParty.Hide()
self.wndParty = wndParty
def CalendarDialog(self):
pass
if self.wndCalendar.IsShow():
self.wndCalendar.Close()
else:
net.CalendarOpen()
def __MakeGameButtonWindow(self):
wndGameButton = uiGameButton.GameButtonWindow()
wndGameButton.SetTop()
wndGameButton.Show()
wndGameButton.SetButtonEvent("STATUS", ui.__mem_func__(self.__OnClickStatusPlusButton))
wndGameButton.SetButtonEvent("SKILL", ui.__mem_func__(self.__OnClickSkillPlusButton))
wndGameButton.SetButtonEvent("QUEST", ui.__mem_func__(self.__OnClickQuestButton))
wndGameButton.SetButtonEvent("HELP", ui.__mem_func__(self.__OnClickHelpButton))
wndGameButton.SetButtonEvent("BUILD", ui.__mem_func__(self.__OnClickBuildButton))
wndGameButton.SetButtonEvent("GIFT", ui.__mem_func__(self.__OnClickGiftButton))
wndGameButton.SetButtonEvent("COMBAT_ZONE", ui.__mem_func__(self.OpenCombatZoneWindow))
wndGameButton.SetButtonEvent("BOSS_EVENT", ui.__mem_func__(self.OpenBOSS_EVENT))
wndGameButton.SetButtonEvent("METIN_EVENT", ui.__mem_func__(self.OpenMETIN_EVENT))
self.wndGameButton = wndGameButton
if app.ENABLE_CHANNEL_CHANGE:
self.wndChangeChannel = uiSystem.MoveChannelDialog()
self.wndChangeChannel.Hide()
def OpenBOSS_EVENT(self):
import event
event.QuestButtonClick(constInfo.BOSS_EVENT)
def CheckBossOpenOrNot(self):
if constInfo.BOSS_EVENT_STATUS == 0:
self.wndGameButton.HideBossButton()
else:
self.wndGameButton.ShowBossButton()
def OpenMETIN_EVENT(self):
import event
event.QuestButtonClick(constInfo.METIN_EVENT)
def CheckMetinOpenOrNot(self):
if constInfo.METIN_EVENT_STATUS == 0:
self.wndGameButton.HideMetinButton()
else:
self.wndGameButton.ShowMetinButton()
def CheckCombatOpenOrNot(self):
if constInfo.COMBAT_ZONE == 0:
self.wndGameButton.HideCombatButton()
else:
self.wndGameButton.ShowCombatButton()
def __IsChatOpen(self):
return True
if app.ENABLE_REFINE_RENEWAL:
def CheckRefineDialog(self, isFail):
self.dlgRefineNew.CheckRefine(isFail)
def __MakeWindows(self):
wndCharacter = uiCharacter.CharacterWindow()
wndInventory = uiInventory.InventoryWindow()
wndInventoryNew = uiSpecialInventory.InventoryWindowNew()
wndInventory.SetTop()
wndInventoryNew.SetTop()
wndInventoryGold = uiInventory.NewGoldWindow()
wndInventory.BindInterfaceClass(self)
wndInventoryNew.BindInterfaceClass(self)
if app.ENABLE_DRAGON_SOUL_SYSTEM:
wndDragonSoul = uiDragonSoul.DragonSoulWindow()
wndDragonSoul.BindInterfaceClass(self)
wndDragonSoulRefine = uiDragonSoul.DragonSoulRefineWindow()
else:
wndDragonSoul = None
wndDragonSoulRefine = None
wndMiniMap = uiMiniMap.MiniMap()
wndSafebox = uiSafebox.SafeboxWindow()
#if app.WJ_ENABLE_TRADABLE_ICON:
wndSafebox.BindInterface(self)
# ITEM_MALL
wndMall = uiSafebox.MallWindow()
self.wndMall = wndMall
# END_OF_ITEM_MALL
self.wndAlmacenMenu = uiSafebox.AlmacenMenu()
self.wndAlmacenMenu.Hide()
wndChatLog = uiChat.ChatLogWindow()
wndChatLog.BindInterface(self)
self.wndCharacter = wndCharacter
self.wndInventory = wndInventory
self.wndInventoryNew = wndInventoryNew
self.wndInventoryGold = wndInventoryGold
self.wndDragonSoul = wndDragonSoul
self.wndDragonSoulRefine = wndDragonSoulRefine
self.wndMiniMap = wndMiniMap
self.wndMiniMap.BindInterface(self)
self.wndSafebox = wndSafebox
self.wndChatLog = wndChatLog
if app.ENABLE_SHOW_CHEST_DROP:
self.wndChestDropInfo = uiChestDropInfo.ChestDropInfoWindow()
if app.ENABLE_KINGDOMS_WAR:
self.wndKingdomsWar = uikingdomswar.Window()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.SetDragonSoulRefineWindow(self.wndDragonSoulRefine)
self.wndDragonSoulRefine.SetInventoryWindows(self.wndInventory, self.wndDragonSoul)
self.wndInventory.SetDragonSoulRefineWindow(self.wndDragonSoulRefine)
if app.ENABLE_MINI_GAME_CATCH_KING:
self.wndCatchKingGame = uiMiniGameCatchKing.MiniGameCatchKing()
if app.BL_67_ATTR:
self.wndAttr67Add = uiAttr67Add.Attr67AddWindow()
if app.WJ_ENABLE_TRADABLE_ICON:
self.wndAttr67Add.BindInterface(self)
self.wndAttr67Add.SetInven(self.wndInventory)
self.wndInventory.BindWindow(self.wndAttr67Add)
#self.wndInventoryNew.BindWindow(self.wndAttr67Add)
if app.ENABLE_SWITCHBOT:
self.wndSwitchbot = uiSwitchbot.SwitchbotWindow()
self.wndSwitchbotManual = uiswitch.DopadorManual()
self.wndSwitchbotManual.Hide()
self.wndSwitchbotMenu = uiswitch.DopadorMenu()
self.wndSwitchbotMenu.Hide()
self.wndSwitchbotMenu.BindInterface(self)
if app.ENABLE_SPECIAL_STORAGE:
self.wndSpecialStorage = uiSpecialStorage.SpecialStorageWindow()
self.wndSpecialStorage.BindInterface(self)
else:
self.wndSpecialStorage = None
self.wndczestadisticas = uicz_estadisticas.CombatZoneEstadisticas()
self.wndczestadisticas.Hide()
def __MakeDialogs(self):
self.dlgExchange = uiExchange.ExchangeDialog()
if app.WJ_ENABLE_TRADABLE_ICON:
self.dlgExchange.BindInterface(self)
self.dlgExchange.SetInven(self.wndInventory)
self.wndInventory.BindWindow(self.dlgExchange)
#self.wndInventoryNew.BindWindow(self.dlgExchange)
self.dlgExchange.LoadDialog()
self.dlgExchange.SetCenterPosition()
self.dlgExchange.Hide()
self.dlgPointReset = uiPointReset.PointResetDialog()
self.dlgPointReset.LoadDialog()
self.dlgPointReset.Hide()
if app.ENABLE_MANAGER_BANK_SYSTEM:
self.managerAccountBank = uibankamanger.BankGui()
self.managerAccountBank.Hide()
self.dlgShop = uiShop.ShopDialog()
if app.WJ_ENABLE_TRADABLE_ICON:
self.dlgShop.BindInterface(self)
self.dlgShop.LoadDialog()
self.dlgShop.Hide()
self.wndTicket = uiTicket.TicketWindow()
self.wndTicket.Hide()
# self.wndItemShop = uiItemShop.ItemShopWindow()
# self.wndItemShop.Hide()
self.dlgRestart = uiRestart.RestartDialog()
self.dlgRestart.LoadDialog()
self.dlgRestart.Hide()
self.dlgSystem = uiSystem.SystemDialog()
self.dlgSystem.LoadDialog()
self.dlgSystem.SetOpenHelpWindowEvent(ui.__mem_func__(self.OpenHelpWindow))
self.dlgSystem.Hide()
self.dlgPassword = uiSafebox.PasswordDialog()
self.dlgPassword.Hide()
self.hyperlinkItemTooltip = uiToolTip.HyperlinkItemToolTip()
self.hyperlinkItemTooltip.Hide()
self.tooltipItem = uiToolTip.ItemToolTip()
self.tooltipItem.BindInterface(self)
self.tooltipItem.Hide()
if app.ENABLE_SHOW_CHEST_DROP:
self.wndChestDropInfo.SetTooltipItem(self.tooltipItem)
self.Itemshop_v2 = uiitemshop_v2.Itemshop()
self.Itemshop_v2.BindToolTipItem(self.tooltipItem)
self.tooltipSkill = uiToolTip.SkillToolTip()
self.tooltipSkill.Hide()
self.dlgRefineNew = uiRefine.RefineDialogNew()
if app.WJ_ENABLE_TRADABLE_ICON:
self.dlgRefineNew.SetInven(self.wndInventory)
self.wndInventory.BindWindow(self.dlgRefineNew)
#self.wndInventoryNew.BindWindow(self.dlgRefineNew)
self.dlgRefineNew.Hide()
if app.ELEMENT_SPELL_WORLDARD:
self.dlgElementSpell = uielementspelladd.ElementsSpellAdd()
self.dlgElementSpell.Hide()
self.dlgElementSpellChange = uielementchange.ElementsSpellChange()
self.dlgElementSpellChange.Hide()
#self.wndDiscord = uidiscord.Discord()
#self.wndDiscord.LoadWindow()
#self.wndDiscord.Show()
#self.wndGuias = uiguias.Guias()
#self.wndGuias.LoadWindow()
#self.wndGuias.Show()
def __MakeTableBonus(self):
self.wndTableBonus = uitablabonus.TableBonusWindows()
self.wndTableBonus.LoadWindow()
self.wndTableBonus.Hide()
def __MakeHelpWindow(self):
self.wndHelp = uiHelp.HelpWindow()
self.wndHelp.LoadDialog()
self.wndHelp.SetCloseEvent(ui.__mem_func__(self.CloseHelpWindow))
self.wndHelp.Hide()
def __MakeTipBoard(self):
self.tipBoard = uiTip.TipBoard()
self.tipBoard.Hide()
self.bigBoard = uiTip.BigBoard()
self.bigBoard.Hide()
if app.dracaryS_DUNGEON_LIB:
self.missionBoard = uiTip.MissionBoard()
self.missionBoard.Hide()
def __MakeWebWindow(self):
if constInfo.IN_GAME_SHOP_ENABLE:
import uiWeb
self.wndWeb = uiWeb.WebWindow()
self.wndWeb.LoadWindow()
self.wndWeb.Hide()
def __MakeCubeWindow(self):
self.wndCube = uiCube.CubeWindow()
self.wndCube.LoadWindow()
self.wndCube.Hide()
if app.ENABLE_SASH_SYSTEM:
def __MakeSashWindow(self):
self.wndSashCombine = uisash.CombineWindow()
self.wndSashCombine.LoadWindow()
self.wndSashCombine.Hide()
self.wndSashAbsorption = uisash.AbsorbWindow()
self.wndSashAbsorption.LoadWindow()
self.wndSashAbsorption.Hide()
if self.wndInventory:
self.wndInventory.SetSashWindow(self.wndSashCombine, self.wndSashAbsorption)
self.wndInventoryNew.SetSashWindow(self.wndSashCombine, self.wndSashAbsorption)
def __MakeCubeResultWindow(self):
self.wndCubeResult = uiCube.CubeResultWindow()
self.wndCubeResult.LoadWindow()
self.wndCubeResult.Hide()
def __MakeCardsInfoWindow(self):
self.wndCardsInfo = uiCards.CardsInfoWindow()
self.wndCardsInfo.LoadWindow()
self.wndCardsInfo.Hide()
def __MakeCardsWindow(self):
self.wndCards = uiCards.CardsWindow()
self.wndCards.LoadWindow()
self.wndCards.Hide()
def __MakeCardsIconWindow(self):
self.wndCardsIcon = uiCards.IngameWindow()
self.wndCardsIcon.LoadWindow()
self.wndCardsIcon.Hide()
if app.ENABLE_MINI_GAME_CATCH_KING:
def __MakeCatchKingIconWindow(self):
self.wndCatchKingIcon = uiMiniGameCatchKing.IngameWindow()
self.wndCatchKingIcon.LoadWindow()
self.wndCatchKingIcon.Hide()
# ACCESSORY_REFINE_ADD_METIN_STONE
def __MakeItemSelectWindow(self):
self.wndItemSelect = uiselectitem.SelectItemWindow()
self.wndItemSelect.Hide()
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
#def __MakeCalendar(self):
#self.wndCalendarADM = uicalendar.UiCalendarAdm()
#self.wndCalendarADM.LoadWindow()
#self.wndCalendarADM.Hide()
#self.wndCalendar = uicalendar.UiCalendar()
#self.wndCalendar.LoadWindow()
#self.wndCalendar.()
#self.wndCalendar.Close()
#self.wndCalendar = uiEventCalendar.EventCalendarWindow()
#self.wndCalendar.ClearEvents()
#self.wndCalendar.Close()
#self.wndCalendarIcon = uicalendar.CalendarIngameWindow()
#self.wndCalendarIcon.LoadWindow()
#self.wndCalendarIcon.Show()
if app.ENABLE_DUNGEON_INFO:
def __MakeTableDungeonInfo(self):
self.wndTableDungeonInfo = uitabledungeon.TableDungeonWindows()
self.wndTableDungeonInfo.Hide()
if app.ENABLE_DROP_ITEM_WORLDARD:
def __MakeDropItem(self):
import uidropitem
self.wndDropItem = uidropitem.DropItemWindows()
self.wndDropItem.Hide()
def OpenDropItem(self):
if self.wndDropItem == None:
self.__MakeDropItem()
if self.wndDropItem.IsShow():
self.wndDropItem.Close()
else:
self.wndDropItem.Show()
if app.ENABLE_CUBE_RENEWAL_WORLDARD:
def __MakeCubeRenewal(self):
import uicuberenewal
self.wndCubeRenewal = uicuberenewal.CubeRenewalWindows()
self.wndCubeRenewal.BindToolTipItem(self.tooltipItem)
self.wndCubeRenewal.Hide()
def __MakeBattlePass(self):
import uibattlepass
self.wndBattlePass = uibattlepass.UiBattlePass()
self.wndBattlePass.Hide()
self.wndBattlePassButton = uibattlepass.UiBattlePassButton()
self.wndBattlePassButton.Hide()
def __MakeRenderTooltip(self):
import uirendertooltip
self.rendertooltip = uirendertooltip.RenderTooltip(self.tooltipItem)
self.rendertooltip.CloseRenderTooltip()
def MakeInterface(self):
self.__MakeMessengerWindow()
self.__MakeGuildWindow()
self.__MakeChatWindow()
self.__MakeParty()
self.__MakeWindows()
self.__MakeDialogs()
self.__MakeUICurtain()
self.__MakeTaskBar()
self.__MakeGameButtonWindow()
self.__MakeHelpWindow()
self.__MakeTipBoard()
self.__MakeWebWindow()
self.__MakeTableBonus()
self.__MakeBattlePass()
if app.ENABLE_CUBE_RENEWAL_WORLDARD:
self.__MakeCubeRenewal()
self.__MakeCubeWindow()
if app.ENABLE_SASH_SYSTEM:
self.__MakeSashWindow()
self.__MakeCubeResultWindow()
self.__MakeCardsInfoWindow()
self.__MakeCardsWindow()
self.__MakeCardsIconWindow()
if app.ENABLE_MINI_GAME_CATCH_KING:
self.__MakeCatchKingIconWindow()
#self.__MakeCalendar()
if app.ENABLE_DROP_ITEM_WORLDARD:
self.__MakeDropItem()
if app.ENABLE_DUNGEON_INFO:
self.__MakeTableDungeonInfo()
self.__MakeRenderTooltip()
# ACCESSORY_REFINE_ADD_METIN_STONE
self.__MakeItemSelectWindow()
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
self.questButtonList = []
self.whisperButtonList = []
self.whisperDialogDict = {}
if app.ENABLE_ZODIAC_MISSION:
self.__Make12ziTimerWindow()
self.__Make12ziRewardWindow()
self.wndInventory.SetItemToolTip(self.tooltipItem)
self.wndInventoryNew.SetItemToolTip(self.tooltipItem)
if app.ENABLE_SASH_SYSTEM:
self.wndSashAbsorption.SetItemToolTip(self.tooltipItem)
self.wndSashCombine.SetItemToolTip(self.tooltipItem)
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.SetItemToolTip(self.tooltipItem)
self.wndDragonSoulRefine.SetItemToolTip(self.tooltipItem)
self.wndSafebox.SetItemToolTip(self.tooltipItem)
self.wndCube.SetItemToolTip(self.tooltipItem)
self.wndCubeResult.SetItemToolTip(self.tooltipItem)
if app.ENABLE_SWITCHBOT:
self.wndSwitchbot.SetItemToolTip(self.tooltipItem)
if app.ENABLE_SPECIAL_STORAGE:
self.wndSpecialStorage.SetItemToolTip(self.tooltipItem)
# ITEM_MALL
self.wndMall.SetItemToolTip(self.tooltipItem)
# END_OF_ITEM_MALL
self.wndCharacter.SetSkillToolTip(self.tooltipSkill)
self.wndTaskBar.SetItemToolTip(self.tooltipItem)
self.wndTaskBar.SetSkillToolTip(self.tooltipSkill)
self.wndGuild.SetSkillToolTip(self.tooltipSkill)
# ACCESSORY_REFINE_ADD_METIN_STONE
self.wndItemSelect.SetItemToolTip(self.tooltipItem)
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
self.dlgShop.SetItemToolTip(self.tooltipItem)
self.dlgExchange.SetItemToolTip(self.tooltipItem)
self.__InitWhisper()
self.DRAGON_SOUL_IS_QUALIFIED = False
if app.LINK_IN_CHAT:
def AnswerOpenLink(self, answer):
if not self.OpenLinkQuestionDialog:
return
self.OpenLinkQuestionDialog.Close()
self.OpenLinkQuestionDialog = None
if not answer:
return
link = constInfo.link
def MakeHyperlinkTooltip(self, hyperlink):
tokens = hyperlink.split(":")
if tokens and len(tokens):
type = tokens[0]
if "item" == type:
self.hyperlinkItemTooltip.SetHyperlinkItem(tokens)
elif "msg" == type and str(tokens[1]) != player.GetMainCharacterName():
self.OpenWhisperDialog(str(tokens[1]))
elif app.LINK_IN_CHAT and "web" == type and tokens[1].startswith("httpXxX") or "web" == type and tokens[1].startswith("httpsXxX"):
os.system("start " + tokens[1].replace("XxX", "://").replace("&","^&"))
elif app.LINK_IN_CHAT and "sysweb" == type:
os.system("start " + tokens[1].replace("XxX", "://"))
elif "chat_mp" == type:
self.OpenWhisperDialog(str(tokens[1]))
## Make Windows & Dialogs
################################
def OpenGift(self):
if self.wndGameButton:
self.wndGameButton.ShowGiftButton()
def Close(self):
if app.RENEWAL_MISSION_BOOKS:
if self.wndBookMission:
self.wndBookMission.Close()
self.wndBookMission.Destroy()
self.wndBookMission = None
if app.ENABLE_GEM_SYSTEM:
if self.wndGemShop:
self.wndGemShop.Close()
self.wndGemShop.Destroy()
self.wndGemShop=None
if app.ENABLE_EXCHANGE_LOG:
if self.wndExchangeLog:
self.wndExchangeLog.Close()
self.wndExchangeLog.Destroy()
self.wndExchangeLog = None
if app.ENABLE_FISH_GAME:
if self.wndFishGame:
self.wndFishGame.Hide()
self.wndFishGame.Destroy()
self.wndFishGame=None
if app.ENABLE_TRACK_WINDOW:
if self.wndTrackWindow:
self.wndTrackWindow.Close()
self.wndTrackWindow.Destroy()
self.wndTrackWindow=None
if app.ENABLE_RENDER_TARGET:
if self.wndRenderTarget:
self.wndRenderTarget.Close()
self.wndRenderTarget.Destroy()
self.wndRenderTarget=None
if self.dlgWhisperWithoutTarget:
self.dlgWhisperWithoutTarget.Hide()
self.dlgWhisperWithoutTarget.Destroy()
del self.dlgWhisperWithoutTarget
if app.ENABLE_ZODIAC_MISSION:
if self.wnd12ziTimer:
self.wnd12ziTimer.Hide()
self.wnd12ziTimer=None
if self.wnd12ziReward:
self.wnd12ziReward.Hide()
self.wnd12ziReward=None
if uiQuest.QuestDialog.__dict__.has_key("QuestCurtain"):
uiQuest.QuestDialog.QuestCurtain.Close()
if self.wndQuestWindow:
for key, eachQuestWindow in self.wndQuestWindow.items():
eachQuestWindow.nextCurtainMode = -1
eachQuestWindow.Hide()
eachQuestWindow.CloseSelf()
eachQuestWindow = None
self.wndQuestWindow = {}
if app.ENABLE_WIKI:
if self.wndWiki:
self.wndWiki.Close()
self.wndWiki.Destroy()
self.wndWiki=None
if app.ENABLE_RARITY:
if self.wndRarityQueque:
self.wndRarityQueque.Hide()
self.wndRarityQueque.Destroy()
self.wndRarityQueque = None
if app.ENABLE_AUTO_SELECT_SKILL:
if self.wndAutoSkill:
self.wndAutoSkill.Hide()
self.wndAutoSkill.Destroy()
self.wndAutoSkill=None
if app.ENABLE_EVENT_MANAGER:
if self.wndEventManager:
self.wndEventManager.Hide()
self.wndEventManager.Destroy()
self.wndEventManager = None
if self.wndEventIcon:
self.wndEventIcon.Hide()
self.wndEventIcon.Destroy()
self.wndEventIcon = None
if app.ENABLE_ITEMSHOP:
if self.wndItemShop:
self.wndItemShop.Hide()
self.wndItemShop.Destroy()
self.wndItemShop = None
if app.ENABLE_DUNGEON_INFO:
if self.wndDungeonInfo:
self.wndDungeonInfo.Close()
self.wndDungeonInfo.Destroy()
self.wndDungeonInfo = None
if app.ENABLE_MINI_GAME_CATCH_KING:
if self.wndCatchKingGame:
self.wndCatchKingGame.Destroy()
del self.wndCatchKingGame
if self.wndCatchKingIcon:
self.wndCatchKingIcon.Destroy()
del self.wndCatchKingIcon
if self.wndGiftBox:
self.wndGiftBox.Clear()
self.wndGiftBox.Hide()
self.wndGiftBox.Destroy()
del self.wndGiftBox
if app.ENABLE_BATTLE_PASS:
if self.wndBattlePassEx:
self.wndBattlePassEx.Close()
self.wndBattlePassEx.Destroy()
self.wndBattlePassEx = None
if app.ENABLE_CHANNEL_CHANGE:
if self.wndChangeChannel:
self.wndChangeChannel.Hide()
self.wndChangeChannel.Destroy()
self.wndChangeChannel = None
if app.ENABLE_NEW_PET_SYSTEM:
if self.wndPet:
self.wndPet.Close()
self.wndPet.Destroy()
del self.wndPet
self.wndPet = None
if self.change_window:
self.change_window.Hide()
self.change_window.Destroy()
del self.change_window
self.change_window = None
#if self.wndDiscord:
#self.wndDiscord.Destroy()
#if self.wndGuias:
#self.wndGuias.Destroy()
if self.wndChat:
self.wndChat.Hide()
self.wndChat.Destroy()
if self.wndTaskBar:
self.wndTaskBar.Hide()
self.wndTaskBar.Destroy()
if self.wndExpandedTaskBar:
self.wndExpandedTaskBar.Hide()
self.wndExpandedTaskBar.Destroy()
if self.wndEnergyBar:
self.wndEnergyBar.Hide()
self.wndEnergyBar.Destroy()
if self.wndCharacter:
self.wndCharacter.Hide()
self.wndCharacter.Destroy()
if self.wndInventory:
self.wndInventory.Hide()
self.wndInventory.Destroy()
if self.wndInventoryNew:
self.wndInventoryNew.Hide()
self.wndInventoryNew.Destroy()
if self.wndInventoryGold:
self.wndInventoryGold.Hide()
self.wndInventoryGold.Destroy()
if self.wndDragonSoul:
self.wndDragonSoul.Hide()
self.wndDragonSoul.Destroy()
if self.wndDragonSoulRefine:
self.wndDragonSoulRefine.Hide()
self.wndDragonSoulRefine.Destroy()
if app.ENABLE_SPECIAL_STORAGE:
if self.wndSpecialStorage:
self.wndSpecialStorage.Hide()
self.wndSpecialStorage.Destroy()
if self.dlgExchange:
self.dlgExchange.Hide()
self.dlgExchange.Destroy()
if self.dlgPointReset:
self.dlgPointReset.Hide()
self.dlgPointReset.Destroy()
if self.dlgShop:
self.dlgShop.Hide()
self.dlgShop.Destroy()
if self.wndTicket:
self.wndTicket.Hide()
self.wndTicket.Destroy()
# if self.wndItemShop:
# self.wndItemShop.Destroy()
if self.dlgRestart:
self.dlgRestart.Hide()
self.dlgRestart.Destroy()
if self.dlgSystem:
self.dlgSystem.Hide()
self.dlgSystem.Destroy()
if self.dlgPassword:
self.dlgPassword.Hide()
self.dlgPassword.Destroy()
if self.wndMiniMap:
self.wndMiniMap.Hide()
self.wndMiniMap.Destroy()
if self.wndSafebox:
self.wndSafebox.Hide()
self.wndSafebox.Destroy()
if self.wndWeb:
self.wndWeb.Hide()
self.wndWeb.Destroy()
self.wndWeb = None
if self.wndMall:
self.wndMall.Hide()
self.wndMall.Destroy()
if self.Itemshop_v2:
self.Itemshop_v2.Hide()
self.Itemshop_v2.Destroy()
if app.ENABLE_MANAGER_BANK_SYSTEM:
if self.managerAccountBank:
self.managerAccountBank.Hide()
self.managerAccountBank.Destroy()
if self.wndParty:
self.wndParty.Hide()
self.wndParty.Destroy()
if app.ENABLE_SWITCHBOT:
if self.wndSwitchbot:
self.wndSwitchbot.Hide()
self.wndSwitchbot.Destroy()
if self.wndSwitchbotMenu:
self.wndSwitchbotMenu.Close()
self.wndSwitchbotMenu.Destroy()
if self.wndSwitchbotManual:
self.wndSwitchbotManual.Close()
self.wndSwitchbotManual.Destroy()
if self.wndczestadisticas:
self.wndczestadisticas.Close()
self.wndczestadisticas.Destroy()
if self.wndAlmacenMenu:
self.wndAlmacenMenu.Close()
self.wndAlmacenMenu.Destroy()
if self.wndHelp:
self.wndHelp.Hide()
self.wndHelp.Destroy()
if self.wndCardsInfo:
self.wndCardsInfo.Destroy()
if self.wndCards:
self.wndCards.Destroy()
if self.wndCardsIcon:
self.wndCardsIcon.Destroy()
if self.wndCube:
self.wndCube.Hide()
self.wndCube.Destroy()
if self.wndCubeResult:
self.wndCubeResult.Hide()
self.wndCubeResult.Destroy()
if app.ENABLE_DUNGEON_INFO:
if self.wndTableDungeonInfo:
self.wndTableDungeonInfo.Close()
self.wndTableDungeonInfo.Destroy()
if self.rendertooltip:
self.rendertooltip.Hide()
self.rendertooltip.Destroy()
if self.wndMessenger:
self.wndMessenger.Hide()
self.wndMessenger.Destroy()
if self.wndGuild:
self.wndGuild.Hide()
self.wndGuild.Destroy()
#if self.wndCalendarIcon:
#self.wndCalendarIcon.Show()
#if self.wndCalendarADM:
#self.wndCalendarADM.Destroy()
#if self.wndCalendar:
# self.wndCalendar.Hide()
# self.wndCalendar.Destroy()
if self.dlgRefineNew:
self.dlgRefineNew.Close()
self.dlgRefineNew.Destroy()
if self.wndGuildBuilding:
self.wndGuildBuilding.Hide()
self.wndGuildBuilding.Destroy()
if self.wndGameButton:
self.wndGameButton.Hide()
self.wndGameButton.Destroy()
if app.ENABLE_SHOW_CHEST_DROP:
if self.wndChestDropInfo:
del self.wndChestDropInfo
# ITEM_MALL
if self.mallPageDlg:
self.mallPageDlg.Hide()
self.mallPageDlg.Destroy()
if app.BL_67_ATTR:
if self.wndAttr67Add:
del self.wndAttr67Add
# END_OF_ITEM_MALL
# ACCESSORY_REFINE_ADD_METIN_STONE
if self.wndItemSelect:
self.wndItemSelect.Hide()
self.wndItemSelect.Destroy()
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
if app.ENABLE_OFFLINESHOP_SYSTEM:
if self.dlgOfflineShop:
self.dlgOfflineShop.Hide()
self.dlgOfflineShop.Destroy()
del self.dlgOfflineShop
if self.dlgOfflineShopPanel:
self.dlgOfflineShopPanel.Hide()
self.dlgOfflineShopPanel.Destroy()
del self.dlgOfflineShopPanel
if self.offlineShopBuilder:
self.offlineShopBuilder.Hide()
self.offlineShopBuilder.Destroy()
del self.offlineShopBuilder
if self.dlgShopMessage:
self.dlgShopMessage.Hide()
self.dlgShopMessage.Destroy()
self.dlgShopMessage=None
if app.ENABLE_SHOP_SEARCH_SYSTEM:
if self.wndPrivateShopSearch:
self.wndPrivateShopSearch.Hide()
self.wndPrivateShopSearch.Destroy()
del self.wndPrivateShopSearch
self.wndPrivateShopSearch=0
if app.ENABLE_DROP_ITEM_WORLDARD:
if self.wndDropItem:
self.wndDropItem.Close()
self.wndDropItem.Destroy()
if app.ENABLE_CUBE_RENEWAL_WORLDARD:
if self.wndCubeRenewal:
self.wndCubeRenewal.Close()
self.wndCubeRenewal.Destroy()
if self.wndBattlePass:
self.wndBattlePass.Close()
self.wndBattlePass.Destroy()
if self.wndBattlePassButton:
self.wndBattlePassButton.Hide()
self.wndBattlePassButton.Destroy()
#self.wndBattlePassButton.Close()
if self.wndTableBonus:
self.wndTableBonus.Close()
self.wndTableBonus.Destroy()
if app.ELEMENT_SPELL_WORLDARD:
if self.dlgElementSpell:
self.dlgElementSpell.Hide()
self.dlgElementSpell.Destroy()
if self.dlgElementSpellChange:
self.dlgElementSpellChange.Hide()
self.dlgElementSpellChange.Destroy()
del self.dlgElementSpell
del self.dlgElementSpellChange
if app.ENABLE_BIYOLOG:
if self.wndBio:
self.wndBio.Hide()
self.wndBio.Destroy()
del self.wndBio
self.wndChatLog.Destroy()
if app.ENABLE_EXPANDED_MONEY_TASKBAR:
if self.wndExpandedMoneyTaskBar:
self.wndExpandedMoneyTaskBar.Hide()
self.wndExpandedMoneyTaskBar.Destroy()
for btn in self.questButtonList:
btn.SetEvent(0)
btn.Hide()
for btn in self.whisperButtonList:
btn.SetEvent(0)
for dlg in self.whisperDialogDict.itervalues():
dlg.Hide()
dlg.Destroy()
for brd in self.guildScoreBoardDict.itervalues():
brd.Hide()
brd.Destroy()
for dlg in self.equipmentDialogDict.itervalues():
dlg.Hide()
dlg.Destroy()
del self.wndczestadisticas
del self.wndSwitchbotManual
del self.wndSwitchbotMenu
del self.wndAlmacenMenu
# ITEM_MALL
del self.mallPageDlg
# END_OF_ITEM_MALL
if app.ENABLE_DROP_ITEM_WORLDARD:
del self.wndDropItem
del self.Itemshop_v2
if app.ENABLE_MANAGER_BANK_SYSTEM:
del self.managerAccountBank
del self.wndGuild
del self.wndMessenger
del self.wndUICurtain
del self.wndChat
del self.wndBattlePass
del self.wndBattlePassButton
if app.ENABLE_CUBE_RENEWAL_WORLDARD:
del self.wndCubeRenewal
del self.wndTableBonus
del self.wndTaskBar
if self.wndExpandedTaskBar:
del self.wndExpandedTaskBar
del self.wndEnergyBar
del self.wndCharacter
del self.wndInventory
del self.wndInventoryNew
del self.wndInventoryGold
if self.wndDragonSoul:
del self.wndDragonSoul
if self.wndDragonSoulRefine:
del self.wndDragonSoulRefine
if app.ENABLE_SPECIAL_STORAGE:
if self.wndSpecialStorage:
del self.wndSpecialStorage
del self.dlgExchange
del self.dlgPointReset
del self.dlgShop
del self.dlgRestart
del self.dlgSystem
del self.dlgPassword
del self.hyperlinkItemTooltip
del self.tooltipItem
del self.tooltipSkill
del self.wndMiniMap
del self.wndSafebox
del self.wndMall
del self.wndParty
del self.wndHelp
del self.wndCardsInfo
del self.wndCards
del self.wndCardsIcon
del self.wndCube
del self.wndCubeResult
del self.inputDialog
del self.wndChatLog
del self.dlgRefineNew
del self.wndGuildBuilding
del self.wndGameButton
del self.tipBoard
del self.bigBoard
if app.dracaryS_DUNGEON_LIB:
del self.missionBoard
if self.wndDungeonTimer:
self.wndDungeonTimer.Hide()
self.wndDungeonTimer=0
del self.wndItemSelect
del self.wndTicket
#del self.wndDiscord
#del self.wndGuias
if app.ENABLE_DUNGEON_INFO:
del self.wndTableDungeonInfo
#del self.wndCalendarIcon
#del self.wndCalendarADM
#del self.wndCalendar
del self.rendertooltip
if app.ENABLE_EXPANDED_MONEY_TASKBAR:
if self.wndExpandedMoneyTaskBar:
self.wndExpandedMoneyTaskBar = None
# del self.wndItemShop
self.questButtonList = []
self.whisperButtonList = []
self.whisperDialogDict = {}
self.guildScoreBoardDict = {}
self.equipmentDialogDict = {}
if app.ENABLE_KINGDOMS_WAR:
if self.wndKingdomsWar:
self.wndKingdomsWar.Hide()
self.wndKingdomsWar.Destroy()
del self.wndKingdomsWar
event.SetInterfaceWindow(None)
uiChat.DestroyChatInputSetWindow()
## Skill
def OnUseSkill(self, slotIndex, coolTime):
self.wndCharacter.OnUseSkill(slotIndex, coolTime)
self.wndTaskBar.OnUseSkill(slotIndex, coolTime)
self.wndGuild.OnUseSkill(slotIndex, coolTime)
def OnActivateSkill(self, slotIndex):
self.wndCharacter.OnActivateSkill(slotIndex)
self.wndTaskBar.OnActivateSkill(slotIndex)
def OnDeactivateSkill(self, slotIndex):
self.wndCharacter.OnDeactivateSkill(slotIndex)
self.wndTaskBar.OnDeactivateSkill(slotIndex)
def OnChangeCurrentSkill(self, skillSlotNumber):
self.wndTaskBar.OnChangeCurrentSkill(skillSlotNumber)
def SelectMouseButtonEvent(self, dir, event):
self.wndTaskBar.SelectMouseButtonEvent(dir, event)
if app.BL_67_ATTR:
def OpenAttr67AddDlg(self):
if self.wndAttr67Add:
self.wndAttr67Add.Show()
if app.WJ_ENABLE_TRADABLE_ICON:
def IsAttr67RegistItem(self):
return self.wndAttr67Add and self.wndAttr67Add.RegistSlotIndex != -1
def IsAttr67SupportItem(self):
return self.wndAttr67Add and self.wndAttr67Add.SupportSlotIndex != -1
## Refresh
def RefreshAlignment(self):
self.wndCharacter.RefreshAlignment()
def RefreshStatus(self):
self.wndTaskBar.RefreshStatus()
self.wndCharacter.RefreshStatus()
self.wndInventory.RefreshStatus()
self.wndInventoryNew.RefreshStatus()
self.wndInventoryGold.RefreshStatus()
if self.wndEnergyBar:
self.wndEnergyBar.RefreshStatus()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.RefreshStatus()
if self.wndTableBonus:
self.wndTableBonus.RefreshBonus()
#if self.wndczestadisticas:
# self.wndczestadisticas.RefreshStatus()
if app.ENABLE_HIDE_COSTUME_SYSTEM:
def costume_hide_clear(self):
self.wndInventory.costume_hide_clear()
def costume_hide_list(self,slot,index):
self.wndInventory.costume_hide_list(slot,index)
def costume_hide_load(self):
self.wndInventory.costume_hide_load()
def RefreshStamina(self):
self.wndTaskBar.RefreshStamina()
def RefreshSkill(self):
self.wndCharacter.RefreshSkill()
self.wndTaskBar.RefreshSkill()
def RefreshInventory(self):
self.wndTaskBar.RefreshQuickSlot()
self.wndInventory.RefreshItemSlot()
self.wndInventoryNew.RefreshItemSlot()
self.wndInventoryGold.RefreshStatus()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.RefreshItemSlot()
if app.ENABLE_SPECIAL_STORAGE:
self.wndSpecialStorage.RefreshItemSlot()
def RefreshCharacter(self): ## Character ÆäÀÌÁöÀÇ ¾ó±¼, Inventory ÆäÀÌÁöÀÇ Àü½Å ±×¸² µîÀÇ Refresh
self.wndCharacter.RefreshCharacter()
self.wndTaskBar.RefreshQuickSlot()
def RefreshQuest(self):
self.wndCharacter.RefreshQuest()
def RefreshSafebox(self):
#self.wndSafebox.RefreshSafebox()
self.wndInventoryNew.RefreshSafebox()
# ITEM_MALL
def RefreshMall(self):
#self.wndSafebox.RefreshMall()
self.wndInventoryNew.RefreshMall()
def OpenItemMall(self):
if not self.mallPageDlg:
self.mallPageDlg = uiShop.MallPageDialog()
self.mallPageDlg.Open()
# END_OF_ITEM_MALL
def RefreshMessenger(self):
self.wndMessenger.RefreshMessenger()
def RefreshGuildInfoPage(self):
self.wndGuild.RefreshGuildInfoPage()
def RefreshGuildBoardPage(self):
self.wndGuild.RefreshGuildBoardPage()
def RefreshGuildMemberPage(self):
self.wndGuild.RefreshGuildMemberPage()
def RefreshGuildMemberPageGradeComboBox(self):
self.wndGuild.RefreshGuildMemberPageGradeComboBox()
def RefreshGuildSkillPage(self):
self.wndGuild.RefreshGuildSkillPage()
def RefreshGuildGradePage(self):
self.wndGuild.RefreshGuildGradePage()
def DeleteGuild(self):
self.wndMessenger.ClearGuildMember()
self.wndGuild.DeleteGuild()
def RefreshMobile(self):
self.dlgSystem.RefreshMobile()
def OnMobileAuthority(self):
self.dlgSystem.OnMobileAuthority()
def OnBlockMode(self, mode):
self.dlgSystem.OnBlockMode(mode)
## Calling Functions
# PointReset
def OpenPointResetDialog(self):
self.dlgPointReset.Show()
self.dlgPointReset.SetTop()
def ClosePointResetDialog(self):
self.dlgPointReset.Close()
# Shop
if (app.WJ_COMBAT_ZONE):
def OpenShopDialog(self, vid, points, curLimit, maxLimit):
self.wndInventory.Show()
self.wndInventory.SetTop()
self.dlgShop.Open(vid, points, curLimit, maxLimit)
self.dlgShop.SetTop()
else:
def OpenShopDialog(self, vid):
self.wndInventory.Show()
self.wndInventory.SetTop()
self.dlgShop.Open(vid)
self.dlgShop.SetTop()
def CloseShopDialog(self):
self.dlgShop.Close()
def RefreshShopDialog(self):
self.dlgShop.Refresh()
## Quest
def OpenCharacterWindowQuestPage(self):
self.wndCharacter.Show()
self.wndCharacter.SetState("QUEST")
def OpenQuestWindow(self, skin, idx):
wnds = ()
q = uiQuest.QuestDialog(skin, idx)
q.SetWindowName("QuestWindow" + str(idx))
q.Show()
if skin:
q.Lock()
wnds = self.__HideWindows()
q.AddOnDoneEvent(lambda tmp_self, args=wnds: self.__ShowWindows(args))
q.AddOnCloseEvent(q.Unlock)
q.AddOnCloseEvent(lambda key = self.wndQuestWindowNewKey:ui.__mem_func__(self.RemoveQuestDialog)(key))
self.wndQuestWindow[self.wndQuestWindowNewKey] = q
self.wndQuestWindowNewKey = self.wndQuestWindowNewKey + 1
# END_OF_UNKNOWN_UPDATE
def RemoveQuestDialog(self, key):
del self.wndQuestWindow[key]
## Exchange
def StartExchange(self):
self.dlgExchange.OpenDialog()
self.dlgExchange.Refresh()
def EndExchange(self):
self.dlgExchange.CloseDialog()
def RefreshExchange(self):
self.dlgExchange.Refresh()
if app.WJ_ENABLE_TRADABLE_ICON:
def CantTradableItemExchange(self, dstSlotIndex, srcSlotIndex):
self.dlgExchange.CantTradableItem(dstSlotIndex, srcSlotIndex)
def BINARY_CALENDAR_OPEN_ADM(self):
return
#self.wndCalendarADM.Show()
def BINARY_CALENDAR_LOAD_EVENTS_ADM(self,index_event,name_event,descrip_event):
return
#self.wndCalendarADM.RegistroEventos(index_event,name_event)
def BINARY_CALENDAR_CLEAR_EVENTS_ADM(self):
return
#self.wndCalendarADM.ClearRegistro()
def BINARY_CALENDAR_LOADING_EVENTS_ADM(self):
return
#self.wndCalendarADM.LoadEvents()
def BINARY_CALENDAR_OPEN(self, currentTimeStamp):
pass
#self.wndCalendar.Open(currentTimeStamp)
def BINARY_CALENDAR_LOAD_EVENTS(self,day,name,image,startAt, endAt,duration):
pass
#wndEventCalendar.AppendEvent(1, "Evento Caja Luz de Luna 1", "alquimia.tga", 1633654036, 7200)
#self.wndCalendar.AppendEvent(day,name,image,startAt, endAt,duration)
def BINARY_CALENDAR_CLEAR_EVENTS(self):
pass
#self.wndCalendar.ClearEvents()
def BINARY_CALENDAR_LOADING_EVENTS(self):
pass
#self.wndCalendar.LoadingEventos()
## Party
def AddPartyMember(self, pid, name):
self.wndParty.AddPartyMember(pid, name)
self.__ArrangeQuestButton()
def UpdatePartyMemberInfo(self, pid):
self.wndParty.UpdatePartyMemberInfo(pid)
def RemovePartyMember(self, pid):
self.wndParty.RemovePartyMember(pid)
##!! 20061026.levites.Äù½ºÆ®_À§Ä¡_º¸Á¤
self.__ArrangeQuestButton()
def LinkPartyMember(self, pid, vid):
self.wndParty.LinkPartyMember(pid, vid)
def UnlinkPartyMember(self, pid):
self.wndParty.UnlinkPartyMember(pid)
def UnlinkAllPartyMember(self):
self.wndParty.UnlinkAllPartyMember()
def ExitParty(self):
self.wndParty.ExitParty()
##!! 20061026.levites.Äù½ºÆ®_À§Ä¡_º¸Á¤
self.__ArrangeQuestButton()
def PartyHealReady(self):
self.wndParty.PartyHealReady()
def ChangePartyParameter(self, distributionMode):
self.wndParty.ChangePartyParameter(distributionMode)
## Safebox
def AskSafeboxPassword(self):
if self.wndSafebox.IsShow():
return
# SAFEBOX_PASSWORD
self.dlgPassword.SetTitle(localeInfo.PASSWORD_TITLE)
self.dlgPassword.SetSendMessage("/safebox_password ")
# END_OF_SAFEBOX_PASSWORD
self.dlgPassword.ShowDialog()
def OpenSafeboxWindow(self, size):
self.dlgPassword.CloseDialog()
#self.wndSafebox.ShowWindow(size)
self.wndInventoryNew.ShowWindow(size)
def RefreshSafeboxMoney(self):
return
self.wndSafebox.RefreshSafeboxMoney()
def CommandCloseSafebox(self):
self.wndInventoryNew.CommandCloseSafebox()
#self.wndSafebox.CommandCloseSafebox()
if app.ELEMENT_SPELL_WORLDARD:
def ElementsSpellOpen(self,itemPos, func, cost, grade_add):
self.dlgElementSpell.Open(itemPos, func, cost, grade_add)
def ElementsSpellChangeOpen(self, itemPos, cost):
self.dlgElementSpellChange.Open(itemPos, cost)
# ITEM_MALL
def AskMallPassword(self):
if self.wndMall.IsShow():
return
self.dlgPassword.SetTitle(localeInfo.MALL_PASSWORD_TITLE)
self.dlgPassword.SetSendMessage("/mall_password ")
self.dlgPassword.ShowDialog()
def OpenMallWindow(self, size):
self.dlgPassword.CloseDialog()
#self.wndMall.ShowWindow(size)
self.wndInventoryNew.ShowWindow(size)
def CommandCloseMall(self):
#self.wndMall.CommandCloseMall()
self.wndInventoryNew.CommandCloseMall()
# END_OF_ITEM_MALL
## Guild
def OnStartGuildWar(self, guildSelf, guildOpp):
self.wndGuild.OnStartGuildWar(guildSelf, guildOpp)
guildWarScoreBoard = uiGuild.GuildWarScoreBoard()
guildWarScoreBoard.Open(guildSelf, guildOpp)
guildWarScoreBoard.Show()
self.guildScoreBoardDict[uiGuild.GetGVGKey(guildSelf, guildOpp)] = guildWarScoreBoard
def OnEndGuildWar(self, guildSelf, guildOpp):
self.wndGuild.OnEndGuildWar(guildSelf, guildOpp)
key = uiGuild.GetGVGKey(guildSelf, guildOpp)
if not self.guildScoreBoardDict.has_key(key):
return
self.guildScoreBoardDict[key].Hide()
self.guildScoreBoardDict[key].Destroy()
del self.guildScoreBoardDict[key]
# GUILDWAR_MEMBER_COUNT
def UpdateMemberCount(self, gulidID1, memberCount1, guildID2, memberCount2):
key = uiGuild.GetGVGKey(gulidID1, guildID2)
if not self.guildScoreBoardDict.has_key(key):
return
self.guildScoreBoardDict[key].UpdateMemberCount(gulidID1, memberCount1, guildID2, memberCount2)
# END_OF_GUILDWAR_MEMBER_COUNT
def OnRecvGuildWarPoint(self, gainGuildID, opponentGuildID, point):
key = uiGuild.GetGVGKey(gainGuildID, opponentGuildID)
if not self.guildScoreBoardDict.has_key(key):
return
guildBoard = self.guildScoreBoardDict[key]
guildBoard.SetScore(gainGuildID, opponentGuildID, point)
## PK Mode
def OnChangePKMode(self):
self.wndCharacter.RefreshAlignment()
self.dlgSystem.OnChangePKMode()
if app.ENABLE_AUTOMATIC_PICK_UP_SYSTEM:
def OnChangePickUPMode(self):
self.dlgSystem.OnChangePickUPMode()
## Refine
def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, special_storage, type):
self.dlgRefineNew.Open(targetItemPos, nextGradeItemVnum, cost, prob, special_storage, type)
def AppendMaterialToRefineDialog(self, vnum, count):
self.dlgRefineNew.AppendMaterial(vnum, count)
if app.ENABLE_MULTI_REFINE_WORLDARD:
def BINARY_MULTI_REFINE_ADD_INFO(self, index, targetItemPos, nextGradeItemVnum, cost, prob, special_storage, type):
self.dlgRefineNew.func_set_info(index, targetItemPos, nextGradeItemVnum, cost, prob, special_storage, type)
def BINARY_MULTI_REFINE_ADD_MATERIAL(self,index, vnum, count):
self.dlgRefineNew.AppendMaterial(index, vnum, count)
def BINARY_MULTI_REFINE_CLEAR_INFO(self):
self.dlgRefineNew.func_clear_info()
def BINARY_MULTI_REFINE_LOAD_INFO(self):
self.dlgRefineNew.Load()
def BINARY_MULTI_REFINE_OPEN(self):
self.dlgRefineNew.Open()
## Show & Hide
def ShowDefaultWindows(self):
self.wndTaskBar.Show()
if hasattr(self, "wndMobileHUD") and self.wndMobileHUD: self.wndMobileHUD.Show()
self.wndMiniMap.Show()
self.wndMiniMap.ShowMiniMap()
if self.wndEnergyBar:
self.wndEnergyBar.Show()
def ShowAllWindows(self):
self.wndTaskBar.Show()
self.wndCharacter.Show()
self.wndInventory.Show()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.Show()
self.wndDragonSoulRefine.Show()
self.wndChat.Show()
self.wndMiniMap.Show()
if self.wndEnergyBar:
self.wndEnergyBar.Show()
if self.wndExpandedTaskBar:
self.wndExpandedTaskBar.Show()
self.wndExpandedTaskBar.SetTop()
if app.ENABLE_EXPANDED_MONEY_TASKBAR:
if self.wndExpandedMoneyTaskBar:
self.wndExpandedMoneyTaskBar.Show()
self.wndExpandedMoneyTaskBar.SetTop()
if app.ENABLE_ZODIAC_MISSION:
if self.wnd12ziTimer:
self.wnd12ziTimer.Show()
if self.wnd12ziReward:
self.wnd12ziReward.Show()
def HideAllWindows(self):
if self.wndTaskBar:
self.wndTaskBar.Hide()
if self.wndAlmacenMenu:
self.wndAlmacenMenu.Hide()
if app.ENABLE_SWITCHBOT:
if self.wndSwitchbot:
self.wndSwitchbot.Hide()
if self.wndSwitchbotMenu:
self.wndSwitchbotMenu.Hide()
if self.wndSwitchbotManual:
self.wndSwitchbotManual.Hide()
if self.wndczestadisticas:
self.wndczestadisticas.Hide()
if self.wndEnergyBar:
self.wndEnergyBar.Hide()
if self.wndCharacter:
self.wndCharacter.Close()
if self.wndInventory:
self.wndInventory.Hide()
if app.ENABLE_EXPANDED_MONEY_TASKBAR:
if self.wndExpandedMoneyTaskBar:
self.wndExpandedMoneyTaskBar.Hide()
if self.wndInventoryGold:
self.wndInventoryGold.Hide()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.Hide()
self.wndDragonSoulRefine.Hide()
if self.wndChat:
self.wndChat.Hide()
if app.ENABLE_ZODIAC_MISSION:
if self.wnd12ziTimer:
self.wnd12ziTimer.Hide()
if self.wnd12ziReward:
self.wnd12ziReward.Hide()
if self.wndMiniMap:
self.wndMiniMap.Hide()
if self.wndMessenger:
self.wndMessenger.Hide()
if self.wndGuild:
self.wndGuild.Hide()
if self.wndExpandedTaskBar:
self.wndExpandedTaskBar.Hide()
if app.ENABLE_SHOW_CHEST_DROP:
if self.wndChestDropInfo:
self.wndChestDropInfo.Hide()
def ShowMouseImage(self):
self.wndTaskBar.ShowMouseImage()
def HideMouseImage(self):
self.wndTaskBar.HideMouseImage()
def ToggleChat(self):
if True == self.wndChat.IsEditMode():
self.wndChat.CloseChat()
else:
# À¥ÆäÀÌÁö°¡ ¿­·ÈÀ»¶§´Â äÆÃ ÀÔ·ÂÀÌ ¾ÈµÊ
if self.wndWeb and self.wndWeb.IsShow():
pass
else:
self.wndChat.OpenChat()
def IsOpenChat(self):
return self.wndChat.IsEditMode()
def SetChatFocus(self):
self.wndChat.SetChatFocus()
if app.RENEWAL_DEAD_PACKET:
def OpenRestartDialog(self, d_time):
self.dlgRestart.OpenDialog(d_time)
self.dlgRestart.SetTop()
else:
def OpenRestartDialog(self):
self.dlgRestart.OpenDialog()
self.dlgRestart.SetTop()
def CloseRestartDialog(self):
self.dlgRestart.Close()
def ToggleSystemDialog(self):
if False == self.dlgSystem.IsShow():
self.dlgSystem.OpenDialog()
self.dlgSystem.SetTop()
else:
self.dlgSystem.Close()
def OpenSystemDialog(self):
self.dlgSystem.OpenDialog()
self.dlgSystem.SetTop()
def ToggleMessenger(self):
if self.wndMessenger.IsShow():
self.wndMessenger.Hide()
else:
self.wndMessenger.SetTop()
self.wndMessenger.Show()
def ToggleMiniMap(self):
if app.IsPressed(app.DIK_LSHIFT) or app.IsPressed(app.DIK_RSHIFT):
if False == self.wndMiniMap.isShowMiniMap():
self.wndMiniMap.ShowMiniMap()
self.wndMiniMap.SetTop()
else:
self.wndMiniMap.HideMiniMap()
else:
self.wndMiniMap.ToggleAtlasWindow()
def PressMKey(self):
if app.IsPressed(app.DIK_LALT) or app.IsPressed(app.DIK_RALT):
self.ToggleMessenger()
else:
self.ToggleMiniMap()
def SetMapName(self, mapName):
self.wndMiniMap.SetMapName(mapName)
def MiniMapScaleUp(self):
self.wndMiniMap.ScaleUp()
def MiniMapScaleDown(self):
self.wndMiniMap.ScaleDown()
def ToggleCharacterWindow(self, state):
if False == player.IsObserverMode():
if False == self.wndCharacter.IsShow():
self.OpenCharacterWindowWithState(state)
else:
if state == self.wndCharacter.GetState():
self.wndCharacter.OverOutItem()
self.wndCharacter.Close()
else:
self.wndCharacter.SetState(state)
def OpenCharacterWindowWithState(self, state):
if False == player.IsObserverMode():
self.wndCharacter.SetState(state)
self.wndCharacter.Show()
self.wndCharacter.SetTop()
def ToggleCharacterWindowStatusPage(self):
self.ToggleCharacterWindow("STATUS")
def ToggleGoldWindow(self):
return
if False == player.IsObserverMode():
self.wndInventoryGold.Show()
def ToggleInventoryWindow(self):
if False == player.IsObserverMode():
if False == self.wndInventory.IsShow():
self.wndInventory.Show()
self.wndInventory.SetTop()
else:
self.wndInventory.OverOutItem()
self.wndInventory.Close()
def ToggleInventoryNewWindow(self):
if False == player.IsObserverMode():
if False == self.wndInventoryNew.IsShow():
self.wndInventoryNew.Show()
self.wndInventoryNew.SetTop()
else:
self.wndInventoryNew.OverOutItem()
self.wndInventoryNew.Close()
def ToggleExpandedButton(self):
if False == player.IsObserverMode():
if False == self.wndExpandedTaskBar.IsShow():
self.wndExpandedTaskBar.Show()
self.wndExpandedTaskBar.SetTop()
else:
self.wndExpandedTaskBar.Close()
if app.ENABLE_EXPANDED_MONEY_TASKBAR:
def ToggleExpandedMoneyButton(self):
if False == self.wndExpandedMoneyTaskBar.IsShow():
self.wndExpandedMoneyTaskBar.Show()
self.wndExpandedMoneyTaskBar.SetTop()
else:
self.wndExpandedMoneyTaskBar.Close()
# ¿ëÈ¥¼®
def DragonSoulActivate(self, deck):
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.ActivateDragonSoulByExtern(deck)
def DragonSoulDeactivate(self):
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.DeactivateDragonSoul()
def Highligt_Item(self, inven_type, inven_pos):
if player.DRAGON_SOUL_INVENTORY == inven_type:
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoul.HighlightSlot(inven_pos)
elif player.SLOT_TYPE_INVENTORY == inven_type:
self.wndInventory.HighlightSlot(inven_pos)
else:
self.wndInventoryNew.HighlightSlot(inven_type, inven_pos)
def DragonSoulGiveQuilification(self):
self.DRAGON_SOUL_IS_QUALIFIED = True
self.wndExpandedTaskBar.SetToolTipText(uiTaskBar.ExpandedTaskBar.BUTTON_DRAGON_SOUL, uiScriptLocale.TASKBAR_DRAGON_SOUL)
def ToggleDragonSoulWindow(self):
if False == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if False == self.wndDragonSoul.IsShow():
if self.DRAGON_SOUL_IS_QUALIFIED:
self.wndDragonSoul.Show()
else:
try:
self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_UNQUALIFIED)
self.wndPopupDialog.Open()
except:
self.wndPopupDialog = uiCommon.PopupDialog()
self.wndPopupDialog.SetText(localeInfo.DRAGON_SOUL_UNQUALIFIED)
self.wndPopupDialog.Open()
else:
self.wndDragonSoul.Close()
def ToggleDragonSoulWindowWithNoInfo(self):
if False == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if False == self.wndDragonSoul.IsShow():
if self.DRAGON_SOUL_IS_QUALIFIED:
self.wndDragonSoul.Show()
else:
self.wndDragonSoul.Close()
if app.ENABLE_SPECIAL_STORAGE:
def ToggleSpecialStorageWindow(self):
return
if False == player.IsObserverMode():
if False == self.wndSpecialStorage.IsShow():
self.wndSpecialStorage.Show()
else:
self.wndSpecialStorage.Close()
def FailDragonSoulRefine(self, reason, inven_type, inven_pos):
if False == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if True == self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.RefineFail(reason, inven_type, inven_pos)
def SucceedDragonSoulRefine(self, inven_type, inven_pos):
if False == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if True == self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.RefineSucceed(inven_type, inven_pos)
def OpenDragonSoulRefineWindow(self):
if False == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if False == self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.Show()
if None != self.wndDragonSoul:
if False == self.wndDragonSoul.IsShow():
self.wndDragonSoul.Show()
def CloseDragonSoulRefineWindow(self):
if False == player.IsObserverMode():
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if True == self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.Close()
def ToggleGuildWindow(self):
if not self.wndGuild.IsShow():
if self.wndGuild.CanOpen():
self.wndGuild.Open()
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GUILD_YOU_DO_NOT_JOIN)
else:
self.wndGuild.OverOutItem()
self.wndGuild.Hide()
def ToggleChatLogWindow(self):
if self.wndChatLog.IsShow():
self.wndChatLog.Hide()
else:
self.wndChatLog.Show()
def ToggleAlmacenMenu(self):
if self.wndAlmacenMenu:
self.wndAlmacenMenu.Open()
def OpenCZEstadisticas(self):
if self.wndczestadisticas:
self.wndczestadisticas.Show()
def SetBonusCombatZone(self,arg,type=0,value=0):
if self.wndczestadisticas:
self.wndczestadisticas.SetBonus(arg,type,value)
def SetTimeCombatZone(self,time):
if self.wndczestadisticas:
self.wndczestadisticas.SetTime(time)
def CloseCZEstadisticas(self):
if self.wndczestadisticas:
self.wndczestadisticas.Hide()
if app.ENABLE_SWITCHBOT:
def ToggleSwitchBotMenu(self):
if self.wndSwitchbotMenu:
self.wndSwitchbotMenu.Open()
def ToggleSwitchBotManual(self):
if self.wndSwitchbotManual:
self.wndSwitchbotManual.Show()
def GetPosChangeItemManual(self):
if self.wndSwitchbotManual:
return self.wndSwitchbotManual.GetPosItemChange()
def ToggleSwitchbotWindow(self):
if self.wndSwitchbot.IsShow():
self.wndSwitchbot.Close()
else:
self.wndSwitchbot.Open()
def RefreshSwitchbotWindow(self):
if self.wndSwitchbot and self.wndSwitchbot.IsShow():
self.wndSwitchbot.RefreshSwitchbotWindow()
def RefreshSwitchbotItem(self, slot):
if self.wndSwitchbot and self.wndSwitchbot.IsShow():
self.wndSwitchbot.RefreshSwitchbotItem(slot)
def CheckGameButton(self):
if self.wndGameButton:
self.wndGameButton.CheckGameButton()
def __OnClickStatusPlusButton(self):
self.ToggleCharacterWindow("STATUS")
def __OnClickSkillPlusButton(self):
self.ToggleCharacterWindow("SKILL")
def __OnClickQuestButton(self):
self.ToggleCharacterWindow("QUEST")
def __OnClickHelpButton(self):
player.SetPlayTime(1)
self.CheckGameButton()
self.OpenHelpWindow()
def __OnClickBuildButton(self):
self.BUILD_OpenWindow()
def OpenHelpWindow(self):
self.wndUICurtain.Show()
self.wndHelp.Open()
def CloseHelpWindow(self):
self.wndUICurtain.Hide()
self.wndHelp.Close()
def OpenWebWindow(self, url):
self.wndWeb.Open(url)
# À¥ÆäÀÌÁö¸¦ ¿­¸é äÆÃÀ» ´Ý´Â´Ù
self.wndChat.CloseChat()
if app.ENABLE_DUNGEON_INFO:
def DUNGEON_INFO_CHECK_SHOW(self):
if self.wndTableDungeonInfo:
if self.wndTableDungeonInfo.IsShow():
self.wndTableDungeonInfo.Close()
else:
import dungeon_info
dungeon_info.Open()
def BINARY_TABLE_DUNGEON_INFO_OPEN(self):
if self.wndTableDungeonInfo:
self.wndTableDungeonInfo.LoadDateInfo()
self.wndTableDungeonInfo.Show()
def BINARY_TABLE_DUNGEON_RANKING_LOAD(self):
if self.wndTableDungeonInfo:
self.wndTableDungeonInfo.LoadRanking()
def BINARY_TABLE_DUNGEON_MISION_LOAD(self):
if self.wndTableDungeonInfo:
self.wndTableDungeonInfo.LoadMision()
def CloseRenderTooltip(self):
self.rendertooltip.CloseRenderTooltip()
def ShowRenderTooltip(self):
self.rendertooltip.ShowRenderTooltip()
def RenderClearDates(self):
self.rendertooltip.RenderClearDates()
def SetRenderDates(self, vnum, type, value3 = None):
self.rendertooltip.SetRenderDates(vnum, type, value3)
def SetRenderWeapon(self, itemVnum):
self.rendertooltip.SetRenderWeapon(itemVnum)
def SetRenderArmor(self, itemVnum):
self.rendertooltip.SetRenderArmor(itemVnum)
def SetRenderAcce(self,itemVnum):
self.rendertooltip.SetRenderAcce(itemVnum)
def SetRenderHair(self,itemVnum,value3):
self.rendertooltip.SetRenderHair(itemVnum,value3)
def SetRenderArmor(self,itemVnum):
self.rendertooltip.SetRenderArmor(itemVnum)
def IsRenderTooltip(self):
if self.rendertooltip.IsRenderTooltip():
return True
return False
# show GIFT
def ShowGift(self):
self.wndTaskBar.ShowGift()
if app.ENABLE_DROP_ITEM_WORLDARD:
def BINARY_DROP_ITEM_OPEN(self):
self.wndDropItem.Show()
if app.ENABLE_CUBE_RENEWAL_WORLDARD:
def BINARY_CUBE_RENEWAL_OPEN(self):
self.wndCubeRenewal.Show()
def BINARY_BATTLEPASS_OPEN(self):
self.wndBattlePass.Show()
def OpenTableBonus(self):
if self.wndTableBonus:
if self.wndTableBonus.IsShow():
self.wndTableBonus.Hide()
else:
self.wndTableBonus.Show()
def CloseWbWindow(self):
self.wndWeb.Close()
def OpenCardsInfoWindow(self):
self.wndCardsInfo.Open()
def OpenCardsWindow(self, safemode):
self.wndCards.Open(safemode)
def UpdateCardsInfo(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.wndCards.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 UpdateCardsFieldInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):
self.wndCards.UpdateCardsFieldInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)
def CardsPutReward(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):
self.wndCards.CardsPutReward(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)
def CardsShowIcon(self):
self.wndCardsIcon.Show()
if app.ENABLE_SASH_SYSTEM:
def ActSash(self, iAct, bWindow):
if iAct == 1:
if bWindow == True:
if not self.wndSashCombine.IsOpened():
self.wndSashCombine.Open()
if not self.wndInventory.IsShow():
self.wndInventory.Show()
else:
if not self.wndSashAbsorption.IsOpened():
self.wndSashAbsorption.Open()
if not self.wndInventory.IsShow():
self.wndInventory.Show()
self.wndInventory.RefreshBagSlotWindow()
elif iAct == 2:
if bWindow == True:
if self.wndSashCombine.IsOpened():
self.wndSashCombine.Close()
else:
if self.wndSashAbsorption.IsOpened():
self.wndSashAbsorption.Close()
self.wndInventory.RefreshBagSlotWindow()
elif iAct == 3 or iAct == 4:
if bWindow == True:
if self.wndSashCombine.IsOpened():
self.wndSashCombine.Refresh(iAct)
else:
if self.wndSashAbsorption.IsOpened():
self.wndSashAbsorption.Refresh(iAct)
self.wndInventory.RefreshBagSlotWindow()
def OpenCubeWindow(self):
self.wndCube.Open()
if False == self.wndInventory.IsShow():
self.wndInventory.Show()
def UpdateCubeInfo(self, gold, itemVnum, count):
self.wndCube.UpdateInfo(gold, itemVnum, count)
def CloseCubeWindow(self):
self.wndCube.Close()
def FailedCubeWork(self):
self.wndCube.Refresh()
def SucceedCubeWork(self, itemVnum, count):
self.wndCube.Clear()
print "Å¥ºê Á¦ÀÛ ¼º°ø! [%d:%d]" % (itemVnum, count)
if 0: # °á°ú ¸Þ½ÃÁö Ãâ·ÂÀº »ý·« ÇÑ´Ù
self.wndCubeResult.SetPosition(*self.wndCube.GetGlobalPosition())
self.wndCubeResult.SetCubeResultItem(itemVnum, count)
self.wndCubeResult.Open()
self.wndCubeResult.SetTop()
def __HideWindows(self):
hideWindows = self.wndTaskBar,\
self.wndCharacter,\
self.wndInventory,\
self.wndInventoryGold,\
self.wndMiniMap,\
self.wndGuild,\
self.wndMessenger,\
self.wndChat,\
self.wndParty,\
self.wndGameButton,
if self.wndEnergyBar:
hideWindows += self.wndEnergyBar,
if app.ENABLE_ZODIAC_MISSION:
if self.wnd12ziTimer:
hideWindows += self.wnd12ziTimer,
if self.wnd12ziReward:
hideWindows += self.wnd12ziReward,
if self.wndExpandedTaskBar:
hideWindows += self.wndExpandedTaskBar,
if app.ENABLE_DRAGON_SOUL_SYSTEM:
hideWindows += self.wndDragonSoul,\
self.wndDragonSoulRefine,
if app.ENABLE_SWITCHBOT and self.wndSwitchbot:
hideWindows += self.wndSwitchbot,
if self.wndSwitchbotManual:
hideWindows += self.wndSwitchbotManual,
if app.ENABLE_EXPANDED_MONEY_TASKBAR:
if self.wndExpandedMoneyTaskBar:
hideWindows += self.wndExpandedMoneyTaskBar,
hideWindows = filter(lambda x:x.IsShow(), hideWindows)
map(lambda x:x.Hide(), hideWindows)
import sys
if self.wndSwitchbotMenu.IsShowNew():
self.wndSwitchbotMenu.Open()
if self.wndAlmacenMenu.IsShowNew():
self.wndAlmacenMenu.Open()
self.wndInventoryGold.CloseWithoutWindow()
self.HideAllQuestButton()
self.HideAllWhisperButton()
if self.wndChat.IsEditMode():
self.wndChat.CloseChat()
return hideWindows
def __ShowWindows(self, wnds):
# opened = False
# if constInfo.NewGoldWindow == 0:
# opened = True
import sys
map(lambda x:x.Show(), wnds)
global IsQBHide
if not IsQBHide:
self.ShowAllQuestButton()
else:
self.HideAllQuestButton()
# if opened:
# self.wndInventoryGold.Close()
self.ShowAllWhisperButton()
# if constInfo.NewGoldWindow == 1:
# self.wndInventoryGold.Open()
def BINARY_OpenAtlasWindow(self):
if self.wndMiniMap:
self.wndMiniMap.ShowAtlas()
def BINARY_SetObserverMode(self, flag):
self.wndGameButton.SetObserverMode(flag)
# ACCESSORY_REFINE_ADD_METIN_STONE
def BINARY_OpenSelectItemWindow(self):
self.wndItemSelect.Open()
# END_OF_ACCESSORY_REFINE_ADD_METIN_STONE
#####################################################################################
### Equipment ###
def OpenEquipmentDialog(self, vid):
dlg = uiEquipmentDialog.EquipmentDialog()
dlg.SetItemToolTip(self.tooltipItem)
dlg.SetCloseEvent(ui.__mem_func__(self.CloseEquipmentDialog))
dlg.Open(vid)
self.equipmentDialogDict[vid] = dlg
def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
if not vid in self.equipmentDialogDict:
return
self.equipmentDialogDict[vid].SetEquipmentDialogItem(slotIndex, vnum, count)
def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
if not vid in self.equipmentDialogDict:
return
self.equipmentDialogDict[vid].SetEquipmentDialogSocket(slotIndex, socketIndex, value)
def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
if not vid in self.equipmentDialogDict:
return
self.equipmentDialogDict[vid].SetEquipmentDialogAttr(slotIndex, attrIndex, type, value)
def CloseEquipmentDialog(self, vid):
if not vid in self.equipmentDialogDict:
return
del self.equipmentDialogDict[vid]
#####################################################################################
#####################################################################################
### Quest ###
def BINARY_ClearQuest(self, index):
btn = self.__FindQuestButton(index)
if 0 != btn:
self.__DestroyQuestButton(btn)
def RecvQuest(self, index, name):
# QUEST_LETTER_IMAGE
self.BINARY_RecvQuest(index, name, "file", localeInfo.GetLetterImageName())
# END_OF_QUEST_LETTER_IMAGE
def BINARY_RecvQuest(self, index, name, iconType, iconName):
btn = self.__FindQuestButton(index)
if 0 != btn:
self.__DestroyQuestButton(btn)
btn = uiWhisper.WhisperButton()
# QUEST_LETTER_IMAGE
##!! 20061026.levites.Äù½ºÆ®_À̹ÌÁö_±³Ã¼
import item
if "item"==iconType:
item.SelectItem(int(iconName))
buttonImageFileName=item.GetIconImageFileName()
else:
buttonImageFileName=iconName
if iconName and (iconType not in ("item", "file")): # type "ex" implied
btn.SetUpVisual("d:/ymir work/ui/game/quest/questicon/%s" % (iconName.replace("open", "close")))
btn.SetOverVisual("d:/ymir work/ui/game/quest/questicon/%s" % (iconName))
btn.SetDownVisual("d:/ymir work/ui/game/quest/questicon/%s" % (iconName))
else:
if localeInfo.IsEUROPE():
btn.SetUpVisual(localeInfo.GetLetterCloseImageName())
btn.SetOverVisual(localeInfo.GetLetterOpenImageName())
btn.SetDownVisual(localeInfo.GetLetterOpenImageName())
else:
btn.SetUpVisual(buttonImageFileName)
btn.SetOverVisual(buttonImageFileName)
btn.SetDownVisual(buttonImageFileName)
btn.Flash()
# END_OF_QUEST_LETTER_IMAGE
if localeInfo.IsARABIC():
btn.SetToolTipText(name, 0, 35)
btn.ToolTipText.SetHorizontalAlignCenter()
else:
btn.SetToolTipText(name, -20, 35)
btn.ToolTipText.SetHorizontalAlignLeft()
listOfTypes = iconType.split(",")
if "blink" in listOfTypes:
btn.Flash()
listOfColors = {
"golden": 0xFFffa200,
"green": 0xFF00e600,
"blue": 0xFF0099ff,
"purple": 0xFFcc33ff,
"fucsia": 0xFFcc0099,
"aqua": 0xFF00ffff,
}
for k,v in listOfColors.iteritems():
if k in listOfTypes:
btn.ToolTipText.SetPackedFontColor(v)
btn.SetEvent(ui.__mem_func__(self.__StartQuest), btn)
btn.Show()
btn.index = index
btn.name = name
self.questButtonList.insert(0, btn)
self.__ArrangeQuestButton()
def __ArrangeQuestButton(self):
screenWidth = wndMgr.GetScreenWidth()
screenHeight = wndMgr.GetScreenHeight()
##!! 20061026.levites.Äù½ºÆ®_À§Ä¡_º¸Á¤
if self.wndParty:
xPos = 100 + 30 if self.wndParty.IsShow() else 20
else:
xPos = 20
if localeInfo.IsARABIC():
xPos = xPos + 15
yPos = 170 * screenHeight / 600
yCount = (screenHeight - 330) / 63
count = 0
for btn in self.questButtonList:
btn.SetPosition(xPos + (int(count/yCount) * 100), yPos + (count%yCount * 63))
count += 1
global IsQBHide
if IsQBHide:
btn.Hide()
else:
btn.Show()
def __StartQuest(self, btn):
event.QuestButtonClick(btn.index)
self.__DestroyQuestButton(btn)
def __FindQuestButton(self, index):
for btn in self.questButtonList:
if btn.index == index:
return btn
return 0
def __DestroyQuestButton(self, btn):
btn.SetEvent(0)
btn.Hide()
btn.Destroy()
self.questButtonList.remove(btn)
self.__ArrangeQuestButton()
def HideAllQuestButton(self):
for btn in self.questButtonList:
btn.Hide()
def ShowAllQuestButton(self):
if app.ENABLE_KINGDOMS_WAR:
if self.wndKingdomsWar.IsShow():
return
for btn in self.questButtonList:
btn.Show()
#####################################################################################
#####################################################################################
### Whisper ###
def __InitWhisper(self):
chat.InitWhisper(self)
## äÆÃâÀÇ "¸Þ½ÃÁö º¸³»±â"¸¦ ´­·¶À»¶§ À̸§ ¾ø´Â ´ëȭâÀ» ¿©´Â ÇÔ¼ö
## À̸§ÀÌ ¾ø±â ¶§¹®¿¡ ±âÁ¸ÀÇ WhisperDialogDict ¿Í º°µµ·Î °ü¸®µÈ´Ù.
def OpenWhisperDialogWithoutTarget(self):
if not self.dlgWhisperWithoutTarget:
dlgWhisper = uiWhisper.WhisperDialog(self.MinimizeWhisperDialog, self.CloseWhisperDialog)
dlgWhisper.BindInterface(self)
dlgWhisper.LoadDialog()
dlgWhisper.OpenWithoutTarget(self.RegisterTemporaryWhisperDialog)
dlgWhisper.SetPosition(self.windowOpenPosition*30,self.windowOpenPosition*30)
dlgWhisper.Show()
self.dlgWhisperWithoutTarget = dlgWhisper
self.windowOpenPosition = (self.windowOpenPosition+1) % 5
else:
self.dlgWhisperWithoutTarget.SetTop()
self.dlgWhisperWithoutTarget.OpenWithoutTarget(self.RegisterTemporaryWhisperDialog)
## À̸§ ¾ø´Â ´ëȭâ¿¡¼­ À̸§À» °áÁ¤ÇßÀ»¶§ WhisperDialogDict¿¡ âÀ» ³Ö¾îÁÖ´Â ÇÔ¼ö
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def RegisterTemporaryWhisperDialog(self, name):
if not self.dlgWhisperWithoutTarget:
return
btn = self.__FindWhisperButton(name)
if 0 != btn:
self.__DestroyWhisperButton(btn)
elif self.whisperDialogDict.has_key(name.lower()):
oldDialog = self.whisperDialogDict[name.lower()]
oldDialog.Hide()
oldDialog.Destroy()
del self.whisperDialogDict[name.lower()]
self.whisperDialogDict[name.lower()] = self.dlgWhisperWithoutTarget
self.dlgWhisperWithoutTarget.OpenWithTarget(name)
self.dlgWhisperWithoutTarget = None
self.__CheckGameMaster(name)
else:
def RegisterTemporaryWhisperDialog(self, name):
if not self.dlgWhisperWithoutTarget:
return
btn = self.__FindWhisperButton(name)
if 0 != btn:
self.__DestroyWhisperButton(btn)
elif self.whisperDialogDict.has_key(name):
oldDialog = self.whisperDialogDict[name]
oldDialog.Hide()
oldDialog.Destroy()
del self.whisperDialogDict[name]
self.whisperDialogDict[name] = self.dlgWhisperWithoutTarget
self.dlgWhisperWithoutTarget.OpenWithTarget(name)
self.dlgWhisperWithoutTarget = None
self.__CheckGameMaster(name)
## ij¸¯ÅÍ ¸Þ´ºÀÇ 1:1 ´ëÈ­ Çϱ⸦ ´­·¶À»¶§ À̸§À» °¡Áö°í ¹Ù·Î âÀ» ¿©´Â ÇÔ¼ö
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def OpenWhisperDialog(self, name, language = 0, empire = 0):
if not self.whisperDialogDict.has_key(name.lower()):
dlg = self.__MakeWhisperDialog(name)
dlg.OpenWithTarget(name)
language = int(language)
empire = int(empire)
if language != 0 and empire != 0:
dlg.SetFlag(language, empire)
dlg.chatLine.SetFocus()
dlg.Show()
self.__CheckGameMaster(name)
btn = self.__FindWhisperButton(name)
if 0 != btn:
dlg.SetFlag(btn.languageID, btn.empireID)
self.__DestroyWhisperButton(btn)
else:
def OpenWhisperDialog(self, name):
if not self.whisperDialogDict.has_key(name):
dlg = self.__MakeWhisperDialog(name)
dlg.OpenWithTarget(name)
dlg.chatLine.SetFocus()
dlg.Show()
self.__CheckGameMaster(name)
btn = self.__FindWhisperButton(name)
if 0 != btn:
self.__DestroyWhisperButton(btn)
## ´Ù¸¥ ij¸¯ÅͷκÎÅÍ ¸Þ¼¼Áö¸¦ ¹Þ¾ÒÀ»¶§ ÀÏ´Ü ¹öư¸¸ ¶ç¿ö µÎ´Â ÇÔ¼ö
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def RecvWhisper(self, name, language = 0, empire = 0):
if not self.whisperDialogDict.has_key(name.lower()):
btn = self.__FindWhisperButton(name)
if 0 == btn:
btn = self.__MakeWhisperButton(name, int(language), int(empire))
btn.Flash()
# if app.ENABLE_WHISPER_FLASHING:
# app.FlashApplication()
chat.AppendChat(chat.CHAT_TYPE_NOTICE, localeInfo.RECEIVE_MESSAGE % (name))
else:
language = int(language)
empire = int(empire)
if language != 0 and empire != 0:
btn.languageID = language
btn.empireID = empire
btn.Flash()
# if app.ENABLE_WHISPER_FLASHING:
# app.FlashApplication()
elif self.IsGameMasterName(name.lower()):
dlg = self.whisperDialogDict[name.lower()]
dlg.SetGameMasterLook()
if language != "" and empire != "":
dlg.SetFlag(language, empire)
else:
def RecvWhisper(self, name):
if not self.whisperDialogDict.has_key(name):
btn = self.__FindWhisperButton(name)
if 0 == btn:
btn = self.__MakeWhisperButton(name)
btn.Flash()
# if app.ENABLE_WHISPER_FLASHING:
# app.FlashApplication()
chat.AppendChat(chat.CHAT_TYPE_NOTICE, localeInfo.RECEIVE_MESSAGE % (name))
else:
btn.Flash()
# if app.ENABLE_WHISPER_FLASHING:
# app.FlashApplication()
elif self.IsGameMasterName(name):
dlg = self.whisperDialogDict[name]
dlg.SetGameMasterLook()
def MakeWhisperButton(self, name):
self.__MakeWhisperButton(name)
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def SetInterfaceFlag(self, name, language, empire):
if self.whisperDialogDict.has_key(name.lower()):
self.whisperDialogDict[name.lower()].SetFlag(language, empire)
else:
btn = self.__FindWhisperButton(name)
if btn != 0:
btn.languageID = language
btn.empireID = empire
## ¹öưÀ» ´­·¶À»¶§ âÀ» ¿©´Â ÇÔ¼ö
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def ShowWhisperDialog(self, btn):
try:
self.__MakeWhisperDialog(btn.name)
dlgWhisper = self.whisperDialogDict[btn.name.lower()]
dlgWhisper.OpenWithTarget(btn.name)
if btn.languageID != 0 and btn.empireID != 0:
dlgWhisper.SetFlag(btn.languageID, btn.empireID)
dlgWhisper.Show()
self.__CheckGameMaster(btn.name)
except:
import dbg
dbg.TraceError("interface.ShowWhisperDialog - Failed to find key")
self.__DestroyWhisperButton(btn)
else:
def ShowWhisperDialog(self, btn):
try:
self.__MakeWhisperDialog(btn.name)
dlgWhisper = self.whisperDialogDict[btn.name]
dlgWhisper.OpenWithTarget(btn.name)
dlgWhisper.Show()
self.__CheckGameMaster(btn.name)
except:
import dbg
dbg.TraceError("interface.ShowWhisperDialog - Failed to find key")
self.__DestroyWhisperButton(btn)
## ¹öư ÃʱâÈ­
#self.__DestroyWhisperButton(btn)
## WhisperDialog â¿¡¼­ ÃÖ¼ÒÈ­ ¸í·ÉÀ» ¼öÇàÇßÀ»¶§ È£ÃâµÇ´Â ÇÔ¼ö
## âÀ» ÃÖ¼ÒÈ­ ÇÕ´Ï´Ù.
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def MinimizeWhisperDialog(self, name, languageID, empireID):
if 0 != name:
self.__MakeWhisperButton(name, languageID, empireID)
self.CloseWhisperDialog(name)
else:
def MinimizeWhisperDialog(self, name):
if 0 != name:
self.__MakeWhisperButton(name)
self.CloseWhisperDialog(name)
## WhisperDialog â¿¡¼­ ´Ý±â ¸í·ÉÀ» ¼öÇàÇßÀ»¶§ È£ÃâµÇ´Â ÇÔ¼ö
## âÀ» Áö¿ó´Ï´Ù.
def CloseWhisperDialog(self, name):
if 0 == name:
if self.dlgWhisperWithoutTarget:
self.dlgWhisperWithoutTarget.Hide()
self.dlgWhisperWithoutTarget.Destroy()
self.dlgWhisperWithoutTarget = None
return
try:
if app.ENABLE_MULTILANGUAGE_SYSTEM:
dlgWhisper = self.whisperDialogDict[name.lower()]
dlgWhisper.Hide()
dlgWhisper.Destroy()
del self.whisperDialogDict[name.lower()]
else:
dlgWhisper = self.whisperDialogDict[name]
dlgWhisper.Hide()
dlgWhisper.Destroy()
del self.whisperDialogDict[name]
except:
import dbg
# dbg.TraceError("interface.CloseWhisperDialog - Failed to find key")
# dbg.TraceError("name: "+str(self.whisperDialogDict[name]))
## ¹öưÀÇ °³¼ö°¡ ¹Ù²î¾úÀ»¶§ ¹öưÀ» ÀçÁ¤·Ä ÇÏ´Â ÇÔ¼ö
def __ArrangeWhisperButton(self):
screenWidth = wndMgr.GetScreenWidth()
screenHeight = wndMgr.GetScreenHeight()
xPos = screenWidth - 70
yPos = 170 * screenHeight / 600
yCount = (screenHeight - 330) / 63
#yCount = (screenHeight - 285) / 63
count = 0
for button in self.whisperButtonList:
button.SetPosition(xPos + (int(count/yCount) * -50), yPos + (count%yCount * 63))
count += 1
## À̸§À¸·Î Whisper ¹öưÀ» ã¾Æ ¸®ÅÏÇØ ÁÖ´Â ÇÔ¼ö
## ¹öưÀº µñ¼Å³Ê¸®·Î ÇÏÁö ¾Ê´Â °ÍÀº Á¤·Ä µÇ¾î ¹ö·Á ¼ø¼­°¡ À¯Áö µÇÁö ¾ÊÀ¸¸ç
## ÀÌ·Î ÀÎÇØ ToolTipµéÀÌ ´Ù¸¥ ¹öưµé¿¡ ÀÇÇØ °¡·ÁÁö±â ¶§¹®ÀÌ´Ù.
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def __FindWhisperButton(self, name):
for button in self.whisperButtonList:
if button.name.lower() == name.lower():
return button
return 0
else:
def __FindWhisperButton(self, name):
for button in self.whisperButtonList:
if button.name == name:
return button
return 0
## âÀ» ¸¸µì´Ï´Ù.
def __MakeWhisperDialog(self, name):
dlgWhisper = uiWhisper.WhisperDialog(self.MinimizeWhisperDialog, self.CloseWhisperDialog)
dlgWhisper.BindInterface(self)
dlgWhisper.LoadDialog()
dlgWhisper.SetPosition(self.windowOpenPosition*30,self.windowOpenPosition*30)
if app.ENABLE_MULTILANGUAGE_SYSTEM:
self.whisperDialogDict[name.lower()] = dlgWhisper
else:
self.whisperDialogDict[name] = dlgWhisper
self.windowOpenPosition = (self.windowOpenPosition+1) % 5
return dlgWhisper
## ¹öưÀ» ¸¸µì´Ï´Ù.
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def __MakeWhisperButton(self, name, languageID = 0, empireID = 0):
whisperButton = uiWhisper.WhisperButton()
whisperButton.SetUpVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
whisperButton.SetOverVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
whisperButton.SetDownVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
if self.IsGameMasterName(name):
whisperButton.SetToolTipTextWithColor(name, 0xffffa200)
else:
whisperButton.SetToolTipText(name)
whisperButton.ToolTipText.SetHorizontalAlignCenter()
whisperButton.SetEvent(ui.__mem_func__(self.ShowWhisperDialog), whisperButton)
whisperButton.Show()
whisperButton.name = name
whisperButton.languageID = int(languageID)
whisperButton.empireID = int(empireID)
self.whisperButtonList.insert(0, whisperButton)
self.__ArrangeWhisperButton()
return whisperButton
else:
def __MakeWhisperButton(self, name):
whisperButton = uiWhisper.WhisperButton()
whisperButton.SetUpVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
whisperButton.SetOverVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
whisperButton.SetDownVisual("d:/ymir work/ui/game/windows/btn_mail_up.sub")
if self.IsGameMasterName(name):
whisperButton.SetToolTipTextWithColor(name, 0xffffa200)
else:
whisperButton.SetToolTipText(name)
whisperButton.ToolTipText.SetHorizontalAlignCenter()
whisperButton.SetEvent(ui.__mem_func__(self.ShowWhisperDialog), whisperButton)
whisperButton.Show()
whisperButton.name = name
self.whisperButtonList.insert(0, whisperButton)
self.__ArrangeWhisperButton()
return whisperButton
def __DestroyWhisperButton(self, button):
button.SetEvent(0)
self.whisperButtonList.remove(button)
self.__ArrangeWhisperButton()
def HideAllWhisperButton(self):
for btn in self.whisperButtonList:
btn.Hide()
def ShowAllWhisperButton(self):
for btn in self.whisperButtonList:
btn.Show()
if app.ENABLE_MULTILANGUAGE_SYSTEM:
def __CheckGameMaster(self, name):
if not self.listGMName.has_key(name.lower()):
return
if self.whisperDialogDict.has_key(name.lower()):
dlg = self.whisperDialogDict[name.lower()]
dlg.SetGameMasterLook()
else:
def __CheckGameMaster(self, name):
if not self.listGMName.has_key(name):
return
if self.whisperDialogDict.has_key(name):
dlg = self.whisperDialogDict[name]
dlg.SetGameMasterLook()
def RegisterGameMasterName(self, name):
if self.listGMName.has_key(name):
return
self.listGMName[name] = "GM"
def IsGameMasterName(self, name):
if self.listGMName.has_key(name):
return True
else:
return False
#####################################################################################
#####################################################################################
### Guild Building ###
def BUILD_OpenWindow(self):
self.wndGuildBuilding = uiGuild.BuildGuildBuildingWindow()
self.wndGuildBuilding.Open()
self.wndGuildBuilding.wnds = self.__HideWindows()
self.wndGuildBuilding.SetCloseEvent(ui.__mem_func__(self.BUILD_CloseWindow))
def BUILD_CloseWindow(self):
self.__ShowWindows(self.wndGuildBuilding.wnds)
self.wndGuildBuilding = None
def BUILD_OnUpdate(self):
if not self.wndGuildBuilding:
return
if self.wndGuildBuilding.IsPositioningMode():
import background
x, y, z = background.GetPickingPoint()
self.wndGuildBuilding.SetBuildingPosition(x, y, z)
def BUILD_OnMouseLeftButtonDown(self):
if not self.wndGuildBuilding:
return
# GUILD_BUILDING
if self.wndGuildBuilding.IsPositioningMode():
self.wndGuildBuilding.SettleCurrentPosition()
return True
elif self.wndGuildBuilding.IsPreviewMode():
pass
else:
return True
# END_OF_GUILD_BUILDING
return False
def BUILD_OnMouseLeftButtonUp(self):
if not self.wndGuildBuilding:
return
if not self.wndGuildBuilding.IsPreviewMode():
return True
return False
def BULID_EnterGuildArea(self, areaID):
# GUILD_BUILDING
mainCharacterName = player.GetMainCharacterName()
masterName = guild.GetGuildMasterName()
if mainCharacterName != masterName:
return
if areaID != player.GetGuildID():
return
# END_OF_GUILD_BUILDING
self.wndGameButton.ShowBuildButton()
def BULID_ExitGuildArea(self, areaID):
self.wndGameButton.HideBuildButton()
#####################################################################################
def IsEditLineFocus(self):
if self.ChatWindow.chatLine.IsFocus():
return 1
if self.ChatWindow.chatToLine.IsFocus():
return 1
return 0
def GetInventoryPageIndex(self):
if self.wndInventory:
return self.wndInventory.GetInventoryPageIndex()
else:
return -1
def AttachItemFromSafebox(self, slotIndex, item_type, itemIndex):
if self.wndInventory and self.wndInventory.IsShow():
self.wndInventory.AttachItemFromSafebox(slotIndex, item_type, itemIndex)
return True
def AttachItemSpecialFromSafebox(self, slotIndex, item_type, itemIndex):
if self.wndSpecialStorage and self.wndSpecialStorage.IsShow():
self.wndSpecialStorage.AttachItemFromSafebox(slotIndex, item_type, itemIndex)
return True
def AttachSpecialToInv(self, slotWindow, slotIndex):
if self.wndInventory and self.wndInventory.IsShow():
self.wndInventory.AttachSpecialToInv(slotWindow, slotIndex)
return True
def AttachInvenItemToOtherWindowSlot(self, slotWindow, slotIndex):
if self.wndInventoryNew and self.wndInventoryNew.IsShow():
if self.wndInventoryNew.categoryPageIndex == 6:
return self.wndInventoryNew.AttachItemFromInventoryToSafebox(slotWindow, slotIndex)
elif self.wndInventoryNew.categoryPageIndex <= 5:
return self.wndInventoryNew.AttachItemFromInventoryToSpecial(slotWindow, slotIndex)
#if self.wndSafebox and self.wndSafebox.IsShow():
# return self.wndSafebox.AttachItemFromInventory(slotWindow, slotIndex)
return False
def SafeboxIsShow(self):
if self.wndInventoryNew and self.wndInventory:
if self.wndInventoryNew.IsShow() and self.wndInventory.IsShow():
return True
if self.wndSafebox and self.wndInventory:
if self.wndSafebox.IsShow() and self.wndInventory.IsShow():
return True
return False
if app.WJ_ENABLE_TRADABLE_ICON:
def SetOnTopWindow(self, onTopWnd):
self.onTopWindow = onTopWnd
def GetOnTopWindow(self):
return self.onTopWindow
def RefreshMarkInventoryBag(self):
self.wndInventory.RefreshMarkSlots()
#self.wndInventoryNew.RefreshMarkSlots()
if app.ENABLE_KINGDOMS_WAR:
def ActKingdomsWar(self, act, score1, score2, score3, limitKills, deads, limiDeads, timeRemained):
if self.wndKingdomsWar:
if act == 1:
self.wndKingdomsWar.ShowWindow(score1, score2, score3, limitKills, deads, limiDeads, timeRemained)
global IsQBHide
IsQBHide = 1
for btn in self.questButtonList:
btn.Hide()
elif act == 2:
self.wndKingdomsWar.RefreshScore(score1, score2, score3, limitKills)
elif act == 3:
self.wndKingdomsWar.RefreshDeads(deads, limiDeads)
def EmptyFunction(self):
pass
if app.ENABLE_DSS_ACTIVE_EFFECT_BUTTON:
def UseDSSButtonEffect(self, enable):
if self.wndInventory:
self.wndInventory.UseDSSButtonEffect(enable)
if app.ENABLE_OFFLINESHOP_SYSTEM:
def MakeOfflineShopMessage(self):
if self.dlgShopMessage == None:
self.dlgShopMessage = ui.MessageWindow()
def AddOfflineShopMessage(self, itemVnum, itemCount, itemPrice):
itemVnum, itemCount, itemPrice = (int(itemVnum), int(itemCount), int(itemPrice))
self.MakeOfflineShopMessage()
item.SelectItem(itemVnum)
if itemCount > 1:
self.dlgShopMessage.AddMessage(localeInfo.OFFLINESHOP_MESSAGE_WITH_COUNT % (itemCount, item.GetItemName(),localeInfo.NumberToMoneyStringNEW(itemPrice)),5)
else:
self.dlgShopMessage.AddMessage(localeInfo.OFFLINESHOP_MESSAGE % (item.GetItemName(),localeInfo.NumberToMoneyStringNEW(itemPrice)),5)
def OpenOfflineShopDialog(self, vid, isOwner):
self.wndInventory.Show()
self.wndInventory.SetTop()
if isOwner:
self.OpenOfflineShopPanel()
else:
if self.dlgOfflineShop==None:
self.MakeOfflineShop()
if self.dlgOfflineShop:
self.dlgOfflineShop.Open(vid)
self.dlgOfflineShop.SetCenterPosition()
self.dlgOfflineShop.SetTop()
def OpenOfflineShopPanel(self):
if self.dlgOfflineShopPanel==None:
self.MakeOfflineShopPanel()
self.dlgOfflineShopPanel.Open()
self.dlgOfflineShopPanel.SetTop()
self.dlgOfflineShopPanel.SetCenterPosition()
#def OpenOfflineShopInputNameDialog(self):
# import uiOfflineShop
# self.inputDialog = uiOfflineShop.OfflineShopInputDialog()
# self.inputDialog.SetAcceptEvent(ui.__mem_func__(self.OpenOfflineShopBuilder))
# self.inputDialog.SetCancelEvent(ui.__mem_func__(self.CloseOfflineShopInputNameDialog))
# self.inputDialog.Open()
#
#def CloseOfflineShopInputNameDialog(self):
# self.inputDialog.Close()
# self.inputDialog = None
# return True
def OpenOfflineShopBuilder(self):
#if (not self.inputDialog):
# return True
#if (not len(self.inputDialog.GetTitle())):
# return True
#if (self.inputDialog.GetType() < 0 or self.inputDialog.GetType() == 0):
# return True
#self.CloseOfflineShopInputNameDialog()
if self.offlineShopBuilder==None:
self.MakeOfflineShopBuilder()
self.offlineShopBuilder.Open(".....")
self.offlineShopBuilder.SetTop()
def DisappearOfflineShop(self, vid):
uiOfflineShopBuilder.HideADBoardWithKey(vid)
def AppearOfflineShop(self, vid, text):
type = 0
if text[0].isdigit():
type = int(text[0])
text = text[1:]
if uiOfflineShopBuilder.ShowADBoardWithKey(vid) == False:
board = uiOfflineShopBuilder.OfflineShopAdvertisementBoard(type)
board.Open(vid, text)
else:
uiOfflineShopBuilder.UpdateADText(vid,type,text)
def MakeOfflineShopBuilder(self):
self.offlineShopBuilder = uiOfflineShopBuilder.OfflineShopBuilder()
#self.offlineShopBuilder.SetItemToolTip(self.tooltipItem)
self.offlineShopBuilder.Hide()
def MakeOfflineShop(self):
self.dlgOfflineShop = uiOfflineShop.OfflineShopDialog()
self.dlgOfflineShop.LoadDialog()
#self.dlgOfflineShop.SetItemToolTip(self.tooltipItem)
self.dlgOfflineShop.Hide()
def MakeOfflineShopPanel(self):
self.dlgOfflineShopPanel = uiOfflineShop.OfflineMyShop()
self.dlgOfflineShopPanel.LoadWindow()
#self.dlgOfflineShopPanel.SetItemToolTip(self.tooltipItem)
def AppendLogOfflineShopPanel(self,name, date, itemvnum, itemcount, price):
if self.dlgOfflineShopPanel==None:
self.MakeOfflineShopPanel()
self.dlgOfflineShopPanel.AppendLog(name, date, itemvnum, itemcount, price)
def AppendLogOfflineShopPanelFirst(self,name, date, itemvnum, itemcount, price):
if self.dlgOfflineShopPanel==None:
self.MakeOfflineShopPanel()
self.dlgOfflineShopPanel.AppendLogFirst(name, date, itemvnum, itemcount, price)
if app.ENABLE_SHOP_SEARCH_SYSTEM:
def __MakePrivateShopSearchWindow(self):
self.wndPrivateShopSearch = uiPrivateShopSearch.PrivateShopSearchDialog()
self.wndPrivateShopSearch.LoadWindow()
#self.wndPrivateShopSearch.Hide()
def OfflineShopBuyed(self, itemID):
if self.wndPrivateShopSearch:
self.wndPrivateShopSearch.SetItemBuyStatus(int(itemID))
def OpenPrivateShopSearch(self, type = 0):
if self.wndPrivateShopSearch == None:
self.__MakePrivateShopSearchWindow()
self.wndPrivateShopSearch.Open(type)
return
if self.wndPrivateShopSearch.IsShow():
self.wndPrivateShopSearch.Hide()
else:
self.wndPrivateShopSearch.Open(type)
def RefreshShopSearch(self):
if self.wndPrivateShopSearch == None:
self.__MakePrivateShopSearchWindow()
self.wndPrivateShopSearch.RefreshMe()
self.wndPrivateShopSearch.RefreshList()
if app.ENABLE_NEW_PET_SYSTEM:
def MakeChangeNameWindow(self):
self.change_window = uiChangeName.NameInputWindow()
def OpenChangeNameWindow(self, srcitemPos, destitemPos, itemVnum, type = False):
if self.change_window == None:
self.MakeChangeNameWindow()
self.change_window.LoadItemData(srcitemPos,destitemPos, itemVnum, type)
self.change_window.Show()
self.change_window.SetTop()
def MakePetWindow(self):
self.wndPet = uiPetSystemNew.PetSystemMain()
self.wndPet.Hide()
def ClearPetData(self):
if self.wndPet == None:
return
self.wndPet.ClearData()
def SetPetSlotIndex(self, index):
if self.wndPet == None:
self.MakePetWindow()
self.wndPet.SetSlotIndex(index)
if self.wndPet.IsShow():
self.wndPet.Open()
def PetUpdate(self, index):
if self.wndPet == None:
return
if index == 0:
self.wndPet.UpdateTime()
elif index == 1:
self.wndPet.UpdateLevel()
self.wndPet.CheckEvolveFlash()
self.wndPet.CheckFeedWindow()
elif index == 2:
self.wndPet.UpdateExp()
elif index == 3:
self.wndPet.UpdateAge()
self.wndPet.CheckEvolveFlash()
self.wndPet.CheckFeedWindow()
self.wndPet.UpdateSkill()
elif index >= 5 and index <= 7:
self.wndPet.UpdateBonus()
elif ((index >= 100 and index <= 114) or (index >= 150 and index <= 164)):
self.wndPet.UpdateSkill()
def OpenPetWindow(self):
if self.wndPet == None:
self.MakePetWindow()
if self.wndPet.IsShow():
self.wndPet.Hide()
else:
self.wndPet.Open()
if app.ENABLE_BIYOLOG:
def MakeBioWindow(self):
if self.wndBio == None:
self.wndBio = uiBiyolog.BiologWindow()
self.wndBio.LoadEmpty()
return True
return False
def OpenBiologWindow(self):
self.MakeBioWindow()
if self.wndBio.IsShow():
self.wndBio.Close()
else:
self.wndBio.Open()
def SetBioData(self, level, count, time):
self.MakeBioWindow()
self.wndBio.LoadData(int(level), int(count), int(time))
def SetBioStone(self, level):
self.MakeBioWindow()
self.wndBio.LoadStone(int(level))
def SetBioGift(self, level):
self.MakeBioWindow()
self.wndBio.LoadGift(int(level))
def SetBioEmpty(self):
if self.MakeBioWindow() == False:
self.wndBio.LoadEmpty()
if app.ENABLE_CHANNEL_CHANGE:
def OpenChangeChannel(self):
if self.wndChangeChannel.IsShow():
self.wndChangeChannel.Hide()
else:
self.wndChangeChannel.Show()
if app.dracaryS_DUNGEON_LIB:
def MakeDungeonTimerWindow(self):
self.wndDungeonTimer = uiDungeonTimer.Cooldown()
self.wndDungeonTimer.Hide()
if app.ENABLE_DUNGEON_INFO:
def MakeDungeonInfo(self):
if self.wndDungeonInfo == None:
self.wndDungeonInfo = uiDungeonInfo.DungeonInfo()
def OpenDungeonInfo(self):
self.MakeDungeonInfo()
if self.wndDungeonInfo.IsShow():
self.wndDungeonInfo.Close()
else:
self.wndDungeonInfo.Open()
if app.ENABLE_BATTLE_PASS:
def MakeBattlePassWindow(self):
if self.wndBattlePassEx == None:
self.wndBattlePassEx = uiBattlePassEx.BattlePassWindow()
def OpenBattlePass(self):
self.MakeBattlePassWindow()
if self.wndBattlePassEx.IsShow():
self.wndBattlePassEx.Close()
else:
self.wndBattlePassEx.Open()
def BattlePassSetStatusEx(self, status):
self.MakeBattlePassWindow()
self.wndBattlePassEx.SetBattlePassStatusEx(int(status))
def BattlePassSetStatus(self, status, leftTime, reward):
self.MakeBattlePassWindow()
self.wndBattlePassEx.SetBattlePassStatus(int(status), int(leftTime), str(reward))
def BattlePassSetMission(self, missionIndex, missionValue):
self.MakeBattlePassWindow()
self.wndBattlePassEx.SetMission(int(missionIndex), int(missionValue))
def BattlePassAppendMission(self, missionIndex, missionReward, missionValue, missionMaxValue, missionSubValue, missinVecIndex):
self.MakeBattlePassWindow()
self.wndBattlePassEx.AppendMission(int(missionIndex), str(missionReward), int(missionValue), int(missionMaxValue), int(missionSubValue), int(missinVecIndex))
def BattlePassClear(self):
self.MakeBattlePassWindow()
self.wndBattlePassEx.BattlePassClear()
if app.ENABLE_ITEMSHOP:
def MakeItemShopWindow(self):
if self.wndItemShop == None:
self.wndItemShop = uiItemShopNew.ItemShopWindow()
def OpenItemShopWindow(self):
self.MakeItemShopWindow()
if self.wndItemShop.IsShow():
self.wndItemShop.Close()
else:
self.wndItemShop.Open()
def OpenItemShopMainWindow(self):
self.MakeItemShopWindow()
self.wndItemShop.Open()
self.wndItemShop.LoadFirstOpening()
def ItemShopHideLoading(self):
self.MakeItemShopWindow()
self.wndItemShop.Open()
self.wndItemShop.CloseLoading()
def ItemShopPurchasesWindow(self):
self.MakeItemShopWindow()
self.wndItemShop.Open()
self.wndItemShop.OpenPurchasesWindow()
def ItemShopUpdateItem(self, itemID, itemMaxSellingCount):
self.MakeItemShopWindow()
self.wndItemShop.UpdateItem(itemID, itemMaxSellingCount)
def ItemShopSetDragonCoin(self,dragonCoin):
self.MakeItemShopWindow()
self.wndItemShop.SetDragonCoin(dragonCoin)
def SetWheelItemData(self, cmd):
self.MakeItemShopWindow()
self.wndItemShop.SetWheelItemData(str(cmd))
def OnSetWhell(self, giftIndex):
self.MakeItemShopWindow()
self.wndItemShop.OnSetWhell(int(giftIndex))
def GetWheelGiftData(self, itemVnum, itemCount):
self.MakeItemShopWindow()
self.wndItemShop.GetWheelGiftData(int(itemVnum), int(itemCount))
if app.ENABLE_EVENT_MANAGER:
def MakeEventIcon(self):
if self.wndEventIcon == None:
self.wndEventIcon = uiEventCalendarNew.MovableImage()
self.wndEventIcon.Show()
def MakeEventCalendar(self):
if self.wndEventManager == None:
self.wndEventManager = uiEventCalendarNew.EventCalendarWindow()
def OpenEventCalendar(self):
self.MakeEventCalendar()
if self.wndEventManager.IsShow():
self.wndEventManager.Close()
else:
self.wndEventManager.Open()
def RefreshEventStatus(self, eventID, eventStatus, eventendTime, eventEndTimeText):
if eventendTime != 0:
eventendTime += app.GetGlobalTimeStamp()
uiEventCalendarNew.SetEventStatus(eventID, eventStatus, eventendTime, eventEndTimeText)
self.RefreshEventManager()
def ClearEventManager(self):
uiEventCalendarNew.server_event_data={}
def RefreshEventManager(self):
if self.wndEventManager:
self.wndEventManager.Refresh()
if self.wndEventIcon:
self.wndEventIcon.Refresh()
def AppendEvent(self, dayIndex, eventID, eventIndex, startTime, endTime, empireFlag, channelFlag, value0, value1, value2, value3, startRealTime, endRealTime, isAlreadyStart):
self.MakeEventCalendar()
self.MakeEventIcon()
#import dbg
#dbg.TraceError("startTime: %d endTime: %d"%(startRealTime, endRealTime))
if startRealTime != 0:
startRealTime += app.GetGlobalTimeStamp()
if endRealTime != 0:
endRealTime += app.GetGlobalTimeStamp()
uiEventCalendarNew.SetServerData(dayIndex, eventID, eventIndex, startTime, endTime, empireFlag, channelFlag, value0, value1, value2, value3, startRealTime, endRealTime, isAlreadyStart)
if app.ENABLE_AUTO_SELECT_SKILL:
def MakeAutoSkillWindow(self):
if self.wndAutoSkill == None:
self.wndAutoSkill = uiAutoSkill.AutoSkillSelect()
def OpenAutoSkillWindow(self):
self.MakeAutoSkillWindow()
self.wndAutoSkill.Show()
if app.ENABLE_SHOW_CHEST_DROP:
def OpenChestDropWindow(self, itemVnum, itemWindow, itemCell):
if self.wndChestDropInfo:
self.wndChestDropInfo.Open(itemVnum, itemWindow, itemCell)
if app.ENABLE_RARITY:
def MakeRarityMessageProcess(self):
if self.wndRarityQueque == None:
self.wndRarityQueque = ui.RarityNotification()
def AddRarityMessage(self, type, percent):
self.MakeRarityMessageProcess()
self.wndRarityQueque.OnMessage(int(type),int(percent))
if app.ENABLE_WIKI:
def OpenWikiWindow(self):
self.__MakeWiki()
if self.wndWiki.IsShow():
self.wndWiki.Close()
else:
self.wndWiki.Open()
def __MakeWiki(self):
if self.wndWiki == None:
self.wndWiki = uiWiki.EncyclopediaofGame()
if app.ENABLE_RENDER_TARGET:
def MakeRenderTargetWindow(self):
if self.wndRenderTarget == None:
self.wndRenderTarget = uiRenderTarget.RenderTargetWindow()
def OpenRenderTargetWindow(self, renderType = 0, renderVnum = 11299):
self.MakeRenderTargetWindow()
self.wndRenderTarget.Open(renderType, renderVnum)
if app.ENABLE_DISCORD_STUFF:
def OpenWhisperWithMessage(self, name):
if not self.whisperDialogDict.has_key(name):
btn = self.__FindWhisperButton(name)
if 0 != btn:
self.ShowWhisperDialog(btn)
def CheckWhisperIsOpen(self, name):
if self.whisperDialogDict:
if self.whisperDialogDict.has_key(name):
return self.whisperDialogDict[name].IsShow()
return False
if app.ENABLE_ZODIAC_MISSION:
def __Make12ziRewardWindow(self):
self.wnd12ziReward = ui12zi.Reward12ziWindow()
self.wnd12ziReward.SetItemToolTip(self.tooltipItem)
self.wnd12ziReward.Hide()
def __Make12ziTimerWindow(self):
self.wnd12ziTimer = ui12zi.FloorLimitTimeWindow()
self.wnd12ziTimer.Hide()
if app.ENABLE_TRACK_WINDOW:
def TrackWindowCheckPacket(self):
self.wndTrackWindow.CheckPacket()
def MakeTrackWindow(self):
if self.wndTrackWindow == None:
self.wndTrackWindow = uiTrack.TrackWindow()
def OpenTrackWindow(self):
self.MakeTrackWindow()
if self.wndTrackWindow.IsShow():
self.wndTrackWindow.Close()
else:
self.wndTrackWindow.Open()
def TrackDungeonInfo(self, cmdData):
self.MakeTrackWindow()
self.wndTrackWindow.TrackDungeonInfo(cmdData)
def TrackBossInfo(self, bossID, bossLeftTime, bossChannel):
self.MakeTrackWindow()
self.wndTrackWindow.TrackBossInfo(int(bossID), int(bossLeftTime), int(bossChannel))
if app.ENABLE_FISH_GAME:
def MakeFishGameWindow(self):
if self.wndFishGame == None:
self.wndFishGame = uiFishGame.FishGameWindow()
def OpenFishGameWindow(self, gameKey):
self.MakeFishGameWindow()
self.wndFishGame.Open(int(gameKey))
def SetFishGameGoal(self, goalCount):
self.MakeFishGameWindow()
self.wndFishGame.SetFishScore(int(goalCount))
def CloseFishGame(self):
self.MakeFishGameWindow()
self.wndFishGame.Hide()
if app.ENABLE_EXCHANGE_LOG:
def MakeExchangeLogWindow(self):
if self.wndExchangeLog == None:
self.wndExchangeLog = uiExchangeLog.ExchangeLog()
def OpenExchangeLog(self):
self.MakeExchangeLogWindow()
if self.wndExchangeLog.IsShow():
self.wndExchangeLog.Close()
else:
self.wndExchangeLog.Open()
def ExchangeLogClear(self, playerCode):
if self.wndExchangeLog:
self.wndExchangeLog.Clear(playerCode)
def ExchangeLogRefresh(self, isLogItemRefresh):
if self.wndExchangeLog:
if isLogItemRefresh:
self.wndExchangeLog.RefreshItems(isLogItemRefresh)
else:
self.wndExchangeLog.Refresh()
def ExchangeLogAppend(self, logID, ownerName, ownerGold, ownerIP, targetName, targetGold, targetIP, date):
if self.wndExchangeLog:
self.wndExchangeLog.ExchangeLogAppend(logID, ownerName, ownerGold, ownerIP, targetName, targetGold, targetIP, date)
def ExchangeLogItemAppend(self, logID, itemPos, itemVnum, itemCount, metinSlot, attrType, attrValue, isOwnerItem):
if self.wndExchangeLog:
self.wndExchangeLog.ExchangeLogItemAppend(logID, itemPos, itemVnum, itemCount, metinSlot, attrType, attrValue, isOwnerItem)
if app.ENABLE_GEM_SYSTEM:
def MakeGemShopWindow(self):
if self.wndGemShop == None:
self.wndGemShop = uiGem.GemShop()
def OpenGemShop(self):
self.MakeGemShopWindow()
if self.wndGemShop.IsShow():
self.wndGemShop.Close()
else:
self.wndGemShop.Open()
def GemUpdateSlotCount(self, slotCount):
if self.wndGemShop:
self.wndGemShop.UpdateSlotCount(int(slotCount))
def GemClear(self):
if self.wndGemShop:
self.wndGemShop.Clear()
def GemSetRefreshLeftTime(self, leftTime):
if self.wndGemShop:
self.wndGemShop.SetRefreshLeftTime(int(leftTime))
def GemSetItemsWithString(self, cmdData):
if self.wndGemShop:
self.wndGemShop.SetItemsWithString(cmdData)
def GemSetBuyedSlot(self, slotIndex, buyedStatus):
if self.wndGemShop:
self.wndGemShop.SetBuyedSlot(int(slotIndex), int(buyedStatus))
if app.ENABLE_MINI_GAME_CATCH_KING:
def MiniGameCatchKingEventStart(self, bigScore):
if self.wndCatchKingGame:
self.wndCatchKingGame.GameStart(bigScore)
def MiniGameCatchKingSetHandCard(self, cardNumber):
if self.wndCatchKingGame:
self.wndCatchKingGame.CatchKingSetHandCard(cardNumber)
def MiniGameCatchKingResultField(self, score, rowType, cardPos, cardValue, keepFieldCard, destroyHandCard, getReward, isFiveNear):
if self.wndCatchKingGame:
self.wndCatchKingGame.CatchKingResultField(score, rowType, cardPos, cardValue, keepFieldCard, destroyHandCard, getReward, isFiveNear)
def MiniGameCatchKingSetEndCard(self, cardPos, cardNumber):
if self.wndCatchKingGame:
self.wndCatchKingGame.CatchKingSetEndCard(cardPos, cardNumber)
def MiniGameCatchKingReward(self, rewardCode):
if self.wndCatchKingGame:
self.wndCatchKingGame.CatchKingReward(rewardCode)
def ClickCatchKingEventButton(self):
if self.wndCatchKingGame:
self.wndCatchKingGame.Open()
def MiniGameCatchKing(self, value):
import dbg
if int(value) == 0:
self.wndCatchKingIcon.Hide()
else:
self.wndCatchKingIcon.Show()
if app.RENEWAL_MISSION_BOOKS:
def MakeBookMission(self):
if self.wndBookMission == None:
self.wndBookMission = uiMission.MissionWindow()
def OpenBookMission(self):
self.MakeBookMission()
if self.wndBookMission.IsShow():
self.wndBookMission.Close()
else:
self.wndBookMission.Open()
def ClearBookMission(self):
self.MakeBookMission()
self.wndBookMission.Clear()
def UpdateMissionInfo(self, cmd):
self.wndBookMission.UpdateMissionInfo(cmd)
def UpdateMissionValue(self, missionID, value):
self.wndBookMission.UpdateMissionValue(int(missionID), int(value))
def RewardMissionData(self, missionID, rewardStatus):
self.wndBookMission.RewardMissionData(int(missionID), int(rewardStatus))
def RemoveMissionData(self, missionID):
self.wndBookMission.RemoveMissionData(int(missionID))
def UpdateMissionEndTime(self, missionID, endTime):
self.wndBookMission.UpdateMissionEndTime(int(missionID), str(endTime))
if __name__ == "__main__":
import app
import wndMgr
import systemSetting
import mouseModule
import grp
import ui
import localeInfo
app.SetMouseHandler(mouseModule.mouseController)
app.SetHairColorEnable(True)
wndMgr.SetMouseHandler(mouseModule.mouseController)
wndMgr.SetScreenSize(systemSetting.GetWidth(), systemSetting.GetHeight())
app.Create(localeInfo.APP_TITLE, systemSetting.GetWidth(), systemSetting.GetHeight(), 1)
mouseModule.mouseController.Create()
class TestGame(ui.Window):
def __init__(self):
ui.Window.__init__(self)
localeInfo.LoadLocaleData()
player.SetItemData(0, 27001, 10)
player.SetItemData(1, 27004, 10)
self.interface = Interface()
self.interface.MakeInterface()
self.interface.ShowDefaultWindows()
self.interface.RefreshInventory()
#self.interface.OpenCubeWindow()
def __del__(self):
ui.Window.__del__(self)
def OnUpdate(self):
app.UpdateGame()
def OnRender(self):
app.RenderGame()
grp.PopState()
grp.SetInterfaceRenderState()
game = TestGame()
game.SetSize(systemSetting.GetWidth(), systemSetting.GetHeight())
game.Show()
app.Loop()