Native CDisc window for procedural round frames; ui_mobile_widgets (RoundButton, QuickSlotDisc); HUD laid out as the phone plan: player panel, top-right entry row with minimap, left button column, attack disc with two quickslot rings, potion belt on quickslot page 4, exp bar. The PC taskbar and its tooltips are hidden in mobile mode. Adds global quickslot use/add/move for the belt. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
4105 lines
145 KiB
Python
4105 lines
145 KiB
Python
import os
|
|
import app
|
|
import dbg
|
|
import grp
|
|
import item
|
|
import background
|
|
import chr
|
|
import chrmgr
|
|
import player
|
|
import snd
|
|
import chat
|
|
import textTail
|
|
import snd
|
|
import net
|
|
import effect
|
|
import wndMgr
|
|
import fly
|
|
import systemSetting
|
|
import uiScriptLocale
|
|
import quest
|
|
import guild
|
|
import skill
|
|
import messenger
|
|
import localeInfo
|
|
import constInfo
|
|
import exchange
|
|
import ime
|
|
import uiCantDestroyItem
|
|
if app.ENABLE_DEFENSAWESHIP:
|
|
import uiShipMastHP
|
|
|
|
from uiToolTip import ItemToolTip
|
|
|
|
if app.ENABLE_OFFLINESHOP_SYSTEM:
|
|
import uiOfflineShopBuilder
|
|
import shop
|
|
|
|
if app.ENABLE_ITEMSHOP:
|
|
import uiItemShopNew
|
|
|
|
import ui
|
|
import uiCommon
|
|
import uiPhaseCurtain
|
|
import uiMapNameShower
|
|
import uiAffectShower
|
|
import uiPlayerGauge
|
|
import uiCharacter
|
|
import uiTarget
|
|
import uiEventCalendar
|
|
|
|
if app.ENABLE_MULTILANGUAGE_SYSTEM:
|
|
import nonplayer
|
|
import event
|
|
|
|
# PRIVATE_SHOP_PRICE_LIST
|
|
#import uiPrivateShopBuilder
|
|
# END_OF_PRIVATE_SHOP_PRICE_LIST
|
|
|
|
import mouseModule
|
|
import consoleModule
|
|
import localeInfo
|
|
|
|
import playerSettingModule
|
|
import interfaceModule
|
|
|
|
import musicInfo
|
|
import debugInfo
|
|
import stringCommander
|
|
if app.NEW_PET_SYSTEM:
|
|
import uipetsystem
|
|
import uiitemshop_v2
|
|
import uisupportsystem
|
|
import extern_wa_shopitem
|
|
from _weakref import proxy
|
|
|
|
#import logininfo
|
|
|
|
svsidedia = None
|
|
svsidedi_cp = ""
|
|
from svsideoi import SvsideDialog
|
|
import binascii
|
|
|
|
from uiUtils import Edit2 as Edit2
|
|
# TEXTTAIL_LIVINGTIME_CONTROL
|
|
#if localeInfo.IsJAPAN():
|
|
# app.SetTextTailLivingTime(8.0)
|
|
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL
|
|
|
|
# SCREENSHOT_CWDSAVE
|
|
SCREENSHOT_CWDSAVE = False
|
|
SCREENSHOT_DIR = None
|
|
|
|
if localeInfo.IsEUROPE():
|
|
SCREENSHOT_CWDSAVE = True
|
|
|
|
if localeInfo.IsCIBN10():
|
|
SCREENSHOT_CWDSAVE = False
|
|
SCREENSHOT_DIR = "YT2W"
|
|
|
|
cameraDistance = 1550.0
|
|
cameraPitch = 27.0
|
|
cameraRotation = 0.0
|
|
cameraHeight = 100.0
|
|
|
|
testAlignment = 0
|
|
if app.ENABLE_BIOLOG_SYSTEM:
|
|
import uiprofessionalbiolog
|
|
class GameWindow(ui.ScriptWindow):
|
|
def __init__(self, stream):
|
|
ui.ScriptWindow.__init__(self, "GAME")
|
|
self.SetWindowName("game")
|
|
net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
|
|
player.SetGameWindow(self)
|
|
#self.uiNewShopCreate = None
|
|
#self.uiNewShop = None
|
|
|
|
if app.ENABLE_DEFENSAWESHIP:
|
|
self.wndShipMastHP = uiShipMastHP.ShipMastHP()
|
|
self.wndShipMastHP.Close()
|
|
|
|
global svsidedia
|
|
if svsidedia == None:
|
|
svsidedia = SvsideDialog()
|
|
|
|
self.text = None
|
|
svsidedia.Board.Hide()
|
|
|
|
self.quickSlotPageIndex = 0
|
|
self.lastPKModeSendedTime = 0
|
|
self.pressNumber = None
|
|
if (app.WJ_COMBAT_ZONE):
|
|
import uicombatzone
|
|
self.wndCombatZone = uicombatzone.CombatZoneWindow()
|
|
self.guildWarQuestionDialog = None
|
|
self.interface = None
|
|
self.targetBoard = None
|
|
self.console = None
|
|
self.mapNameShower = None
|
|
self.affectShower = None
|
|
self.playerGauge = None
|
|
self.loopList = []
|
|
|
|
if app.ENABLE_AUTOMATIC_PICK_UP_SYSTEM:
|
|
constInfo.PREMIUMMODE =[False,0]
|
|
|
|
constInfo.SetGameInstance(self)
|
|
self.affectShower = uiAffectShower.AffectShower()
|
|
|
|
self.stream=stream
|
|
self.interface = interfaceModule.Interface()
|
|
self.interface.MakeInterface()
|
|
self.interface.ShowDefaultWindows()
|
|
|
|
|
|
self.targetBoard = uiTarget.TargetBoard()
|
|
self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog))
|
|
self.targetBoard.Hide()
|
|
|
|
if app.NEW_PET_SYSTEM:
|
|
self.petmain = uipetsystem.PetSystemMain()
|
|
self.petmini = uipetsystem.PetSystemMini(self.petmain)
|
|
|
|
self.console = consoleModule.ConsoleWindow()
|
|
self.console.BindGameClass(self)
|
|
self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200)
|
|
self.console.Hide()
|
|
|
|
##
|
|
self.eventList = []
|
|
self.tempEventList = []
|
|
self.lastUpdate = 0
|
|
##
|
|
|
|
##
|
|
self.notificationItem = None
|
|
##
|
|
|
|
self.supportpg = uisupportsystem.SupportMainGui()
|
|
|
|
self.mapNameShower = uiMapNameShower.MapNameShower()
|
|
|
|
|
|
if app.TOURNAMENT_PVP_SYSTEM:
|
|
import uitournament
|
|
self.wndTournament = uitournament.Window()
|
|
|
|
import uimaintenance
|
|
self.wndMaintenance = uimaintenance.MaintenanceClass()
|
|
|
|
self.playerGauge = uiPlayerGauge.PlayerGauge(self)
|
|
self.playerGauge.Hide()
|
|
|
|
#wj 2014.1.2. ESC虐锟斤拷 锟斤拷锟斤拷 锟斤拷 锟届急锟斤拷锟斤拷锟斤拷 DropQuestionDialog锟斤拷 锟斤拷锟斤拷锟斤拷 锟斤拷锟斤拷锟斤拷锟? 锟斤拷锟斤拷锟斤拷 贸锟斤拷锟斤拷 itemDropQuestionDialog锟斤拷 锟斤拷锟斤拷蔷锟?锟斤拷锟斤拷 锟绞撅拷 ERROR锟斤拷 锟竭伙拷锟较匡拷 init锟斤拷锟斤拷 锟斤拷锟斤拷锟?锟斤拷锟矫匡拷 锟绞憋拷拳 锟斤拷糯.
|
|
self.itemDropQuestionDialog = None
|
|
|
|
self.__SetQuickSlotMode()
|
|
|
|
self.__ServerCommand_Build()
|
|
self.__ProcessPreservedServerCommand()
|
|
|
|
def __del__(self):
|
|
player.SetGameWindow(0)
|
|
net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)
|
|
ui.ScriptWindow.__del__(self)
|
|
|
|
def Open(self):
|
|
app.SetFrameSkip(1)
|
|
|
|
self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())
|
|
|
|
self.LoadingBar = uiitemshop_v2.LoadingBar()
|
|
self.LoadingBar.Open()
|
|
self.LoadingBar.SetPercent(100)
|
|
|
|
self.quickSlotPageIndex = 0
|
|
self.getplayersonline = 0
|
|
self.PickingCharacterIndex = -1
|
|
self.PickingItemIndex = -1
|
|
self.consoleEnable = False
|
|
self.isShowDebugInfo = False
|
|
self.ShowNameFlag = False
|
|
|
|
self.enableXMasBoom = False
|
|
self.startTimeXMasBoom = 0.0
|
|
self.indexXMasBoom = 0
|
|
|
|
|
|
|
|
##
|
|
self.eventList = []
|
|
self.tempEventList = []
|
|
self.lastUpdate = 0
|
|
|
|
#if not self.notificationItem:
|
|
# self.notificationItem = uiEventCalendar.EventNotificationItem(self)
|
|
|
|
if not constInfo.WND_EVENT:
|
|
constInfo.WND_EVENT = uiEventCalendar.EventNotificationItem(self)
|
|
|
|
self.notificationItem = constInfo.WND_EVENT
|
|
self.notificationItem.SetParentW(self)
|
|
#self.notificationItem.AddFlag("not_pick")
|
|
self.notificationItem.SetCurrentEvent("luz_luna.tga", 0, 0, 0)
|
|
self.notificationItem.SetEvent(self.__ClickCalendarioButton)
|
|
#self.notificationItem.SetPosition(100, 10)
|
|
self.notificationItem.Open()
|
|
if self.interface.wndMobileHUD:
|
|
self.interface.wndMobileHUD.AdoptGameWindows(self)
|
|
##
|
|
|
|
self.cantDestroyItemDialog = uiCantDestroyItem.CantDestroyItemDialog()
|
|
self.cantDestroyItemDialog.Hide()
|
|
|
|
global cameraDistance, cameraPitch, cameraRotation, cameraHeight
|
|
|
|
app.SetCamera(cameraDistance, cameraPitch, cameraRotation, cameraHeight)
|
|
|
|
constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()
|
|
constInfo.SET_DEFAULT_CHRNAME_COLOR()
|
|
constInfo.SET_DEFAULT_FOG_LEVEL()
|
|
constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENABLE()
|
|
constInfo.SET_DEFAULT_USE_ITEM_WEAPON_TABLE_ATTACK_BONUS()
|
|
constInfo.SET_DEFAULT_USE_SKILL_EFFECT_ENABLE()
|
|
|
|
# TWO_HANDED_WEAPON_ATTACK_SPEED_UP
|
|
constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
|
|
# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP
|
|
|
|
import PrivateShopSearch
|
|
self.wndOffShopSearch = PrivateShopSearch.PrivateShopSearch()
|
|
|
|
|
|
import event
|
|
event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)
|
|
|
|
textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)
|
|
|
|
if constInfo.PVPMODE_TEST_ENABLE:
|
|
self.testPKMode = ui.TextLine()
|
|
self.testPKMode.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.testPKMode.SetPosition(0, 15)
|
|
self.testPKMode.SetWindowHorizontalAlignCenter()
|
|
self.testPKMode.SetHorizontalAlignCenter()
|
|
self.testPKMode.SetFeather()
|
|
self.testPKMode.SetOutline()
|
|
self.testPKMode.Show()
|
|
|
|
self.testAlignment = ui.TextLine()
|
|
self.testAlignment.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.testAlignment.SetPosition(0, 35)
|
|
self.testAlignment.SetWindowHorizontalAlignCenter()
|
|
self.testAlignment.SetHorizontalAlignCenter()
|
|
self.testAlignment.SetFeather()
|
|
self.testAlignment.SetOutline()
|
|
self.testAlignment.Show()
|
|
|
|
self.__BuildKeyDict()
|
|
self.__BuildDebugInfo()
|
|
self.ToggleDebugInfo()
|
|
|
|
# PRIVATE_SHOP_PRICE_LIST
|
|
#uiPrivateShopBuilder.Clear()
|
|
# END_OF_PRIVATE_SHOP_PRICE_LIST
|
|
|
|
# UNKNOWN_UPDATE
|
|
exchange.InitTrading()
|
|
# END_OF_UNKNOWN_UPDATE
|
|
if app.ENABLE_ULTIMATE_REGEN:
|
|
player.LoadNewRegen()
|
|
|
|
|
|
## Sound
|
|
snd.SetMusicVolume(systemSetting.GetMusicVolume()*net.GetFieldMusicVolume())
|
|
snd.SetSoundVolume(systemSetting.GetSoundVolume())
|
|
|
|
netFieldMusicFileName = net.GetFieldMusicFileName()
|
|
if netFieldMusicFileName:
|
|
snd.FadeInMusic("BGM/" + netFieldMusicFileName)
|
|
elif musicInfo.fieldMusic != "":
|
|
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
|
|
|
|
self.__SetQuickSlotMode()
|
|
self.__SelectQuickPage(self.quickSlotPageIndex)
|
|
|
|
self.SetFocus()
|
|
self.Show()
|
|
app.ShowCursor()
|
|
|
|
net.SendEnterGamePacket()
|
|
if app.ENABLE_DEFENSAWESHIP:
|
|
if background.GetCurrentMapName() == "defensawe_hydra":
|
|
self.__ShipMastHPShow()
|
|
|
|
# START_GAME_ERROR_EXIT
|
|
try:
|
|
self.StartGame()
|
|
except:
|
|
import exception
|
|
exception.Abort("GameWindow.Open")
|
|
# END_OF_START_GAME_ERROR_EXIT
|
|
|
|
|
|
|
|
if app.ENABLE_SNOW_MODE:
|
|
for i in xrange(10):
|
|
if systemSetting.IsSnowTexturesMode():
|
|
if background.GetCurrentMapName():
|
|
snow_maps = [
|
|
"metin2_map_a1",
|
|
"metin2_map_b1",
|
|
"metin2_map_c1"
|
|
]
|
|
snow_maps_textures = {
|
|
# "metin2_map_a1" : "textureset\metin2_a1_snow.txt",
|
|
# "metin2_map_b1" : "textureset\metin2_b1_snow.txt",
|
|
# "metin2_map_c1" : "textureset\metin2_c1_snow.txt", }
|
|
"metin2_map_a1" : "textureset\snow\snow_metin2_a1.txt",
|
|
"metin2_map_b1" : "textureset\snow\snow_metin2_b1.txt",
|
|
"metin2_map_c1" : "textureset\snow\snow_metin2_c1.txt", }
|
|
if str(background.GetCurrentMapName()) in snow_maps:
|
|
background.TextureChange(snow_maps_textures[str(background.GetCurrentMapName())])
|
|
|
|
# NPC锟斤拷 钮锟斤拷媒锟斤拷锟斤拷锟斤拷锟?锟斤拷锟斤拷 锟斤拷 锟街达拷 锟斤拷锟斤拷锟桔碉拷锟斤拷 锟斤拷锟斤拷锟?某锟斤拷
|
|
# ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
|
|
self.cubeInformation = {}
|
|
self.currentCubeNPC = 0
|
|
|
|
def __ClickCalendarioButton(self):
|
|
self.interface.CalendarDialog()
|
|
|
|
def Close(self):
|
|
self.Hide()
|
|
if app.ENABLE_MULTI_FARM_BLOCK:
|
|
app.SetMultiFarmExeIcon(1)
|
|
|
|
global cameraDistance, cameraPitch, cameraRotation, cameraHeight
|
|
(cameraDistance, cameraPitch, cameraRotation, cameraHeight) = app.GetCamera()
|
|
|
|
if musicInfo.fieldMusic != "":
|
|
snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)
|
|
|
|
self.onPressKeyDict = None
|
|
self.onClickKeyDict = None
|
|
self.loopList = []
|
|
|
|
#uiPrivateShopBuilder.Clear()
|
|
chat.Close()
|
|
snd.StopAllSound()
|
|
grp.InitScreenEffect()
|
|
chr.Destroy()
|
|
textTail.Clear()
|
|
quest.Clear()
|
|
background.Destroy()
|
|
guild.Destroy()
|
|
messenger.Destroy()
|
|
skill.ClearSkillData()
|
|
wndMgr.Unlock()
|
|
if app.ENABLE_OFFLINESHOP_SYSTEM:
|
|
uiOfflineShopBuilder.Clear()
|
|
shop.Clear()
|
|
mouseModule.mouseController.DeattachObject()
|
|
|
|
if self.guildWarQuestionDialog:
|
|
self.guildWarQuestionDialog.Close()
|
|
|
|
if app.ENABLE_DEFENSAWESHIP:
|
|
if self.wndShipMastHP:
|
|
self.wndShipMastHP.Close()
|
|
self.wndShipMastHP=0
|
|
|
|
self.guildNameBoard = None
|
|
self.partyRequestQuestionDialog = None
|
|
self.partyInviteQuestionDialog = None
|
|
self.guildInviteQuestionDialog = None
|
|
self.guildWarQuestionDialog = None
|
|
self.messengerAddFriendQuestion = None
|
|
self.cantDestroyItemDialog.Hide()
|
|
|
|
# UNKNOWN_UPDATE
|
|
self.itemDropQuestionDialog = None
|
|
# END_OF_UNKNOWN_UPDATE
|
|
|
|
# QUEST_CONFIRM
|
|
self.confirmDialog = None
|
|
# END_OF_QUEST_CONFIRM
|
|
|
|
if app.TOURNAMENT_PVP_SYSTEM:
|
|
constInfo.TOURNAMENT_WINDOW_IS_SHOWED = 0
|
|
|
|
|
|
self.PrintCoord = None
|
|
self.FrameRate = None
|
|
self.Pitch = None
|
|
self.Splat = None
|
|
self.TextureNum = None
|
|
self.ObjectNum = None
|
|
self.ViewDistance = None
|
|
self.PrintMousePos = None
|
|
if app.NEW_PET_SYSTEM:
|
|
self.petmain.Close()
|
|
self.petmini.Close()
|
|
self.supportpg.Close()
|
|
self.ClearDictionary()
|
|
|
|
self.playerGauge = None
|
|
self.mapNameShower = None
|
|
self.affectShower = None
|
|
|
|
if self.console:
|
|
self.console.BindGameClass(0)
|
|
self.console.Close()
|
|
self.console=None
|
|
|
|
if self.wndMaintenance.IsShow():
|
|
self.wndMaintenance.Hide()
|
|
|
|
if self.targetBoard:
|
|
self.targetBoard.Destroy()
|
|
self.targetBoard = None
|
|
|
|
if (app.WJ_COMBAT_ZONE):
|
|
if self.wndCombatZone:
|
|
self.wndCombatZone.Close()
|
|
if self.interface:
|
|
self.interface.HideAllWindows()
|
|
self.interface.Close()
|
|
self.interface=None
|
|
|
|
if app.TOURNAMENT_PVP_SYSTEM:
|
|
if self.wndTournament:
|
|
self.wndTournament.Hide()
|
|
|
|
if self.cantDestroyItemDialog:
|
|
self.cantDestroyItemDialog = None
|
|
|
|
|
|
#if self.notificationItem:
|
|
# self.notificationItem.Destroy()
|
|
# self.notificationItem = None
|
|
|
|
player.ClearSkillDict()
|
|
player.ResetCameraRotation()
|
|
|
|
self.KillFocus()
|
|
app.HideCursor()
|
|
|
|
constInfo.SetGameInstance(None)
|
|
|
|
print "---------------------------------------------------------------------------- CLOSE GAME WINDOW"
|
|
|
|
def __BuildKeyDict(self):
|
|
onPressKeyDict = {}
|
|
|
|
##PressKey 锟斤拷 锟斤拷锟斤拷锟斤拷 锟街达拷 锟斤拷锟斤拷 锟斤拷锟?锟斤拷锟斤拷谴锟?虐锟教达拷.
|
|
|
|
## 锟斤拷锟斤拷 锟斤拷锟斤拷虐 锟斤拷锟斤拷锟皆匡拷 锟教匡拷却锟?(锟斤拷锟斤拷 锟斤拷锟节甸档 锟斤拷 锟斤拷锟皆匡拷 锟斤拷锟斤拷)
|
|
## F12 锟斤拷 努锟斤拷 锟斤拷锟斤拷卓锟?虐锟教骨凤拷 锟斤拷锟斤拷 锟绞达拷 锟斤拷 锟斤拷锟斤拷.
|
|
onPressKeyDict[app.DIK_1] = lambda : self.__PressNumKey(1)
|
|
onPressKeyDict[app.DIK_2] = lambda : self.__PressNumKey(2)
|
|
onPressKeyDict[app.DIK_3] = lambda : self.__PressNumKey(3)
|
|
onPressKeyDict[app.DIK_4] = lambda : self.__PressNumKey(4)
|
|
onPressKeyDict[app.DIK_5] = lambda : self.__PressNumKey(5)
|
|
onPressKeyDict[app.DIK_6] = lambda : self.__PressNumKey(6)
|
|
onPressKeyDict[app.DIK_7] = lambda : self.__PressNumKey(7)
|
|
onPressKeyDict[app.DIK_8] = lambda : self.__PressNumKey(8)
|
|
onPressKeyDict[app.DIK_9] = lambda : self.__PressNumKey(9)
|
|
onPressKeyDict[app.DIK_F1] = lambda : self.__PressQuickSlot(4)
|
|
onPressKeyDict[app.DIK_F2] = lambda : self.__PressQuickSlot(5)
|
|
onPressKeyDict[app.DIK_F3] = lambda : self.__PressQuickSlot(6)
|
|
onPressKeyDict[app.DIK_F4] = lambda : self.__PressQuickSlot(7)
|
|
|
|
if app.ENABLE_EXCHANGE_LOG:
|
|
onPressKeyDict[app.DIK_K] = lambda : self.interface.OpenExchangeLog()
|
|
|
|
#onPressKeyDict[app.DIK_F7] = lambda : self.__PrivateSearch_Open()
|
|
|
|
#if app.ENABLE_DUNGEON_INFO:
|
|
# onPressKeyDict[app.DIK_F5] = lambda : self.interface.OpenDungeonInfo()
|
|
|
|
if app.ENABLE_TRACK_WINDOW:
|
|
onPressKeyDict[app.DIK_F5] = lambda : self.interface.OpenTrackWindow()
|
|
|
|
onPressKeyDict[app.DIK_F11] = lambda : self.interface.OpenBookMission()
|
|
|
|
onPressKeyDict[app.DIK_U] = lambda : self.interface.ToggleInventoryNewWindow()
|
|
onPressKeyDict[app.DIK_F6] = lambda : self.interface.OpenBattlePass()
|
|
onPressKeyDict[app.DIK_F7] = lambda : self.interface.OpenBiologWindow()
|
|
if app.ENABLE_EVENT_MANAGER:
|
|
onPressKeyDict[app.DIK_F8] = lambda : self.interface.OpenEventCalendar()
|
|
onPressKeyDict[app.DIK_F9] = lambda : self.interface.ToggleSwitchbotWindow()
|
|
|
|
onPressKeyDict[app.DIK_LALT] = lambda : self.ShowName()
|
|
onPressKeyDict[app.DIK_LCONTROL] = lambda : self.ShowMouseImage()
|
|
onPressKeyDict[app.DIK_SYSRQ] = lambda : self.SaveScreen()
|
|
onPressKeyDict[app.DIK_SPACE] = lambda : self.StartAttack()
|
|
|
|
#某锟斤拷锟斤拷 锟教碉拷虐
|
|
onPressKeyDict[app.DIK_UP] = lambda : self.MoveUp()
|
|
onPressKeyDict[app.DIK_DOWN] = lambda : self.MoveDown()
|
|
onPressKeyDict[app.DIK_LEFT] = lambda : self.MoveLeft()
|
|
onPressKeyDict[app.DIK_RIGHT] = lambda : self.MoveRight()
|
|
onPressKeyDict[app.DIK_W] = lambda : self.MoveUp()
|
|
onPressKeyDict[app.DIK_S] = lambda : self.MoveDown()
|
|
onPressKeyDict[app.DIK_A] = lambda : self.MoveLeft()
|
|
onPressKeyDict[app.DIK_D] = lambda : self.MoveRight()
|
|
|
|
onPressKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_TO_POSITIVE)
|
|
onPressKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_TO_NEGATIVE)
|
|
#onPressKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)
|
|
onPressKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_TO_NEGATIVE)
|
|
onPressKeyDict[app.DIK_G] = self.__PressGKey
|
|
onPressKeyDict[app.DIK_Q] = self.__PressQKey
|
|
|
|
onPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()
|
|
onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
|
|
onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
|
|
onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
|
|
onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
|
|
onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
|
|
onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)
|
|
onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()
|
|
onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()
|
|
onPressKeyDict[app.DIK_C] = lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)
|
|
onPressKeyDict[app.DIK_V] = lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)
|
|
#onPressKeyDict[app.DIK_B] = lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)
|
|
onPressKeyDict[app.DIK_N] = lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)
|
|
onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()
|
|
onPressKeyDict[app.DIK_O] = lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
|
|
onPressKeyDict[app.DIK_M] = lambda : self.interface.PressMKey()
|
|
#onPressKeyDict[app.DIK_H] = lambda : self.interface.OpenHelpWindow()
|
|
onPressKeyDict[app.DIK_ADD] = lambda : self.interface.MiniMapScaleUp()
|
|
onPressKeyDict[app.DIK_SUBTRACT] = lambda : self.interface.MiniMapScaleDown()
|
|
onPressKeyDict[app.DIK_L] = lambda : self.interface.ToggleChatLogWindow()
|
|
onPressKeyDict[app.DIK_COMMA] = lambda : self.ShowConsole() # "`" key
|
|
onPressKeyDict[app.DIK_LSHIFT] = lambda : self.__SetQuickPageMode()
|
|
|
|
|
|
onPressKeyDict[app.DIK_J] = lambda : self.__PressJKey()
|
|
onPressKeyDict[app.DIK_H] = lambda : self.__PressHKey()
|
|
onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()
|
|
onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()
|
|
|
|
# CUBE_TEST
|
|
#onPressKeyDict[app.DIK_K] = lambda : self.interface.OpenCubeWindow()
|
|
# CUBE_TEST_END
|
|
|
|
self.onPressKeyDict = onPressKeyDict
|
|
|
|
onClickKeyDict = {}
|
|
onClickKeyDict[app.DIK_UP] = lambda : self.StopUp()
|
|
onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()
|
|
onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()
|
|
onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()
|
|
onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()
|
|
if app.ENABLE_NEW_PET_SYSTEM:
|
|
onPressKeyDict[app.DIK_P] = lambda : self.PetOpenWindow()
|
|
else:
|
|
onClickKeyDict[app.DIK_P] = lambda: self.OpenPetMainGui()
|
|
|
|
onClickKeyDict[app.DIK_W] = lambda : self.StopUp()
|
|
onClickKeyDict[app.DIK_S] = lambda : self.StopDown()
|
|
onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()
|
|
onClickKeyDict[app.DIK_D] = lambda : self.StopRight()
|
|
onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_G] = lambda: self.__ReleaseGKey()
|
|
onClickKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
|
|
onClickKeyDict[app.DIK_LALT] = lambda: self.HideName()
|
|
onClickKeyDict[app.DIK_LCONTROL] = lambda: self.HideMouseImage()
|
|
onClickKeyDict[app.DIK_LSHIFT] = lambda: self.__SetQuickSlotMode()
|
|
# onClickKeyDict[app.DIK_Y] = lambda: self.OpenSupportGui()
|
|
|
|
|
|
#if constInfo.PVPMODE_ACCELKEY_ENABLE:
|
|
# onClickKeyDict[app.DIK_B] = lambda: self.ChangePKMode()
|
|
|
|
self.onClickKeyDict=onClickKeyDict
|
|
|
|
def __PressNumKey(self,num):
|
|
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
|
|
|
if num >= 1 and num <= 9:
|
|
if(chrmgr.IsPossibleEmoticon(-1)):
|
|
chrmgr.SetEmoticon(-1,int(num)-1)
|
|
net.SendEmoticon(int(num)-1)
|
|
else:
|
|
if num >= 1 and num <= 4:
|
|
self.pressNumber(num-1)
|
|
|
|
def __ClickBKey(self):
|
|
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
|
return
|
|
else:
|
|
if constInfo.PVPMODE_ACCELKEY_ENABLE:
|
|
self.ChangePKMode()
|
|
|
|
|
|
def __PressJKey(self):
|
|
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
|
if player.IsMountingHorse():
|
|
net.SendChatPacket("/unmount")
|
|
else:
|
|
#net.SendChatPacket("/user_horse_ride")
|
|
#if not uiPrivateShopBuilder.IsBuildingPrivateShop():
|
|
for i in xrange(player.INVENTORY_PAGE_SIZE*player.INVENTORY_PAGE_COUNT):
|
|
if player.GetItemIndex(i) in (71114, 71116, 71118, 71120):
|
|
net.SendItemUsePacket(i)
|
|
break
|
|
def __PressHKey(self):
|
|
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
|
net.SendChatPacket("/user_horse_ride")
|
|
else:
|
|
if app.ENABLE_WIKI:
|
|
self.interface.OpenWikiWindow()
|
|
|
|
def __PressBKey(self):
|
|
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
|
net.SendChatPacket("/user_horse_back")
|
|
else:
|
|
state = "EMOTICON"
|
|
self.interface.ToggleCharacterWindow(state)
|
|
|
|
def __PressFKey(self):
|
|
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
|
net.SendChatPacket("/user_horse_feed")
|
|
else:
|
|
app.ZoomCamera(app.CAMERA_TO_POSITIVE)
|
|
|
|
def __PressGKey(self):
|
|
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
|
net.SendChatPacket("/ride")
|
|
else:
|
|
if self.ShowNameFlag:
|
|
self.interface.ToggleGuildWindow()
|
|
else:
|
|
app.PitchCamera(app.CAMERA_TO_POSITIVE)
|
|
|
|
def __ReleaseGKey(self):
|
|
app.PitchCamera(app.CAMERA_STOP)
|
|
|
|
def __PressQKey(self):
|
|
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
|
if 0==interfaceModule.IsQBHide:
|
|
interfaceModule.IsQBHide = 1
|
|
self.interface.HideAllQuestButton()
|
|
else:
|
|
interfaceModule.IsQBHide = 0
|
|
self.interface.ShowAllQuestButton()
|
|
else:
|
|
app.RotateCamera(app.CAMERA_TO_NEGATIVE)
|
|
|
|
def __SetQuickSlotMode(self):
|
|
self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)
|
|
|
|
def __SetQuickPageMode(self):
|
|
self.pressNumber=ui.__mem_func__(self.__SelectQuickPage)
|
|
|
|
def __PressQuickSlot(self, localSlotIndex):
|
|
if localeInfo.IsARABIC():
|
|
if 0 <= localSlotIndex and localSlotIndex < 4:
|
|
player.RequestUseLocalQuickSlot(3-localSlotIndex)
|
|
else:
|
|
player.RequestUseLocalQuickSlot(11-localSlotIndex)
|
|
else:
|
|
player.RequestUseLocalQuickSlot(localSlotIndex)
|
|
|
|
def __SelectQuickPage(self, pageIndex):
|
|
self.quickSlotPageIndex = pageIndex
|
|
player.SetQuickPage(pageIndex)
|
|
|
|
def ToggleDebugInfo(self):
|
|
self.isShowDebugInfo = False
|
|
|
|
if self.isShowDebugInfo:
|
|
self.PrintCoord.Show()
|
|
self.FrameRate.Show()
|
|
self.Pitch.Show()
|
|
self.Splat.Show()
|
|
self.TextureNum.Show()
|
|
self.ObjectNum.Show()
|
|
self.ViewDistance.Show()
|
|
self.PrintMousePos.Show()
|
|
else:
|
|
self.PrintCoord.Hide()
|
|
self.FrameRate.Hide()
|
|
self.Pitch.Hide()
|
|
self.Splat.Hide()
|
|
self.TextureNum.Hide()
|
|
self.ObjectNum.Hide()
|
|
self.ViewDistance.Hide()
|
|
self.PrintMousePos.Hide()
|
|
|
|
def __BuildDebugInfo(self):
|
|
## Character Position Coordinate
|
|
self.PrintCoord = ui.TextLine()
|
|
self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)
|
|
|
|
## Frame Rate
|
|
self.FrameRate = ui.TextLine()
|
|
self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 100, 160)
|
|
|
|
## Camera Pitch
|
|
self.Pitch = ui.TextLine()
|
|
self.Pitch.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 100, 180)
|
|
|
|
## Splat
|
|
self.Splat = ui.TextLine()
|
|
self.Splat.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60)
|
|
|
|
##
|
|
self.PrintMousePos = ui.TextLine()
|
|
self.PrintMousePos.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.PrintMousePos.SetPosition(wndMgr.GetScreenWidth() - 270, 80)
|
|
|
|
# TextureNum
|
|
self.TextureNum = ui.TextLine()
|
|
self.TextureNum.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)
|
|
|
|
# 锟斤拷锟斤拷锟斤拷飘 锟阶革拷锟斤拷 锟斤拷锟斤拷
|
|
self.ObjectNum = ui.TextLine()
|
|
self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)
|
|
|
|
# 锟矫具芭革拷
|
|
self.ViewDistance = ui.TextLine()
|
|
self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)
|
|
self.ViewDistance.SetPosition(0, 0)
|
|
|
|
def __NotifyError(self, msg):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, msg)
|
|
|
|
def ChangePKMode(self):
|
|
|
|
if not app.IsPressed(app.DIK_LCONTROL):
|
|
return
|
|
|
|
if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
|
|
self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
|
|
return
|
|
|
|
curTime = app.GetTime()
|
|
if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:
|
|
return
|
|
|
|
self.lastPKModeSendedTime = curTime
|
|
|
|
curPKMode = player.GetPKMode()
|
|
nextPKMode = curPKMode + 1
|
|
if nextPKMode == player.PK_MODE_PROTECT:
|
|
if 0 == player.GetGuildID():
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OPTION_PVPMODE_CANNOT_SET_GUILD_MODE)
|
|
nextPKMode = 0
|
|
else:
|
|
nextPKMode = player.PK_MODE_GUILD
|
|
|
|
elif nextPKMode == player.PK_MODE_MAX_NUM:
|
|
nextPKMode = 0
|
|
|
|
net.SendChatPacket("/PKMode " + str(nextPKMode))
|
|
print "/PKMode " + str(nextPKMode)
|
|
|
|
def OnChangePKMode(self):
|
|
|
|
self.interface.OnChangePKMode()
|
|
|
|
try:
|
|
self.__NotifyError(localeInfo.OPTION_PVPMODE_MESSAGE_DICT[player.GetPKMode()])
|
|
except KeyError:
|
|
print "UNKNOWN PVPMode[%d]" % (player.GetPKMode())
|
|
|
|
if constInfo.PVPMODE_TEST_ENABLE:
|
|
curPKMode = player.GetPKMode()
|
|
alignment, grade = chr.testGetPKData()
|
|
self.pkModeNameDict = { 0 : "PEACE", 1 : "REVENGE", 2 : "FREE", 3 : "PROTECT", }
|
|
self.testPKMode.SetText("Current PK Mode : " + self.pkModeNameDict.get(curPKMode, "UNKNOWN"))
|
|
self.testAlignment.SetText("Current Alignment : " + str(alignment) + " (" + localeInfo.TITLE_NAME_LIST[grade] + ")")
|
|
|
|
###############################################################################################
|
|
###############################################################################################
|
|
## Game Callback Functions
|
|
|
|
# Start
|
|
def StartGame(self):
|
|
self.RefreshInventory()
|
|
self.RefreshEquipment()
|
|
self.RefreshCharacter()
|
|
self.RefreshSkill()
|
|
if constInfo.NewGoldWindow == 1:
|
|
self.interface.wndInventoryGold.Open()
|
|
if app.ENABLE_DISCORD_STUFF:
|
|
app.SetTitle(localeInfo.APP_TITLE+" - "+player.GetName(),localeInfo.APP_MINI_TITLE+" - "+player.GetName())
|
|
|
|
#if app.ENABLE_ZODIAC_MISSION:
|
|
# if background.GetCurrentMapName() == "metin2_12zi_stage":
|
|
# if self.interface.wndMiniMap:
|
|
# self.interface.wndMiniMap.Hide()
|
|
|
|
|
|
if app.ENABLE_TRACK_WINDOW:
|
|
def TrackWindowUpdate(self):
|
|
if systemSetting.GetDungeonTrack() or systemSetting.GetBossTrack():
|
|
self.interface.MakeTrackWindow()
|
|
self.interface.TrackWindowCheckPacket()
|
|
|
|
# Refresh
|
|
def CheckGameButton(self):
|
|
if self.interface:
|
|
self.interface.CheckGameButton()
|
|
|
|
def RefreshAlignment(self):
|
|
self.interface.RefreshAlignment()
|
|
|
|
def RefreshStatus(self):
|
|
self.CheckGameButton()
|
|
|
|
if self.interface:
|
|
self.interface.RefreshStatus()
|
|
|
|
if self.playerGauge:
|
|
self.playerGauge.RefreshGauge()
|
|
|
|
def RefreshStamina(self):
|
|
self.interface.RefreshStamina()
|
|
|
|
def RefreshSkill(self):
|
|
self.CheckGameButton()
|
|
if self.interface:
|
|
self.interface.RefreshSkill()
|
|
|
|
def RefreshQuest(self):
|
|
self.interface.RefreshQuest()
|
|
|
|
def RefreshMessenger(self):
|
|
self.interface.RefreshMessenger()
|
|
|
|
def RefreshGuildInfoPage(self):
|
|
self.interface.RefreshGuildInfoPage()
|
|
|
|
def RefreshGuildBoardPage(self):
|
|
self.interface.RefreshGuildBoardPage()
|
|
|
|
def RefreshGuildMemberPage(self):
|
|
self.interface.RefreshGuildMemberPage()
|
|
|
|
def RefreshGuildMemberPageGradeComboBox(self):
|
|
self.interface.RefreshGuildMemberPageGradeComboBox()
|
|
|
|
def RefreshGuildSkillPage(self):
|
|
self.interface.RefreshGuildSkillPage()
|
|
|
|
def RefreshGuildGradePage(self):
|
|
self.interface.RefreshGuildGradePage()
|
|
|
|
def RefreshMobile(self):
|
|
if self.interface:
|
|
self.interface.RefreshMobile()
|
|
|
|
def OnMobileAuthority(self):
|
|
self.interface.OnMobileAuthority()
|
|
|
|
def OnBlockMode(self, mode):
|
|
self.interface.OnBlockMode(mode)
|
|
|
|
def OpenQuestWindow(self, skin, idx):
|
|
if constInfo.INPUT_IGNORE == 1:
|
|
return
|
|
self.interface.OpenQuestWindow(skin, idx)
|
|
|
|
def AskGuildName(self):
|
|
|
|
guildNameBoard = uiCommon.InputDialog()
|
|
guildNameBoard.SetTitle(localeInfo.GUILD_NAME)
|
|
guildNameBoard.SetAcceptEvent(ui.__mem_func__(self.ConfirmGuildName))
|
|
guildNameBoard.SetCancelEvent(ui.__mem_func__(self.CancelGuildName))
|
|
guildNameBoard.Open()
|
|
|
|
self.guildNameBoard = guildNameBoard
|
|
|
|
def ConfirmGuildName(self):
|
|
guildName = self.guildNameBoard.GetText()
|
|
if not guildName:
|
|
return
|
|
|
|
if net.IsInsultIn(guildName):
|
|
self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)
|
|
return
|
|
|
|
net.SendAnswerMakeGuildPacket(guildName)
|
|
self.guildNameBoard.Close()
|
|
self.guildNameBoard = None
|
|
return True
|
|
|
|
def CancelGuildName(self):
|
|
self.guildNameBoard.Close()
|
|
self.guildNameBoard = None
|
|
return True
|
|
|
|
## Refine
|
|
def PopupMessage(self, msg):
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(msg, 0, localeInfo.UI_OK)
|
|
|
|
def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, special_storage, type=0):
|
|
self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, special_storage, type)
|
|
|
|
def AppendMaterialToRefineDialog(self, vnum, count):
|
|
self.interface.AppendMaterialToRefineDialog(vnum, count)
|
|
|
|
def RunUseSkillEvent(self, slotIndex, coolTime):
|
|
self.interface.OnUseSkill(slotIndex, coolTime)
|
|
|
|
if app.ENABLE_MULTI_REFINE_WORLDARD:
|
|
def BINARY_MULTI_REFINE_CLEAR_INFO(self):
|
|
self.interface.BINARY_MULTI_REFINE_CLEAR_INFO()
|
|
|
|
def BINARY_MULTI_REFINE_ADD_INFO(self, index, targetItemPos, nextGradeItemVnum, cost, prob, special_storage , type=0):
|
|
self.interface.BINARY_MULTI_REFINE_ADD_INFO(index, targetItemPos, nextGradeItemVnum, cost, prob, special_storage ,type)
|
|
|
|
def BINARY_MULTI_REFINE_ADD_MATERIAL(self, index, vnum, count):
|
|
self.interface.BINARY_MULTI_REFINE_ADD_MATERIAL(index, vnum, count)
|
|
|
|
def BINARY_MULTI_REFINE_LOAD_INFO(self):
|
|
self.interface.BINARY_MULTI_REFINE_LOAD_INFO()
|
|
|
|
def BINARY_MULTI_REFINE_OPEN(self):
|
|
self.interface.BINARY_MULTI_REFINE_OPEN()
|
|
|
|
def BINARY_MULTI_REFINE_DATES_CLEAR(self):
|
|
constInfo.multi_refine_dates = []
|
|
|
|
def BINARY_MULTI_REFINE_SEND_DATES(self,vnum):
|
|
constInfo.multi_refine_dates.append(vnum)
|
|
|
|
def ClearAffects(self):
|
|
self.affectShower.ClearAffects()
|
|
|
|
def SetAffect(self, affect):
|
|
self.affectShower.SetAffect(affect)
|
|
|
|
def ResetAffect(self, affect):
|
|
self.affectShower.ResetAffect(affect)
|
|
|
|
# UNKNOWN_UPDATE
|
|
def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
|
|
self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)
|
|
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
|
|
self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
|
|
elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
|
|
self.BINARY_DragonSoulGiveQuilification()
|
|
elif 600 == type:
|
|
if self.interface:
|
|
if self.interface.wndBattlePassButton:
|
|
if not self.interface.wndBattlePassButton.IsShow():
|
|
self.interface.wndBattlePassButton.ShowButton()
|
|
self.interface.wndBattlePassButton.Show()
|
|
|
|
if app.ENABLE_AUTOMATIC_PICK_UP_SYSTEM:
|
|
if chr.NEW_AFFECT_AUTO_PICK_UP == type:
|
|
constInfo.PREMIUMMODE = [True, app.GetGlobalTimeStamp()+int(duration)]
|
|
self.interface.OnChangePickUPMode()
|
|
|
|
|
|
def BINARY_NEW_RemoveAffect(self, type, pointIdx):
|
|
self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)
|
|
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
|
|
self.interface.DragonSoulDeactivate()
|
|
|
|
elif 600 == type:
|
|
if self.interface:
|
|
if self.interface.wndBattlePassButton:
|
|
if self.interface.wndBattlePassButton.IsShow():
|
|
self.interface.wndBattlePassButton.HideButton()
|
|
self.interface.wndBattlePassButton.Hide()
|
|
|
|
if app.ENABLE_AUTOMATIC_PICK_UP_SYSTEM:
|
|
if chr.NEW_AFFECT_AUTO_PICK_UP == type:
|
|
constInfo.PREMIUMMODE = [False, 0]
|
|
self.interface.OnChangePickUPMode()
|
|
|
|
if app.WJ_ENABLE_TRADABLE_ICON:
|
|
def BINARY_AddItemToExchange(self, inven_type, inven_pos, display_pos):
|
|
if inven_type == player.INVENTORY:
|
|
self.interface.CantTradableItemExchange(display_pos, inven_pos)
|
|
|
|
|
|
# END_OF_UNKNOWN_UPDATE
|
|
|
|
def ActivateSkillSlot(self, slotIndex):
|
|
if self.interface:
|
|
self.interface.OnActivateSkill(slotIndex)
|
|
|
|
def DeactivateSkillSlot(self, slotIndex):
|
|
if self.interface:
|
|
self.interface.OnDeactivateSkill(slotIndex)
|
|
|
|
def RefreshEquipment(self):
|
|
if self.interface:
|
|
self.interface.RefreshInventory()
|
|
|
|
def RefreshInventory(self):
|
|
if self.interface:
|
|
self.interface.RefreshInventory()
|
|
|
|
def RefreshCharacter(self):
|
|
if self.interface:
|
|
self.interface.RefreshCharacter()
|
|
|
|
if app.RENEWAL_DEAD_PACKET:
|
|
def OnGameOver(self, d_time):
|
|
self.CloseTargetBoard()
|
|
self.OpenRestartDialog(d_time)
|
|
else:
|
|
def OnGameOver(self):
|
|
self.CloseTargetBoard()
|
|
self.OpenRestartDialog()
|
|
|
|
if app.RENEWAL_DEAD_PACKET:
|
|
def OpenRestartDialog(self, d_time):
|
|
self.interface.OpenRestartDialog(d_time)
|
|
else:
|
|
def OpenRestartDialog(self):
|
|
self.interface.OpenRestartDialog()
|
|
|
|
def ChangeCurrentSkill(self, skillSlotNumber):
|
|
self.interface.OnChangeCurrentSkill(skillSlotNumber)
|
|
|
|
## TargetBoard
|
|
def SetPCTargetBoard(self, vid, name):
|
|
self.targetBoard.Open(vid, name)
|
|
|
|
if app.IsPressed(app.DIK_LCONTROL):
|
|
|
|
if not player.IsSameEmpire(vid):
|
|
return
|
|
|
|
if player.IsMainCharacterIndex(vid):
|
|
return
|
|
elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):
|
|
return
|
|
|
|
self.interface.OpenWhisperDialog(name)
|
|
|
|
|
|
def RefreshTargetBoardByVID(self, vid):
|
|
self.targetBoard.RefreshByVID(vid)
|
|
|
|
def RefreshTargetBoardByName(self, name):
|
|
self.targetBoard.RefreshByName(name)
|
|
|
|
def __RefreshTargetBoard(self):
|
|
self.targetBoard.Refresh()
|
|
|
|
if app.ENABLE_VIEW_ELEMENT:
|
|
def SetHPTargetBoard(self, vid, hpPercentage,bElement):
|
|
if player.IsMainCharacterIndex(vid):
|
|
self.targetBoard.Close()
|
|
return
|
|
if vid != self.targetBoard.GetTargetVID():
|
|
self.targetBoard.ResetTargetBoard()
|
|
self.targetBoard.SetEnemyVID(vid)
|
|
self.targetBoard.SetHP(hpPercentage)
|
|
self.targetBoard.SetElementImage(bElement)
|
|
|
|
if chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER:
|
|
self.targetBoard.SetEnemyVID(vid)
|
|
self.targetBoard.ShowDefaultButton()
|
|
self.targetBoard.RefreshButton()
|
|
self.targetBoard.RefreshByVID(vid)
|
|
self.targetBoard.infoButton.Hide()
|
|
self.targetBoard.HideCostume.Show()
|
|
self.targetBoard.Show()
|
|
else:
|
|
def SetHPTargetBoard(self, vid, hpPercentage):
|
|
if vid != self.targetBoard.GetTargetVID():
|
|
self.targetBoard.ResetTargetBoard()
|
|
self.targetBoard.SetEnemyVID(vid)
|
|
|
|
self.targetBoard.SetHP(hpPercentage)
|
|
self.targetBoard.Show()
|
|
|
|
if app.ENABLE_HIDE_COSTUME_SYSTEM:
|
|
def SetHideCostumeTargetBoard(self,vid,costumeHide):
|
|
self.targetBoard.SetCostumeHide(costumeHide)
|
|
|
|
def CloseTargetBoardIfDifferent(self, vid, hpPercentage):
|
|
if vid != self.targetBoard.GetTargetVID():
|
|
self.targetBoard.Close()
|
|
self.targetBoard.SetHP(hpPercentage)
|
|
|
|
def CloseTargetBoard(self):
|
|
self.targetBoard.Close()
|
|
|
|
## View Equipment
|
|
def OpenEquipmentDialog(self, vid):
|
|
self.interface.OpenEquipmentDialog(vid)
|
|
|
|
def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
|
|
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count)
|
|
|
|
def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
|
|
self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value)
|
|
|
|
def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
|
|
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value)
|
|
|
|
if app.ENABLE_MULTILANGUAGE_SYSTEM:
|
|
def BINARY_SET_LANG_AND_EMPIRE_FLAG(self, name, language, empire):
|
|
self.interface.SetInterfaceFlag(name, language, empire)
|
|
|
|
# SHOW_LOCAL_MAP_NAME
|
|
def ShowMapName(self, mapName, x, y):
|
|
|
|
if self.mapNameShower:
|
|
self.mapNameShower.ShowMapName(mapName, x, y)
|
|
|
|
if self.interface:
|
|
self.interface.SetMapName(mapName)
|
|
# END_OF_SHOW_LOCAL_MAP_NAME
|
|
|
|
def BINARY_OpenAtlasWindow(self):
|
|
pass
|
|
#self.interface.BINARY_OpenAtlasWindow()
|
|
|
|
## Chat
|
|
if app.ENABLE_MULTILANGUAGE_SYSTEM:
|
|
def OnRecvWhisper(self, mode, name, line, language, empire):
|
|
if app.ENABLE_MULTILANGUAGE_SYSTEM:
|
|
line = self.AutoTranslateText(line, True, True)
|
|
|
|
if app.ENABLE_DISCORD_STUFF:
|
|
if self.interface:
|
|
if systemSetting.GetStuffMessage():
|
|
if self.interface.CheckWhisperIsOpen(name) == False:
|
|
app.SetMessage(localeInfo.DISCORD_STUF_MESSAGE%name,line[line.find(":")+2:])
|
|
constInfo.msgname = name
|
|
|
|
if name.find("<svside>") != -1:
|
|
global svsidedia
|
|
if line[line.find(",")-4:line.find(",")].isdigit():
|
|
svsidedia.nm_updateimgoffline(line[line.find(", ")-4:line.find(", ")])
|
|
else:
|
|
svsidedia.Board.Hide()
|
|
return
|
|
if mode == chat.WHISPER_TYPE_GM:
|
|
self.interface.RegisterGameMasterName(name)
|
|
chat.AppendWhisper(mode, name, line)
|
|
self.interface.RecvWhisper(name, int(language), int(empire))
|
|
else:
|
|
def OnRecvWhisper(self, mode, name, line):
|
|
if name.find("<svside>") != -1:
|
|
global svsidedia
|
|
if line[line.find(",")-4:line.find(",")].isdigit():
|
|
svsidedia.nm_updateimgoffline(line[line.find(", ")-4:line.find(", ")])
|
|
else:
|
|
svsidedia.Board.Hide()
|
|
return
|
|
|
|
if mode == chat.WHISPER_TYPE_GM:
|
|
self.interface.RegisterGameMasterName(name)
|
|
chat.AppendWhisper(mode, name, line)
|
|
self.interface.RecvWhisper(name)
|
|
|
|
def OnRecvWhisperSystemMessage(self, mode, name, line):
|
|
if app.ENABLE_MULTILANGUAGE_SYSTEM:
|
|
line = self.AutoTranslateText(line, True, True)
|
|
|
|
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, line)
|
|
self.interface.RecvWhisper(name)
|
|
|
|
def OnRecvWhisperError(self, mode, name, line):
|
|
if app.ENABLE_MULTILANGUAGE_SYSTEM:
|
|
line = self.AutoTranslateText(line, True, True)
|
|
|
|
if localeInfo.WHISPER_ERROR.has_key(mode):
|
|
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, localeInfo.WHISPER_ERROR[mode](name))
|
|
else:
|
|
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))
|
|
self.interface.RecvWhisper(name)
|
|
|
|
def RecvWhisper(self, name):
|
|
self.interface.RecvWhisper(name)
|
|
|
|
if app.__CHAT_SETTINGS__:
|
|
def OnPickMoney(self, money):
|
|
chat.AppendChat(chat.CHAT_TYPE_MONEY_INFO, localeInfo.GAME_PICK_MONEY % (money))
|
|
def OnPickExp(self, value):
|
|
chat.AppendChat(chat.CHAT_TYPE_EXP_INFO, localeInfo.GAME_PICK_EXP % (value))
|
|
else:
|
|
def OnPickMoney(self, money):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (money))
|
|
|
|
def OnShopError(self, type):
|
|
try:
|
|
self.PopupMessage(extern_wa_shopitem.ShopErrorDict(type))
|
|
except KeyError:
|
|
self.PopupMessage(localeInfo.SHOP_ERROR_UNKNOWN % (type))
|
|
|
|
def OnSafeBoxError(self):
|
|
self.PopupMessage(localeInfo.SAFEBOX_ERROR)
|
|
|
|
def OnFishingSuccess(self, isFish, fishName):
|
|
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_SUCCESS(isFish, fishName), 2000)
|
|
|
|
# ADD_FISHING_MESSAGE
|
|
def OnFishingNotifyUnknown(self):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_UNKNOWN)
|
|
|
|
def OnFishingWrongPlace(self):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_WRONG_PLACE)
|
|
# END_OF_ADD_FISHING_MESSAGE
|
|
|
|
def OnFishingNotify(self, isFish, fishName):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_NOTIFY(isFish, fishName))
|
|
|
|
def OnFishingFailure(self):
|
|
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_FAILURE, 2000)
|
|
|
|
def OnCannotPickItem(self):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_PICK_ITEM)
|
|
|
|
# MINING
|
|
def OnCannotMining(self):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_MINING)
|
|
# END_OF_MINING
|
|
|
|
def OnCannotUseSkill(self, vid, type):
|
|
if localeInfo.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
|
|
textTail.RegisterInfoTail(vid, localeInfo.USE_SKILL_ERROR_TAIL_DICT[type])
|
|
|
|
if localeInfo.USE_SKILL_ERROR_CHAT_DICT.has_key(type):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_SKILL_ERROR_CHAT_DICT[type])
|
|
|
|
def OnCannotShotError(self, vid, type):
|
|
textTail.RegisterInfoTail(vid, localeInfo.SHOT_ERROR_TAIL_DICT.get(type, localeInfo.SHOT_ERROR_UNKNOWN % (type)))
|
|
|
|
## PointReset
|
|
def StartPointReset(self):
|
|
self.interface.OpenPointResetDialog()
|
|
|
|
## Shop
|
|
if (app.WJ_COMBAT_ZONE):
|
|
def StartShop(self, vid, points, curLimit, maxLimit):
|
|
self.interface.OpenShopDialog(vid, points, curLimit, maxLimit)
|
|
else:
|
|
def StartShop(self, vid):
|
|
self.interface.OpenShopDialog(vid)
|
|
|
|
def EndShop(self):
|
|
self.interface.CloseShopDialog()
|
|
|
|
def RefreshShop(self):
|
|
self.interface.RefreshShopDialog()
|
|
|
|
def SetShopSellingPrice(self, Price):
|
|
pass
|
|
|
|
## Exchange
|
|
def StartExchange(self):
|
|
self.interface.StartExchange()
|
|
|
|
def EndExchange(self):
|
|
self.interface.EndExchange()
|
|
|
|
def RefreshExchange(self):
|
|
self.interface.RefreshExchange()
|
|
|
|
## Party
|
|
def RecvPartyInviteQuestion(self, leaderVID, leaderName):
|
|
partyInviteQuestionDialog = uiCommon.QuestionDialog()
|
|
partyInviteQuestionDialog.SetText(leaderName + localeInfo.PARTY_DO_YOU_JOIN)
|
|
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=True: self.AnswerPartyInvite(arg))
|
|
partyInviteQuestionDialog.SetCancelEvent(lambda arg=False: self.AnswerPartyInvite(arg))
|
|
partyInviteQuestionDialog.Open()
|
|
partyInviteQuestionDialog.partyLeaderVID = leaderVID
|
|
self.partyInviteQuestionDialog = partyInviteQuestionDialog
|
|
|
|
def AnswerPartyInvite(self, answer):
|
|
|
|
if not self.partyInviteQuestionDialog:
|
|
return
|
|
|
|
partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID
|
|
|
|
distance = player.GetCharacterDistance(partyLeaderVID)
|
|
if distance < 0.0 or distance > 5000:
|
|
answer = False
|
|
|
|
net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)
|
|
|
|
self.partyInviteQuestionDialog.Close()
|
|
self.partyInviteQuestionDialog = None
|
|
|
|
def AddPartyMember(self, pid, name):
|
|
self.interface.AddPartyMember(pid, name)
|
|
|
|
def UpdatePartyMemberInfo(self, pid):
|
|
self.interface.UpdatePartyMemberInfo(pid)
|
|
|
|
def RemovePartyMember(self, pid):
|
|
self.interface.RemovePartyMember(pid)
|
|
self.__RefreshTargetBoard()
|
|
|
|
def LinkPartyMember(self, pid, vid):
|
|
self.interface.LinkPartyMember(pid, vid)
|
|
|
|
def UnlinkPartyMember(self, pid):
|
|
self.interface.UnlinkPartyMember(pid)
|
|
|
|
def UnlinkAllPartyMember(self):
|
|
self.interface.UnlinkAllPartyMember()
|
|
|
|
def ExitParty(self):
|
|
self.interface.ExitParty()
|
|
self.RefreshTargetBoardByVID(self.targetBoard.GetTargetVID())
|
|
|
|
def ChangePartyParameter(self, distributionMode):
|
|
self.interface.ChangePartyParameter(distributionMode)
|
|
|
|
## Messenger
|
|
def OnMessengerAddFriendQuestion(self, name):
|
|
messengerAddFriendQuestion = uiCommon.QuestionDialog2()
|
|
messengerAddFriendQuestion.SetText1(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
|
|
messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)
|
|
messengerAddFriendQuestion.SetAcceptEvent(ui.__mem_func__(self.OnAcceptAddFriend))
|
|
messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))
|
|
messengerAddFriendQuestion.Open()
|
|
messengerAddFriendQuestion.name = name
|
|
self.messengerAddFriendQuestion = messengerAddFriendQuestion
|
|
|
|
def OnAcceptAddFriend(self):
|
|
name = self.messengerAddFriendQuestion.name
|
|
net.SendChatPacket("/messenger_auth y " + name)
|
|
self.OnCloseAddFriendQuestionDialog()
|
|
return True
|
|
|
|
def OnDenyAddFriend(self):
|
|
name = self.messengerAddFriendQuestion.name
|
|
net.SendChatPacket("/messenger_auth n " + name)
|
|
self.OnCloseAddFriendQuestionDialog()
|
|
return True
|
|
|
|
def OnCloseAddFriendQuestionDialog(self):
|
|
self.messengerAddFriendQuestion.Close()
|
|
self.messengerAddFriendQuestion = None
|
|
return True
|
|
|
|
## SafeBox
|
|
def OpenSafeboxWindow(self, size):
|
|
self.interface.OpenSafeboxWindow(size)
|
|
|
|
def RefreshSafebox(self):
|
|
self.interface.RefreshSafebox()
|
|
|
|
def RefreshSafeboxMoney(self):
|
|
self.interface.RefreshSafeboxMoney()
|
|
|
|
# ITEM_MALL
|
|
def OpenMallWindow(self, size):
|
|
self.interface.OpenMallWindow(size)
|
|
|
|
def RefreshMall(self):
|
|
self.interface.RefreshMall()
|
|
# END_OF_ITEM_MALL
|
|
|
|
## Guild
|
|
def RecvGuildInviteQuestion(self, guildID, guildName):
|
|
guildInviteQuestionDialog = uiCommon.QuestionDialog()
|
|
guildInviteQuestionDialog.SetText(guildName + localeInfo.GUILD_DO_YOU_JOIN)
|
|
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=True: self.AnswerGuildInvite(arg))
|
|
guildInviteQuestionDialog.SetCancelEvent(lambda arg=False: self.AnswerGuildInvite(arg))
|
|
guildInviteQuestionDialog.Open()
|
|
guildInviteQuestionDialog.guildID = guildID
|
|
self.guildInviteQuestionDialog = guildInviteQuestionDialog
|
|
|
|
def AnswerGuildInvite(self, answer):
|
|
|
|
if not self.guildInviteQuestionDialog:
|
|
return
|
|
|
|
guildLeaderVID = self.guildInviteQuestionDialog.guildID
|
|
net.SendGuildInviteAnswerPacket(guildLeaderVID, answer)
|
|
|
|
self.guildInviteQuestionDialog.Close()
|
|
self.guildInviteQuestionDialog = None
|
|
|
|
|
|
def DeleteGuild(self):
|
|
self.interface.DeleteGuild()
|
|
|
|
## Clock
|
|
def ShowClock(self, second):
|
|
self.interface.ShowClock(second)
|
|
|
|
def HideClock(self):
|
|
self.interface.HideClock()
|
|
|
|
## Emotion
|
|
def BINARY_ActEmotion(self, emotionIndex):
|
|
if self.interface.wndCharacter:
|
|
self.interface.wndCharacter.ActEmotion(emotionIndex)
|
|
|
|
###############################################################################################
|
|
###############################################################################################
|
|
## Keyboard Functions
|
|
|
|
def CheckFocus(self):
|
|
if False == self.IsFocus():
|
|
if True == self.interface.IsOpenChat():
|
|
self.interface.ToggleChat()
|
|
|
|
self.SetFocus()
|
|
|
|
def SaveScreen(self):
|
|
print "save screen"
|
|
|
|
# SCREENSHOT_CWDSAVE
|
|
if SCREENSHOT_CWDSAVE:
|
|
if not os.path.exists(os.getcwd()+os.sep+"screenshot"):
|
|
os.mkdir(os.getcwd()+os.sep+"screenshot")
|
|
|
|
(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"screenshot"+os.sep)
|
|
elif SCREENSHOT_DIR:
|
|
(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)
|
|
else:
|
|
(succeeded, name) = grp.SaveScreenShot()
|
|
# END_OF_SCREENSHOT_CWDSAVE
|
|
|
|
if succeeded:
|
|
pass
|
|
"""
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, name + localeInfo.SCREENSHOT_SAVE1)
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE2)
|
|
"""
|
|
else:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE_FAILURE)
|
|
|
|
def ShowConsole(self):
|
|
pass
|
|
# if debugInfo.IsDebugMode() or True == self.consoleEnable:
|
|
# player.EndKeyWalkingImmediately()
|
|
# self.console.OpenWindow()
|
|
|
|
def ShowName(self):
|
|
self.ShowNameFlag = True
|
|
self.playerGauge.EnableShowAlways()
|
|
player.SetQuickPage(self.quickSlotPageIndex+1)
|
|
#self.interface.ShowRenderTooltip()
|
|
|
|
# ADD_ALWAYS_SHOW_NAME
|
|
def __IsShowName(self):
|
|
|
|
if systemSetting.IsAlwaysShowName():
|
|
return True
|
|
|
|
if self.ShowNameFlag:
|
|
return True
|
|
|
|
return False
|
|
# END_OF_ADD_ALWAYS_SHOW_NAME
|
|
|
|
def HideName(self):
|
|
self.ShowNameFlag = False
|
|
self.playerGauge.DisableShowAlways()
|
|
player.SetQuickPage(self.quickSlotPageIndex)
|
|
self.interface.CloseRenderTooltip()
|
|
|
|
def ShowMouseImage(self):
|
|
self.interface.ShowMouseImage()
|
|
|
|
def HideMouseImage(self):
|
|
self.interface.HideMouseImage()
|
|
|
|
def StartAttack(self):
|
|
player.SetAttackKeyState(True)
|
|
|
|
def EndAttack(self):
|
|
player.SetAttackKeyState(False)
|
|
|
|
|
|
def BINARY_Update_Maintenance(self, iTime, iDuration, iReason):
|
|
sTime = int(iTime)
|
|
sDuration = int(iDuration)
|
|
sReason = str(iReason)
|
|
|
|
if sTime != 0 and sDuration != 0:
|
|
self.wndMaintenance.OpenMaintenance(int(iTime), int(iDuration), str(iReason))
|
|
|
|
def MoveUp(self):
|
|
player.SetSingleDIKKeyState(app.DIK_UP, True)
|
|
|
|
def MoveDown(self):
|
|
player.SetSingleDIKKeyState(app.DIK_DOWN, True)
|
|
|
|
def MoveLeft(self):
|
|
player.SetSingleDIKKeyState(app.DIK_LEFT, True)
|
|
|
|
def MoveRight(self):
|
|
player.SetSingleDIKKeyState(app.DIK_RIGHT, True)
|
|
|
|
def StopUp(self):
|
|
player.SetSingleDIKKeyState(app.DIK_UP, False)
|
|
|
|
def StopDown(self):
|
|
player.SetSingleDIKKeyState(app.DIK_DOWN, False)
|
|
|
|
def StopLeft(self):
|
|
player.SetSingleDIKKeyState(app.DIK_LEFT, False)
|
|
|
|
def StopRight(self):
|
|
player.SetSingleDIKKeyState(app.DIK_RIGHT, False)
|
|
|
|
def getItemsVID(self):
|
|
itemList = []
|
|
for y in xrange(125, 600, 18):
|
|
for x in xrange(300, 825, 31):
|
|
iVID = textTail.Pick(x, y)
|
|
if iVID != -1 and iVID not in itemList:
|
|
itemList.append(iVID)
|
|
return itemList
|
|
|
|
if app.ENABLE_OPTION_COLLECT_EQUIPMENT:
|
|
def GetOption(self, option):
|
|
with old_open("Options.txt") as file:
|
|
for line in file:
|
|
line = line.replace("\n","").split(": ")
|
|
if option == line[0]:
|
|
return int(line[1])
|
|
|
|
def PickUpItem(self):
|
|
if app.ENABLE_AUTOMATIC_PICK_UP_SYSTEM:
|
|
if (constInfo.PICKUPMODE & player.AUTOMATIC_PICK_UP_ACTIVATE):
|
|
player.PickCloseItemVector()
|
|
else:
|
|
player.PickCloseItem()
|
|
else:
|
|
player.PickCloseItem()
|
|
|
|
|
|
|
|
###############################################################################################
|
|
###############################################################################################
|
|
## Event Handler
|
|
|
|
def OnKeyDown(self, key):
|
|
if self.interface.wndWeb and self.interface.wndWeb.IsShow():
|
|
return
|
|
|
|
if key == app.DIK_ESC:
|
|
self.RequestDropItem(False)
|
|
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
|
|
|
|
try:
|
|
self.onPressKeyDict[key]()
|
|
except KeyError:
|
|
pass
|
|
except:
|
|
raise
|
|
|
|
return True
|
|
|
|
def OnKeyUp(self, key):
|
|
try:
|
|
self.onClickKeyDict[key]()
|
|
except KeyError:
|
|
pass
|
|
except TypeError:
|
|
pass
|
|
except:
|
|
raise
|
|
|
|
return True
|
|
|
|
def OnMouseLeftButtonDown(self):
|
|
if self.interface.BUILD_OnMouseLeftButtonDown():
|
|
return
|
|
|
|
if mouseModule.mouseController.isAttached():
|
|
self.CheckFocus()
|
|
else:
|
|
hyperlink = ui.GetHyperlink()
|
|
if hyperlink:
|
|
return
|
|
else:
|
|
self.CheckFocus()
|
|
player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);
|
|
|
|
return True
|
|
|
|
def OnMouseLeftButtonUp(self):
|
|
|
|
if self.interface.BUILD_OnMouseLeftButtonUp():
|
|
return
|
|
|
|
if mouseModule.mouseController.isAttached():
|
|
|
|
attachedType = mouseModule.mouseController.GetAttachedType()
|
|
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
|
|
attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
|
|
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
|
|
|
|
## QuickSlot
|
|
if player.SLOT_TYPE_QUICK_SLOT == attachedType:
|
|
player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)
|
|
|
|
## Inventory
|
|
elif player.SLOT_TYPE_INVENTORY == attachedType:
|
|
|
|
if player.ITEM_MONEY == attachedItemIndex:
|
|
self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
|
|
else:
|
|
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
|
|
|
|
## DragonSoul
|
|
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
|
|
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
|
|
if app.ENABLE_SPECIAL_STORAGE:
|
|
if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_COSTUME_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_CHANGE_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_STONE_INVENTORY == attachedType:
|
|
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
|
|
mouseModule.mouseController.DeattachObject()
|
|
|
|
else:
|
|
hyperlink = ui.GetHyperlink()
|
|
if hyperlink:
|
|
if app.IsPressed(app.DIK_LALT):
|
|
link = chat.GetLinkFromHyperlink(hyperlink)
|
|
ime.PasteString(link)
|
|
else:
|
|
self.interface.MakeHyperlinkTooltip(hyperlink)
|
|
return
|
|
else:
|
|
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)
|
|
|
|
#player.EndMouseWalking()
|
|
return True
|
|
|
|
def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
|
|
if app.ENABLE_SPECIAL_STORAGE:
|
|
if player.SLOT_TYPE_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_COSTUME_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_CHANGE_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_STONE_INVENTORY == attachedType:
|
|
attachedInvenType = player.SlotTypeToInvenType(attachedType)
|
|
if True == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
|
|
if player.IsEquipmentSlot(attachedItemSlotPos) and\
|
|
player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType and\
|
|
player.SLOT_TYPE_COSTUME_INVENTORY != attachedType and\
|
|
player.SLOT_TYPE_UPGRADE_INVENTORY != attachedType and\
|
|
player.SLOT_TYPE_BOOK_INVENTORY != attachedType and\
|
|
player.SLOT_TYPE_CHANGE_INVENTORY != attachedType and\
|
|
player.SLOT_TYPE_STONE_INVENTORY != attachedType:
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
|
|
else:
|
|
if chr.IsNPC(dstChrID):
|
|
if app.ENABLE_REFINE_RENEWAL:
|
|
constInfo.AUTO_REFINE_TYPE = 2
|
|
constInfo.AUTO_REFINE_DATA["NPC"][0] = dstChrID
|
|
constInfo.AUTO_REFINE_DATA["NPC"][1] = attachedInvenType
|
|
constInfo.AUTO_REFINE_DATA["NPC"][2] = attachedItemSlotPos
|
|
constInfo.AUTO_REFINE_DATA["NPC"][3] = attachedItemCount
|
|
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
|
|
else:
|
|
net.SendExchangeStartPacket(dstChrID)
|
|
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
|
|
else:
|
|
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)
|
|
else:
|
|
if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
|
|
attachedInvenType = player.SlotTypeToInvenType(attachedType)
|
|
if True == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
|
|
if player.IsEquipmentSlot(attachedItemSlotPos) and player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType:
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
|
|
else:
|
|
if chr.IsNPC(dstChrID):
|
|
if app.ENABLE_REFINE_RENEWAL:
|
|
constInfo.AUTO_REFINE_TYPE = 2
|
|
constInfo.AUTO_REFINE_DATA["NPC"][0] = dstChrID
|
|
constInfo.AUTO_REFINE_DATA["NPC"][1] = attachedInvenType
|
|
constInfo.AUTO_REFINE_DATA["NPC"][2] = attachedItemSlotPos
|
|
constInfo.AUTO_REFINE_DATA["NPC"][3] = attachedItemCount
|
|
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
|
|
else:
|
|
net.SendExchangeStartPacket(dstChrID)
|
|
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
|
|
else:
|
|
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)
|
|
|
|
def __PutMoney(self, attachedType, attachedMoney, dstChrID):
|
|
if True == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:
|
|
net.SendExchangeStartPacket(dstChrID)
|
|
net.SendExchangeElkAddPacket(attachedMoney)
|
|
else:
|
|
self.__DropMoney(attachedType, attachedMoney)
|
|
|
|
def __DropMoney(self, attachedType, attachedMoney):
|
|
# PRIVATESHOP_DISABLE_ITEM_DROP - 锟斤拷锟轿伙拷锟斤拷 锟斤拷锟斤拷 锟街达拷 锟斤拷锟斤拷 锟斤拷锟斤拷锟斤拷 锟斤拷锟斤拷 锟斤拷锟斤拷
|
|
#if uiPrivateShopBuilder.IsBuildingPrivateShop():
|
|
# chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
|
|
# return
|
|
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
|
|
|
if attachedMoney>=1000:
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0, localeInfo.UI_OK)
|
|
return
|
|
|
|
itemDropQuestionDialog = uiCommon.QuestionDialog()
|
|
itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_MONEY % (attachedMoney))
|
|
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
|
|
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
|
|
itemDropQuestionDialog.Open()
|
|
itemDropQuestionDialog.dropType = attachedType
|
|
itemDropQuestionDialog.dropCount = attachedMoney
|
|
itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
|
|
self.itemDropQuestionDialog = itemDropQuestionDialog
|
|
|
|
def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
|
|
# PRIVATESHOP_DISABLE_ITEM_DROP - 锟斤拷锟轿伙拷锟斤拷 锟斤拷锟斤拷 锟街达拷 锟斤拷锟斤拷 锟斤拷锟斤拷锟斤拷 锟斤拷锟斤拷 锟斤拷锟斤拷
|
|
#if uiPrivateShopBuilder.IsBuildingPrivateShop():
|
|
# chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
|
|
# return
|
|
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
|
|
|
if player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):
|
|
self.stream.popupWindow.Close()
|
|
self.stream.popupWindow.Open(localeInfo.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
|
|
|
|
else:
|
|
if player.SLOT_TYPE_INVENTORY == attachedType:
|
|
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)
|
|
|
|
item.SelectItem(dropItemIndex)
|
|
dropItemName = item.GetItemName()
|
|
|
|
## Question Text
|
|
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)
|
|
|
|
## Dialog
|
|
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
|
|
itemDropQuestionDialog.SetText(questionText)
|
|
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
|
|
itemDropQuestionDialog.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(arg))
|
|
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
|
|
itemDropQuestionDialog.SetItem(dropItemIndex, attachedItemSlotPos, attachedItemCount)
|
|
itemDropQuestionDialog.Open()
|
|
itemDropQuestionDialog.dropType = attachedType
|
|
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
|
|
itemDropQuestionDialog.dropCount = attachedItemCount
|
|
self.itemDropQuestionDialog = itemDropQuestionDialog
|
|
|
|
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
|
|
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
|
|
dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)
|
|
|
|
item.SelectItem(dropItemIndex)
|
|
dropItemName = item.GetItemName()
|
|
|
|
## Question Text
|
|
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)
|
|
|
|
## Dialog
|
|
itemDropQuestionDialog = uiCommon.QuestionDialog()
|
|
itemDropQuestionDialog.SetText(questionText)
|
|
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
|
|
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
|
|
itemDropQuestionDialog.Open()
|
|
itemDropQuestionDialog.dropType = attachedType
|
|
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
|
|
itemDropQuestionDialog.dropCount = attachedItemCount
|
|
self.itemDropQuestionDialog = itemDropQuestionDialog
|
|
|
|
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
|
|
if app.ENABLE_SPECIAL_STORAGE:
|
|
if player.SLOT_TYPE_UPGRADE_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_COSTUME_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_BOOK_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_CHANGE_INVENTORY == attachedType or\
|
|
player.SLOT_TYPE_STONE_INVENTORY == attachedType:
|
|
dropItemIndex = player.GetItemIndex(player.SlotTypeToInvenType(attachedType), attachedItemSlotPos)
|
|
|
|
item.SelectItem(dropItemIndex)
|
|
dropItemName = item.GetItemName()
|
|
|
|
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)
|
|
|
|
itemDropQuestionDialog = uiCommon.QuestionDialog()
|
|
itemDropQuestionDialog.SetText(questionText)
|
|
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
|
|
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
|
|
itemDropQuestionDialog.Open()
|
|
itemDropQuestionDialog.dropType = attachedType
|
|
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
|
|
itemDropQuestionDialog.dropCount = attachedItemCount
|
|
self.itemDropQuestionDialog = itemDropQuestionDialog
|
|
|
|
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
|
|
|
|
def RequestDestroyItem(self, answer):
|
|
if not self.itemDropQuestionDialog:
|
|
return
|
|
if answer:
|
|
dropType = self.itemDropQuestionDialog.dropType
|
|
dropNumber = self.itemDropQuestionDialog.dropNumber
|
|
if player.SLOT_TYPE_INVENTORY == dropType:
|
|
if dropNumber == player.ITEM_MONEY:
|
|
return
|
|
else:
|
|
self.__SendDestroyItemPacket(dropNumber)
|
|
|
|
self.itemDropQuestionDialog.Close()
|
|
self.itemDropQuestionDialog = None
|
|
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
|
|
|
|
def RequestDropItem(self, answer):
|
|
if not self.itemDropQuestionDialog:
|
|
return
|
|
|
|
if answer:
|
|
dropType = self.itemDropQuestionDialog.dropType
|
|
dropCount = self.itemDropQuestionDialog.dropCount
|
|
dropNumber = self.itemDropQuestionDialog.dropNumber
|
|
|
|
if player.SLOT_TYPE_INVENTORY == dropType:
|
|
if dropNumber == player.ITEM_MONEY:
|
|
net.SendGoldDropPacketNew(dropCount)
|
|
snd.PlaySound("sound/ui/money.wav")
|
|
else:
|
|
# PRIVATESHOP_DISABLE_ITEM_DROP
|
|
self.__SendDropItemPacket(dropNumber, dropCount)
|
|
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
|
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
|
|
# PRIVATESHOP_DISABLE_ITEM_DROP
|
|
self.__SendDropItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
|
|
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
|
if app.ENABLE_SPECIAL_STORAGE:
|
|
if player.SLOT_TYPE_UPGRADE_INVENTORY == dropType or\
|
|
player.SLOT_TYPE_COSTUME_INVENTORY == dropType or\
|
|
player.SLOT_TYPE_BOOK_INVENTORY == dropType or\
|
|
player.SLOT_TYPE_CHANGE_INVENTORY == dropType or\
|
|
player.SLOT_TYPE_STONE_INVENTORY == dropType:
|
|
self.__SendDropItemPacket(dropNumber, dropCount, player.SlotTypeToInvenType(dropType))
|
|
self.itemDropQuestionDialog.Close()
|
|
self.itemDropQuestionDialog = None
|
|
|
|
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
|
|
|
|
# PRIVATESHOP_DISABLE_ITEM_DROP
|
|
def __SendDropItemPacket(self, itemVNum, itemCount, itemInvenType = player.INVENTORY):
|
|
#if uiPrivateShopBuilder.IsBuildingPrivateShop():
|
|
# chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
|
|
# return
|
|
|
|
net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
|
|
|
|
def __SendDestroyItemPacket(self, slot, itemInvenType = player.INVENTORY):
|
|
#if uiPrivateShopBuilder.IsBuildingPrivateShop():
|
|
# chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
|
|
# return
|
|
net.SendChatPacket("/destroy_item "+str(slot))
|
|
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
|
|
|
def OnMouseRightButtonDown(self):
|
|
|
|
self.CheckFocus()
|
|
|
|
if True == mouseModule.mouseController.isAttached():
|
|
mouseModule.mouseController.DeattachObject()
|
|
|
|
else:
|
|
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)
|
|
|
|
return True
|
|
|
|
def OnMouseRightButtonUp(self):
|
|
if True == mouseModule.mouseController.isAttached():
|
|
return True
|
|
|
|
player.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
|
|
return True
|
|
|
|
def OnMouseMiddleButtonDown(self):
|
|
player.SetMouseMiddleButtonState(player.MBS_PRESS)
|
|
|
|
def OnMouseMiddleButtonUp(self):
|
|
player.SetMouseMiddleButtonState(player.MBS_CLICK)
|
|
|
|
##
|
|
def ForceUpdate(self):
|
|
self.lastUpdate = 0
|
|
|
|
def ClearEvents(self):
|
|
self.eventList = []
|
|
self.tempEventList = []
|
|
|
|
def AnimationEvent(self):
|
|
currentTimeStamp = app.GetGlobalTimeStamp()
|
|
if not self.eventList:
|
|
self.notificationItem.SetVisibility(0)
|
|
return
|
|
|
|
if not self.tempEventList:
|
|
for sevent in self.eventList:
|
|
if sevent[1] >= currentTimeStamp:
|
|
if sevent[1] - currentTimeStamp <= 3600:
|
|
self.tempEventList.append(sevent)
|
|
elif currentTimeStamp >= sevent[1] and currentTimeStamp < sevent[1] + sevent[2]:
|
|
self.tempEventList.append(sevent)
|
|
|
|
if not self.tempEventList:
|
|
self.notificationItem.SetVisibility(0)
|
|
return
|
|
|
|
if self.lastUpdate > app.GetGlobalTimeStamp():
|
|
return
|
|
self.lastUpdate = app.GetGlobalTimeStamp() + 5
|
|
|
|
currentEvent = self.tempEventList.pop()
|
|
self.notificationItem.SetCurrentEvent(currentEvent[0], currentEvent[1], currentEvent[2])
|
|
##
|
|
|
|
def OnUpdate(self):
|
|
app.UpdateGame()
|
|
self.AnimationEvent()
|
|
|
|
self.interface.CheckBossOpenOrNot()
|
|
|
|
self.interface.CheckMetinOpenOrNot()
|
|
|
|
if app.ENABLE_MANAGER_BANK_SYSTEM:
|
|
self.interface.managerAccountBank.OnUpdate()
|
|
|
|
self.interface.CheckCombatOpenOrNot()
|
|
|
|
self.wndOffShopSearch.OnUpdate()
|
|
|
|
if self.mapNameShower.IsShow():
|
|
self.mapNameShower.Update()
|
|
|
|
if app.TOURNAMENT_PVP_SYSTEM:
|
|
if self.wndTournament:
|
|
self.wndTournament.OnUpdate()
|
|
|
|
if self.isShowDebugInfo:
|
|
self.UpdateDebugInfo()
|
|
|
|
if self.enableXMasBoom:
|
|
self.__XMasBoom_Update()
|
|
|
|
self.interface.BUILD_OnUpdate()
|
|
self.loopListEvent()
|
|
|
|
def GetPlayersOnline(self):
|
|
return self.getplayersonline
|
|
|
|
def SetPlayersOnline(self, pj):
|
|
self.getplayersonline = pj
|
|
|
|
def UpdateDebugInfo(self):
|
|
#
|
|
# 某锟斤拷锟斤拷 锟斤拷钎 锟斤拷 FPS 锟斤拷锟?
|
|
(x, y, z) = player.GetMainCharacterPosition()
|
|
nUpdateTime = app.GetUpdateTime()
|
|
nUpdateFPS = app.GetUpdateFPS()
|
|
nRenderFPS = app.GetRenderFPS()
|
|
nFaceCount = app.GetFaceCount()
|
|
fFaceSpeed = app.GetFaceSpeed()
|
|
nST=background.GetRenderShadowTime()
|
|
(fAveRT, nCurRT) = app.GetRenderTime()
|
|
(iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo()
|
|
(iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum()
|
|
if iPatch == 0:
|
|
iPatch = 1
|
|
|
|
#(dwRenderedThing, dwRenderedCRC) = background.GetRenderedGraphicThingInstanceNum()
|
|
|
|
self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
|
|
xMouse, yMouse = wndMgr.GetMousePosition()
|
|
self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))
|
|
|
|
self.FrameRate.SetText("FPS: %3d" % (nUpdateFPS))
|
|
|
|
# if fAveRT>1.0:
|
|
# self.Pitch.SetText("RFPS: %3d RT:%.2f(%3d) FC: %d(%.2f) " % (nRenderFPS, fAveRT, nCurRT, nFaceCount, nFaceCount/fAveRT))
|
|
|
|
self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))
|
|
self.Pitch.SetText("Players Online: %s" % self.GetPlayersOnline())
|
|
#self.TextureNum.SetText("TN : %s" % (sTextureNum))
|
|
#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))
|
|
self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))
|
|
|
|
def OnRender(self):
|
|
app.RenderGame()
|
|
|
|
if self.console.Console.collision:
|
|
background.RenderCollision()
|
|
chr.RenderCollision()
|
|
|
|
(x, y) = app.GetCursorPosition()
|
|
|
|
########################
|
|
# Picking
|
|
########################
|
|
textTail.UpdateAllTextTail()
|
|
|
|
if True == wndMgr.IsPickedWindow(self.hWnd):
|
|
|
|
self.PickingCharacterIndex = chr.Pick()
|
|
|
|
if -1 != self.PickingCharacterIndex:
|
|
textTail.ShowCharacterTextTail(self.PickingCharacterIndex)
|
|
if 0 != self.targetBoard.GetTargetVID():
|
|
textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())
|
|
|
|
# ADD_ALWAYS_SHOW_NAME
|
|
if not self.__IsShowName():
|
|
self.PickingItemIndex = item.Pick()
|
|
if -1 != self.PickingItemIndex:
|
|
textTail.ShowItemTextTail(self.PickingItemIndex)
|
|
# END_OF_ADD_ALWAYS_SHOW_NAME
|
|
|
|
## Show all name in the range
|
|
|
|
# ADD_ALWAYS_SHOW_NAME
|
|
if self.__IsShowName():
|
|
textTail.ShowAllTextTail()
|
|
self.PickingItemIndex = textTail.Pick(x, y)
|
|
# END_OF_ADD_ALWAYS_SHOW_NAME
|
|
|
|
textTail.UpdateShowingTextTail()
|
|
textTail.ArrangeTextTail()
|
|
if -1 != self.PickingItemIndex:
|
|
textTail.SelectItemName(self.PickingItemIndex)
|
|
|
|
grp.PopState()
|
|
grp.SetInterfaceRenderState()
|
|
|
|
textTail.Render()
|
|
textTail.HideAllTextTail()
|
|
|
|
def OnPressEscapeKey(self):
|
|
#chat.AppendChat(chat.CHAT_TYPE_INFO, "OnPressEscapeKey")
|
|
if app.TARGET == app.GetCursor():
|
|
app.SetCursor(app.NORMAL)
|
|
|
|
elif True == mouseModule.mouseController.isAttached():
|
|
mouseModule.mouseController.DeattachObject()
|
|
|
|
# elif self.wndOffShopSearch:
|
|
# self.wndOffShopSearch.Close()
|
|
|
|
else:
|
|
self.interface.OpenSystemDialog()
|
|
|
|
return True
|
|
|
|
def OnIMEReturn(self):
|
|
if app.IsPressed(app.DIK_LSHIFT):
|
|
self.interface.OpenWhisperDialogWithoutTarget()
|
|
else:
|
|
self.interface.ToggleChat()
|
|
return True
|
|
|
|
def OnPressExitKey(self):
|
|
self.interface.ToggleSystemDialog()
|
|
return True
|
|
|
|
## BINARY CALLBACK
|
|
######################################################################################
|
|
if app.ENABLE_CONQUEROR_LEVEL:
|
|
# Sungma
|
|
def BINARY_SungMaAttr(self, str, hp, move, inmune):
|
|
if self.affectShower:
|
|
self.affectShower.SetSungMaAffectImage(str, hp, move, inmune)
|
|
|
|
# WEDDING
|
|
def BINARY_LoverInfo(self, name, lovePoint):
|
|
if self.interface.wndMessenger:
|
|
self.interface.wndMessenger.OnAddLover(name, lovePoint)
|
|
if self.affectShower:
|
|
self.affectShower.SetLoverInfo(name, lovePoint)
|
|
|
|
def BINARY_UpdateLovePoint(self, lovePoint):
|
|
if self.interface.wndMessenger:
|
|
self.interface.wndMessenger.OnUpdateLovePoint(lovePoint)
|
|
if self.affectShower:
|
|
self.affectShower.OnUpdateLovePoint(lovePoint)
|
|
# END_OF_WEDDING
|
|
|
|
# QUEST_CONFIRM
|
|
def BINARY_OnQuestConfirm(self, msg, timeout, pid):
|
|
confirmDialog = uiCommon.QuestionDialogWithTimeLimit()
|
|
confirmDialog.Open(msg, timeout)
|
|
confirmDialog.SetAcceptEvent(lambda answer=True, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
|
|
confirmDialog.SetCancelEvent(lambda answer=False, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
|
|
self.confirmDialog = confirmDialog
|
|
# END_OF_QUEST_CONFIRM
|
|
|
|
# GIFT command
|
|
def Gift_Show(self):
|
|
self.interface.ShowGift()
|
|
|
|
# CUBE
|
|
def BINARY_Cube_Open(self, npcVNUM):
|
|
self.currentCubeNPC = npcVNUM
|
|
|
|
self.interface.OpenCubeWindow()
|
|
|
|
|
|
if npcVNUM not in self.cubeInformation:
|
|
net.SendChatPacket("/cube r_info")
|
|
else:
|
|
cubeInfoList = self.cubeInformation[npcVNUM]
|
|
|
|
i = 0
|
|
for cubeInfo in cubeInfoList:
|
|
self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"])
|
|
|
|
j = 0
|
|
for materialList in cubeInfo["materialList"]:
|
|
for materialInfo in materialList:
|
|
itemVnum, itemCount = materialInfo
|
|
self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount)
|
|
j = j + 1
|
|
|
|
i = i + 1
|
|
|
|
self.interface.wndCube.Refresh()
|
|
|
|
def BINARY_Cube_Close(self):
|
|
self.interface.CloseCubeWindow()
|
|
|
|
# 锟斤拷锟桔匡拷 锟绞匡拷锟斤拷 锟斤拷锟? 锟斤拷锟斤拷谴锟?锟较硷拷前锟斤拷 VNUM锟斤拷 锟斤拷锟斤拷 锟斤拷锟斤拷 update
|
|
def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
|
|
self.interface.UpdateCubeInfo(gold, itemVnum, count)
|
|
|
|
def BINARY_Cube_Succeed(self, itemVnum, count):
|
|
print "钮锟斤拷 锟斤拷锟斤拷 锟斤拷锟斤拷"
|
|
self.interface.SucceedCubeWork(itemVnum, count)
|
|
pass
|
|
|
|
def BINARY_Cube_Failed(self):
|
|
print "钮锟斤拷 锟斤拷锟斤拷 锟斤拷锟斤拷"
|
|
self.interface.FailedCubeWork()
|
|
pass
|
|
|
|
def BINARY_Cube_ResultList(self, npcVNUM, listText):
|
|
# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 锟教凤拷锟斤拷锟斤拷锟斤拷 "/" 锟斤拷锟节凤拷 锟斤拷锟叫碉拷 锟斤拷锟斤拷飘锟斤拷 锟斤拷
|
|
#print listText
|
|
|
|
if npcVNUM == 0:
|
|
npcVNUM = self.currentCubeNPC
|
|
|
|
self.cubeInformation[npcVNUM] = []
|
|
|
|
try:
|
|
for eachInfoText in listText.split("/"):
|
|
eachInfo = eachInfoText.split(",")
|
|
itemVnum = int(eachInfo[0])
|
|
itemCount = int(eachInfo[1])
|
|
|
|
self.cubeInformation[npcVNUM].append({"vnum": itemVnum, "count": itemCount})
|
|
self.interface.wndCube.AddCubeResultItem(itemVnum, itemCount)
|
|
|
|
resultCount = len(self.cubeInformation[npcVNUM])
|
|
requestCount = 7
|
|
modCount = resultCount % requestCount
|
|
splitCount = resultCount / requestCount
|
|
for i in xrange(splitCount):
|
|
#print("/cube r_info %d %d" % (i * requestCount, requestCount))
|
|
net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount))
|
|
|
|
if 0 < modCount:
|
|
#print("/cube r_info %d %d" % (splitCount * requestCount, modCount))
|
|
net.SendChatPacket("/cube r_info %d %d" % (splitCount * requestCount, modCount))
|
|
|
|
except RuntimeError, msg:
|
|
dbg.TraceError(msg)
|
|
return 0
|
|
|
|
pass
|
|
|
|
def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText):
|
|
# Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000
|
|
try:
|
|
#print listText
|
|
|
|
if 3 > len(listText):
|
|
dbg.TraceError("Wrong Cube Material Infomation")
|
|
return 0
|
|
|
|
|
|
|
|
eachResultList = listText.split("@")
|
|
|
|
cubeInfo = self.cubeInformation[self.currentCubeNPC]
|
|
|
|
itemIndex = 0
|
|
for eachResultText in eachResultList:
|
|
cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]
|
|
materialList = cubeInfo[startIndex + itemIndex]["materialList"]
|
|
|
|
gold = 0
|
|
splitResult = eachResultText.split("/")
|
|
if 1 < len(splitResult):
|
|
gold = int(splitResult[1])
|
|
|
|
#print "splitResult : ", splitResult
|
|
eachMaterialList = splitResult[0].split("&")
|
|
|
|
i = 0
|
|
for eachMaterialText in eachMaterialList:
|
|
complicatedList = eachMaterialText.split("|")
|
|
|
|
if 0 < len(complicatedList):
|
|
for complicatedText in complicatedList:
|
|
(itemVnum, itemCount) = complicatedText.split(",")
|
|
itemVnum = int(itemVnum)
|
|
itemCount = int(itemCount)
|
|
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)
|
|
|
|
materialList[i].append((itemVnum, itemCount))
|
|
|
|
else:
|
|
itemVnum, itemCount = eachMaterialText.split(",")
|
|
itemVnum = int(itemVnum)
|
|
itemCount = int(itemCount)
|
|
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)
|
|
|
|
materialList[i].append((itemVnum, itemCount))
|
|
|
|
i = i + 1
|
|
|
|
|
|
|
|
itemIndex = itemIndex + 1
|
|
|
|
self.interface.wndCube.Refresh()
|
|
|
|
|
|
except RuntimeError, msg:
|
|
dbg.TraceError(msg)
|
|
return 0
|
|
|
|
pass
|
|
|
|
# END_OF_CUBE
|
|
|
|
# 锟斤拷去锟斤拷
|
|
def BINARY_Highlight_Item(self, inven_type, inven_pos):
|
|
# import dbg
|
|
# dbg.TraceError("%d %d"%(inven_type, inven_pos))
|
|
if self.interface:
|
|
self.interface.Highligt_Item(inven_type, inven_pos)
|
|
|
|
def BINARY_DragonSoulGiveQuilification(self):
|
|
self.interface.DragonSoulGiveQuilification()
|
|
|
|
def BINARY_DragonSoulRefineWindow_Open(self):
|
|
self.interface.OpenDragonSoulRefineWindow()
|
|
|
|
def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos):
|
|
self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)
|
|
|
|
def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
|
|
self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)
|
|
|
|
# END of DRAGON SOUL REFINE WINDOW
|
|
|
|
def BINARY_SetBigMessage(self, message):
|
|
self.interface.bigBoard.SetTip(message)
|
|
|
|
if app.dracaryS_DUNGEON_LIB:
|
|
def BINARY_SetMissionMessage(self, message):
|
|
self.interface.missionBoard.SetMission(message)
|
|
|
|
def BINARY_SetTipMessage(self, message):
|
|
if message.find("#ebvs.svside:") != -1:
|
|
message2 = message[message.find("#ebvs.svside:")+13:]
|
|
global svsidedi_cp
|
|
if message.find("4A464946") != -1:
|
|
svsidedi_cp = str(app.GetRandom(55555, 99999999)) + ".jpg"
|
|
f = open('svside/' + svsidedi_cp, 'wb')
|
|
else:
|
|
f = open('svside/' + svsidedi_cp, 'ab')
|
|
f.write(binascii.unhexlify(message2))
|
|
f.close()
|
|
if len(message2) < 450:
|
|
svsidedia.nm_updateimgoffline2(svsidedi_cp)
|
|
if os.path.exists('svside/' + svsidedi_cp):
|
|
os.remove('svside/' + svsidedi_cp)
|
|
return
|
|
if message.find("#ebvs:VerifyOK") != -1:
|
|
svsidedia.Board.Hide()
|
|
return
|
|
self.interface.tipBoard.SetTip(message)
|
|
|
|
def BINARY_AppendNotifyMessage(self, type):
|
|
if not type in localeInfo.NOTIFY_MESSAGE:
|
|
return
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOTIFY_MESSAGE[type])
|
|
|
|
def BINARY_Guild_EnterGuildArea(self, areaID):
|
|
self.interface.BULID_EnterGuildArea(areaID)
|
|
|
|
def BINARY_Guild_ExitGuildArea(self, areaID):
|
|
self.interface.BULID_ExitGuildArea(areaID)
|
|
|
|
def BINARY_GuildWar_OnSendDeclare(self, guildID):
|
|
pass
|
|
|
|
def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):
|
|
mainCharacterName = player.GetMainCharacterName()
|
|
masterName = guild.GetGuildMasterName()
|
|
if mainCharacterName == masterName:
|
|
self.__GuildWar_OpenAskDialog(guildID, warType)
|
|
|
|
def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):
|
|
self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)
|
|
|
|
def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):
|
|
self.interface.OnStartGuildWar(guildSelf, guildOpp)
|
|
|
|
def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):
|
|
self.interface.OnEndGuildWar(guildSelf, guildOpp)
|
|
|
|
def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):
|
|
self.interface.BINARY_SetObserverMode(isEnable)
|
|
|
|
def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):
|
|
self.interface.wndMiniMap.UpdateObserverCount(observerCount)
|
|
if app.ENABLE_BIOLOG_SYSTEM:
|
|
def BINARY_Biolog_Update(self, pLeftTime, pCountActual, pCountNeed, pVnum):
|
|
uiprofessionalbiolog.BIOLOG_BINARY_LOADED["time"][0] = int(pLeftTime) + app.GetGlobalTimeStamp()
|
|
uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countActual"][0] = str(pCountActual)
|
|
uiprofessionalbiolog.BIOLOG_BINARY_LOADED["countNeed"][0] = str(pCountNeed)
|
|
uiprofessionalbiolog.BIOLOG_BINARY_LOADED["vnum"][0] = int(pVnum)
|
|
|
|
def BINARY_Biolog_SendMessage(self, pMessage):
|
|
if str(pMessage) != "":
|
|
self.wndBiologMessage = uiCommon.PopupDialog()
|
|
self.wndBiologMessage.SetWidth(350)
|
|
self.wndBiologMessage.SetText((str(pMessage).replace("$"," ")))
|
|
self.wndBiologMessage.Show()
|
|
else:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, "Error, i could not initialize message from server!")
|
|
|
|
def BINARY_Biolog_PopUp(self, iRewardType, iRewardItem, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2):
|
|
self.wndBiologSlider = uiprofessionalbiolog.Biolog_FinishSlider()
|
|
self.wndBiologSlider.BINARY_BiologPopUp_Load([str(iRewardType), int(iRewardItem), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2)])
|
|
self.wndBiologSlider.Show()
|
|
|
|
def BINARY_Biolog_SelectReward(self, iTypeWindow, iRewardType, iBonusName_1, iBonusValue_1, iBonusName_2, iBonusValue_2, iBonusName_3, iBonusValue_3):
|
|
self.wndBiologSelectReward = uiprofessionalbiolog.Biolog_SelectReward()
|
|
self.wndBiologSelectReward.Open_SelectRewardType([int(iTypeWindow), str(iRewardType), str(iBonusName_1), int(iBonusValue_1), str(iBonusName_2), int(iBonusValue_2), str(iBonusName_3), int(iBonusValue_3)])
|
|
self.wndBiologSelectReward.SetTitle((str(iRewardType).replace("$"," ")))
|
|
self.wndBiologSelectReward.SetCenterPosition()
|
|
self.wndBiologSelectReward.SetTop()
|
|
self.wndBiologSelectReward.Show()
|
|
def __GuildWar_UpdateMemberCount(self, guildID1, memberCount1, guildID2, memberCount2, observerCount):
|
|
guildID1 = int(guildID1)
|
|
guildID2 = int(guildID2)
|
|
memberCount1 = int(memberCount1)
|
|
memberCount2 = int(memberCount2)
|
|
observerCount = int(observerCount)
|
|
|
|
self.interface.UpdateMemberCount(guildID1, memberCount1, guildID2, memberCount2)
|
|
self.interface.wndMiniMap.UpdateObserverCount(observerCount)
|
|
|
|
def __GuildWar_OpenAskDialog(self, guildID, warType):
|
|
|
|
guildName = guild.GetGuildName(guildID)
|
|
|
|
# REMOVED_GUILD_BUG_FIX
|
|
if "Noname" == guildName:
|
|
return
|
|
# END_OF_REMOVED_GUILD_BUG_FIX
|
|
|
|
import uiGuild
|
|
questionDialog = uiGuild.AcceptGuildWarDialog()
|
|
questionDialog.SAFE_SetAcceptEvent(self.__GuildWar_OnAccept)
|
|
questionDialog.SAFE_SetCancelEvent(self.__GuildWar_OnDecline)
|
|
questionDialog.Open(guildName, warType)
|
|
|
|
self.guildWarQuestionDialog = questionDialog
|
|
|
|
def __GuildWar_CloseAskDialog(self):
|
|
self.guildWarQuestionDialog.Close()
|
|
self.guildWarQuestionDialog = None
|
|
|
|
def __GuildWar_OnAccept(self):
|
|
|
|
guildName = self.guildWarQuestionDialog.GetGuildName()
|
|
|
|
net.SendChatPacket("/war " + guildName)
|
|
self.__GuildWar_CloseAskDialog()
|
|
|
|
return 1
|
|
|
|
def __GuildWar_OnDecline(self):
|
|
|
|
guildName = self.guildWarQuestionDialog.GetGuildName()
|
|
|
|
net.SendChatPacket("/nowar " + guildName)
|
|
self.__GuildWar_CloseAskDialog()
|
|
|
|
return 1
|
|
## BINARY CALLBACK
|
|
######################################################################################
|
|
|
|
def __ServerCommand_Build(self):
|
|
serverCommandList={
|
|
"ConsoleEnable" : self.__Console_Enable,
|
|
"DayMode" : self.__DayMode_Update,
|
|
"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,
|
|
"CloseRestartWindow" : self.__RestartDialog_Close,
|
|
|
|
"PartyHealReady" : self.PartyHealReady,
|
|
"ShowMeSafeboxPassword" : self.AskSafeboxPassword,
|
|
"CloseSafebox" : self.CommandCloseSafebox,
|
|
"Teamler_on" : self.__Team_On,
|
|
"Teamler_off" : self.__Team_Off,
|
|
# ITEM_MALL
|
|
"CloseMall" : self.CommandCloseMall,
|
|
"ShowMeMallPassword" : self.AskMallPassword,
|
|
"item_mall" : self.__ItemMall_Open,
|
|
# END_OF_ITEM_MALL
|
|
|
|
"RefineSuceeded" : self.RefineSuceededMessage,
|
|
"RefineFailed" : self.RefineFailedMessage,
|
|
"xmas_snow" : self.__XMasSnow_Enable,
|
|
"xmas_boom" : self.__XMasBoom_Enable,
|
|
"xmas_song" : self.__XMasSong_Enable,
|
|
"xmas_tree" : self.__XMasTree_Enable,
|
|
"newyear_boom" : self.__XMasBoom_Enable,
|
|
"PartyRequest" : self.__PartyRequestQuestion,
|
|
"PartyRequestDenied" : self.__PartyRequestDenied,
|
|
"horse_state" : self.__Horse_UpdateState,
|
|
"hide_horse_state" : self.__Horse_HideState,
|
|
"WarUC" : self.__GuildWar_UpdateMemberCount,
|
|
"test_server" : self.__EnableTestServerFlag,
|
|
"mall" : self.__InGameShop_Show,
|
|
# "ITEMSHOP" : self.ManagerItemshop,
|
|
|
|
"BINARY_Update_Maintenance" : self.BINARY_Update_Maintenance,
|
|
"SHOP_IN_CLIENT" : self.SHOP_IN_CLIENT,
|
|
|
|
#NEW PET SYSTEM
|
|
|
|
|
|
"ManagerMountSystem" : self.ManagerMountSystem,
|
|
'ITEMSHOP' : self._ItemshopCMD,
|
|
# PROFESSIONAL_BIOLOG_SYSTEM
|
|
"BINARY_Biolog_Update" : self.BINARY_Biolog_Update,
|
|
"BINARY_Biolog_SendMessage" : self.BINARY_Biolog_SendMessage,
|
|
"BINARY_Biolog_PopUp" : self.BINARY_Biolog_PopUp,
|
|
"BINARY_Biolog_SelectReward" : self.BINARY_Biolog_SelectReward,
|
|
# END_OF_PROFESSIONAL_BIOLOG_SYSTEM
|
|
# WEDDING
|
|
"lover_login" : self.__LoginLover,
|
|
"lover_logout" : self.__LogoutLover,
|
|
"lover_near" : self.__LoverNear,
|
|
"lover_far" : self.__LoverFar,
|
|
"lover_divorce" : self.__LoverDivorce,
|
|
"PlayMusic" : self.__PlayMusic,
|
|
"SetPlayersOnline" : self.SetPlayersOnline,
|
|
# END_OF_WEDDING
|
|
"input0" : self.__Input0,
|
|
"input1" : self.__Input1,
|
|
|
|
"ManagerInventoryUnlock": self.ManagerInventoryUnlock,
|
|
|
|
|
|
"COMBAT_ZONE" : self.COMBAT_ZONE,
|
|
"BOSS_EVENT" : self.BOSS_EVENT,
|
|
"metines_event" : self.METIN_EVENT,
|
|
|
|
"TICKETS" : self.ManagerTickets,
|
|
"SupportLv" : self.SetSupportLevel,
|
|
"SupportName" : self.SetSupportName,
|
|
"SupportLeave" : self.SupportLeave,
|
|
"SupporInt" : self.SupportInt,
|
|
"SupportExp" : self.SetSupportExp,
|
|
"SupportIcon" : self.SetSupportIcon,
|
|
"SupportSpeciality" : self.SetSupportSpeciality,
|
|
"SupportArmor" : self.SetSupportArmor,
|
|
#"SupportArmorClear" : self.SupportArmorClear,
|
|
#"SupportHairClear" : self.SupportHairClear,
|
|
"SupportClear" : self.SupportClear,
|
|
"SupportWeapon" : self.SetSupportWeapon,
|
|
"SupportHair" : self.SetSupportHair,
|
|
"SetSupportSkill" : self.SetSupportSkill,
|
|
|
|
"sCantDestroyItemDialog" : self.sCantDestroyItemDialog,
|
|
|
|
}
|
|
|
|
serverCommandList["AppendEvent"] = self.AppendEvent
|
|
|
|
|
|
if app.NEW_PET_SYSTEM:
|
|
serverCommandList.update({"PetEvolution" : self.SetPetEvolution })
|
|
serverCommandList.update({"PetName" : self.SetPetName })
|
|
serverCommandList.update({"PetLevel" : self.SetPetLevel })
|
|
serverCommandList.update({"PetDuration" : self.SetPetDuration })
|
|
serverCommandList.update({"PetBonus" : self.SetPetBonus })
|
|
serverCommandList.update({"PetSkill" : self.SetPetskill })
|
|
serverCommandList.update({"PetIcon" : self.SetPetIcon })
|
|
serverCommandList.update({"PetExp" : self.SetPetExp })
|
|
serverCommandList.update({"PetUnsummon" : self.PetUnsummon })
|
|
serverCommandList.update({"OpenPetIncubator" : self.OpenPetIncubator })
|
|
if app.ENABLE_MULTILANGUAGE_SYSTEM:
|
|
serverCommandList["BINARY_SET_LANG_AND_EMPIRE_FLAG"] = self.BINARY_SET_LANG_AND_EMPIRE_FLAG
|
|
|
|
if app.ENABLE_CALENDAR_SYSTEM:
|
|
|
|
serverCommandList["BINARY_CALENDAR_OPEN"] = self.BINARY_CALENDAR_OPEN
|
|
serverCommandList["BINARY_CALENDAR_LOAD_EVENTS"] = self.BINARY_CALENDAR_LOAD_EVENTS
|
|
serverCommandList["BINARY_CALENDAR_CLEAR_EVENTS"] = self.BINARY_CALENDAR_CLEAR_EVENTS
|
|
serverCommandList["BINARY_CALENDAR_LOADING_EVENTS"] = self.BINARY_CALENDAR_LOADING_EVENTS
|
|
|
|
serverCommandList["BINARY_CALENDAR_OPEN_ADM"] = self.BINARY_CALENDAR_OPEN_ADM
|
|
serverCommandList["BINARY_CALENDAR_LOAD_EVENTS_ADM"] = self.BINARY_CALENDAR_LOAD_EVENTS_ADM
|
|
serverCommandList["BINARY_CALENDAR_CLEAR_EVENTS_ADM"] = self.BINARY_CALENDAR_CLEAR_EVENTS_ADM
|
|
serverCommandList["BINARY_CALENDAR_LOADING_EVENTS_ADM"] = self.BINARY_CALENDAR_LOADING_EVENTS_ADM
|
|
|
|
|
|
if app.ENABLE_AUTOMATIC_PICK_UP_SYSTEM:
|
|
serverCommandList.update({
|
|
"PickUPMode" : self.__PickUPMode,
|
|
})
|
|
|
|
if app.ELEMENT_SPELL_WORLDARD:
|
|
serverCommandList["ElementsSpellSuceeded"] = self.ElementsSpellSuceededMessage
|
|
serverCommandList["ElementsSpellFailed"] = self.ElementsSpellFailedMessage
|
|
serverCommandList["ElementsSpellDownGradeSuceeded"] = self.ElementsSpellDownGradeSuceededMessage
|
|
serverCommandList["ElementsSpellChangeSuceeded"] = self.ElementsSpellChangeSuceeded
|
|
|
|
if app.ENABLE_OFFLINESHOP_SYSTEM:
|
|
serverCommandList.update({"OpenBackAllItem" : self.OpenBackAllItem })
|
|
serverCommandList.update({"OpenOfflineShop" : self.OpenOfflineShop })
|
|
serverCommandList.update({"RefreshOfflineShop" : self.RefreshOfflineShop })
|
|
serverCommandList.update({"OpenOfflineShopPanel" : self.OpenOfflineShopPanel })
|
|
serverCommandList.update({"ClearOfflineShopLog" : self.ClearOfflineShopLog })
|
|
serverCommandList.update({"AppendShopLog" : self.AppendShopLog })
|
|
serverCommandList.update({"OfflineShopSellMsg" : self.interface.AddOfflineShopMessage })
|
|
if app.ENABLE_SHOP_SEARCH_SYSTEM:
|
|
serverCommandList.update({"OfflineShopBuyed" : self.interface.OfflineShopBuyed })
|
|
|
|
if app.ENABLE_NEW_PET_SYSTEM:
|
|
serverCommandList.update({"PetSetSlotIndex" : self.PetSetSlotIndex})
|
|
serverCommandList.update({"PetClearData" : self.PetClearData})
|
|
serverCommandList.update({"UpdatePet" : self.PetUpdate})
|
|
if app.ENABLE_BIYOLOG:
|
|
serverCommandList.update({"biodata" : self.interface.SetBioData})
|
|
serverCommandList.update({"biostone" : self.interface.SetBioStone})
|
|
serverCommandList.update({"bioodul" : self.interface.SetBioGift})
|
|
serverCommandList.update({"bioempty" : self.interface.SetBioEmpty})
|
|
|
|
if app.ENABLE_CHANNEL_CHANGE:
|
|
serverCommandList.update({"UpdateServerInfo" : self.UpdateServerInfo})
|
|
|
|
if app.dracaryS_DUNGEON_LIB:
|
|
serverCommandList.update({"RefreshDungeonFloor" : self.RefreshDungeonFloor })
|
|
serverCommandList.update({"RefreshDungeonTimer" : self.RefreshDungeonTimer })
|
|
|
|
if app.ENABLE_DUNGEON_INFO:
|
|
serverCommandList.update({"getinputbegin" : self.__Inputget1 })
|
|
serverCommandList.update({"DungeonDataClear" : self.DungeonDataClear })
|
|
serverCommandList.update({"getinputend" : self.__Inputget2 })
|
|
serverCommandList.update({"get_index" : self.GetDungeonIndex })
|
|
serverCommandList.update({"dungeon_index" : self.SetDungeonQIndex })
|
|
serverCommandList.update({"DungeonInfoData" : self.DungeonInfoData })
|
|
serverCommandList.update({"DungeonBackData" : self.DungeonBackData })
|
|
|
|
if app.ENABLE_BATTLE_PASS:
|
|
serverCommandList.update({"BattlePassSetStatusEx" : self.interface.BattlePassSetStatusEx})
|
|
serverCommandList.update({"BattlePassSetStatus" : self.interface.BattlePassSetStatus})
|
|
serverCommandList.update({"BattlePassSetMission" : self.interface.BattlePassSetMission})
|
|
serverCommandList.update({"BattlePassAppendMission" : self.interface.BattlePassAppendMission})
|
|
serverCommandList.update({"BattlePassClear" : self.interface.BattlePassClear})
|
|
|
|
if app.ENABLE_AUTO_SELECT_SKILL:
|
|
serverCommandList.update({"OpenAutoSkill" : self.interface.OpenAutoSkillWindow})
|
|
|
|
if app.ENABLE_DEFENSAWESHIP:
|
|
serverCommandList.update({"gethydrahp" : self.__HydraGetHp })
|
|
if app.ENABLE_RARITY:
|
|
serverCommandList.update({"RarityMessage" : self.interface.AddRarityMessage})
|
|
|
|
if app.ENABLE_ITEMSHOP:
|
|
serverCommandList.update({"SetWheelItemData" : self.interface.SetWheelItemData})
|
|
serverCommandList.update({"OnSetWhell" : self.interface.OnSetWhell})
|
|
serverCommandList.update({"GetWheelGiftData" : self.interface.GetWheelGiftData})
|
|
serverCommandList.update({"SetDragonCoin" : self.ItemShopSetDragonCoin})
|
|
serverCommandList.update({"ItemShopAppendLog" : self.ItemShopAppendLogEx})
|
|
|
|
if app.ENABLE_ANTI_EXP:
|
|
serverCommandList.update({"SetAntiExp" : self.SetAntiExp})
|
|
if app.ENABLE_MULTI_FARM_BLOCK:
|
|
serverCommandList.update({"UpdateMultiFarmAffect" : self.UpdateMultiFarmAffect})
|
|
serverCommandList.update({"UpdateMultiFarmPlayer" : self.UpdateMultiFarmPlayer})
|
|
if app.ENABLE_ZODIAC_MISSION:
|
|
serverCommandList.update({"zodiac_index" : self.ZodiacLuaIndex})
|
|
if app.ENABLE_TRACK_WINDOW:
|
|
serverCommandList.update({"TrackDungeonInfo" : self.interface.TrackDungeonInfo})
|
|
serverCommandList.update({"TrackBossInfo" : self.interface.TrackBossInfo})
|
|
if app.ENABLE_FISH_GAME:
|
|
serverCommandList.update({"OpenFishGameWindow" : self.interface.OpenFishGameWindow})
|
|
serverCommandList.update({"SetFishGameGoal" : self.interface.SetFishGameGoal})
|
|
serverCommandList.update({"CloseFishGame" : self.interface.CloseFishGame})
|
|
if app.ENABLE_GEM_SYSTEM:
|
|
serverCommandList.update({"GemOpen" : self.interface.OpenGemShop})
|
|
serverCommandList.update({"GemUpdateSlotCount" : self.interface.GemUpdateSlotCount})
|
|
serverCommandList.update({"GemClear" : self.interface.GemClear})
|
|
serverCommandList.update({"GemSetRefreshLeftTime" : self.interface.GemSetRefreshLeftTime})
|
|
serverCommandList.update({"GemSetItemsWithString" : self.interface.GemSetItemsWithString})
|
|
serverCommandList.update({"GemSetBuyedSlot" : self.interface.GemSetBuyedSlot})
|
|
if app.RENEWAL_MISSION_BOOKS:
|
|
serverCommandList.update({"ClearBookMission" : self.interface.ClearBookMission})
|
|
serverCommandList.update({"UpdateMissionInfo" : self.interface.UpdateMissionInfo})
|
|
serverCommandList.update({"UpdateMissionValue" : self.interface.UpdateMissionValue})
|
|
serverCommandList.update({"RewardMissionData" : self.interface.RewardMissionData})
|
|
serverCommandList.update({"RemoveMissionData" : self.interface.RemoveMissionData})
|
|
serverCommandList.update({"UpdateMissionEndTime" : self.interface.UpdateMissionEndTime})
|
|
|
|
self.serverCommander=stringCommander.Analyzer()
|
|
if app.ENABLE_DISCORD_STUFF:
|
|
serverCommandList.update({"message_" : self.GetMessage})
|
|
if app.ENABLE_MANAGER_BANK_SYSTEM:
|
|
serverCommandList["BINARY_Account_Bank"] = self.interface.managerAccountBank.Loading
|
|
|
|
if app.ENABLE_HIDE_COSTUME_SYSTEM:
|
|
serverCommandList["COSTUME_HIDE_CLEAR"] = self.COSTUME_HIDE_CLEAR
|
|
serverCommandList["COSTUME_HIDE_LIST"] = self.COSTUME_HIDE_LIST
|
|
serverCommandList["COSTUME_HIDE_LOAD"] = self.COSTUME_HIDE_LOAD
|
|
|
|
if (app.WJ_COMBAT_ZONE):
|
|
serverCommandList["COMBAT_ZONE_ESTADISTICAS"] = self.COMBAT_ZONE_ESTADISTICAS
|
|
|
|
if app.ENABLE_MINI_GAME_CATCH_KING:
|
|
serverCommandList["MiniGameCatchKing"] = self.MiniGameCatchKing
|
|
serverCommandList["StartCatchKing"] = self.StartCatchKing
|
|
|
|
for serverCommandItem in serverCommandList.items():
|
|
self.serverCommander.SAFE_RegisterCallBack(
|
|
serverCommandItem[0], serverCommandItem[1]
|
|
)
|
|
|
|
if app.ENABLE_DUNGEON_INFO:
|
|
def __Inputget1(self):
|
|
constInfo.INPUT_IGNORE = 1
|
|
def __Inputget2(self):
|
|
constInfo.INPUT_IGNORE = 0
|
|
def SetDungeonQIndex(self,id):
|
|
constInfo.dungeon_qf_index = int(id)
|
|
def GetDungeonIndex(self):
|
|
net.SendQuestInputStringPacket(constInfo.DungeonWarp)
|
|
constInfo.DungeonWarp = ""
|
|
def DungeonDataClear(self):
|
|
constInfo.py_Flag.clear()
|
|
def DungeonBackData(self, data):
|
|
if len(data) > 0:
|
|
first_list = data[:len(data)-1].split("#")
|
|
for j in xrange(len(first_list)):
|
|
second_list = first_list[j].split("|")
|
|
if len(second_list) == 2:
|
|
constInfo.SetFlag("%d_back"%int(second_list[0]),int(second_list[1])+app.GetGlobalTimeStamp())
|
|
def DungeonInfoData(self, data):
|
|
if len(data) > 0:
|
|
first_list = data[:len(data)-1].split("#")
|
|
for j in xrange(len(first_list)):
|
|
second_list = first_list[j].split("|")
|
|
if len(second_list) == 2:
|
|
constInfo.SetFlag("%d_cooldown"%int(second_list[0]),int(second_list[1])+app.GetGlobalTimeStamp())
|
|
|
|
if app.ENABLE_DROP_ITEM_WORLDARD:
|
|
def BINARY_DROP_ITEM_OPEN(self):
|
|
if self.interface:
|
|
self.interface.BINARY_DROP_ITEM_OPEN()
|
|
|
|
if app.ENABLE_AUTOMATIC_PICK_UP_SYSTEM:
|
|
def __PickUPMode(self, mode, modeX):
|
|
constInfo.PICKUPMODE = int(mode)
|
|
constInfo.RARITYMODE = int(modeX)
|
|
self.interface.OnChangePickUPMode()
|
|
|
|
if app.ENABLE_DUNGEON_INFO:
|
|
|
|
def OpenTableDungeonInfo(self):
|
|
if self.interface:
|
|
self.interface.DUNGEON_INFO_CHECK_SHOW()
|
|
|
|
|
|
def BINARY_TABLE_DUNGEON_INFO_OPEN(self):
|
|
if self.interface:
|
|
self.interface.BINARY_TABLE_DUNGEON_INFO_OPEN()
|
|
|
|
def BINARY_TABLE_DUNGEON_RANKING_LOAD(self):
|
|
if self.interface:
|
|
self.interface.BINARY_TABLE_DUNGEON_RANKING_LOAD()
|
|
def BINARY_TABLE_DUNGEON_MISION_LOAD(self):
|
|
if self.interface:
|
|
self.interface.BINARY_TABLE_DUNGEON_MISION_LOAD()
|
|
|
|
if app.ENABLE_CUBE_RENEWAL_WORLDARD:
|
|
def BINARY_CUBE_RENEWAL_OPEN(self):
|
|
if self.interface:
|
|
self.interface.BINARY_CUBE_RENEWAL_OPEN()
|
|
|
|
if app.ELEMENT_SPELL_WORLDARD:
|
|
def BINARY_ELEMENTS_SPELL_OPEN(self, itemPos , func, cost, grade_add):
|
|
self.interface.ElementsSpellOpen(itemPos, func, cost, grade_add)
|
|
|
|
def BINARY_ELEMENTS_SPELL_OPEN_CHANGE(self, itemPos, cost):
|
|
self.interface.ElementsSpellChangeOpen(itemPos, cost)
|
|
|
|
def ElementsSpellSuceededMessage(self):
|
|
self.PopupMessage(localeInfo.REFINE_ELEMENT_UPGRADE_SUCCESS_TEXT)
|
|
|
|
def ElementsSpellFailedMessage(self):
|
|
self.PopupMessage(localeInfo.REFINE_ELEMENT_UPGRADE_FAIL_TEXT)
|
|
|
|
def ElementsSpellDownGradeSuceededMessage(self):
|
|
self.PopupMessage(localeInfo.REFINE_ELEMENT_DOWNGRADE_TEXT)
|
|
|
|
def ElementsSpellChangeSuceeded(self,vnum,element_type):
|
|
import uiScriptLocale
|
|
|
|
item.SelectItem(int(vnum))
|
|
|
|
ELEMENT_NAME = {
|
|
item.APPLY_ATTBONUS_ELEC : uiScriptLocale.REFINE_ELEMENT_CHANGE_ELECT,
|
|
item.APPLY_ATTBONUS_FIRE : uiScriptLocale.REFINE_ELEMENT_CHANGE_FIRE,
|
|
item.APPLY_ATTBONUS_ICE : uiScriptLocale.REFINE_ELEMENT_CHANGE_ICE,
|
|
item.APPLY_ATTBONUS_WIND : uiScriptLocale.REFINE_ELEMENT_CHANGE_WIND,
|
|
item.APPLY_ATTBONUS_EARTH : uiScriptLocale.REFINE_ELEMENT_CHANGE_EARTH,
|
|
item.APPLY_ATTBONUS_DARK : uiScriptLocale.REFINE_ELEMENT_CHANGE_DARK,
|
|
}
|
|
|
|
self.PopupMessage(localeInfo.REFINE_ELEMENT_CHANGE_TEXT %(item.GetItemName(),ELEMENT_NAME[int(element_type)]))
|
|
|
|
|
|
def BINARY_BATTLEPASS_OPEN(self):
|
|
if self.interface:
|
|
self.interface.BINARY_BATTLEPASS_OPEN()
|
|
|
|
def BINARY_BATTLEPASS_MP(self):
|
|
if self.interface:
|
|
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, "BattlePass" ,"Enhorabuena! has terminado una mision del pase de batalla.")
|
|
self.interface.RecvWhisper("BattlePass")
|
|
|
|
def BINARY_ServerCommand_Run(self, line):
|
|
#dbg.TraceError(line)
|
|
try:
|
|
#print " BINARY_ServerCommand_Run", line
|
|
return self.serverCommander.Run(line)
|
|
except RuntimeError, msg:
|
|
dbg.TraceError(msg)
|
|
return 0
|
|
|
|
def __ProcessPreservedServerCommand(self):
|
|
try:
|
|
command = net.GetPreservedServerCommand()
|
|
while command:
|
|
print " __ProcessPreservedServerCommand", command
|
|
self.serverCommander.Run(command)
|
|
command = net.GetPreservedServerCommand()
|
|
except RuntimeError, msg:
|
|
dbg.TraceError(msg)
|
|
return 0
|
|
|
|
def PartyHealReady(self):
|
|
self.interface.PartyHealReady()
|
|
|
|
|
|
def AskSafeboxPassword(self):
|
|
self.interface.AskSafeboxPassword()
|
|
|
|
# ITEM_MALL
|
|
def AskMallPassword(self):
|
|
self.interface.AskMallPassword()
|
|
|
|
def __ItemMall_Open(self):
|
|
self.interface.OpenItemMall();
|
|
|
|
def CommandCloseMall(self):
|
|
self.interface.CommandCloseMall()
|
|
# END_OF_ITEM_MALL
|
|
|
|
def RefineSuceededMessage(self):
|
|
snd.PlaySound("sound/ui/make_soket.wav")
|
|
if app.ENABLE_REFINE_RENEWAL:
|
|
self.interface.CheckRefineDialog(False)
|
|
if constInfo.IS_AUTO_REFINE:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_SUCCESS)
|
|
else:
|
|
self.PopupMessage(localeInfo.REFINE_SUCCESS)
|
|
else:
|
|
self.PopupMessage(localeInfo.REFINE_SUCCESS)
|
|
|
|
def RefineFailedMessage(self):
|
|
snd.PlaySound("sound/ui/jaeryun_fail.wav")
|
|
if app.ENABLE_REFINE_RENEWAL:
|
|
self.interface.CheckRefineDialog(True)
|
|
if constInfo.IS_AUTO_REFINE:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE)
|
|
else:
|
|
self.PopupMessage(localeInfo.REFINE_FAILURE)
|
|
else:
|
|
self.PopupMessage(localeInfo.REFINE_FAILURE)
|
|
|
|
def CommandCloseSafebox(self):
|
|
self.interface.CommandCloseSafebox()
|
|
|
|
if app.NEW_PET_SYSTEM:
|
|
def SetPetEvolution(self, evo):
|
|
petname = ["Cucciolo", "Selvaggio", "Coraggioso", "Eroico"]
|
|
self.petmain.SetEvolveName(petname[int(evo)])
|
|
constInfo.PETMINIEVO = int(evo)
|
|
|
|
def SetPetName(self, name):
|
|
if len(name) > 1 and name != "":
|
|
self.petmini.Show()
|
|
self.petmain.SetName(name)
|
|
|
|
def SetPetLevel(self, level):
|
|
self.petmain.SetLevel(level)
|
|
constInfo.PETMINILEVEL = int(level)
|
|
|
|
def SetPetDuration(self, dur, durt):
|
|
if int(durt) > 0:
|
|
self.petmini.SetDuration(dur, durt)
|
|
self.petmain.SetDuration(dur, durt)
|
|
|
|
def SetPetBonus(self, hp, dif, sp):
|
|
self.petmain.SetHp(hp)
|
|
self.petmain.SetDef(dif)
|
|
self.petmain.SetSp(sp)
|
|
|
|
def SetPetskill(self, slot, idx, lv):
|
|
self.petmini.SetSkill(slot, idx, lv)
|
|
self.petmain.SetSkill(slot, idx, lv)
|
|
self.affectShower.BINARY_NEW_AddAffect(5400+int(idx),int(constInfo.LASTAFFECT_POINT)+1,int(constInfo.LASTAFFECT_VALUE)+1, 0)
|
|
if int(slot)==0:
|
|
constInfo.SKILL_PET1=5400+int(idx)
|
|
if int(slot)==1:
|
|
constInfo.SKILL_PET2=5400+int(idx)
|
|
if int(slot)==2:
|
|
constInfo.SKILL_PET3=5400+int(idx)
|
|
|
|
def SetPetIcon(self, vnum):
|
|
if int(vnum) > 0:
|
|
self.petmini.SetImageSlot(vnum)
|
|
self.petmain.SetImageSlot(vnum)
|
|
|
|
def SetPetExp(self, exp, expi, exptot):
|
|
if int(exptot) > 0:
|
|
self.petmini.SetExperience(exp, expi, exptot)
|
|
self.petmain.SetExperience(exp, expi, exptot)
|
|
|
|
def PetUnsummon(self):
|
|
self.petmini.SetDefaultInfo()
|
|
self.petmini.Close()
|
|
self.petmain.SetDefaultInfo()
|
|
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET1),0)
|
|
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET2),0)
|
|
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET3),0)
|
|
constInfo.SKILL_PET1 = 0
|
|
constInfo.SKILL_PET2 = 0
|
|
constInfo.SKILL_PET3 = 0
|
|
|
|
def OpenPetMainGui(self):
|
|
if constInfo.PETGUI == 0:
|
|
self.petmain.Show()
|
|
self.petmain.SetTop()
|
|
constInfo.PETGUI = 1
|
|
else:
|
|
self.petmain.Close()
|
|
constInfo.PETGUI = 0
|
|
|
|
def OpenPetIncubator(self, pet_new = 0):
|
|
import uipetincubatrice
|
|
self.petinc = uipetincubatrice.PetSystemIncubator(pet_new)
|
|
self.petinc.Show()
|
|
self.petinc.SetTop()
|
|
|
|
def OpenPetMini(self):
|
|
self.petmini.Show()
|
|
self.petmini.SetTop()
|
|
|
|
def OpenPetFeed(self):
|
|
self.feedwind = uipetfeed.PetFeedWindow()
|
|
self.feedwind.Show()
|
|
self.feedwind.SetTop()
|
|
|
|
def __Horse_HideState(self):
|
|
self.affectShower.SetHorseState(0, 0, 0)
|
|
|
|
def __Horse_UpdateState(self, level, health, battery):
|
|
self.affectShower.SetHorseState(int(level), int(health), int(battery))
|
|
|
|
def __IsXMasMap(self):
|
|
mapDict = ( "metin2_map_n_flame_01",
|
|
"metin2_map_n_desert_01",
|
|
"metin2_map_spiderdungeon",
|
|
"metin2_map_deviltower1", )
|
|
|
|
if background.GetCurrentMapName() in mapDict:
|
|
return False
|
|
|
|
return True
|
|
|
|
def __XMasSnow_Enable(self, mode):
|
|
|
|
self.__XMasSong_Enable(mode)
|
|
|
|
if "1"==mode:
|
|
|
|
if not self.__IsXMasMap():
|
|
return
|
|
|
|
print "XMAS_SNOW ON"
|
|
background.EnableSnow(1)
|
|
|
|
else:
|
|
print "XMAS_SNOW OFF"
|
|
background.EnableSnow(0)
|
|
|
|
def __XMasBoom_Enable(self, mode):
|
|
if "1"==mode:
|
|
|
|
if not self.__IsXMasMap():
|
|
return
|
|
|
|
print "XMAS_BOOM ON"
|
|
self.__DayMode_Update("dark")
|
|
self.enableXMasBoom = True
|
|
self.startTimeXMasBoom = app.GetTime()
|
|
else:
|
|
print "XMAS_BOOM OFF"
|
|
self.__DayMode_Update("light")
|
|
self.enableXMasBoom = False
|
|
|
|
def __XMasTree_Enable(self, grade):
|
|
|
|
print "XMAS_TREE ", grade
|
|
background.SetXMasTree(int(grade))
|
|
|
|
def __XMasSong_Enable(self, mode):
|
|
if "1"==mode:
|
|
print "XMAS_SONG ON"
|
|
|
|
XMAS_BGM = "xmas.mp3"
|
|
|
|
if app.IsExistFile("BGM/" + XMAS_BGM)==1:
|
|
if musicInfo.fieldMusic != "":
|
|
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)
|
|
|
|
musicInfo.fieldMusic=XMAS_BGM
|
|
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
|
|
|
|
else:
|
|
print "XMAS_SONG OFF"
|
|
|
|
if musicInfo.fieldMusic != "":
|
|
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)
|
|
|
|
musicInfo.fieldMusic=musicInfo.METIN2THEMA
|
|
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
|
|
|
|
def __RestartDialog_Close(self):
|
|
self.interface.CloseRestartDialog()
|
|
|
|
def __Console_Enable(self):
|
|
constInfo.CONSOLE_ENABLE = True
|
|
self.consoleEnable = True
|
|
app.EnableSpecialCameraMode()
|
|
ui.EnablePaste(True)
|
|
|
|
## DayMode
|
|
def __PRESERVE_DayMode_Update(self, mode):
|
|
if "light"==mode:
|
|
background.SetEnvironmentData(0)
|
|
elif "dark"==mode:
|
|
|
|
if not self.__IsXMasMap():
|
|
return
|
|
|
|
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
|
|
background.SetEnvironmentData(1)
|
|
|
|
def DayMode_Update(self, mode):
|
|
self.__DayMode_Update(mode)
|
|
|
|
def __DayMode_Update(self, mode):
|
|
if "light"==mode:
|
|
self.__DayMode_OnCompleteChangeToLight()
|
|
elif "dark"==mode:
|
|
|
|
if not self.__IsXMasMap():
|
|
return
|
|
|
|
self.__DayMode_OnCompleteChangeToDark()
|
|
|
|
def __DayMode_OnCompleteChangeToLight(self):
|
|
background.SetEnvironmentData(0)
|
|
|
|
def __DayMode_OnCompleteChangeToDark(self):
|
|
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
|
|
background.SetEnvironmentData(1)
|
|
|
|
## XMasBoom
|
|
def __XMasBoom_Update(self):
|
|
|
|
self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )
|
|
if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):
|
|
return
|
|
|
|
boomTime = self.BOOM_DATA_LIST[self.indexXMasBoom][0]
|
|
boomCount = self.BOOM_DATA_LIST[self.indexXMasBoom][1]
|
|
|
|
if app.GetTime() - self.startTimeXMasBoom > boomTime:
|
|
|
|
self.indexXMasBoom += 1
|
|
|
|
for i in xrange(boomCount):
|
|
self.__XMasBoom_Boom()
|
|
|
|
def __XMasBoom_Boom(self):
|
|
x, y, z = player.GetMainCharacterPosition()
|
|
randX = app.GetRandom(-150, 150)
|
|
randY = app.GetRandom(-150, 150)
|
|
|
|
snd.PlaySound3D(x+randX, -y+randY, z, "sound/common/etc/salute.mp3")
|
|
|
|
def __PartyRequestQuestion(self, vid):
|
|
vid = int(vid)
|
|
partyRequestQuestionDialog = uiCommon.QuestionDialog()
|
|
partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + localeInfo.PARTY_DO_YOU_ACCEPT)
|
|
partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
|
|
partyRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)
|
|
partyRequestQuestionDialog.SetAcceptEvent(lambda arg=True: self.__AnswerPartyRequest(arg))
|
|
partyRequestQuestionDialog.SetCancelEvent(lambda arg=False: self.__AnswerPartyRequest(arg))
|
|
partyRequestQuestionDialog.Open()
|
|
partyRequestQuestionDialog.vid = vid
|
|
self.partyRequestQuestionDialog = partyRequestQuestionDialog
|
|
|
|
def __AnswerPartyRequest(self, answer):
|
|
if not self.partyRequestQuestionDialog:
|
|
return
|
|
|
|
vid = self.partyRequestQuestionDialog.vid
|
|
|
|
if answer:
|
|
net.SendChatPacket("/party_request_accept " + str(vid))
|
|
else:
|
|
net.SendChatPacket("/party_request_deny " + str(vid))
|
|
|
|
self.partyRequestQuestionDialog.Close()
|
|
self.partyRequestQuestionDialog = None
|
|
|
|
def __PartyRequestDenied(self):
|
|
self.PopupMessage(localeInfo.PARTY_REQUEST_DENIED)
|
|
|
|
if app.TOURNAMENT_PVP_SYSTEM:
|
|
def BINARY_Tournament_OnRecvData(self, leftTime, membersOnline_A, membersOnline_B, membersDead_A, membersDead_B, memberLives):
|
|
self.wndTournament.Append([int(leftTime), str(membersOnline_A), str(membersOnline_B), str(membersDead_A), str(membersDead_B), str(memberLives)])
|
|
|
|
|
|
if (app.WJ_COMBAT_ZONE):
|
|
def BINARY_CombatZone_Manager(self, tokens, arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0):
|
|
if tokens == "OpenWindow":
|
|
self.wndCombatZone.Open(arg1, arg2, arg3, arg4)
|
|
|
|
|
|
elif tokens == "RegisterRank":
|
|
self.wndCombatZone.RegisterRanking()
|
|
|
|
elif tokens == "StartFlashing":
|
|
if self.interface:
|
|
self.interface.wndMiniMap.btnCombatZone.FlashEx()
|
|
|
|
elif tokens == "StartMp":
|
|
if self.interface:
|
|
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, "Evento", "Se ha activado el EVENTO TOTAL WAR durante 1h. Para poder participar en el evento pulsa el boton B del minimapa")
|
|
self.interface.RecvWhisper("Evento")
|
|
|
|
elif tokens == "Time":
|
|
if self.interface:
|
|
self.interface.SetTimeCombatZone(arg1)
|
|
|
|
elif tokens == "BonusClear":
|
|
if self.interface:
|
|
self.interface.SetBonusCombatZone("CLEAR")
|
|
|
|
elif tokens == "Bonus":
|
|
if self.interface:
|
|
self.interface.SetBonusCombatZone("ADD",arg1,arg2)
|
|
|
|
elif tokens == "RefreshShop":
|
|
if self.interface:
|
|
|
|
self.interface.dlgShop.SetCombatZonePoints(arg1)
|
|
self.interface.dlgShop.SetLimitCombatZonePoints(arg2, arg3)
|
|
|
|
def COMBAT_ZONE_ESTADISTICAS(self, tokens):
|
|
if tokens == "OPEN":
|
|
if self.interface:
|
|
self.interface.OpenCZEstadisticas()
|
|
elif tokens == "CLOSE":
|
|
if self.interface:
|
|
self.interface.CloseCZEstadisticas()
|
|
|
|
def __EnableTestServerFlag(self):
|
|
app.EnableTestServerFlag()
|
|
|
|
def __InGameShop_Show(self, url):
|
|
if constInfo.IN_GAME_SHOP_ENABLE:
|
|
self.interface.OpenWebWindow(url)
|
|
|
|
# def ManagerItemshop(self, cmd):
|
|
# cmd = cmd.split('#')
|
|
# if cmd[0] == 'QID':
|
|
# constInfo.ItemShop['QID'] = int(cmd[1])
|
|
# elif cmd[0] == 'INPUT':
|
|
# constInfo.INPUT_IGNORE = int(cmd[1])
|
|
# elif cmd[0] == 'SEND':
|
|
# net.SendQuestInputStringPacket(str(constInfo.ItemShop['QCMD']))
|
|
# constInfo.ItemShop['QCMD'] = ''
|
|
# elif cmd[0] == 'CREATE_CATEGORY':
|
|
# constInfo.ItemShop['ITEMS'][cmd[1]][int(cmd[2])] = []
|
|
# elif cmd[0] == 'SET_ITEM':
|
|
# constInfo.ItemShop['ITEMS'][cmd[1]][int(cmd[2])].append([int(cmd[3]), int(cmd[4]), int(cmd[5]), [(int(cmd[6]), int(cmd[7])), (int(cmd[8]), int(cmd[9])), (int(cmd[10]), int(cmd[11])), (int(cmd[12]), int(cmd[13])), (int(cmd[14]), int(cmd[15])), (int(cmd[16]), int(cmd[17])), (int(cmd[18]), int(cmd[19]))], [int(cmd[20]), int(cmd[21]), int(cmd[22])], int(cmd[23]), int(cmd[24]), int(cmd[25])])
|
|
# elif cmd[0] == 'CLEAR_CONTENT':
|
|
# constInfo.ItemShop['ITEMS']['mostBought'] = []
|
|
# constInfo.ItemShop['ITEMS']['hotOffers'] = []
|
|
# elif cmd[0] == 'SET_ITEM_MOSTBOUGHT':
|
|
# constInfo.ItemShop['ITEMS']['mostBought'].append([int(cmd[1]), int(cmd[2]), int(cmd[3]), [(int(cmd[4]), int(cmd[5])), (int(cmd[6]), int(cmd[7])), (int(cmd[8]), int(cmd[9])), (int(cmd[10]), int(cmd[11])), (int(cmd[12]), int(cmd[13])), (int(cmd[14]), int(cmd[15])), (int(cmd[16]), int(cmd[17]))], [int(cmd[17]), int(cmd[19]), int(cmd[20])], int(cmd[21]), int(cmd[22]), int(cmd[23])])
|
|
# elif cmd[0] == 'SET_ITEM_HOTOFFERS':
|
|
# constInfo.ItemShop['ITEMS']['hotOffers'].append([int(cmd[1]), int(cmd[2]), int(cmd[3]), [(int(cmd[4]), int(cmd[5])), (int(cmd[6]), int(cmd[7])), (int(cmd[8]), int(cmd[9])), (int(cmd[10]), int(cmd[11])), (int(cmd[12]), int(cmd[13])), (int(cmd[14]), int(cmd[15])), (int(cmd[16]), int(cmd[17]))], [int(cmd[17]), int(cmd[19]), int(cmd[20])], int(cmd[21]), int(cmd[22]), int(cmd[23])])
|
|
# elif cmd[0] == 'SET_LOG':
|
|
# constInfo.ItemShop['LOGS'].append([int(cmd[1]), int(cmd[2]), int(cmd[3]), cmd[4], [(int(cmd[5]), int(cmd[6])), (int(cmd[7]), int(cmd[8])), (int(cmd[9]), int(cmd[10])), (int(cmd[11]), int(cmd[12])), (int(cmd[13]), int(cmd[14])), (int(cmd[15]), int(cmd[16])), (int(cmd[17]), int(cmd[18]))], [int(cmd[19]), int(cmd[20]), int(cmd[21])]])
|
|
# elif cmd[0] == 'SEND_COINS':
|
|
# constInfo.COINS_DRS = [int(cmd[1]), int(cmd[2])]
|
|
# elif cmd[0] == 'SEND_3RD_SHOP_COIN':
|
|
# self.interface.wndItemShop.Set3rdCoins(int(cmd[1]))
|
|
# elif cmd[0] == 'ALLOW_SPIN_WHEEL':
|
|
# self.interface.wndItemShop.SpinWheel()
|
|
# elif cmd[0] == 'CLEAR_WHEEL_CONTENT':
|
|
# constInfo.ItemShop['WOD'] = [[], []]
|
|
# elif cmd[0] == 'SET_WHEEL_PRIZE':
|
|
# prize = cmd[2].split(',')
|
|
# if cmd[1] == 'G':
|
|
# for i in xrange(len(prize)-1):
|
|
# constInfo.ItemShop['WOD'][1].append(int(prize[i]))
|
|
# elif cmd[1] == 'B':
|
|
# for i in xrange(len(prize)-1):
|
|
# constInfo.ItemShop['WOD'][0].append(int(prize[i]))
|
|
# elif cmd[0] == 'OPEN':
|
|
# self.interface.wndItemShop.Open(int(cmd[1]))
|
|
# elif cmd[0] == 'REFRESH_CONTENT':
|
|
# self.interface.wndItemShop.RefreshWindow()
|
|
|
|
# WEDDING
|
|
def __LoginLover(self):
|
|
if self.interface.wndMessenger:
|
|
self.interface.wndMessenger.OnLoginLover()
|
|
|
|
def __LogoutLover(self):
|
|
if self.interface.wndMessenger:
|
|
self.interface.wndMessenger.OnLogoutLover()
|
|
if self.affectShower:
|
|
self.affectShower.HideLoverState()
|
|
|
|
def __LoverNear(self):
|
|
if self.affectShower:
|
|
self.affectShower.ShowLoverState()
|
|
|
|
def __LoverFar(self):
|
|
if self.affectShower:
|
|
self.affectShower.HideLoverState()
|
|
|
|
if app.ENABLE_MANAGER_BANK_SYSTEM:
|
|
def BINARY_Account_Bank_Logs(self):
|
|
self.interface.managerAccountBank.BINARY_Account_Bank_Logs()
|
|
|
|
def __LoverDivorce(self):
|
|
if self.interface.wndMessenger:
|
|
self.interface.wndMessenger.ClearLoverInfo()
|
|
if self.affectShower:
|
|
self.affectShower.ClearLoverState()
|
|
|
|
if app.ENABLE_SEND_TARGET_INFO:
|
|
def BINARY_AddTargetMonsterDropInfo(self, raceNum, itemVnum, itemCount):
|
|
if not raceNum in constInfo.MONSTER_INFO_DATA:
|
|
constInfo.MONSTER_INFO_DATA.update({raceNum : {}})
|
|
constInfo.MONSTER_INFO_DATA[raceNum].update({"items" : []})
|
|
curList = constInfo.MONSTER_INFO_DATA[raceNum]["items"]
|
|
|
|
isUpgradeable = False
|
|
isMetin = False
|
|
item.SelectItem(itemVnum)
|
|
if item.GetItemType() == item.ITEM_TYPE_WEAPON or item.GetItemType() == item.ITEM_TYPE_ARMOR:
|
|
isUpgradeable = True
|
|
elif item.GetItemType() == item.ITEM_TYPE_METIN:
|
|
isMetin = True
|
|
|
|
for curItem in curList:
|
|
if isUpgradeable:
|
|
if curItem.has_key("vnum_list") and curItem["vnum_list"][0] / 10 * 10 == itemVnum / 10 * 10:
|
|
if not (itemVnum in curItem["vnum_list"]):
|
|
curItem["vnum_list"].append(itemVnum)
|
|
return
|
|
elif isMetin:
|
|
if curItem.has_key("vnum_list"):
|
|
baseVnum = curItem["vnum_list"][0]
|
|
if curItem.has_key("vnum_list") and (baseVnum - baseVnum%1000) == (itemVnum - itemVnum%1000):
|
|
if not (itemVnum in curItem["vnum_list"]):
|
|
curItem["vnum_list"].append(itemVnum)
|
|
return
|
|
else:
|
|
if curItem.has_key("vnum") and curItem["vnum"] == itemVnum and curItem["count"] == itemCount:
|
|
return
|
|
|
|
if isUpgradeable or isMetin:
|
|
curList.append({"vnum_list":[itemVnum], "count":itemCount})
|
|
else:
|
|
curList.append({"vnum":itemVnum, "count":itemCount})
|
|
|
|
def BINARY_RefreshTargetMonsterDropInfo(self, raceNum):
|
|
self.targetBoard.RefreshMonsterInfoBoard()
|
|
|
|
def __PlayMusic(self, flag, filename):
|
|
flag = int(flag)
|
|
if flag:
|
|
snd.FadeOutAllMusic()
|
|
musicInfo.SaveLastPlayFieldMusic()
|
|
snd.FadeInMusic("BGM/" + filename)
|
|
else:
|
|
snd.FadeOutAllMusic()
|
|
musicInfo.LoadLastPlayFieldMusic()
|
|
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
|
|
|
|
if app.ENABLE_KINGDOMS_WAR:
|
|
def ActKingdomsWar(self, act, score1, score2, score3, limitKills, deads, limiDeads, timeRemained):
|
|
if self.interface:
|
|
self.interface.ActKingdomsWar(act, score1, score2, score3, limitKills, deads, limiDeads, timeRemained)
|
|
|
|
if app.ENABLE_SASH_SYSTEM:
|
|
def ActSash(self, iAct, bWindow):
|
|
if self.interface:
|
|
self.interface.ActSash(iAct, bWindow)
|
|
|
|
def AlertSash(self, bWindow):
|
|
snd.PlaySound("sound/ui/make_soket.wav")
|
|
if bWindow:
|
|
self.PopupMessage(localeInfo.SASH_DEL_SERVEITEM)
|
|
else:
|
|
self.PopupMessage(localeInfo.SASH_DEL_ABSORDITEM)
|
|
|
|
def OpenIShopWindow(self):
|
|
import event
|
|
constInfo.ItemShop['QCMD'] = 'OPEN_SHOP#'
|
|
event.QuestButtonClick(constInfo.ItemShop['QID'])
|
|
# END_OF_WEDDING
|
|
|
|
|
|
##################################
|
|
### Inventory By SeMa Start
|
|
##################################
|
|
def ManagerInventoryUnlock(self, cmd):
|
|
cmd = cmd.split("|")
|
|
if cmd[0] == "Reload":
|
|
net.SendChatPacket("/reload_inventory")
|
|
elif cmd[0] == "Hide":
|
|
constInfo.Inventory_Locked["Keys_Can_Unlock_%d"%(int(cmd[2]))] = int(cmd[1])
|
|
elif cmd[0] == "Message":
|
|
dbg.LogBox("Necesitas "+str(cmd[1])+" items para desbloquearlo")
|
|
##################################
|
|
### Inventory By SeMa End
|
|
##################################
|
|
|
|
def ManagerTickets(self, cmd):
|
|
cmd = cmd.split('#')
|
|
if cmd[0] == 'QID':
|
|
constInfo.Tickets['QID'] = int(cmd[1])
|
|
elif cmd[0] == 'INPUT':
|
|
constInfo.INPUT_IGNORE = int(cmd[1])
|
|
elif cmd[0] == 'SEND':
|
|
net.SendQuestInputLongStringPacket(str(constInfo.Tickets['QCMD']))
|
|
constInfo.Tickets['QCMD'] = ''
|
|
elif cmd[0] == 'CLEAR_CONTENT':
|
|
constInfo.Tickets['MY_TICKETS'] = []
|
|
constInfo.Tickets['GLOBAL_TICKETS'] = []
|
|
elif cmd[0] == 'CLEAR_PERMISIONS':
|
|
constInfo.Tickets['PERMISIONS'] = []
|
|
elif cmd[0] == 'SET_TICKET':
|
|
date = cmd[4].split('[_]')
|
|
constInfo.Tickets['GLOBAL_TICKETS'].append([cmd[1], cmd[2].replace('[_]', ' '), int(cmd[3]), date[0], date[1], int(cmd[5]), cmd[6], cmd[7].replace('[_]', ' '), int(cmd[8])])
|
|
if cmd[6] == player.GetName():
|
|
constInfo.Tickets['MY_TICKETS'].append([cmd[1], cmd[2].replace('[_]', ' '), int(cmd[3]), date[0], date[1], int(cmd[5]), cmd[6], cmd[7].replace('[_]', ' '), int(cmd[8])])
|
|
elif cmd[0] == 'CREATE_ANSWER':
|
|
constInfo.Tickets['ANSWERS'][cmd[1]] = []
|
|
elif cmd[0] == 'SET_ANSWER':
|
|
date = cmd[3].split('[_]')
|
|
constInfo.Tickets['ANSWERS'][cmd[1]].append([cmd[2], date[0], date[1], cmd[4].replace('[_]', ' ')])
|
|
elif cmd[0] == 'SET_PERMISION':
|
|
constInfo.Tickets['PERMISIONS'].append([cmd[1], int(cmd[2]), int(cmd[3]), int(cmd[4])])
|
|
elif cmd[0] == 'OPEN':
|
|
self.interface.wndTicket.Open(int(cmd[1]))
|
|
elif cmd[0] == 'REFRESH_CONTENT':
|
|
self.interface.wndTicket.RefreshPage()
|
|
|
|
def ManagerMountSystem(self, status, vnum):
|
|
constInfo.Mount_Affect = {"status":int(status),"vnum":int(vnum)}
|
|
self.affectShower.SetMountActive()
|
|
|
|
def _ItemshopCMD(self, command):
|
|
cmd = command.split('/')
|
|
|
|
if cmd[0] == 'QID': ## 1 argument
|
|
constInfo.ITEMSHOP['qid'] = int(cmd[1])
|
|
elif cmd[0] == 'QUESTCMD':
|
|
net.SendQuestInputStringPacket(str(constInfo.ITEMSHOP['questCMD']))
|
|
constInfo.ITEMSHOP['questCMD'] = 'NULL#'
|
|
elif cmd[0] == 'UPDATETABLE_SET':
|
|
constInfo.ITEMSHOP['tableUpdate'] = cmd[1]
|
|
elif cmd[0] == 'CLEAR_ITEMS':
|
|
constInfo.ITEMSHOP['items']['itemshop'] = {}
|
|
constInfo.ITEMSHOP['items']['voteshop'] = {}
|
|
constInfo.ITEMSHOP['items']['achievementshop'] = {}
|
|
constInfo.ITEMSHOP['items']['startpage']['mostBought'] = []
|
|
constInfo.ITEMSHOP['items']['startpage']['hotOffers'] = []
|
|
## fill items
|
|
elif cmd[0] == 'CREATE_CATEGORY': ## 2 arguments, shop, categoryID
|
|
constInfo.ITEMSHOP['items'][cmd[1]][int(cmd[2])] = []
|
|
elif cmd[0] == 'ADD_ITEM_IS': ## category, type, id, vnum, [socket], [attr], price, percent, time, runOut
|
|
socket = cmd[5].split(",")
|
|
attr = cmd[6].split(",")
|
|
constInfo.ITEMSHOP['items']['itemshop'][int(cmd[1])].append([int(cmd[2]), int(cmd[3]), [int(cmd[4]),int(socket[0]),int(socket[1]),int(socket[2]), int(attr[0]),int(attr[1]),int(attr[2]),int(attr[3]),int(attr[4]),int(attr[5]),int(attr[6]),int(attr[7]),int(attr[8]),int(attr[9]),int(attr[10]),int(attr[11]),int(attr[12]),int(attr[13])], int(cmd[7]), int(cmd[8]), int(cmd[9]), int(cmd[10])])
|
|
elif cmd[0] == 'ADD_ITEM_VS': ## category, type, id, vnum, [socket], [attr], price, percent, time, runOut
|
|
socket = cmd[5].split(",")
|
|
attr = cmd[6].split(",")
|
|
constInfo.ITEMSHOP['items']['voteshop'][int(cmd[1])].append([int(cmd[2]), int(cmd[3]), [int(cmd[4]),int(socket[0]),int(socket[1]),int(socket[2]), int(attr[0]),int(attr[1]),int(attr[2]),int(attr[3]),int(attr[4]),int(attr[5]),int(attr[6]),int(attr[7]),int(attr[8]),int(attr[9]),int(attr[10]),int(attr[11]),int(attr[12]),int(attr[13])], int(cmd[7]), int(cmd[8]), int(cmd[9]), int(cmd[10])])
|
|
elif cmd[0] == 'ADD_ITEM_AS': ## category, type, id, vnum, [socket], [attr], price, percent, time, runOut
|
|
socket = cmd[5].split(",")
|
|
attr = cmd[6].split(",")
|
|
constInfo.ITEMSHOP['items']['achievementshop'][int(cmd[1])].append([int(cmd[2]), int(cmd[3]), [int(cmd[4]),int(socket[0]),int(socket[1]),int(socket[2]), int(attr[0]),int(attr[1]),int(attr[2]),int(attr[3]),int(attr[4]),int(attr[5]),int(attr[6]),int(attr[7]),int(attr[8]),int(attr[9]),int(attr[10]),int(attr[11]),int(attr[12]),int(attr[13])], int(cmd[7]), int(cmd[8]), int(cmd[9]), int(cmd[10])])
|
|
elif cmd[0] == 'ADD_ITEM_MOSTBOUGHT': ## type, id, vnum, [socket], [attr], price, percent, time, runOut
|
|
socket = cmd[4].split(",")
|
|
attr = cmd[5].split(",")
|
|
constInfo.ITEMSHOP['items']['startpage']['mostBought'].append([int(cmd[1]), int(cmd[2]), [int(cmd[3]),int(socket[0]),int(socket[1]),int(socket[2]), int(attr[0]),int(attr[1]),int(attr[2]),int(attr[3]),int(attr[4]),int(attr[5]),int(attr[6]),int(attr[7]),int(attr[8]),int(attr[9]),int(attr[10]),int(attr[11]),int(attr[12]),int(attr[13])], int(cmd[6]), int(cmd[7]), int(cmd[8]), int(cmd[9])])
|
|
elif cmd[0] == 'ADD_ITEM_HOTOFFERS': ## type, id, vnum, [socket], [attr], price, percent, time, runOut
|
|
socket = cmd[4].split(",")
|
|
attr = cmd[5].split(",")
|
|
constInfo.ITEMSHOP['items']['startpage']['hotOffers'].append([int(cmd[1]), int(cmd[2]), [int(cmd[3]),int(socket[0]),int(socket[1]),int(socket[2]), int(attr[0]),int(attr[1]),int(attr[2]),int(attr[3]),int(attr[4]),int(attr[5]),int(attr[6]),int(attr[7]),int(attr[8]),int(attr[9]),int(attr[10]),int(attr[11]),int(attr[12]),int(attr[13])], int(cmd[6]), int(cmd[7]), int(cmd[8]), int(cmd[9])])
|
|
elif cmd[0] == 'ADD_ITEM_CATEGORY':
|
|
## hola_mundo => hola mundo
|
|
constInfo.ITEMSHOP['category'].append([int(cmd[1]), cmd[2].replace("_", " "), cmd[3], cmd[4]])
|
|
elif cmd[0] == 'ADD_ITEM_SUBCATEGORY':
|
|
## hola_mundo => hola mundo
|
|
#constInfo.ITEMSHOP['category'].append([int(cmd[1]), cmd[2].replace("_", " "), cmd[3]])
|
|
#constInfo.ITEMSHOP['subCategories'].update({1: []})
|
|
if not int(cmd[3]) in constInfo.ITEMSHOP['subCategories']:
|
|
constInfo.ITEMSHOP['subCategories'].update({int(cmd[3]): []})
|
|
|
|
constInfo.ITEMSHOP['subCategories'][int(cmd[3])].append([int(cmd[1]), cmd[2].replace("_", " ")])
|
|
elif cmd[0] == 'SET_IS_COINS':
|
|
self.interface.Itemshop_v2.SetItemshopCoins(int(cmd[1]))
|
|
elif cmd[0] == 'SET_VS_COINS':
|
|
self.interface.Itemshop_v2.SetVoteshopCoins(int(cmd[1]))
|
|
elif cmd[0] == 'SET_AS_COINS':
|
|
self.interface.Itemshop_v2.SetAchievementshopCoins(int(cmd[1]))
|
|
elif cmd[0] == 'OPEN':
|
|
self.interface.Itemshop_v2.Open(int(cmd[1]), int(cmd[2]),int(cmd[3]), cmd[4], cmd[5])
|
|
elif cmd[0] == 'LOADING':
|
|
self.LoadingBar.SetPercent(int(cmd[1]))
|
|
elif cmd[0] == "COINS":
|
|
constInfo.COINS_DRS[0] = int(cmd[1])
|
|
constInfo.COINS_DRS[1] = int(cmd[2])
|
|
|
|
def __Input0(self):
|
|
constInfo.INPUT_IGNORE = 0
|
|
|
|
def __Input1(self):
|
|
constInfo.INPUT_IGNORE = 1
|
|
|
|
def __Team_On(self, name):
|
|
if self.interface.wndMessenger:
|
|
self.interface.wndMessenger.OnLogin(2, name)
|
|
|
|
def __Team_Off(self, name):
|
|
if self.interface.wndMessenger:
|
|
self.interface.wndMessenger.OnLogout(2, name)
|
|
|
|
def SHOP_IN_CLIENT(self, arg):
|
|
constInfo.SHOP_IN_CLIENT = int(arg)
|
|
|
|
|
|
def COMBAT_ZONE(self, arg):
|
|
constInfo.COMBAT_ZONE = int(arg)
|
|
|
|
def BOSS_EVENT(self, arg1, status):
|
|
constInfo.BOSS_EVENT = int(arg1)
|
|
constInfo.BOSS_EVENT_STATUS = int(status)
|
|
|
|
def METIN_EVENT(self, arg1, status):
|
|
constInfo.METIN_EVENT = int(arg1)
|
|
constInfo.METIN_EVENT_STATUS = int(status)
|
|
|
|
def SetSupportArmor(self, armor, time, permanente):
|
|
self.supportpg.SetArmor(armor, time, permanente)
|
|
|
|
#def SupportArmorClear(self):
|
|
#self.supportpg.SetArmorClear()
|
|
|
|
#def SupportHairClear(self):
|
|
#self.supportpg.SupportHairClear()
|
|
|
|
|
|
def SetSupportWeapon(self, weapon, time, permanente):
|
|
self.supportpg.SetWeapon(weapon, time, permanente)
|
|
|
|
def SetSupportHair(self, hair, time, permanente):
|
|
self.supportpg.SetHair(hair, time, permanente)
|
|
|
|
def SetSupportSkill(self, slot, vnum, time):
|
|
self.supportpg.SetSkill(slot, vnum, time)
|
|
|
|
def SupportClear(self,index):
|
|
self.supportpg.SupportClear(int(index))
|
|
|
|
def OpenSupportGui(self):
|
|
if constInfo.SUPPORTGUI == 0:
|
|
self.supportpg.Show()
|
|
self.supportpg.SetTop()
|
|
constInfo.SUPPORTGUI = 1
|
|
else:
|
|
self.supportpg.Close()
|
|
constInfo.SUPPORTGUI = 0
|
|
|
|
def SetSupportLevel(self, level):
|
|
constInfo.SUPPORT_SHOW = 1
|
|
|
|
def SetSupportName(self, name, name2):
|
|
pass
|
|
|
|
def SupportLeave(self):
|
|
self.supportpg.SetDefaultInfo()
|
|
self.supportpg.Close()
|
|
constInfo.SUPPORT_SHOW = 0
|
|
|
|
def SupportInt(self , ints):
|
|
pass
|
|
|
|
def SetSupportExp(self, exp, exptot):
|
|
pass
|
|
|
|
def SetSupportIcon(self, vnum):
|
|
pass
|
|
|
|
def SetSupportSpeciality(self,speciality):
|
|
pass
|
|
|
|
def BINARY_CALENDAR_OPEN_ADM(self):
|
|
self.interface.BINARY_CALENDAR_OPEN_ADM()
|
|
|
|
def BINARY_CALENDAR_LOAD_EVENTS_ADM(self,index_event,name_event,descrip_event):
|
|
self.interface.BINARY_CALENDAR_LOAD_EVENTS_ADM(index_event,name_event,descrip_event)
|
|
|
|
def BINARY_CALENDAR_CLEAR_EVENTS_ADM(self):
|
|
self.interface.BINARY_CALENDAR_CLEAR_EVENTS_ADM()
|
|
|
|
def BINARY_CALENDAR_LOADING_EVENTS_ADM(self):
|
|
self.interface.BINARY_CALENDAR_LOADING_EVENTS_ADM()
|
|
|
|
|
|
def BINARY_CALENDAR_OPEN(self, currentTimeStamp):
|
|
self.interface.BINARY_CALENDAR_OPEN(app.GetGlobalTimeStamp())
|
|
|
|
def BINARY_CALENDAR_LOAD_EVENTS(self,day,name,image,startAt, endAt,duration):
|
|
self.interface.BINARY_CALENDAR_LOAD_EVENTS(day,name,image,startAt, endAt,duration)
|
|
|
|
def BINARY_CALENDAR_CLEAR_EVENTS(self):
|
|
#pass
|
|
self.interface.BINARY_CALENDAR_CLEAR_EVENTS()
|
|
|
|
def BINARY_CALENDAR_LOADING_EVENTS(self):
|
|
self.interface.BINARY_CALENDAR_LOADING_EVENTS()
|
|
|
|
if app.ENABLE_HIDE_COSTUME_SYSTEM:
|
|
def COSTUME_HIDE_CLEAR(self):
|
|
self.interface.costume_hide_clear()
|
|
def COSTUME_HIDE_LIST(self,slot,index):
|
|
self.interface.costume_hide_list(slot,index)
|
|
def COSTUME_HIDE_LOAD(self):
|
|
self.interface.costume_hide_load()
|
|
|
|
if app.ENABLE_SWITCHBOT:
|
|
def RefreshSwitchbotWindow(self):
|
|
self.interface.RefreshSwitchbotWindow()
|
|
|
|
def RefreshSwitchbotItem(self, slot):
|
|
self.interface.RefreshSwitchbotItem(slot)
|
|
|
|
def AppendEvent(self, image, timeStamp, duration):
|
|
self.eventList.append([image, int(timeStamp), int(duration)])
|
|
|
|
if app.ENABLE_OFFLINESHOP_SYSTEM:
|
|
def StartOfflineShop(self, vid, isOwner):
|
|
if self.interface:
|
|
self.interface.OpenOfflineShopDialog(vid, isOwner)
|
|
def StartOfflineShopPanel(self):
|
|
if self.interface:
|
|
self.interface.OpenOfflineShopPanel()
|
|
|
|
def ClearOfflineShopLog(self):
|
|
if self.interface:
|
|
if self.interface.dlgOfflineShopPanel:
|
|
if self.interface.dlgOfflineShopPanel.GetChild("ListBox"):
|
|
self.interface.dlgOfflineShopPanel.GetChild("ListBox").RemoveAllItems()
|
|
|
|
def AppendShopLog(self, name, date, itemvnum, itemcount, price):
|
|
self.interface.AppendLogOfflineShopPanel(name, date, itemvnum, itemcount, price)
|
|
|
|
def AppendShopLogFirst(self, name, date, itemvnum, itemcount, price):
|
|
self.interface.AppendLogOfflineShopPanelFirst(str(name), str(date), int(itemvnum), int(itemcount), int(price))
|
|
|
|
def EndOfflineShop(self):
|
|
if self.interface:
|
|
if self.interface.dlgOfflineShop:
|
|
if self.interface.dlgOfflineShop.IsShow():
|
|
self.interface.dlgOfflineShop.Close()
|
|
if self.interface.dlgOfflineShopPanel:
|
|
if self.interface.dlgOfflineShopPanel.IsShow():
|
|
self.interface.dlgOfflineShopPanel.Close()
|
|
if self.interface.offlineShopBuilder:
|
|
if self.interface.offlineShopBuilder.IsShow():
|
|
self.interface.offlineShopBuilder.Close()
|
|
def RefreshOfflineShop(self):
|
|
if self.interface:
|
|
if self.interface.dlgOfflineShop:
|
|
self.interface.dlgOfflineShop.Refresh()
|
|
if self.interface.dlgOfflineShopPanel:
|
|
if self.interface.dlgOfflineShopPanel.IsShow():
|
|
self.interface.dlgOfflineShopPanel.Refresh()
|
|
if self.interface.offlineShopBuilder:
|
|
if self.interface.offlineShopBuilder.IsShow():
|
|
self.interface.offlineShopBuilder.Refresh()
|
|
def OpenOfflineShop(self):
|
|
if self.interface:
|
|
self.interface.OpenOfflineShopBuilder()
|
|
def OpenBackAllItem(self):
|
|
backItem = uiCommon.QuestionDialog()
|
|
backItem.SetText(localeInfo.OFFLINESHOP_GET_BACK_ITEMS) # HELLO WORLD
|
|
backItem.SetAcceptText(localeInfo.UI_ACCEPT)
|
|
backItem.SetCancelText(localeInfo.UI_DENY)
|
|
backItem.SetAcceptEvent(lambda arg=TRUE: self.__AnswerGetBackItems(arg))
|
|
backItem.SetCancelEvent(lambda arg=FALSE: self.__AnswerGetBackItems(arg))
|
|
backItem.Open()
|
|
self.partyRequestQuestionDialog=backItem
|
|
|
|
def __AnswerGetBackItems(self, answer):
|
|
if not self.partyRequestQuestionDialog:
|
|
return
|
|
if answer:
|
|
net.SendGetBackItems()
|
|
self.partyRequestQuestionDialog.Close()
|
|
self.partyRequestQuestionDialog = None
|
|
|
|
def OpenOfflineShopPanel(self):
|
|
if self.interface:
|
|
self.interface.OpenOfflineShopPanel()
|
|
def BINARY_OfflineShop_Appear(self, vid, text):
|
|
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
|
|
if self.interface:
|
|
self.interface.AppearOfflineShop(vid, text)
|
|
|
|
def BINARY_OfflineShop_Disappear(self, vid):
|
|
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
|
|
if self.interface:
|
|
self.interface.DisappearOfflineShop(vid)
|
|
|
|
if app.BL_67_ATTR:
|
|
def OpenAttr67AddDlg(self):
|
|
if self.interface:
|
|
self.interface.OpenAttr67AddDlg()
|
|
|
|
def sCantDestroyItemDialog(self):
|
|
if self.cantDestroyItemDialog:
|
|
self.cantDestroyItemDialog.Open()
|
|
|
|
|
|
if app.ENABLE_SHOP_SEARCH_SYSTEM:
|
|
def OpenPrivateShopSearch(self, type):
|
|
if self.interface:
|
|
self.interface.OpenPrivateShopSearch(type)
|
|
|
|
def RefreshShopSearch(self):
|
|
if self.interface:
|
|
self.interface.RefreshShopSearch()
|
|
|
|
def BuyShopSearch(self):
|
|
self.interface.RefreshShopSearch()
|
|
|
|
def BuyShopSearch2(self):
|
|
if self.interface:
|
|
if self.interface.wndPrivateShopSearch.IsShow():
|
|
self.interface.wndPrivateShopSearch.StartSearch()
|
|
|
|
if app.ENABLE_NEW_PET_SYSTEM:
|
|
def PetSetSlotIndex(self, index):
|
|
self.interface.SetPetSlotIndex(index)
|
|
def PetClearData(self):
|
|
self.interface.ClearPetData()
|
|
def PetOpenWindow(self):
|
|
self.interface.OpenPetWindow()
|
|
def PetUpdate(self, index):
|
|
self.interface.PetUpdate(int(index))
|
|
|
|
def AddLoopEvent(self, name, event):
|
|
for i in self.loopList:
|
|
if i[0] == name:
|
|
i[1] = event
|
|
return # already have.
|
|
list = [name,event]
|
|
self.loopList.append(list)
|
|
def RemoveLoopEvent(self, name):
|
|
for i in xrange(len(self.loopList)):
|
|
if self.loopList[i][0] == name:
|
|
del self.loopList[i]
|
|
return
|
|
def loopListEvent(self):
|
|
for i in xrange(len(self.loopList)):
|
|
returnValue = self.loopList[i][1]()
|
|
if returnValue == True:
|
|
del self.loopList[i]
|
|
|
|
def BINARY_OnRecvBulkWhisper(self, content):
|
|
content = content.replace("$", " ")
|
|
self.interface.RegisterGameMasterName(localeInfo.SYSTEM_WHISPER)
|
|
chat.AppendWhisper(chat.WHISPER_TYPE_CHAT, localeInfo.SYSTEM_WHISPER, content)
|
|
self.interface.RecvWhisper(localeInfo.SYSTEM_WHISPER)
|
|
|
|
if app.ENABLE_MULTILANGUAGE_SYSTEM:
|
|
def AutoTranslateText(self, line, localeText = False, isQuestText = False):
|
|
new_buf = line
|
|
if localeText:
|
|
new_buf = self.GetLCText(line)
|
|
if isQuestText:
|
|
for j in xrange(new_buf.count("*^")):
|
|
new_buf=self.GetQuestText(new_buf)
|
|
return new_buf
|
|
def IsFloat(self, string):
|
|
try:
|
|
number = float(string)
|
|
return True
|
|
except:
|
|
return False
|
|
return False
|
|
def MakeStringToList(self, args):
|
|
new_list=[]
|
|
arg_list = args.split("&")
|
|
for j in xrange(len(arg_list)):
|
|
argText = arg_list[j]
|
|
|
|
if not argText or argText == "" or argText == " ":
|
|
continue
|
|
elif argText.isdigit():
|
|
new_list.append(int(argText))
|
|
elif self.IsFloat(argText):
|
|
new_list.append(float(argText))
|
|
else:
|
|
itemLink = argText.find("I")
|
|
if itemLink>=0 and len(argText) > itemLink+1:
|
|
itemVnum = argText[itemLink+1:]
|
|
if itemVnum.isdigit() == True:
|
|
itemVnum = int(itemVnum)
|
|
item.SelectItem(itemVnum)
|
|
new_list.append(item.GetItemName())
|
|
continue
|
|
|
|
mobLink = argText.find("M")
|
|
if mobLink>=0 and len(argText) > mobLink+1:
|
|
mobVnum = argText[mobLink+1:]
|
|
if mobVnum.isdigit() == True:
|
|
mobVnum = int(mobVnum)
|
|
mobName = nonplayer.GetMonsterName(mobVnum)
|
|
if not mobName or mobName == "":
|
|
mobName = "None"
|
|
new_list.append(mobName)
|
|
continue
|
|
|
|
if app.ENABLE_NEW_PET_SYSTEM:
|
|
petLink = argText.find("P")
|
|
if petLink>=0 and len(argText) > petLink+1:
|
|
petSkill = argText[petLink+1:]
|
|
if petSkill.isdigit() == True:
|
|
petSkill = int(petSkill)
|
|
new_list.append(str(constInfo.pet_skill_data[petSkill][0]))
|
|
continue
|
|
|
|
skillLink = argText.find("S")
|
|
if skillLink>=0 and len(argText) > skillLink+1:
|
|
skillIndex = argText[skillLink+1:]
|
|
if skillIndex.isdigit() == True:
|
|
skillIndex = int(skillIndex)
|
|
skillName = skill.GetSkillName(skillIndex)
|
|
if not skillName or skillName == "":
|
|
skillName = "None"
|
|
new_list.append(skillName)
|
|
continue
|
|
|
|
hyperLink = argText.find("H")
|
|
if hyperLink>=0 and len(argText) > hyperLink+1:
|
|
hyperlinkText = argText[hyperLink+1:]
|
|
if hyperlinkText.find("item:") != -1:
|
|
itemVnum = int(hyperlinkText.split(":")[1], 16)
|
|
item.SelectItem(itemVnum)
|
|
hyperText = "|cffffc700|H%s|h[%s]|h|r" %(hyperlinkText,item.GetItemName())
|
|
new_list.append(hyperText)
|
|
continue
|
|
|
|
privLink = argText.find("'")
|
|
if privLink>=0 and len(argText) > privLink+1:
|
|
privIndex = argText[privLink+1:]
|
|
if privIndex.isdigit() == True:
|
|
privIndex = int(privIndex)
|
|
privList = ["All","Shinsoo","Chunjo","Jinno"]
|
|
new_list.append(privList[privIndex])
|
|
continue
|
|
|
|
goldLink = argText.find("Y")
|
|
if goldLink>=0 and len(argText) > goldLink+1:
|
|
goldPrice = argText[goldLink+1:]
|
|
if goldPrice.isdigit() == True:
|
|
goldPrice = int(goldPrice)
|
|
new_list.append(constInfo.NumberToString(goldPrice))
|
|
continue
|
|
|
|
effectLink = argText.find("E")
|
|
if effectLink>=0 and len(argText) > effectLink+1:
|
|
effectText = argText[effectLink+1:]
|
|
effectSplit = effectText.split(":")
|
|
if len(effectSplit) == 2:
|
|
if effectSplit[0].isdigit() and effectSplit[1].isdigit():
|
|
new_list.append(ItemToolTip.AFFECT_DICT[int(effectSplit[0])](int(effectSplit[1])))
|
|
continue
|
|
valueLink = argText.find("%")
|
|
if valueLink >= 0:
|
|
new_list.append(int(argText[0]))
|
|
continue
|
|
new_list.append(argText)
|
|
return new_list
|
|
|
|
def GetLCText(self, buf):
|
|
bufSplit = buf.split(" ")
|
|
new_text=buf
|
|
if bufSplit[0].isdigit() == True:
|
|
if localeInfo.LC.has_key(int(bufSplit[0]))==True:
|
|
if len(bufSplit) > 1:
|
|
new_arg= ""
|
|
for j in xrange(len(bufSplit)-1):
|
|
new_arg+= "%s&"% str(bufSplit[1+j])
|
|
try:
|
|
new_text=localeInfo.LC[int(bufSplit[0])] % tuple(self.MakeStringToList(new_arg[:len(new_arg)-1]))
|
|
except:
|
|
new_text=buf
|
|
else:
|
|
try:
|
|
new_text=localeInfo.LC[int(bufSplit[0])]
|
|
except:
|
|
new_text=buf
|
|
else:
|
|
new_text=buf
|
|
return new_text
|
|
|
|
def GetLocaleString(self, type, buf):
|
|
buf = self.AutoTranslateText(buf, True, True)
|
|
if type == chat.CHAT_TYPE_NOTICE:
|
|
self.BINARY_SetTipMessage(buf)
|
|
elif type == chat.CHAT_TYPE_BIG_NOTICE:
|
|
self.BINARY_SetBigMessage(buf)
|
|
elif type == chat.CHAT_TYPE_MISSION:
|
|
self.BINARY_SetMissionMessage(buf)
|
|
chat.AppendChat(type, buf)
|
|
|
|
#Example: ^LC_NAME %d %s I%d M%d*^
|
|
def GetQuestText(self, buf):
|
|
firstpos = buf.find("^")
|
|
secondpos = buf.find("*^")
|
|
if firstpos < 0 or secondpos < 0:
|
|
return buf
|
|
cmd = buf[firstpos+1:secondpos]
|
|
new_text=""
|
|
bufSplit = cmd.split(" ")
|
|
#if bufSplit[0].isdigit() == False:
|
|
if localeInfo.QUEST.has_key(str(bufSplit[0]))==True:
|
|
if len(bufSplit) > 1:
|
|
new_arg= ""
|
|
for j in xrange(len(bufSplit)-1):
|
|
new_arg+= "%s&"% str(bufSplit[1+j])
|
|
try:
|
|
new_text=localeInfo.QUEST[str(bufSplit[0])] % tuple(self.MakeStringToList(new_arg[:len(new_arg)-1]))
|
|
except:
|
|
return buf
|
|
else:
|
|
try:
|
|
new_text=localeInfo.QUEST[str(bufSplit[0])]
|
|
except:
|
|
return buf
|
|
else:
|
|
return buf
|
|
|
|
return buf.replace("^"+cmd+"*^",new_text)
|
|
|
|
def GetQuestString(self, buf, skin):
|
|
buf = self.AutoTranslateText(buf, False, True)
|
|
if buf.find("*^") != -1:
|
|
buf = buf.replace("*^","")
|
|
if buf.find("^") != -1:
|
|
buf= buf.replace("^","")
|
|
event.AddEvent(buf,skin)
|
|
|
|
def GetQuestLetterName(self, packet_type, index, flag, title, clockname, countername, iconfilename, clockvalue, countervalue):
|
|
title = self.AutoTranslateText(title, False, True)
|
|
quest.Add(packet_type,index,title,clockname,clockvalue,countername,countervalue,iconfilename,flag)
|
|
self.RefreshQuest()
|
|
|
|
if app.ENABLE_CHANNEL_CHANGE:
|
|
def SetChannelIndex(self, channel):
|
|
if self.interface.wndChangeChannel:
|
|
self.interface.wndChangeChannel.channel = int(channel)
|
|
def UpdateServerInfo(self, channel):
|
|
net.SetServerInfo("%s, Ch %s" % (localeInfo.SERVERNAME, str(channel)))
|
|
|
|
if app.dracaryS_DUNGEON_LIB:
|
|
def RefreshDungeonTimer(self, Floor,Time):
|
|
if self.interface:
|
|
if self.interface.wndMiniMap:
|
|
self.interface.wndMiniMap.Hide()
|
|
self.interface.MakeDungeonTimerWindow()
|
|
if self.interface.wndDungeonTimer:
|
|
self.interface.wndDungeonTimer.RefreshDungeonTimer(Time, Floor)
|
|
def RefreshDungeonFloor(self, Floor2):
|
|
if self.interface:
|
|
if self.interface.wndMiniMap:
|
|
self.interface.wndMiniMap.Hide()
|
|
self.interface.MakeDungeonTimerWindow()
|
|
if self.interface.wndDungeonTimer:
|
|
self.interface.wndDungeonTimer.RefreshDungeonFloor(Floor2)
|
|
|
|
if app.ENABLE_ITEMSHOP:
|
|
def ItemShopClear(self, updateTime):
|
|
uiItemShopNew.ItemShopClear(int(updateTime))
|
|
def ItemShopUpdateItem(self, itemID, itemVnum, itemPrice, itemDiscount, itemOffertime, itemTopSelling, itemAddedTime, itemSellingCount, itemMaxSellingCount):
|
|
uiItemShopNew.ItemShopUpdateItem(int(itemID), int(itemVnum), long(itemPrice), int(itemDiscount), int(itemOffertime), int(itemTopSelling), int(itemAddedTime), long(itemSellingCount), int(itemMaxSellingCount))
|
|
self.interface.ItemShopUpdateItem(int(itemID), int(itemMaxSellingCount))
|
|
def ItemShopAppendItem(self, categoryIndex, categorySubIndex, itemID, itemVnum, itemPrice, itemDiscount, itemOffertime, itemTopSelling, itemAddedTime, itemSellingCount, itemMaxSellingCount):
|
|
uiItemShopNew.ItemShopAppendItem(int(categoryIndex), int(categorySubIndex), int(itemID), int(itemVnum), long(itemPrice), int(itemDiscount), int(itemOffertime), int(itemTopSelling), int(itemAddedTime), long(itemSellingCount), int(itemMaxSellingCount))
|
|
def ItemShopHideLoading(self):
|
|
self.interface.ItemShopHideLoading()
|
|
def ItemShopOpenMainPage(self):
|
|
self.interface.OpenItemShopMainWindow()
|
|
def ItemShopLogClear(self):
|
|
uiItemShopNew.ItemShopLogClear()
|
|
def ItemShopAppendLog(self, dateText, dateTime, playerName, ipAdress, itemVnum, itemCount, itemPrice):
|
|
uiItemShopNew.ItemShopAppendLog(str(dateText), int(dateTime), str(playerName), str(ipAdress), int(itemVnum), int(itemCount), long(itemPrice))
|
|
def ItemShopPurchasesWindow(self):
|
|
self.interface.ItemShopPurchasesWindow()
|
|
def ItemShopSetDragonCoin(self, dragonCoin):
|
|
self.interface.ItemShopSetDragonCoin(long(dragonCoin))
|
|
def ItemShopAppendLogEx(self, dateText, dateText2,dateTime, playerName, ipAdress, itemVnum, itemCount, itemPrice):
|
|
uiItemShopNew.ItemShopAppendLog(str(dateText)+" "+str(dateText2), int(dateTime), str(playerName), str(ipAdress), int(itemVnum), int(itemCount), long(itemPrice))
|
|
|
|
if app.ENABLE_EVENT_MANAGER:
|
|
def ClearEventManager(self):
|
|
self.interface.ClearEventManager()
|
|
def RefreshEventManager(self):
|
|
self.interface.RefreshEventManager()
|
|
def RefreshEventStatus(self, eventID, eventStatus, eventendTime, eventEndTimeText):
|
|
self.interface.RefreshEventStatus(int(eventID), int(eventStatus), int(eventendTime), str(eventEndTimeText))
|
|
def AppendEvent(self, dayIndex, eventID, eventIndex, startTime, endTime, empireFlag, channelFlag, value0, value1, value2, value3, startRealTime, endRealTime, isAlreadyStart):
|
|
self.interface.AppendEvent(int(dayIndex),int(eventID), int(eventIndex), str(startTime), str(endTime), int(empireFlag), int(channelFlag), int(value0), int(value1), int(value2), int(value3), int(startRealTime), int(endRealTime), int(isAlreadyStart))
|
|
|
|
if app.ENABLE_DEFENSAWESHIP:
|
|
def __ShipMastHPShow(self):
|
|
if self.wndShipMastHP:
|
|
self.wndShipMastHP.Open(10000000, 10000000)
|
|
def __HydraGetHp(self, curPoint):
|
|
if self.wndShipMastHP:
|
|
new = int(curPoint)
|
|
self.wndShipMastHP.SetShipMastHP(new, 10000000)
|
|
|
|
if app.ENABLE_SHOW_CHEST_DROP:
|
|
def OpenChestDrop(self, chestIndex):
|
|
self.interface.OpenChestDropWindow(int(chestIndex),0, -1)
|
|
#if u close this clear function only send 1 packet.
|
|
item.GetDropClear(int(chestIndex))#every time clear for update.
|
|
|
|
if app.ENABLE_ANTI_EXP:
|
|
def SetAntiExp(self, flag):
|
|
flag = int(flag)
|
|
if self.interface:
|
|
ptr = [self.interface.wndTaskBar]
|
|
for gui in ptr:
|
|
if gui:
|
|
if flag:
|
|
guiptr = gui.GetChild("AntiExp")
|
|
guiptr.SetUpVisual("d:/ymir work/ui/game/anti_exp/no_exp_0.tga")
|
|
guiptr.SetOverVisual("d:/ymir work/ui/game/anti_exp/no_exp_1.tga")
|
|
guiptr.SetDownVisual("d:/ymir work/ui/game/anti_exp/no_exp_2.tga")
|
|
|
|
if gui.IsChild("RestExp_Value"):
|
|
gui.GetChild("Exp_Value").Hide()
|
|
if gui.IsChild("Exp_Value"):
|
|
gui.GetChild("RestExp_Value").Hide()
|
|
|
|
for j in range(1,5):
|
|
if gui.IsChild("EXPGauge_0%d"%j):
|
|
gui.GetChild("EXPGauge_0%d"%j).SetDiffuseColor(104.0/255.0,104.0/255.0,104.0/255.0,1)
|
|
|
|
else:
|
|
guiptr = gui.GetChild("AntiExp")
|
|
guiptr.SetUpVisual("d:/ymir work/ui/game/anti_exp/exp_0.tga")
|
|
guiptr.SetOverVisual("d:/ymir work/ui/game/anti_exp/exp_1.tga")
|
|
guiptr.SetDownVisual("d:/ymir work/ui/game/anti_exp/exp_2.tga")
|
|
|
|
if gui.IsChild("RestExp_Value"):
|
|
gui.GetChild("Exp_Value").Show()
|
|
if gui.IsChild("Exp_Value"):
|
|
gui.GetChild("RestExp_Value").Show()
|
|
|
|
for j in range(1,5):
|
|
if gui.IsChild("EXPGauge_0%d"%j):
|
|
gui.GetChild("EXPGauge_0%d"%j).SetDiffuseColor(201,160,51,1)
|
|
|
|
if app.ENABLE_MULTI_FARM_BLOCK:
|
|
def UpdateMultiFarmPlayer(self, multiFarmPlayer):
|
|
self.affectShower.SetMultiFarmPlayer(str(multiFarmPlayer))
|
|
def UpdateMultiFarmAffect(self, multiFarmStatus, isNewStatus):
|
|
self.affectShower.SetMultiFarmInfo(int(multiFarmStatus))
|
|
if int(isNewStatus) == 1:
|
|
if int(multiFarmStatus) == 1:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MULTI_FARM_ACTIVE_CHAT)
|
|
else:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MULTI_FARM_DEACTIVE_CHAT)
|
|
app.SetMultiFarmExeIcon(int(multiFarmStatus))
|
|
|
|
if app.ENABLE_DISCORD_STUFF:
|
|
def GetMessage(self):
|
|
if self.interface:
|
|
self.interface.OpenWhisperWithMessage(constInfo.msgname)
|
|
constInfo.msgname=""
|
|
if app.ENABLE_ZODIAC_MISSION:
|
|
def ZodiacLuaIndex(self,p):
|
|
constInfo.ZodiacLua = int(p)
|
|
def ZodiacLuaIndex(self,p):
|
|
constInfo.ZodiacLua = int(p)
|
|
def BINARY_SetMissionMessage(self, message):
|
|
if self.interface.missionBoard:
|
|
self.interface.missionBoard.SetMission(message)
|
|
def ZodiacJumpButtonShow(self):
|
|
if self.interface:
|
|
self.interface.wnd12ziTimer.Show12ziJumpButton()
|
|
def ZodiacJumpButtonClose(self):
|
|
if self.interface:
|
|
self.interface.wnd12ziTimer.CloseJumpButton()
|
|
def Refresh12ziTimer(self, Time, Nextfloor, Floor):
|
|
if self.interface:
|
|
self.interface.wnd12ziTimer.Refresh12ziTimer(Time, Nextfloor, Floor)
|
|
self.interface.wnd12ziTimer.Show()
|
|
def ZodiacDayorNight(self):
|
|
if self.interface:
|
|
self.interface.wnd12ziTimer.DayorNigh12zi()
|
|
def OpenUI12zi(self,yellomark,greenmark,yellowreward,greenreward):
|
|
if self.interface:
|
|
self.interface.wnd12ziReward.Open(yellomark,greenmark,yellowreward,greenreward)
|
|
def OpenZodiac(self):
|
|
if self.interface:
|
|
self.interface.wnd12ziReward.Show()
|
|
def SetBeadCount(self, count):
|
|
if self.interface:
|
|
self.interface.wndMiniMap.beadInfo.SetText("%d"%count)
|
|
self.interface.wndMiniMap.beadInfo.Show()
|
|
def NextBeadUpdateTime(self, value):
|
|
if self.interface:
|
|
self.interface.wndMiniMap.beadTime = int(value)
|
|
def OpenReviveDialog(self,count):
|
|
constInfo.RevivePrismaCount = int(count)
|
|
def OpenReviveDialog_Me(self,count_me):
|
|
constInfo.RevivePrismaCount_Me = int(count_me)
|
|
|
|
if app.ENABLE_EXCHANGE_LOG:
|
|
def ExchangeLogClear(self, playerCode):
|
|
self.interface.ExchangeLogClear(playerCode)
|
|
def ExchangeLogRefresh(self, isLogItemRefresh):
|
|
self.interface.ExchangeLogRefresh(isLogItemRefresh)
|
|
def ExchangeLogAppend(self, logID, ownerName, ownerGold, ownerIP, targetName, targetGold, targetIP, date):
|
|
self.interface.ExchangeLogAppend(logID, ownerName, ownerGold, ownerIP, targetName, targetGold, targetIP, date)
|
|
def ExchangeLogItemAppend(self, logID, itemPos, itemVnum, itemCount, metinSlot, attrType, attrValue, isOwnerItem):
|
|
self.interface.ExchangeLogItemAppend(logID, itemPos, itemVnum, itemCount, metinSlot, attrType, attrValue, isOwnerItem)
|
|
|
|
def BINARY_Cards_UpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points):
|
|
self.interface.UpdateCardsInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points)
|
|
|
|
def BINARY_Cards_FieldUpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):
|
|
self.interface.UpdateCardsFieldInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)
|
|
|
|
def BINARY_Cards_PutReward(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):
|
|
self.interface.CardsPutReward(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)
|
|
|
|
def BINARY_Cards_ShowIcon(self):
|
|
self.interface.CardsShowIcon()
|
|
|
|
def BINARY_Cards_Open(self, safemode):
|
|
self.interface.OpenCardsWindow(safemode)
|
|
|
|
if app.ENABLE_MINI_GAME_CATCH_KING:
|
|
def MiniGameCatchKingEvent(self, isEnable):
|
|
pass
|
|
|
|
def MiniGameCatchKingEventStart(self, bigScore):
|
|
self.interface.MiniGameCatchKingEventStart(bigScore)
|
|
|
|
def MiniGameCatchKingSetHandCard(self, cardNumber):
|
|
self.interface.MiniGameCatchKingSetHandCard(cardNumber)
|
|
|
|
def MiniGameCatchKingResultField(self, score, rowType, cardPos, cardValue, keepFieldCard, destroyHandCard, getReward, isFiveNear):
|
|
self.interface.MiniGameCatchKingResultField(score, rowType, cardPos, cardValue, keepFieldCard, destroyHandCard, getReward, isFiveNear)
|
|
|
|
def MiniGameCatchKingSetEndCard(self, cardPos, cardNumber):
|
|
self.interface.MiniGameCatchKingSetEndCard(cardPos, cardNumber)
|
|
|
|
def MiniGameCatchKingReward(self, rewardCode):
|
|
self.interface.MiniGameCatchKingReward(rewardCode)
|
|
|
|
def MiniGameCatchKing(self, value):
|
|
player.SetEventGame(int(value))
|
|
self.interface.MiniGameCatchKing(value)
|
|
|
|
def StartCatchKing(self):
|
|
self.interface.ClickCatchKingEventButton()
|