4103 lines
144 KiB
Python
4103 lines
144 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()
|
|
##
|
|
|
|
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()
|