Paste2.org - Viewing Paste ka4F0CjF

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 quest
import guild
import skill
import messenger
import localeInfo
import constInfo
import exchange
import ime
import translate
import uiminimap
import uiMiniGameFishEvent
import uiMiniGame
import uiminigameattendance
import ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
import time
import uiPrivateShopBuilder
import mouseModule
import consoleModule
import localeInfo
import playerSettingModule
import interfaceModule
import musicInfo
import debugInfo
import stringCommander
import event
import constInfo_new
if app.ENABLE_LUCKY_BOX:
import uiLuckyBox
if app.ENABLE_SKILL_SELECT_SYSTEM:
import uiskillselect
if app.ENABLE_WORD_GAME_EVENT:
import uiWordGameSystem
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
import uiOfflineShopBuilder
import uiOfflineShop
if app.ENABLE_NEW_PET_SYSTEM:
import uipetsystem
if app.ENABLE_SOCCER_BALL_EVENT:
import uifutboltopu
if app.ENABLE_SKILL_BOOK_READING:
import uibkoku
if app.ENABLE_SPIRIT_STONE_READING:
import uiruhtasi
if app.WJ_COMBAT_ZONE:
import uicombatzone
if app.ENABLE_12ZI:
import ui12zi
if app.ENABLE_WHISPER_ADMIN_SYSTEM:
import uiwhisperadmin
if app.ENABLE_ADMIN_BAN_MANAGER:
import uiadmintool
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
import uikeyboardsettings
if app.ENABLE_MINI_GAME_CATCH_KING:
import uiminigamecatchking
if app.ENABLE_STONE_EVENT:
import uistone_event
if app.ENABLE_BOSS_TRACKING:
import uibosstracking
if app.ENABLE_RENEW_MESSENGER_WHISPER:
import uicontact
from _weakref import proxy
# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = None
if localeInfo.IsEUROPE():
SCREENSHOT_CWDSAVE = TRUE
if localeInfo.IsCIBN10():
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = "YT2W"
cameraDistance = 1550.0
cameraPitch = 27.0
cameraRotation = 0.0
cameraHeight = 100.0
testAlignment = 0
BPisLodaded = 0
class GameWindow(ui.ScriptWindow):
if app.ENABLE_MAIL_BOX_SYSTEM:
MailBoxOpenT = 0
def __init__(self, stream):
ui.ScriptWindow.__init__(self, "GAME")
self.SetWindowName("game")
net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
player.SetGameWindow(self)
if app.ENABLE_WORD_GAME_EVENT:
self.wordgame = uiWordGameSystem.WordGameWindow()
self.wordgame.Close()
if app.ENABLE_BOSS_TRACKING:
self.bosstracking = uibosstracking.BossTrackingInfoWindow()
self.bosstracking.Hide()
if app.ENABLE_SOCCER_BALL_EVENT:
self.topver = uifutboltopu.TopEventi()
self.topver.Close()
if app.ENABLE_STONE_EVENT:
self.stone_event = uistone_event.StoneEventWindow()
self.stone_event.Hide()
if (app.WJ_COMBAT_ZONE):
self.wndCombatZone = uicombatzone.CombatZoneWindow()
self.quickSlotPageIndex = 0
self.lastPKModeSendedTime = 0
self.pressNumber = None
self.guildWarQuestionDialog = None
self.interface = None
self.targetBoard = None
self.console = None
self.mapNameShower = None
self.affectShower = None
self.playerGauge = None
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
self.dlgKeyboardSettings = None
self.stream=stream
self.interface = interfaceModule.Interface()
self.interface.SetStream(self.stream)
self.interface.MakeInterface()
self.interface.ShowDefaultWindows()
self.stream.isAutoSelect = 0
self.curtain = uiPhaseCurtain.PhaseCurtain()
self.curtain.speed = 0.03
self.curtain.Hide()
self.targetBoard = uiTarget.TargetBoard()
self.targetBoard.SetWhisperEvent(ui.__mem_func__(self.interface.OpenWhisperDialog))
self.targetBoard.Hide()
self.console = consoleModule.ConsoleWindow()
self.console.BindGameClass(self)
self.console.SetConsoleSize(wndMgr.GetScreenWidth(), 200)
self.console.Hide()
self.mapNameShower = uiMapNameShower.MapNameShower()
self.affectShower = uiAffectShower.AffectShower()
if app.ENABLE_NEW_PET_SYSTEM:
self.petmain = uipetsystem.PetSystemMain()
if (app.ENABLE_PET_ATTR_DETERMINE):
self.petmain.SetItemToolTip(self.interface.tooltipItem)
self.petmain.BindInterface(self.interface)
self.petmini = uipetsystem.PetSystemMini()
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
self.dlgKeyboardSettings = uikeyboardsettings.KeyChangeWindow(self)
if app.ENABLE_ADMIN_BAN_MANAGER:
self.wndAdminTool = uiadmintool.AdminTool()
if app.ENABLE_SPIRIT_STONE_READING:
self.ruhtasi = uiruhtasi.RuhTasi()
self.ruhtasi.Hide()
if app.ENABLE_SKILL_BOOK_READING:
self.bkoku = uibkoku.BKOku()
self.bkoku.Hide()
if app.ENABLE_WHISPER_ADMIN_SYSTEM:
self.adminWhisperManager = uiwhisperadmin.WhisperManager()
self.playerGauge = uiPlayerGauge.PlayerGauge(self)
self.playerGauge.Hide()
self.itemDropQuestionDialog = None
self.__SetQuickSlotMode()
self.__ServerCommand_Build()
self.__ProcessPreservedServerCommand()
def __del__(self):
player.SetGameWindow(0)
net.ClearPhaseWindow(net.PHASE_WINDOW_GAME, self)
ui.ScriptWindow.__del__(self)
def Open(self):
app.SetFrameSkip(1)
self.SetSize(wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())
self.quickSlotPageIndex = 0
self.PickingCharacterIndex = -1
self.PickingItemIndex = -1
self.consoleEnable = FALSE
self.isShowDebugInfo = FALSE
self.ShowNameFlag = FALSE
self.enableXMasBoom = FALSE
self.startTimeXMasBoom = 0.0
self.indexXMasBoom = 0
if app.ENABLE_SOUL_ROULETTE_SYSTEM:
self.enableXMasSoul = FALSE
self.startTimeXMasSoul = 0.0
self.indexXMasSoul = 0
global cameraDistance, cameraPitch, cameraRotation, cameraHeight
app.SetCamera(cameraDistance, cameraPitch, cameraRotation, cameraHeight)
constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()
constInfo.SET_DEFAULT_CHRNAME_COLOR()
constInfo.SET_DEFAULT_FOG_LEVEL()
constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENABLE()
constInfo.SET_DEFAULT_USE_ITEM_WEAPON_TABLE_ATTACK_BONUS()
constInfo.SET_DEFAULT_USE_SKILL_EFFECT_ENABLE()
constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
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()
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
self.dlgKeyboardSettings.BuildKeyDict()
# PRIVATE_SHOP_PRICE_LIST
uiPrivateShopBuilder.Clear()
# END_OF_PRIVATE_SHOP_PRICE_LIST
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
uiOfflineShopBuilder.Clear()
# UNKNOWN_UPDATE
exchange.InitTrading()
# END_OF_UNKNOWN_UPDATE
if debugInfo.IsDebugMode():
self.ToggleDebugInfo()
## 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_ENVIRONMENT_EFFECT_OPTION:
if constInfo_new.night == 1:
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)
# START_GAME_ERROR_EXIT
try:
self.StartGame()
except:
import exception
exception.Abort("GameWindow.Open")
# END_OF_START_GAME_ERROR_EXIT
self.cubeInformation = {}
self.currentCubeNPC = 0
if app.ENABLE_FOG_FIX:
if systemSetting.GetFogMode():
background.SetFogMode(True)
else:
background.SetFogMode(False)
def Close(self):
self.Hide()
global cameraDistance, cameraPitch, cameraRotation, cameraHeight
(cameraDistance, cameraPitch, cameraRotation, cameraHeight) = app.GetCamera()
if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)
self.onPressKeyDict = None
self.onClickKeyDict = None
chat.Close()
snd.StopAllSound()
grp.InitScreenEffect()
chr.Destroy()
textTail.Clear()
quest.Clear()
background.Destroy()
guild.Destroy()
messenger.Destroy()
skill.ClearSkillData()
wndMgr.Unlock()
mouseModule.mouseController.DeattachObject()
if self.guildWarQuestionDialog:
self.guildWarQuestionDialog.Close()
self.guildNameBoard = None
self.partyRequestQuestionDialog = None
self.partyInviteQuestionDialog = None
self.guildInviteQuestionDialog = None
self.guildWarQuestionDialog = None
self.messengerAddFriendQuestion = None
# UNKNOWN_UPDATE
self.itemDropQuestionDialog = None
# END_OF_UNKNOWN_UPDATE
# QUEST_CONFIRM
self.confirmDialog = None
# END_OF_QUEST_CONFIRM
self.PrintCoord = None
self.FrameRate = None
self.Pitch = None
self.Splat = None
self.TextureNum = None
self.ObjectNum = None
self.ViewDistance = None
self.PrintMousePos = None
self.ClearDictionary()
self.playerGauge = None
self.mapNameShower = None
self.affectShower = None
if self.console:
self.console.BindGameClass(0)
self.console.Close()
self.console=None
if self.targetBoard:
self.targetBoard.Destroy()
self.targetBoard = None
if app.ENABLE_WORD_GAME_EVENT:
if self.wordgame:
self.wordgame.Close()
self.wordgame = None
if app.ENABLE_NEW_PET_SYSTEM:
self.petmain.Close()
self.petmini.Close()
if app.ENABLE_SOCCER_BALL_EVENT:
if self.topver:
self.topver.Close()
self.topver = None
if app.ENABLE_BOSS_TRACKING:
if self.bosstracking:
self.bosstracking.Destroy()
self.bosstracking = None
if app.ENABLE_STONE_EVENT:
if self.stone_event:
self.stone_event.Destroy()
self.stone_event = None
if app.ENABLE_ADMIN_BAN_MANAGER:
if self.adminWhisperManager:
self.adminWhisperManager.Hide()
if app.ENABLE_SPIRIT_STONE_READING:
if self.ruhtasi:
self.ruhtasi.Destroy()
self.ruhtasi = None
if app.ENABLE_WHISPER_ADMIN_SYSTEM:
if self.adminWhisperManager:
self.adminWhisperManager.Hide()
if app.ENABLE_SKILL_BOOK_READING:
if self.bkoku:
self.bkoku.Destroy()
self.bkoku = None
if (app.WJ_COMBAT_ZONE):
if self.wndCombatZone:
self.wndCombatZone.Close()
if self.interface:
self.interface.HideAllWindows()
self.interface.Close()
self.interface=None
player.ClearSkillDict()
player.ResetCameraRotation()
self.KillFocus()
app.HideCursor()
print "---------------------------------------------------------------------------- CLOSE GAME WINDOW"
if app.ENABLE_STONE_EVENT:
def StoneEvent(self, arg):
if 1 == int(arg):
self.stone_event.Show()
else:
self.stone_event.Hide()
def BINARY_ReceiveChannel(self, channel):
if self.interface:
if self.interface.wndMiniMap:
self.interface.wndMiniMap.UpdateChannelInfo(channel)
constInfo.channel_idx = channel
if app.ENABLE_SPIRIT_STONE_READING:
def ruhcac(self):
self.ruhtasi.Show()
if app.ENABLE_SKILL_BOOK_READING:
def bkac(self):
self.bkoku.Show()
if app.ENABLE_WORD_GAME_EVENT:
def WordGameWindowShow(self):
self.wordgame.Show()
if app.ENABLE_SOCCER_BALL_EVENT:
def FutbolTopuVer(self):
self.topver.Show()
def __BuildKeyDict(self):
onPressKeyDict = {}
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)
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_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_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()
onPressKeyDict[app.DIK_LSHIFT] = lambda : self.__SetQuickPageMode()
onPressKeyDict[app.DIK_J] = lambda : self.__PressJKey()
onPressKeyDict[app.DIK_H] = lambda : self.__PressHKey()
onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()
onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()
if app.ENABLE_DRAGON_SOUL_SYSTEM:
onPressKeyDict[app.DIK_O] = lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
if app.ENABLE_SPLIT_INVENTORY_SYSTEM:
onPressKeyDict[app.DIK_K] = lambda : self.interface.ToggleSpecialInventoryWindow()
self.onPressKeyDict = onPressKeyDict
onClickKeyDict = {}
onClickKeyDict[app.DIK_UP] = lambda : self.StopUp()
onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()
onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()
onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()
onClickKeyDict[app.DIK_W] = lambda : self.StopUp()
onClickKeyDict[app.DIK_S] = lambda : self.StopDown()
onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_D] = lambda : self.StopRight()
onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_G] = lambda: self.__ReleaseGKey()
onClickKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_LALT] = lambda: self.HideName()
onClickKeyDict[app.DIK_LCONTROL] = lambda: self.HideMouseImage()
onClickKeyDict[app.DIK_LSHIFT] = lambda: self.__SetQuickSlotMode()
if app.ENABLE_NEW_PET_SYSTEM:
onClickKeyDict[app.DIK_P] = lambda: self.OpenPetMainGui()
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:
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
if not uiPrivateShopBuilder.IsBuildingPrivateShop() and not uiOfflineShopBuilder.IsBuildingOfflineShop():
for i in xrange(player.INVENTORY_PAGE_SIZE):
if player.GetItemIndex(i) in (71114, 71116, 71118, 71120):
net.SendItemUsePacket(i)
break
else:
if not uiPrivateShopBuilder.IsBuildingPrivateShop():
for i in xrange(player.INVENTORY_PAGE_SIZE):
if player.GetItemIndex(i) in (71114, 71116, 71118, 71120):
net.SendItemUsePacket(i)
break
def __PressHKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_ride")
else:
self.interface.OpenHelpWindow()
def __PressBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_back")
else:
state = "EMOTICON"
self.interface.ToggleCharacterWindow(state)
def __PressFKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_feed")
else:
app.ZoomCamera(app.CAMERA_TO_POSITIVE)
def __PressGKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/ride")
else:
if self.ShowNameFlag:
self.interface.ToggleGuildWindow()
else:
app.PitchCamera(app.CAMERA_TO_POSITIVE)
def __ReleaseGKey(self):
app.PitchCamera(app.CAMERA_STOP)
if app.ENABLE_ADMIN_BAN_MANAGER:
def OpenAdminTool(self):
if self.wndAdminTool.IsShow():
self.wndAdminTool.Hide()
else:
self.wndAdminTool.Show()
def __PressQKey(self):
if (app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL)):
if (interfaceModule.IsQBHide == 0):
interfaceModule.IsQBHide = 1
self.interface.HideAllQuestButton()
else:
interfaceModule.IsQBHide = 0
self.interface.ShowAllQuestButton()
else:
app.RotateCamera(app.CAMERA_TO_NEGATIVE)
def __PressPKey(self):
if (app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL)):
if (interfaceModule.IsWhisperHide == 0):
interfaceModule.IsWhisperHide = 1
self.interface.HideAllWhisperButton()
else:
interfaceModule.IsWhisperHide = 0
self.interface.ShowAllWhisperButton()
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 __PressTeleport(self):
if self.interface:
self.interface.ToggleTeleportWindow()
def __SelectQuickPage(self, pageIndex):
self.quickSlotPageIndex = pageIndex
player.SetQuickPage(pageIndex)
def ToggleDebugInfo(self):
self.isShowDebugInfo = not self.isShowDebugInfo
if self.isShowDebugInfo:
self.PrintCoord.Show()
self.FrameRate.Show()
self.Pitch.Show()
self.Splat.Show()
self.TextureNum.Show()
self.ObjectNum.Show()
self.ViewDistance.Show()
self.PrintMousePos.Show()
else:
self.PrintCoord.Hide()
self.FrameRate.Hide()
self.Pitch.Hide()
self.Splat.Hide()
self.TextureNum.Hide()
self.ObjectNum.Hide()
self.ViewDistance.Hide()
self.PrintMousePos.Hide()
def __BuildDebugInfo(self):
self.PrintCoord = ui.TextLine()
self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)
self.FrameRate = ui.TextLine()
self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20)
self.Pitch = ui.TextLine()
self.Pitch.SetFontName(localeInfo.UI_DEF_FONT)
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40)
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)
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)
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
def PressNumberKey(self, key):
self.pressNumber(key)
def PressQuickSlot(self, key):
player.RequestUseLocalQuickSlot(key)
def SelectQuickPage(self, key):
if app.IsPressed(app.DIK_LSHIFT):
self.quickSlotPageIndex = key
player.SetQuickPage(key)
def SetEmoticon(self, key):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if (chrmgr.IsPossibleEmoticon(-1)):
chrmgr.SetEmoticon(-1, key)
net.SendEmoticon(key)
def ShowNameNew(self):
self.ShowNameFlag = True
self.playerGauge.EnableShowAlways()
def HideNameNew(self):
self.ShowNameFlag = False
self.playerGauge.DisableShowAlways()
def PressExtraKey(self, key):
if key == "RIDE_HORSE":
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_ride")
elif key == "RIDE_PEED":
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_feed")
elif key == "RIDE":
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/ride")
elif key == "RIDE_J":
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if player.IsMountingHorse():
net.SendChatPacket("/unmount")
else:
if not uiPrivateShopBuilder.IsBuildingPrivateShop():
if app.ENABLE_MOUNT_SYSTEM:
for i in xrange(180):
index = player.GetItemIndex(i)
if index:
item.SelectItem(index)
subType = item.GetItemSubType()
if subType == item.USE_MOUNT:
net.SendItemUsePacket(i)
break
else:
return
elif key == "RIDE_BYE":
net.SendChatPacket("/user_horse_back")
elif key == "QUEST_SCROLL_ONOFF":
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()
elif key == "GUILD_WINDOW":
if app.IsPressed(app.DIK_LALT):
self.interface.ToggleGuildWindow()
elif key == "MESSENGER_WINDOW":
if app.IsPressed(app.DIK_LCONTROL):
self.interface.ToggleMessenger()
elif key == "SHOW_MINIMAP":
if app.IsPressed(app.DIK_LSHIFT):
if False == self.interface.wndMiniMap.isShowMiniMap():
self.interface.wndMiniMap.ShowMiniMap()
self.interface.wndMiniMap.SetTop()
else:
self.interface.wndMiniMap.HideMiniMap()
elif key == "HIDE_PM":
if 0 == interfaceModule.IsWisperHide:
interfaceModule.IsWisperHide = 1
self.interface.HideAllWhisperButton()
else:
interfaceModule.IsWisperHide = 0
self.interface.ShowAllWhisperButton()
elif key == "OPEN_WHISPER":
self.interface.OpenWhisperDialogWithoutTarget()
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] + ")")
# Start
def StartGame(self):
self.RefreshInventory()
self.RefreshEquipment()
self.RefreshCharacter()
self.RefreshSkill()
# Refresh
def CheckGameButton(self):
if self.interface:
self.interface.CheckGameButton()
def RefreshAlignment(self):
self.interface.RefreshAlignment()
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 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):
import constInfo
if constInfo.INPUT_IGNORE == 1:
return
if constInfo.GIFT_INPUT == 1:
return
self.interface.OpenQuestWindow(skin, idx)
def HideAllQuestWindow(self):
self.interface.HideAllQuestWindow()
def AskGuildName(self):
guildNameBoard = uiCommon.InputDialog()
guildNameBoard.SetTitle(localeInfo.GUILD_NAME)
guildNameBoard.SetAcceptEvent(ui.__mem_func__(self.ConfirmGuildName))
guildNameBoard.SetCancelEvent(ui.__mem_func__(self.CancelGuildName))
guildNameBoard.Open()
self.guildNameBoard = guildNameBoard
def ConfirmGuildName(self):
guildName = self.guildNameBoard.GetText()
if not guildName:
return
if net.IsInsultIn(guildName):
self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)
return
net.SendAnswerMakeGuildPacket(guildName)
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE
def CancelGuildName(self):
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE
## Refine
def PopupMessage(self, msg):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(msg, 0, localeInfo.UI_OK)
def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, type=0):
self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, type)
def AppendMaterialToRefineDialog(self, vnum, count):
self.interface.AppendMaterialToRefineDialog(vnum, count)
def RunUseSkillEvent(self, slotIndex, coolTime):
self.interface.OnUseSkill(slotIndex, coolTime)
def ClearAffects(self):
self.affectShower.ClearAffects()
def SetAffect(self, affect):
self.affectShower.SetAffect(affect)
def ResetAffect(self, affect):
self.affectShower.ResetAffect(affect)
# UNKNOWN_UPDATE
def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
self.BINARY_DragonSoulGiveQuilification()
elif app.ENABLE_DS_SET and chr.NEW_AFFECT_DS_SET == type:
self.interface.DragonSoulSetGrade(value)
if app.ENABLE_BATTLE_PASS:
if type == chr.NEW_AFFECT_BATTLE_PASS:
if self.interface:
if self.interface.wndBattlePassButton:
self.interface.wndBattlePassButton.ShowButton()
self.interface.wndBattlePassButton.Show()
if self.interface.wndBattlePass:
self.interface.wndBattlePass.SetBattlePassInfo(value, duration)
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 app.ENABLE_DS_SET and chr.NEW_AFFECT_DS_SET == type:
self.interface.DragonSoulSetGrade(0)
if app.ENABLE_BATTLE_PASS:
if type == chr.NEW_AFFECT_BATTLE_PASS:
if self.interface and self.interface.wndBattlePassButton:
self.interface.wndBattlePassButton.HideButton()
self.interface.wndBattlePassButton.Hide()
# END_OF_UNKNOWN_UPDATE
def ActivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnActivateSkill(slotIndex)
def DeactivateSkillSlot(self, slotIndex):
if self.interface:
self.interface.OnDeactivateSkill(slotIndex)
def RefreshEquipment(self):
if self.interface:
self.interface.RefreshInventory()
def RefreshInventory(self):
if self.interface:
self.interface.RefreshInventory()
def RefreshCharacter(self):
if self.interface:
self.interface.RefreshCharacter()
def OnGameOver(self):
self.CloseTargetBoard()
self.OpenRestartDialog()
def OpenRestartDialog(self):
self.interface.OpenRestartDialog()
def ChangeCurrentSkill(self, skillSlotNumber):
self.interface.OnChangeCurrentSkill(skillSlotNumber)
def ExInvenItemUseMsg(self, current_stage, need_left, need_count):
if app.ENABLE_EXTEND_INVEN_SYSTEM:
self.interface.ExInvenItemUseMsg(current_stage, need_left, need_count)
if app.ENABLE_STONE_EVENT:
def BINARY_STONE_EVENT(self, arg1):
self.stone_event.SetPoint(arg1)
if app.ENABLE_12ZI:
def OpenUI12zi(self, yellowmark, greenmark, yellowreward, greenreward, goldreward):
self.interface.OpenUI12zi(yellowmark, greenmark, yellowreward, greenreward, goldreward)
def Refresh12ziTimer(self, currentFloor, jumpCount, limitTime, elapseTime):
self.interface.Refresh12ziTimer(currentFloor, jumpCount, limitTime, elapseTime)
def Show12ziJumpButton(self):
self.interface.Show12ziJumpButton()
def Hide12ziTimer(self):
self.interface.Hide12ziTimer()
def OpenReviveDialog(self, vid, itemcount):
self.targetBoard.OpenReviveDialog(vid, itemcount);
def NotEnoughPrism(self, itemcount):
self.PopupMessage(localeInfo.NOT_ENOUGH_PRISM % (itemcount))
def RefreshShopItemToolTip(self):
self.interface.RefreshShopItemToolTip()
def __Refresh12ziTimer1(self):
net.SendChatPacket("/open_cz")
def __Refresh12ziTimer2(self, a, b, c, d, e):
self.OpenUI12zi(int(a), int(b), int(c), int(d), int(e))
## TargetBoard
def SetPCTargetBoard(self, vid, name):
self.targetBoard.Open(vid, name)
if app.IsPressed(app.DIK_LCONTROL):
if not player.IsSameEmpire(vid):
return
if player.IsMainCharacterIndex(vid):
return
elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):
return
self.interface.OpenWhisperDialog(name)
def RefreshTargetBoardByVID(self, vid):
self.targetBoard.RefreshByVID(vid)
def RefreshTargetBoardByName(self, name):
self.targetBoard.RefreshByName(name)
def __RefreshTargetBoard(self):
self.targetBoard.Refresh()
if app.ENABLE_VIEW_TARGET_DECIMAL_HP: #ENABLE_VIEW_ELEMENT
def SetHPTargetBoard(self, vid, hpPercentage, iMinHP, iMaxHP, bElement):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)
self.targetBoard.SetHP(hpPercentage, iMinHP, iMaxHP)
self.targetBoard.SetElementImage(bElement)
self.targetBoard.Show()
else:
def SetHPTargetBoard(self, vid, hpPercentage, bElement):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)
self.targetBoard.SetHP(hpPercentage)
self.targetBoard.SetElementImage(bElement)
self.targetBoard.Show()
def CloseTargetBoardIfDifferent(self, vid):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.Close()
def CloseTargetBoard(self):
self.targetBoard.Close()
## View Equipment
def OpenEquipmentDialog(self, vid):
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.interface.OpenEquipmentDialog(vid)
def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count, transmutation, evolution):
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count, transmutation, evolution)
def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value)
def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value)
def ViewEquipRequest(self, vid):
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
vid = int(vid)
eqRequestQuestionDialog = uiCommon.QuestionDialog()
eqRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + ' giydiklerini g�rmek istiyor?')
eqRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
eqRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)
eqRequestQuestionDialog.SetAcceptEvent(lambda arg = True: self.AnswerViewEquipRequest(arg))
eqRequestQuestionDialog.SetCancelEvent(lambda arg = False: self.AnswerViewEquipRequest(arg))
eqRequestQuestionDialog.Open()
eqRequestQuestionDialog.vid = vid
self.eqRequestQuestionDialog = eqRequestQuestionDialog
def AnswerViewEquipRequest(self, answer):
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
if not self.eqRequestQuestionDialog:
return
else:
vid = self.eqRequestQuestionDialog.vid
if answer:
net.SendChatPacket('/view_equip_accept ' + str(vid))
else:
net.SendChatPacket('/view_equip_deny ' + str(vid))
self.eqRequestQuestionDialog.Close()
self.eqRequestQuestionDialog = None
return
def ViewEquipRequestDenied(self):
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
self.PopupMessage('Profil g�r�nt�leme iste�i reddedildi.')
if app.ENABLE_RENEW_MESSENGER_WHISPER:
def BINARY_OpenWhisperBySearchName(self, name):
self.interface.OpenWhisperDialog(name)
def BINARY_Profile_OnRecvData(self, name, job, level, empire, guild, language, status, location, year, month, day):
self.interface.RecvWhisperProfile(name, job, level, empire, guild, language, status, location, year, month, day)
if str(name) == str(player.GetMainCharacterName()):
uicontact.PROFILE_DICT.update({"job":job,"status":status,"location":location,"year":year,"month":month,"day":day})
# SHOW_LOCAL_MAP_NAME
def ShowMapName(self, mapName, x, y):
if self.mapNameShower:
self.mapNameShower.ShowMapName(mapName, x, y)
if self.interface:
self.interface.SetMapName(mapName)
# END_OF_SHOW_LOCAL_MAP_NAME
def BINARY_OpenAtlasWindow(self):
self.interface.BINARY_OpenAtlasWindow()
## Chat
if app.ENABLE_RENEW_MESSENGER_WHISPER:
def OnRecvWhisper(self, mode, name, line, job, level, empire, guild, language, status, location, year, month, day):
if mode == chat.WHISPER_TYPE_GM:
self.interface.RegisterGameMasterName(name)
chat.AppendWhisper(mode, name, "%s %s" % (uicontact.GetWhisperSendedTime(), line))
self.interface.RecvWhisper(name, job, level, empire, guild, language, status, location, year, month, day)
else:
def OnRecvWhisper(self, mode, name, line):
if mode == chat.WHISPER_TYPE_GM:
self.interface.RegisterGameMasterName(name)
chat.AppendWhisper(mode, name, line)
self.interface.RecvWhisper(name)
def OnRecvWhisperSystemMessage(self, mode, name, line):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, line)
self.interface.RecvWhisper(name)
def OnRecvWhisperError(self, mode, name, line):
if localeInfo.WHISPER_ERROR.has_key(mode):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, localeInfo.WHISPER_ERROR[mode](name))
else:
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))
self.interface.RecvWhisper(name)
def RecvWhisper(self, name):
self.interface.RecvWhisper(name)
if app.ENABLE_WHISPER_ADMIN_SYSTEM:
def OnRecvWhisperAdminSystem(self, name, line, color):
def ExistCustomColor(val):
return (val > 0)
def GetColor(type):
WHISPER_COLOR_MESSAGE = {
0: "|cffffffff|H|h",
1: "|cffff796a|H|h",
2: "|cffb1ff80|H|h",
3: "|cff46deff|H|h"
}
return WHISPER_COLOR_MESSAGE[type]
def ResizeTextWithColor(color, text):
return str("%s%s|h|r" % (GetColor(color), text))
import datetime
now = datetime.datetime.now()
ret = line.replace("#", " ")
if ExistCustomColor(int(color)):
ret = ResizeTextWithColor(int(color), ret)
else:
ret = ResizeTextWithColor(0, ret)
text = localeInfo.WHISPER_ADMIN_MESSAGE % (ret)
self.interface.RegisterGameMasterName(name)
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, text)
self.interface.RecvWhisper(name)
def OnPickExp(self, money):
if constInfo.ExpDrop == 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_EXP % (money))
else:
return
def OnPickMoney(self, money):
if constInfo.YangDrop == 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (money))
else:
return
def OnPickCheque(self, cheque):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHEQUE_SYSTEM_PICK_WON % (cheque))
if app.ENABLE_12ZI:
def SetBeadCount(self, value):
self.interface.SetBeadCount(value)
def NextBeadUpdateTime(self, value):
self.interface.NextBeadUpdateTime(value)
def OnShopError(self, type):
try:
self.PopupMessage(localeInfo.SHOP_ERROR_DICT[type])
except KeyError:
self.PopupMessage(localeInfo.SHOP_ERROR_UNKNOWN % (type))
def OnSafeBoxError(self):
self.PopupMessage(localeInfo.SAFEBOX_ERROR)
def OnFishingSuccess(self, isFish, fishName):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_SUCCESS(isFish, fishName), 2000)
# ADD_FISHING_MESSAGE
def OnFishingNotifyUnknown(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_UNKNOWN)
def OnFishingWrongPlace(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_WRONG_PLACE)
# END_OF_ADD_FISHING_MESSAGE
def OnFishingNotify(self, isFish, fishName):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_NOTIFY(isFish, fishName))
def OnFishingFailure(self):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_FAILURE, 2000)
def OnCannotPickItem(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_PICK_ITEM)
# MINING
def OnCannotMining(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_MINING)
# END_OF_MINING
def OnCannotUseSkill(self, vid, type):
if localeInfo.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
textTail.RegisterInfoTail(vid, localeInfo.USE_SKILL_ERROR_TAIL_DICT[type])
if localeInfo.USE_SKILL_ERROR_CHAT_DICT.has_key(type):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_SKILL_ERROR_CHAT_DICT[type])
def OnCannotShotError(self, vid, type):
textTail.RegisterInfoTail(vid, localeInfo.SHOT_ERROR_TAIL_DICT.get(type, localeInfo.SHOT_ERROR_UNKNOWN % (type)))
## PointReset
def StartPointReset(self):
self.interface.OpenPointResetDialog()
## Shop
if (app.WJ_COMBAT_ZONE):
def StartShop(self, vid, points, curLimit, maxLimit):
self.interface.OpenShopDialog(vid, points, curLimit, maxLimit)
else:
def StartShop(self, vid):
self.interface.OpenShopDialog(vid)
def EndShop(self):
self.interface.CloseShopDialog()
def RefreshShop(self):
self.interface.RefreshShopDialog()
def SetShopSellingPrice(self, Price):
pass
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
def StartOfflineShop(self, vid):
self.interface.OpenOfflineShopDialog(vid)
def EndOfflineShop(self):
self.interface.CloseOfflineShopDialog()
def RefreshOfflineShop(self):
self.interface.RefreshOfflineShopDialog()
def RefreshOfflineShopManager(self):
self.interface.RefreshOfflineShopDialogManager()
def CloseOfflineShopManager(self):
self.interface.CloseOfflineShopDialogManager()
## Exchange
def StartExchange(self):
self.interface.StartExchange()
def EndExchange(self):
self.interface.EndExchange()
def RefreshExchange(self):
self.interface.RefreshExchange()
if app.ENABLE_TRADABLE_ICON:
def AddExchangeItemSlotIndex(self, idx):
self.interface.AddExchangeItemSlotIndex(idx)
## Party
if app.ENABLE_NEW_USER_CARE:
def RecvPartyInviteQuestion(self, leaderVID, leaderName):
partyInviteQuestionDialog = uiCommon.QuestionDialogWithTimeLimit()
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=True: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.SetCancelEvent(lambda arg=False: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.Open(leaderName + localeInfo.PARTY_DO_YOU_JOIN, 10)
partyInviteQuestionDialog.SetTimeOverMsg(localeInfo.PARTY_ANSWER_TIMEOVER)
partyInviteQuestionDialog.SetCancelOnTimeOver()
partyInviteQuestionDialog.partyLeaderVID = leaderVID
self.partyInviteQuestionDialog = partyInviteQuestionDialog
else:
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
if not app.ENABLE_NEW_USER_CARE:
distance = player.GetCharacterDistance(partyLeaderVID)
if distance < 0.0 or distance > 5000:
answer = False
net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)
self.partyInviteQuestionDialog.Close()
self.partyInviteQuestionDialog = None
if app.ENABLE_PARTY_UPDATE:
def AddPartyMember(self, pid, name, mapIdx, channel):
self.interface.AddPartyMember(pid, name, mapIdx, channel)
else:
def AddPartyMember(self, pid, name):
self.interface.AddPartyMember(pid, name)
def UpdatePartyMemberInfo(self, pid):
self.interface.UpdatePartyMemberInfo(pid)
def RemovePartyMember(self, pid):
self.interface.RemovePartyMember(pid)
self.__RefreshTargetBoard()
if app.ENABLE_PARTY_UPDATE:
def LinkPartyMember(self, pid, vid, mapIdx, channel):
self.interface.LinkPartyMember(pid, vid, mapIdx, channel)
else:
def LinkPartyMember(self, pid, vid):
self.interface.LinkPartyMember(pid, vid)
def UnlinkPartyMember(self, pid):
self.interface.UnlinkPartyMember(pid)
def UnlinkAllPartyMember(self):
self.interface.UnlinkAllPartyMember()
def ExitParty(self):
self.interface.ExitParty()
self.RefreshTargetBoardByVID(self.targetBoard.GetTargetVID())
def ChangePartyParameter(self, distributionMode):
self.interface.ChangePartyParameter(distributionMode)
## Messenger
def OnMessengerAddFriendQuestion(self, name):
messengerAddFriendQuestion = uiCommon.QuestionDialog2()
messengerAddFriendQuestion.SetText1(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)
messengerAddFriendQuestion.SetAcceptEvent(ui.__mem_func__(self.OnAcceptAddFriend))
messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))
messengerAddFriendQuestion.Open()
messengerAddFriendQuestion.name = name
self.messengerAddFriendQuestion = messengerAddFriendQuestion
def OnAcceptAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth y " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUE
def OnDenyAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth n " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUE
def OnCloseAddFriendQuestionDialog(self):
self.messengerAddFriendQuestion.Close()
self.messengerAddFriendQuestion = None
return TRUE
## SafeBox
def OpenSafeboxWindow(self, size):
self.interface.OpenSafeboxWindow(size)
def RefreshSafebox(self):
self.interface.RefreshSafebox()
def RefreshSafeboxMoney(self):
self.interface.RefreshSafeboxMoney()
# ITEM_MALL
def OpenMallWindow(self, size):
self.interface.OpenMallWindow(size)
def RefreshMall(self):
self.interface.RefreshMall()
# END_OF_ITEM_MALL
## Guild
def RecvGuildInviteQuestion(self, guildID, guildName):
guildInviteQuestionDialog = uiCommon.QuestionDialog()
guildInviteQuestionDialog.SetText(guildName + localeInfo.GUILD_DO_YOU_JOIN)
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.Open()
guildInviteQuestionDialog.guildID = guildID
self.guildInviteQuestionDialog = guildInviteQuestionDialog
def AnswerGuildInvite(self, answer):
if not self.guildInviteQuestionDialog:
return
guildLeaderVID = self.guildInviteQuestionDialog.guildID
net.SendGuildInviteAnswerPacket(guildLeaderVID, answer)
self.guildInviteQuestionDialog.Close()
self.guildInviteQuestionDialog = None
def DeleteGuild(self):
self.interface.DeleteGuild()
## Clock
def ShowClock(self, second):
self.interface.ShowClock(second)
def HideClock(self):
self.interface.HideClock()
## Emotion
def BINARY_ActEmotion(self, emotionIndex):
if self.interface.wndCharacter:
self.interface.wndCharacter.ActEmotion(emotionIndex)
###############################################################################################
###############################################################################################
## Keyboard Functions
def CheckFocus(self):
if FALSE == self.IsFocus():
if TRUE == self.interface.IsOpenChat():
self.interface.ToggleChat()
self.SetFocus()
def SaveScreen(self):
print "save screen"
# SCREENSHOT_CWDSAVE
if SCREENSHOT_CWDSAVE:
if not os.path.exists(os.getcwd()+os.sep+"screenshot"):
os.mkdir(os.getcwd()+os.sep+"screenshot")
(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"screenshot"+os.sep)
elif SCREENSHOT_DIR:
(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)
else:
(succeeded, name) = grp.SaveScreenShot()
# END_OF_SCREENSHOT_CWDSAVE
if succeeded:
pass
chat.AppendChat(chat.CHAT_TYPE_INFO, name + localeInfo.SCREENSHOT_SAVE1)
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE2)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE_FAILURE)
def ShowConsole(self):
if debugInfo.IsDebugMode() or TRUE == self.consoleEnable:
player.EndKeyWalkingImmediately()
self.console.OpenWindow()
def ShowName(self):
self.ShowNameFlag = TRUE
self.playerGauge.EnableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex+1)
if app.ENABLE_GRAPHIC_NAME:
# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):
if systemSetting.IsAlwaysShowName() == 0:
return True
if self.ShowNameFlag:
return True
return False
def __IsShowNameItem(self):
if systemSetting.IsAlwaysShowName() == 1:
return True
return False
# END_OF_ADD_ALWAYS_SHOW_NAME
else:
# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):
if systemSetting.IsAlwaysShowName():
return TRUE
if self.ShowNameFlag:
return TRUE
return FALSE
# END_OF_ADD_ALWAYS_SHOW_NAME
def HideName(self):
self.ShowNameFlag = FALSE
self.playerGauge.DisableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex)
def ShowMouseImage(self):
self.interface.ShowMouseImage()
def HideMouseImage(self):
self.interface.HideMouseImage()
def StartAttack(self):
player.SetAttackKeyState(TRUE)
def EndAttack(self):
player.SetAttackKeyState(FALSE)
def MoveUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, TRUE)
def MoveDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, TRUE)
def MoveLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, TRUE)
def MoveRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, TRUE)
def StopUp(self):
player.SetSingleDIKKeyState(app.DIK_UP, FALSE)
def StopDown(self):
player.SetSingleDIKKeyState(app.DIK_DOWN, FALSE)
def StopLeft(self):
player.SetSingleDIKKeyState(app.DIK_LEFT, FALSE)
def StopRight(self):
player.SetSingleDIKKeyState(app.DIK_RIGHT, FALSE)
def PickUpItem(self):
player.PickCloseItem()
###############################################################################################
###############################################################################################
## Event Handler
def OnKeyDown(self, key):
if self.interface.wndWeb and self.interface.wndWeb.IsShow():
return
if key == app.DIK_ESC:
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
if self.interface:
self.dlgKeyboardSettings.OnKeyDown(key)
try:
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
pass
else:
self.onPressKeyDict[key]()
except KeyError:
pass
except:
raise
return TRUE
def OnKeyUp(self, key):
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
if self.interface:
self.dlgKeyboardSettings.OnKeyUp(key)
try:
if app.ENABLE_KEYBOARD_SETTINGS_SYSTEM:
pass
else:
self.onClickKeyDict[key]()
except KeyError:
pass
except:
raise
return TRUE
def OnMouseLeftButtonDown(self):
if self.interface.BUILD_OnMouseLeftButtonDown():
return
if mouseModule.mouseController.isAttached():
self.CheckFocus()
else:
hyperlink = ui.GetHyperlink()
if hyperlink:
return
else:
self.CheckFocus()
player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);
return TRUE
def OnMouseLeftButtonUp(self):
if self.interface.BUILD_OnMouseLeftButtonUp():
return
if mouseModule.mouseController.isAttached():
attachedType = mouseModule.mouseController.GetAttachedType()
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
## QuickSlot
if player.SLOT_TYPE_QUICK_SLOT == attachedType:
player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)
## Inventory
elif player.SLOT_TYPE_INVENTORY == attachedType or\
(player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or\
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType or\
player.SLOT_TYPE_STONE_INVENTORY == attachedType or\
player.SLOT_TYPE_BOX_INVENTORY == attachedType or\
player.SLOT_TYPE_EFSUN_INVENTORY == attachedType or\
player.SLOT_TYPE_CICEK_INVENTORY == attachedType and app.ENABLE_SPLIT_INVENTORY_SYSTEM):
if player.ITEM_MONEY == attachedItemIndex:
self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
elif player.ITEM_CHEQUE == attachedItemIndex:
self.__PutCheque(attachedType, attachedItemCount, self.PickingCharacterIndex)
else:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
## DragonSoul
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
mouseModule.mouseController.DeattachObject()
if app.ENABLE_AUTO_HUNT_SYSTEM:
if player.SLOT_TYPE_AUTOHUNT_ITEM == attachedType:
self.interface.AutohuntRemoveItemSlot(attachedItemSlotPos)
if player.SLOT_TYPE_AUTOHUNT_SKILL == attachedType:
self.interface.AutohuntRemoveSkillSlot(attachedItemSlotPos)
else:
hyperlink = ui.GetHyperlink()
if hyperlink:
if app.IsPressed(app.DIK_LALT):
link = chat.GetLinkFromHyperlink(hyperlink)
ime.PasteString(link)
else:
self.interface.MakeHyperlinkTooltip(hyperlink)
return
else:
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)
#player.EndMouseWalking()
return TRUE
def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType or\
(player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or\
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType or\
player.SLOT_TYPE_STONE_INVENTORY == attachedType or\
player.SLOT_TYPE_BOX_INVENTORY == attachedType or\
player.SLOT_TYPE_EFSUN_INVENTORY == attachedType or\
player.SLOT_TYPE_CICEK_INVENTORY == attachedType and app.ENABLE_SPLIT_INVENTORY_SYSTEM):
attachedInvenType = player.SlotTypeToInvenType(attachedType)
if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
if player.IsEquipmentSlot(attachedItemSlotPos) and player.SLOT_TYPE_DRAGON_SOUL_INVENTORY != attachedType:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
else:
if chr.IsNPC(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
if app.ENABLE_MELEY_LAIR_DUNGEON:
if chr.IsStone(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
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
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 app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
if uiOfflineShopBuilder.IsBuildingOfflineShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if uiOfflineShop.IsEditingOfflineShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
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 __PutCheque(self, attachedType, attachedCheque, dstChrID):
if True == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangePsgAddPacket(attachedCheque)
else:
self.__DropCheque(attachedType, attachedCheque)
def __DropCheque(self, attachedType, attachedCheque):
if attachedCheque>=999:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_CHEQUE_FAILURE_100_OVER, 0, localeInfo.UI_OK)
return
itemDropQuestionDialog = uiCommon.QuestionDialog()
itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_CHEQUE % (attachedCheque))
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropCount = attachedCheque
itemDropQuestionDialog.dropNumber = player.ITEM_CHEQUE
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 app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
if uiOfflineShopBuilder.IsBuildingOfflineShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if uiOfflineShop.IsEditingOfflineShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
else:
if player.SLOT_TYPE_INVENTORY == attachedType or\
(player.SLOT_TYPE_SKILL_BOOK_INVENTORY == attachedType or\
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == attachedType or\
player.SLOT_TYPE_STONE_INVENTORY == attachedType or\
player.SLOT_TYPE_BOX_INVENTORY == attachedType or\
player.SLOT_TYPE_EFSUN_INVENTORY == attachedType or\
player.SLOT_TYPE_CICEK_INVENTORY == attachedType and app.ENABLE_SPLIT_INVENTORY_SYSTEM):
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)
item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()
## Question Text
itemPrice = player.GetISellItemPrice(attachedItemSlotPos)
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP_NEW(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.SetSellEvent(lambda arg=True: self.RequestSellItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)
item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()
## Question Text
itemPrice = player.GetISellItemPrice(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP_NEW(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.SetSellEvent(lambda arg=True: self.RequestSellItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialog
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
def RequestDropItem(self, answer):
if not self.itemDropQuestionDialog:
return
if answer:
dropType = self.itemDropQuestionDialog.dropType
dropCount = self.itemDropQuestionDialog.dropCount
dropNumber = self.itemDropQuestionDialog.dropNumber
if player.SLOT_TYPE_INVENTORY == dropType or\
(player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or\
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or\
player.SLOT_TYPE_STONE_INVENTORY == dropType or\
player.SLOT_TYPE_BOX_INVENTORY == dropType or\
player.SLOT_TYPE_EFSUN_INVENTORY == dropType or\
player.SLOT_TYPE_CICEK_INVENTORY == dropType and app.ENABLE_SPLIT_INVENTORY_SYSTEM):
if dropNumber == player.ITEM_MONEY:
net.SendGoldDropPacketNew(dropCount)
snd.PlaySound("sound/ui/money.wav")
elif dropNumber == player.ITEM_CHEQUE:
net.SendChequeDropPacketNew(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
elif app.ENABLE_SPLIT_INVENTORY_SYSTEM:
if player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or player.SLOT_TYPE_STONE_INVENTORY == dropType or player.SLOT_TYPE_BOX_INVENTORY == dropType or player.SLOT_TYPE_EFSUN_INVENTORY == dropType or player.SLOT_TYPE_CICEK_INVENTORY == dropType:
self.__SendDropItemPacket(dropNumber, dropCount, player.SLOT_TYPE_SKILL_BOOK_INVENTORY or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY or player.SLOT_TYPE_STONE_INVENTORY or player.SLOT_TYPE_BOX_INVENTORY or player.SLOT_TYPE_EFSUN_INVENTORY or player.SLOT_TYPE_CICEK_INVENTORY)
self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
def RequestDestroyItem(self, answer):
if not self.itemDropQuestionDialog:
return
if answer:
dropType = self.itemDropQuestionDialog.dropType
dropCount = self.itemDropQuestionDialog.dropCount
dropNumber = self.itemDropQuestionDialog.dropNumber
if player.SLOT_TYPE_INVENTORY == dropType or\
(player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or\
player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or\
player.SLOT_TYPE_STONE_INVENTORY == dropType or\
player.SLOT_TYPE_BOX_INVENTORY == dropType or\
player.SLOT_TYPE_EFSUN_INVENTORY == dropType or\
player.SLOT_TYPE_CICEK_INVENTORY == dropType and app.ENABLE_SPLIT_INVENTORY_SYSTEM):
if dropNumber == player.ITEM_MONEY:
return
else:
self.__SendDestroyItemPacket(dropNumber)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
self.__SendSellItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
def RequestSellItem(self, answer):
if not self.itemDropQuestionDialog:
return
if answer:
dropType = self.itemDropQuestionDialog.dropType
dropCount = self.itemDropQuestionDialog.dropCount
dropNumber = self.itemDropQuestionDialog.dropNumber
if player.SLOT_TYPE_INVENTORY == dropType or player.SLOT_TYPE_SKILL_BOOK_INVENTORY == dropType or player.SLOT_TYPE_UPGRADE_ITEMS_INVENTORY == dropType or player.SLOT_TYPE_STONE_INVENTORY == dropType or player.SLOT_TYPE_BOX_INVENTORY == dropType or player.SLOT_TYPE_EFSUN_INVENTORY == dropType or player.SLOT_TYPE_CICEK_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
return
else:
self.__SendSellItemPacket(dropNumber)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
self.__SendSellItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
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
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
if uiOfflineShopBuilder.IsBuildingOfflineShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if uiOfflineShop.IsEditingOfflineShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
def __SendDestroyItemPacket(self, itemVNum, itemInvenType = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
if uiOfflineShopBuilder.IsBuildingOfflineShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
if uiOfflineShop.IsEditingOfflineShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
net.SendItemDestroyPacket(itemVNum)
def __SendSellItemPacket(self, itemVNum, itemInvenTyoe = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
net.SendItemSellPacket(itemVNum)
def OnMouseRightButtonDown(self):
self.CheckFocus()
if TRUE == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()
else:
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)
return TRUE
def OnMouseRightButtonUp(self):
if TRUE == mouseModule.mouseController.isAttached():
return TRUE
player.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
return TRUE
def OnMouseMiddleButtonDown(self):
player.SetMouseMiddleButtonState(player.MBS_PRESS)
def OnMouseMiddleButtonUp(self):
player.SetMouseMiddleButtonState(player.MBS_CLICK)
def OnUpdate(self):
app.UpdateGame()
if self.mapNameShower.IsShow():
self.mapNameShower.Update()
if self.isShowDebugInfo:
self.UpdateDebugInfo()
if self.enableXMasBoom:
self.__XMasBoom_Update()
if app.ENABLE_SOUL_ROULETTE_SYSTEM:
if self.enableXMasSoul:
self.__XMasSoul_Update()
if 1 == constInfo.AUTO_PICK_UP:
self.PickUpItem()
if 1 == constInfo.DRAGON_SOULD_REFINE_OPEN:
constInfo.DRAGON_SOULD_REFINE_OPEN = 0
self.BINARY_DragonSoulRefineWindow_Open()
if app.ENABLE_BOSS_TRACKING:
if 1== constInfo.BOSS_TRACKING:
constInfo.BOSS_TRACKING = 0
self.OpenBossTracking()
if app.ENABLE_PREMIUM_AFFECT_SYSTEM:
if systemSetting.IsEnablePremiumAffect():
self.affectShower.Show()
else:
self.affectShower.Hide()
def UpdateDebugInfo(self):
(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
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
if app.ENABLE_GRAPHIC_NAME:
# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
if self.__IsShowNameItem():
textTail.ShowJustItemTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAME
else:
# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAME
if app.ENABLE_GRAPHIC_ON_OFF:
if systemSetting.IsShowSalesText():
uiPrivateShopBuilder.UpdateADBoard()
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
uiOfflineShopBuilder.UpdateADBoard()
textTail.UpdateShowingTextTail()
textTail.ArrangeTextTail()
if -1 != self.PickingItemIndex:
textTail.SelectItemName(self.PickingItemIndex)
grp.PopState()
grp.SetInterfaceRenderState()
textTail.Render()
textTail.HideAllTextTail()
def OnPressEscapeKey(self):
if app.TARGET == app.GetCursor():
app.SetCursor(app.NORMAL)
elif TRUE == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()
else:
self.interface.OpenSystemDialog()
return TRUE
def OnIMEReturn(self):
if app.IsPressed(app.DIK_LSHIFT):
self.interface.OpenWhisperDialogWithoutTarget()
else:
self.interface.ToggleChat()
return TRUE
def OnPressExitKey(self):
self.interface.ToggleSystemDialog()
return TRUE
## BINARY CALLBACK
######################################################################################
# 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.SetText1(msg)
confirmDialog.Open(timeout)
confirmDialog.SetAcceptEvent(lambda answer=True, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
confirmDialog.SetCancelEvent(lambda answer=False, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
self.confirmDialog = confirmDialog
# END_OF_QUEST_CONFIRM
# GIFT command
def Gift_Show(self):
self.interface.ShowGift()
# CUBE
def BINARY_Cube_Open(self, npcVNUM):
self.currentCubeNPC = npcVNUM
self.interface.OpenCubeWindow()
if npcVNUM not in self.cubeInformation:
net.SendChatPacket("/cube r_info")
else:
cubeInfoList = self.cubeInformation[npcVNUM]
i = 0
for cubeInfo in cubeInfoList:
self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"])
j = 0
for materialList in cubeInfo["materialList"]:
for materialInfo in materialList:
itemVnum, itemCount, percent = materialInfo
self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount, percent)
j = j + 1
i = i + 1
self.interface.wndCube.Refresh()
def BINARY_Cube_Close(self):
self.interface.CloseCubeWindow()
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):
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):
net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount))
if 0 < 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):
try:
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"]
percent = 0
gold = 0
splitResult = eachResultText.split("]")
if 1 < len(splitResult):
new_gold = str(splitResult[1]).split("/")
new_gold2 = str(new_gold[0]).split("/")
gold = int(new_gold2[0])
percent = int(splitResult[1])
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)
count_test = str(itemCount).split("/")
itemCount = int(count_test[0])
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount, percent)
materialList[i].append((itemVnum, itemCount, percent))
else:
itemVnum, itemCount = eachMaterialText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount, percent)
materialList[i].append((itemVnum, itemCount,percent))
i = i + 1
itemIndex = itemIndex + 1
self.interface.wndCube.Refresh()
except RuntimeError, msg:
dbg.TraceError(msg)
return 0
pass
# END_OF_CUBE
def BINARY_AttrTransfer_Open(self):
self.interface.OpenAttrTransferWindow()
def BINARY_AttrTransfer_Close(self):
self.interface.CloseAttrTransferWindow()
def BINARY_AttrTransfer_Success(self):
self.interface.AttrTransferSuccess()
def BINARY_Highlight_Item(self, inven_type, inven_pos):
if self.interface:
self.interface.Highligt_Item(inven_type, inven_pos)
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
## OfflineShop
if app.ENABLE_CHEQUE_SYSTEM:
def __CashOfflineShop_Open(self):
self.interface.OpenOfflineShopInputNameDialog(True)
def __OfflineShop_Open(self):
self.interface.OpenOfflineShopInputNameDialog(False)
else:
def __OfflineShop_Open(self):
self.interface.OpenOfflineShopInputNameDialog()
def __OpenOfflineShopSalesWindow(self):
self.interface.OpenOfflineShopSalesWindow()
def __ClearOfflineShopSalesWindow(self):
constInfo_new.OFFLINE_SHOP_SALES = []
def BINARY_OfflineShop_Appear(self, vid, text):
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
self.interface.AppearOfflineShop(vid, text)
def BINARY_OfflineShop_Disappear(self, vid):
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_NPC):
self.interface.DisappearOfflineShop(vid)
def BINARY_OfflineShop_Count(self, count):
pass
def BINARY_OfflineShop_Open(self, isOpen, mapIndex, time):
self.interface.ToggleOfflineShopAdminPanelWindow(isOpen, mapIndex, time)
def BINARY_OfflineShop_Sales(self, buyerName, itemVnum, itemCount, itemPrice, itemCheque, itemDate):
constInfo_new.OFFLINE_SHOP_SALES.append([buyerName, itemVnum, itemCount, itemPrice, itemCheque, itemDate],)
if app.ENABLE_MINI_GAME_OKEY:
## MiniGame Rumi
def BINARY_Cards_UpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points):
self.interface.UpdateCardsInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points)
def BINARY_Cards_FieldUpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):
self.interface.UpdateCardsFieldInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)
def BINARY_Cards_PutReward(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):
self.interface.CardsPutReward(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)
def BINARY_Cards_ShowIcon(self):
self.interface.CardsShowIcon()
def BINARY_Cards_Open(self, safemode):
self.interface.OpenCardsWindow(safemode)
def BINARY_DragonSoulGiveQuilification(self):
self.interface.DragonSoulGiveQuilification()
def BINARY_DragonSoulRefineWindow_Open(self):
self.interface.OpenDragonSoulRefineWindow()
def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos):
self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)
def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)
# END of DRAGON SOUL REFINE WINDOW
def BINARY_DungeonInfo_Open(self):
self.interface.ToggleDungeonInfoWindow()
def BINARY_SetBigMessage(self, message):
self.interface.bigBoard.SetTip(message)
def BINARY_SetTipMessage(self, message):
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])
if app.ENABLE_12ZI:
def BINARY_SetMissionMessage(self, message):
self.interface.missionBoard.SetMission(message)
def BINARY_SetSubMissionMessage(self, message):
self.interface.missionBoard.SetSubMission(message)
def BINARY_CleanMissionMessage(self):
self.interface.missionBoard.CleanMission()
if app.ENABLE_OX_RENEWAL:
def BINARY_SetBigControlMessage(self, message):
self.interface.bigBoardControl.SetTip(message)
def BINARY_Guild_EnterGuildArea(self, areaID):
self.interface.BULID_EnterGuildArea(areaID)
def BINARY_Guild_ExitGuildArea(self, areaID):
self.interface.BULID_ExitGuildArea(areaID)
def BINARY_GuildWar_OnSendDeclare(self, guildID):
pass
def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):
mainCharacterName = player.GetMainCharacterName()
masterName = guild.GetGuildMasterName()
if mainCharacterName == masterName:
self.__GuildWar_OpenAskDialog(guildID, warType)
def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):
self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)
def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):
self.interface.OnStartGuildWar(guildSelf, guildOpp)
def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):
self.interface.OnEndGuildWar(guildSelf, guildOpp)
def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):
self.interface.BINARY_SetObserverMode(isEnable)
def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):
self.interface.wndMiniMap.UpdateObserverCount(observerCount)
def __GuildWar_UpdateMemberCount(self, guildID1, memberCount1, guildID2, memberCount2, observerCount):
guildID1 = int(guildID1)
guildID2 = int(guildID2)
memberCount1 = int(memberCount1)
memberCount2 = int(memberCount2)
observerCount = int(observerCount)
self.interface.UpdateMemberCount(guildID1, memberCount1, guildID2, memberCount2)
self.interface.wndMiniMap.UpdateObserverCount(observerCount)
def __GuildWar_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
######################################################################################
def __ServerCommand_Build(self):
serverCommandList={
"ConsoleEnable" : self.__Console_Enable,
"DayMode" : self.__DayMode_Update,
"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,
"CloseRestartWindow" : self.__RestartDialog_Close,
"OpenPrivateShop" : self.__PrivateShop_Open,
"PartyHealReady" : self.PartyHealReady,
"ShowMeSafeboxPassword" : self.AskSafeboxPassword,
"CloseSafebox" : self.CommandCloseSafebox,
"CloseMall" : self.CommandCloseMall,
"ShowMeMallPassword" : self.AskMallPassword,
"item_mall" : self.__ItemMall_Open,
"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,
"TICKETS" : self.ManagerTickets,
# WEDDING
"lover_login" : self.__LoginLover,
"lover_logout" : self.__LogoutLover,
"lover_near" : self.__LoverNear,
"lover_far" : self.__LoverFar,
"lover_divorce" : self.__LoverDivorce,
"PlayMusic" : self.__PlayMusic,
# END_OF_WEDDING
"AttrTransferMessage" : self.AttrTransferMessage,
# PRIVATE_SHOP_PRICE_LIST
"MyShopPriceList" : self.__PrivateShop_PriceList,
# END_OF_PRIVATE_SHOP_PRICE_LIST
"MakeVisibleOX" : self.MakeVisibleOX,
"RemoveTitleOX" : self.RemoveTitleOX,
"Update" : self.Update,
"getinputbegin" : self.__Inputget1,
"getinputend" : self.__Inputget2,
"getinputbegin" : self.__Inputget1,
"getinputend" : self.__Inputget2,
"getinput" : self.__Inputget3,
"GetInputStringStart" : self.GetInputStringStart,
"GetInputStringEnd" : self.GetInputStringEnd,
}
if app.ENABLE_SKILL_SELECT_SYSTEM:
serverCommandList.update({"OpenBec1Gui" : self.__BecSystem1 })
serverCommandList.update({"OpenBec2Gui" : self.__BecSystem3 })
serverCommandList.update({"OpenBec3Gui" : self.__BecSystem2 })
serverCommandList.update({"OpenBec4Gui" : self.__BecSystem4 })
serverCommandList.update({"OpenBec5Gui" : self.__BecSystem5 })
serverCommandList.update({"zihinsel_oto_bec" : self.zihinsel_oto_bec })
serverCommandList.update({"bedensel_oto_bec" : self.bedensel_oto_bec })
serverCommandList.update({"karabuyu_oto_bec" : self.karabuyu_oto_bec })
serverCommandList.update({"buyulusilah_oto_bec" : self.buyulusilah_oto_bec })
serverCommandList.update({"yakin_oto_bec" : self.yakin_oto_bec })
serverCommandList.update({"uzak_oto_bec" : self.uzak_oto_bec })
serverCommandList.update({"ejderha_oto_bec" : self.ejderha_oto_bec })
serverCommandList.update({"iyilestirme_oto_bec" : self.iyilestirme_oto_bec })
serverCommandList.update({"lycany_oto_bec" : self.lycany_oto_bec })
if app.ENABLE_CONQUEROR_LEVEL:
serverCommandList.update({"ConquerorMap187" : self.ConquerorMap187 })
serverCommandList.update({"ConquerorMap190" : self.ConquerorMap190 })
if app.ENABLE_ADMIN_BAN_MANAGER:
serverCommandList.update({"OpenAdminTool" : self.OpenAdminTool })
if app.ENABLE_WHISPER_ADMIN_SYSTEM:
serverCommandList.update({"OpenWhisperTool" : self.OpenWhisperSystem })
if app.ENABLE_PACKET_INFO_SYSTEM:
serverCommandList.update({"switch_bot_message" : self.SwitchBotMessage })
serverCommandList.update({"battle_pass_finish_mission" : self.BattlePassMessage })
serverCommandList.update({"battle_pass_finish_full_mission" : self.BattlePassMessageFull })
if app.ENABLE_SOUL_ROULETTE_SYSTEM:
serverCommandList["xmas_soul"] = self.__XMasSoul_Enable
if app.ENABLE_STONE_EVENT:
serverCommandList["IsStoneEvent"] = self.StoneEvent
if app.ENABLE_SOCCER_BALL_EVENT:
serverCommandList["FutbolEventGui"] = self.FutbolTopuVer
if app.ENABLE_WORD_GAME_EVENT:
serverCommandList["KelimeEventGui"] = self.WordGameWindowShow
if app.ENABLE_DUNGEON_INFO_SYSTEM:
serverCommandList.update({"DungeonInfo" : self.DungeonInfo })
serverCommandList.update({"CleanDungeonInfo" : self.CleanDungeonInfo })
serverCommandList.update({"CleanDungeonRanking" : self.CleanDungeonRanking })
serverCommandList.update({"GetDungeonInfo" : self.GetDungeonInfo })
serverCommandList.update({"UpdateDungeonInfo" : self.UpdateDungeonInfo })
serverCommandList.update({"UpdateDungeonRanking" : self.UpdateDungeonRanking })
serverCommandList.update({"UpdateMyDungeonRanking" : self.UpdateMyDungeonRanking })
serverCommandList.update({"OpenDungeonRanking" : self.OpenDungeonRanking })
if app.ENABLE_AUTO_HUNT_SYSTEM:
serverCommandList.update({"OtomatikAvWindow" : self.__otomatikavstart })
if app.ENABLE_HALLOWEEN_EVENT_SYSTEM:
serverCommandList["halloween_rewards"] = self.SHalounRewards
serverCommandList["level_halloween"] = self.SHalounLevel
serverCommandList["points_halloween"] = self.SPointsHaloun
serverCommandList["eveniment_haloun"] = self.SHalloweenStatus
if app.ENABLE_SPIRIT_STONE_READING:
serverCommandList["ruhtasiekranac"] = self.ruhcac
if app.ENABLE_SKILL_BOOK_READING:
serverCommandList["bkekranac"] = self.bkac
if app.ENABLE_VIEW_EQUIPMENT_SYSTEM:
serverCommandList["ViewEquipRequest"] = self.ViewEquipRequest
serverCommandList["ViewEquipRequestDenied"] = self.ViewEquipRequestDenied
if app.ENABLE_EXPRESSING_EMOTION:
serverCommandList["RegisterSpecialEmotion"] = self.RegisterSpecialEmotion
serverCommandList["ClearSpecialEmotions"] = self.ClearSpecialEmotions
if app.ENABLE_SPLIT_INVENTORY_SYSTEM:
serverCommandList.update({"OpenSpecialInventoryWindow" : self.OpenSpecialInventoryWindow })
if app.ENABLE_WHISPER_ADMIN_SYSTEM:
serverCommandList["OnRecvWhisperAdminSystem"] = self.OnRecvWhisperAdminSystem
if app.ENABLE_ATTR_6TH_7TH_SYSTEM:
serverCommandList["attr_6th_7th"] = self.attr_6th_7th
serverCommandList["Attr67Add"] = self.Attr67Add
if app.ENABLE_SOUL_SYSTEM:
serverCommandList["RefineSoulSuceeded"] = self.__RefineSoulSuceededMessage
serverCommandList["RefineSoulFailed"] = self.__RefineSoulFailedMessage
if app.ENABLE_12ZI:
serverCommandList.update({"OpenUI12zi" : self.__Refresh12ziTimer2 })
serverCommandList.update({"NextFloorButton" : self.Show12ziJumpButton })
if app.ENABLE_GAYA_SYSTEM:
serverCommandList.update({"OpenGuiGem" : self.OpenGuiGem })
serverCommandList.update({"GemCheck" : self.GemCheck })
serverCommandList.update({"OpenGuiGemMarket" : self.OpenGuiGemMarket })
serverCommandList.update({"GemMarketSlotsDesblock" : self.GemMarketSlotsDesblock })
serverCommandList.update({"GemMarketItems" : self.GemMarketItems })
serverCommandList.update({"GemMarketClear" : self.GemMarketClear })
serverCommandList.update({"GemMarketTime" : self.GemTimeMarket })
if app.ENABLE_LUCKY_BOX:
serverCommandList["OpenLuckyBox"] = self.OpenLuckyBox
serverCommandList["CloseLuckyBox"] = self.CloseLuckyBox
if app.ENABLE_DS_CHANGE_ATTR:
serverCommandList.update({"DS_ChangeAttr_Success" : self.DS_ChangeAttr_Success })
serverCommandList.update({"DS_ChangeAttr_Failed" : self.DS_ChangeAttr_Success })
if app.ENABLE_BIO_SYSTEM:
serverCommandList["biyologlvl"] = self.BiyologLvBildirim
serverCommandList["biyolog_update"] = self.__BiyologMission
serverCommandList["biyolog_open"] = self.BiyologOpen
if app.ENABLE_MAIL_BOX_SYSTEM:
serverCommandList.update({"MailBoxRefresh" : self.MailBoxRefresh })
serverCommandList.update({"MailBoxOpen" : self.MailBoxOpen })
serverCommandList.update({"MailBoxMini" : self.MailBoxMiniMap })
if app.ENABLE_OFFLINE_PRIVATE_SHOP_SYSTEM:
serverCommandList.update({"OpenOfflineShop" : self.__OfflineShop_Open })
serverCommandList.update({"OpenOfflineShopSalesWindow" : self.__OpenOfflineShopSalesWindow })
serverCommandList.update({"ClearOfflineShopSales" : self.__ClearOfflineShopSalesWindow })
if app.ENABLE_HIDRA_DUNGEON_RELEASE:
serverCommandList["BINARY_Update_Mast_HP"] = self.BINARY_Update_Mast_HP
serverCommandList["BINARY_Update_Mast_Window"] = self.BINARY_Update_Mast_Window
if app.ENABLE_CHEQUE_COUPON_SYSTEM:
serverCommandList["OpenChequeTicket"] = self.__OpenChequeTicket
if app.ENABLE_GAYA_TICKET_SYSTEM:
serverCommandList["OpenGemTicket"] = self.__OpenGemTicket
if app.ENABLE_HIDE_COSTUME_SYSTEM:
serverCommandList.update({"SetBodyCostumeHidden" : self.SetBodyCostumeHidden })
serverCommandList.update({"SetHairCostumeHidden" : self.SetHairCostumeHidden })
serverCommandList.update({"SetSashCostumeHidden" : self.SetSashCostumeHidden })
serverCommandList.update({"SetWeaponCostumeHidden" : self.SetWeaponCostumeHidden })
serverCommandList.update({"SetAuraCostumeHidden" : self.SetAuraCostumeHidden })
if app.ENABLE_MELEY_LAIR_DUNGEON:
serverCommandList.update({"ClearDragonLairRanking" : self.ClearDragonLairRanking })
serverCommandList.update({"OpenDragonLairRanking" : self.OpenDragonLairRanking })
serverCommandList.update({"AddDragonLairRanking" : self.AddDragonLairRanking })
if app.ENABLE_NEW_PET_SYSTEM:
serverCommandList.update({"PetEvolution" : self.SetPetEvolution })
serverCommandList.update({"PetName" : self.SetPetName })
serverCommandList.update({"PetLevel" : self.SetPetLevel })
serverCommandList.update({"PetAgeDuration" : self.SetPetAgeDuration })
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_PET_ATTR_DETERMINE:
serverCommandList["OnResultPetAttrDetermine"] = self.__OnResultPetAttrDetermine
serverCommandList["OnResultPetAttrChange"] = self.__OnResultPetAttrChange
self.serverCommander=stringCommander.Analyzer()
for serverCommandItem in serverCommandList.items():
self.serverCommander.SAFE_RegisterCallBack(
serverCommandItem[0], serverCommandItem[1]
)
if app.ENABLE_EXPRESSING_EMOTION:
def ClearSpecialEmotions(self):
constInfo_new.SPECIAL_EMOTIONS = []
constInfo_new.SPECIAL_EMOTIONS_TIME = []
self.interface.ClearSpecialEmotions()
def RegisterSpecialEmotion(self, emotionIdx, leftTime):
SPECIAL_EMOTIONS = constInfo_new.SPECIAL_EMOTIONS
SPECIAL_EMOTIONS_TIME = constInfo_new.SPECIAL_EMOTIONS_TIME
emotionIdx, leftTime = int(emotionIdx), int(leftTime)
if not emotionIdx in SPECIAL_EMOTIONS:
if len(SPECIAL_EMOTIONS) < 12:
SPECIAL_EMOTIONS.append(emotionIdx)
SPECIAL_EMOTIONS_TIME.append(leftTime)
self.interface.RegisterSpecialEmotions()
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OPEN_THE_SPECIAL_ACTION_KIT % constInfo_new.GET_SPECIAL_EMOTION_NAME(emotionIdx))
if app.ENABLE_STONE_POINT_SYSTEM:
def OnPickStonePoint(self, stone):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.STONE_POINT_SYSTEM_PICK_STONE_POINT % (stone))
if app.ENABLE_GAYA_SYSTEM:
def OnPickGem(self, gem):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GEM_SYSTEM_PICK_GEM % (gem))
def OpenGuiGem(self):
self.interface.OpenGuiGem()
def GemCheck(self):
self.interface.GemCheck()
def OpenGuiGemMarket(self):
self.interface.OpenGuiGemMarket()
def GemMarketItems(self, vnums, gem, count):
self.interface.GemMarketItems(vnums, gem, count)
def GemMarketSlotsDesblock(self, slot0, slot1, slot2, slot3, slot4, slot5):
self.interface.GemMarketSlotsDesblock(slot0, slot1, slot2, slot3, slot4, slot5)
def GemMarketClear(self):
self.interface.GemMarketClear()
def GemTimeMarket(self, time):
self.interface.GemTime(time)
if app.ENABLE_SPLIT_INVENTORY_SYSTEM:
def OpenSpecialInventoryWindow(self, category):
self.interface.OpenSpecialInventoryWindow(int(category))
if app.ENABLE_SOUL_SYSTEM:
def __RefineSoulSuceededMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.SOUL_REFINE_SUCCESS)
def __RefineSoulFailedMessage(self):
snd.PlaySound("sound/ui/jaeryun_fail.wav")
self.PopupMessage(localeInfo.SOUL_REFINE_FAILURE)
def 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 __Inputget1(self):
constInfo.INPUT_IGNORE = 1
def __Inputget2(self):
constInfo.INPUT_IGNORE = 0
def __Inputget3(self):
net.SendQuestInputStringPacket("1")
def GetInputStringStart(self):
constInfo.INPUT_IGNORE = 1
def GetInputStringEnd(self):
constInfo.INPUT_IGNORE = 0
def PartyHealReady(self):
self.interface.PartyHealReady()
def AskSafeboxPassword(self):
self.interface.AskSafeboxPassword()
# ITEM_MALL
def AskMallPassword(self):
self.interface.AskMallPassword()
def __ItemMall_Open(self):
self.interface.OpenItemMall();
def CommandCloseMall(self):
self.interface.CommandCloseMall()
# END_OF_ITEM_MALL
def AttrTransferMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.COMB_ALERT)
def RefineSuceededMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.REFINE_SUCCESS)
if app.ENABLE_REFINE_RENEWAL:
self.interface.CheckRefineDialog(False)
def RefineFailedMessage(self):
snd.PlaySound("sound/ui/jaeryun_fail.wav")
self.PopupMessage(localeInfo.REFINE_FAILURE)
if app.ENABLE_REFINE_RENEWAL:
self.interface.CheckRefineDialog(True)
def CommandCloseSafebox(self):
self.interface.CommandCloseSafebox()
# PRIVATE_SHOP_PRICE_LIST
if app.ENABLE_CHEQUE_SYSTEM:
def __PrivateShop_PriceList(self, itemVNum, itemPrice, itemPriceCheque):
uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice, itemPriceCheque)
else:
def __PrivateShop_PriceList(self, itemVNum, itemPrice):
uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice)
# END_OF_PRIVATE_SHOP_PRICE_LIST
if app.ENABLE_NEW_PET_SYSTEM:
def SetPetEvolution(self, evo):
petname = ["Genc", "Vahsi", "Cesur", "Kahraman"]
self.petmain.SetEvolveName(petname[int(evo)])
def SetPetName(self, name):
if len(name) > 1 and name != "":
self.petmini.Show()
self.petmain.SetName(name)
def SetPetLevel(self, level):
self.petmain.SetLevel(level)
def SetPetDuration(self, dur, durt):
if int(durt) > 0:
self.petmini.SetDuration(dur, durt)
self.petmain.SetDuration(dur, durt)
def SetPetAgeDuration(self, age):
if (int(age)) > 0:
self.petmain.SetAgeDuration(age)
def SetPetBonus(self, hp, dif, sp):
self.petmain.SetHp(hp)
self.petmain.SetDef(dif)
self.petmain.SetSp(sp)
def SetPetskill(self, slot, idx, lv):
if int(lv) > 0:
self.petmini.SetSkill(slot, idx, lv)
self.petmain.SetSkill(slot, idx, lv)
self.affectShower.BINARY_NEW_AddAffect(5400+int(idx),int(constInfo.LASTAFFECT_POINT)+1,int(constInfo.LASTAFFECT_VALUE)+1, 0)
if int(slot)==0:
constInfo.SKILL_PET1=5400+int(idx)
if int(slot)==1:
constInfo.SKILL_PET2=5400+int(idx)
if int(slot)==2:
constInfo.SKILL_PET3=5400+int(idx)
def SetPetIcon(self, vnum):
if int(vnum) > 0:
self.petmini.SetImageSlot(vnum)
self.petmain.SetImageSlot(vnum)
def SetPetExp(self, exp, expi, exptot):
if int(exptot) > 0:
self.petmini.SetExperience(exp, expi, exptot)
self.petmain.SetExperience(exp, expi, exptot)
def PetUnsummon(self):
self.petmini.SetDefaultInfo()
self.petmini.Close()
self.petmain.SetDefaultInfo()
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET1),0)
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET2),0)
self.affectShower.BINARY_NEW_RemoveAffect(int(constInfo.SKILL_PET3),0)
constInfo.SKILL_PET1 = 0
constInfo.SKILL_PET2 = 0
constInfo.SKILL_PET3 = 0
def OpenPetMainGui(self):
if self.petmain.IsShow() == True:
self.petmain.Close()
else:
self.petmain.Show()
self.petmain.SetTop()
def OpenPetIncubator(self, pet_new = 0):
import uipetincubatrice
self.petinc = uipetincubatrice.PetSystemIncubator(pet_new)
self.petinc.Show()
self.petinc.SetTop()
def OpenPetMini(self):
self.petmini.Show()
self.petmini.SetTop()
def OpenPetFeed(self):
import uipetfeed
self.feedwind = uipetfeed.PetFeedWindow()
self.feedwind.Show()
self.feedwind.SetTop()
if (app.ENABLE_PET_ATTR_DETERMINE):
def __OnResultPetAttrDetermine(self, pet_type):
self.petmain.OnResultPetAttrDetermine(int(pet_type))
def __OnResultPetAttrChange(self, pet_type):
self.petmain.OnResultPetAttrChange(int(pet_type))
def Gift_Show(self):
if constInfo.PET_MAIN == 0:
self.petmain.Show()
constInfo.PET_MAIN =1
self.petmain.SetTop()
else:
self.petmain.Hide()
constInfo.PET_MAIN =0
if app.ENABLE_CONQUEROR_LEVEL:
def ConquerorMap187(self):
self.affectShower.SetConqueror_187()
def ConquerorMap190(self):
self.affectShower.SetConqueror_190()
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 app.ENABLE_ENVIRONMENT_EFFECT_OPTION:
# background.SetXMasShowEvent(1)
if not self.__IsXMasMap():
return
print "XMAS_SNOW ON"
background.EnableSnow(1)
else:
#if app.ENABLE_ENVIRONMENT_EFFECT_OPTION:
# background.SetXMasShowEvent(0)
print "XMAS_SNOW OFF"
background.EnableSnow(0)
def __XMasBoom_Enable(self, mode):
if "1" == mode:
if app.ENABLE_ENVIRONMENT_EFFECT_OPTION:
#if not background.IsBoomMap():
# return
if not self.__IsXMasMap():
return
else:
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))
if app.ENABLE_DS_CHANGE_ATTR:
def DS_ChangeAttr_Success(self):
self.interface.DS_AttrSuccess()
def DS_ChangeAttr_Failed(self):
self.interface.DS_AttrFailed()
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)
if app.ENABLE_SOUL_ROULETTE_SYSTEM:
def __XMasSoul_Enable(self, mode):
if "1" == mode:
if not self.__IsXMasMap():
return
print "XMAS_SOUL ON"
self.__DayMode_Update("red")
self.enableXMasSoul = True
self.startTimeXMasSoul = app.GetTime()
else:
print "XMAS_SOUL OFF"
self.__DayMode_Update("light")
self.enableXMasSoul = False
def __RestartDialog_Close(self):
self.interface.CloseRestartDialog()
if app.ENABLE_AUTO_HUNT_SYSTEM:
def __otomatikavstart(self):
constInfo_new.StartHunt = 1
def __Console_Enable(self):
constInfo.CONSOLE_ENABLE = TRUE
self.consoleEnable = TRUE
app.EnableSpecialCameraMode()
ui.EnablePaste(TRUE)
## PrivateShop
def __PrivateShop_Open(self):
self.interface.OpenPrivateShopInputNameDialog()
def BINARY_PrivateShop_Appear(self, vid, text):
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):
self.interface.AppearPrivateShop(vid, text)
def BINARY_PrivateShop_Disappear(self, vid):
if (chr.GetInstanceType(vid) == chr.INSTANCE_TYPE_PLAYER):
self.interface.DisappearPrivateShop(vid)
## DayMode
def __PRESERVE_DayMode_Update(self, mode):
if "light" == mode:
if app.ENABLE_12ZI:
if not self.__IsXMasMap():
return
background.SetEnvironmentData(0)
else:
background.SetEnvironmentData(0)
elif "dark" == mode:
if app.ENABLE_ENVIRONMENT_EFFECT_OPTION:
#if not background.IsBoomMap():
# return
if not self.__IsXMasMap():
return
else:
if not self.__IsXMasMap():
return
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)
def __DayMode_Update(self, mode):
if "light" == mode:
if app.ENABLE_12ZI:
if not self.__IsXMasMap():
return
self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)
elif "dark" == mode:
if app.ENABLE_ENVIRONMENT_EFFECT_OPTION:
#if not background.IsBoomMap():
# return
if not self.__IsXMasMap():
return
else:
if not self.__IsXMasMap():
return
self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToDark)
if app.ENABLE_SOUL_ROULETTE_SYSTEM:
if "red" == mode:
if not self.__IsXMasMap():
return
self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToRed)
def __DayMode_OnCompleteChangeToLight(self):
if app.ENABLE_12ZI:
background.SetEnvironmentData(0)
else:
background.SetEnvironmentData(0)
self.curtain.FadeIn()
def __DayMode_OnCompleteChangeToDark(self):
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
background.SetEnvironmentData(1)
self.curtain.FadeIn()
if app.ENABLE_SOUL_ROULETTE_SYSTEM:
def __DayMode_OnCompleteChangeToRed(self):
background.RegisterEnvironmentData(1, constInfo_new.ENVIRONMENT_RED)
background.SetEnvironmentData(1)
self.curtain.FadeIn()
if app.ENABLE_12ZI:
def BINARY_SetEnvironment(self, idx):
self.indexEnv = idx
self.curtain.SAFE_FadeOut(self.__SetEnvironment)
def __SetEnvironment(self):
background.SetEnvironmentData(self.indexEnv)
self.curtain.FadeIn()
## XMasBoom
def __XMasBoom_Update(self):
self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )
if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):
return
boomTime = self.BOOM_DATA_LIST[self.indexXMasBoom][0]
boomCount = self.BOOM_DATA_LIST[self.indexXMasBoom][1]
if app.GetTime() - self.startTimeXMasBoom > boomTime:
self.indexXMasBoom += 1
for i in xrange(boomCount):
self.__XMasBoom_Boom()
def __XMasBoom_Boom(self):
x, y, z = player.GetMainCharacterPosition()
randX = app.GetRandom(-150, 150)
randY = app.GetRandom(-150, 150)
snd.PlaySound3D(x+randX, -y+randY, z, "sound/common/etc/salute.mp3")
if app.ENABLE_SOUL_ROULETTE_SYSTEM:
def __XMasSoul_Update(self):
self.SOUL_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )
if self.indexXMasSoul >= len(self.SOUL_DATA_LIST):
return
soulTime = self.SOUL_DATA_LIST[self.indexXMasSoul][0]
soulCount = self.SOUL_DATA_LIST[self.indexXMasSoul][1]
if app.GetTime() - self.startTimeXMasSoul > soulTime:
self.indexXMasSoul += 1
for i in xrange(soulCount):
self.__XMasSoul_Soul()
def __XMasSoul_Soul(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")
if app.ENABLE_NEW_USER_CARE:
def __PartyRequestQuestion(self, vid, name):
vid = int(vid)
partyRequestQuestionDialog = uiCommon.QuestionDialogWithTimeLimit()
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(name + localeInfo.PARTY_DO_YOU_ACCEPT, 10)
partyRequestQuestionDialog.SetTimeOverMsg(localeInfo.PARTY_ANSWER_TIMEOVER)
partyRequestQuestionDialog.SetCancelOnTimeOver()
partyRequestQuestionDialog.vid = vid
self.partyRequestQuestionDialog = partyRequestQuestionDialog
else:
def __PartyRequestQuestion(self, vid):
vid = int(vid)
partyRequestQuestionDialog = uiCommon.QuestionDialog()
partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + localeInfo.PARTY_DO_YOU_ACCEPT)
partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
partyRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)
partyRequestQuestionDialog.SetAcceptEvent(lambda arg=True: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.SetCancelEvent(lambda arg=False: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.Open()
partyRequestQuestionDialog.vid = vid
self.partyRequestQuestionDialog = partyRequestQuestionDialog
def __AnswerPartyRequest(self, answer):
if not self.partyRequestQuestionDialog:
return
vid = self.partyRequestQuestionDialog.vid
if answer:
net.SendChatPacket("/party_request_accept " + str(vid))
else:
net.SendChatPacket("/party_request_deny " + str(vid))
self.partyRequestQuestionDialog.Close()
self.partyRequestQuestionDialog = None
def __PartyRequestDenied(self):
self.PopupMessage(localeInfo.PARTY_REQUEST_DENIED)
if (app.WJ_COMBAT_ZONE):
def BINARY_CombatZone_Manager(self, tokens, arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0):
if tokens == "OpenWindow":
self.wndCombatZone.Open(arg1, arg2, arg3, arg4)
elif tokens == "RegisterRank":
self.wndCombatZone.RegisterRanking()
elif tokens == "StartFlashing":
if self.interface:
self.interface.wndMiniMap.btnCombatZone.FlashEx()
elif tokens == "RefreshShop":
if self.interface:
self.interface.dlgShop.SetCombatZonePoints(arg1)
self.interface.dlgShop.SetLimitCombatZonePoints(arg2, arg3)
def __EnableTestServerFlag(self):
app.EnableTestServerFlag()
def __InGameShop_Show(self, url):
if constInfo.IN_GAME_SHOP_ENABLE:
constInfo.ItemShop['QCMD'] = 'OPEN_SHOP#'
event.QuestButtonClick(constInfo.ItemShop['QID'])
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()
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.SendQuestInputTicketLongStringPacket(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()
if app.ENABLE_OX_INVISIBILITY_SYSTEM:
def MakeVisibleOX(self):
chrmgr.ShowAllPlayers()
def RemoveTitleOX(self):
chrmgr.RemoveAllPlayersTitle()
# 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_ATTR_6TH_7TH_SYSTEM:
def attr_6th_7th(self):
self.interface.OpenAttr67AddDialog()
def Attr67Add(self):
self.wndPopupDialog = uiCommon.PopupDialog()
self.wndPopupDialog.SetText(localeInfo.ATTR_6TH_7TH_POSSIBILITY)
self.wndPopupDialog.Open()
if app.ENABLE_WHISPER_ADMIN_SYSTEM:
def OpenWhisperSystem(self):
if self.adminWhisperManager.IsShow():
self.adminWhisperManager.Hide()
else:
self.adminWhisperManager.Show()
def __LoverDivorce(self):
if self.interface.wndMessenger:
self.interface.wndMessenger.ClearLoverInfo()
if self.affectShower:
self.affectShower.ClearLoverState()
def __PlayMusic(self, flag, filename):
flag = int(flag)
if flag:
snd.FadeOutAllMusic()
musicInfo.SaveLastPlayFieldMusic()
snd.FadeInMusic("BGM/" + filename)
else:
snd.FadeOutAllMusic()
musicInfo.LoadLastPlayFieldMusic()
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
if app.ENABLE_HIDRA_DUNGEON_RELEASE:
def BINARY_Update_Mast_HP(self, hp):
self.interface.BINARY_Update_Mast_HP(int(hp))
def BINARY_Update_Mast_Window(self, i):
self.interface.BINARY_Update_Mast_Window(int(i))
def Update(self, ch):
import serverInfo
net.SetServerInfo("%s, CH%s" % (serverInfo.SERVER_NAME, str(ch)))
constInfo.ch = int(ch)
if app.ENABLE_BOSS_TRACKING:
def OpenBossTracking(self):
self.bosstracking.Open()
def CloseBossTracking(self):
self.bosstracking.__OnClose()
def BINARY_BOSS_TRACKING(self, kill_time, start_time, channel, mob_vnum, map_index):
self.bosstracking.SetData(kill_time, start_time, channel, mob_vnum, map_index)
if app.ENABLE_MINI_GAME_CATCH_KING:
def MiniGameCatchKingEvent(self, isEnable):
if self.interface:
self.interface.SetCatchKingEventStatus(isEnable)
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)
if app.ENABLE_ATTENDANCE_EVENT:
def MiniGameAttendanceEvent(self, isEnable):
if self.interface:
self.interface.SetAttendanceEventStatus(isEnable)
def MiniGameAttendanceSetData(self, type, value):
self.interface.MiniGameAttendanceSetData(type, value)
def RefreshHitCount(self, vid):
if vid == self.targetBoard.GetTargetVID():
self.targetBoard.RefreshHitCount(vid)
def OpenDragonLairRanking(self):
if self.interface:
self.interface.OpenDragonLairRanking()
def AddDragonLairRanking(self, data):
if self.interface:
line = int(data.split("#")[1])
name = str(data.split("#")[2])
empire = int(data.split("#")[3])
killcount = int(data.split("#")[4])
self.interface.AddDragonLairRanking(line, name, empire, killcount)
if app.ENABLE_MELEY_LAIR_DUNGEON:
def ClearDragonLairRanking(self, type):
if self.interface:
self.interface.ClearDragonLairRanking(int(type))
def OpenDragonLairRanking(self, type):
if self.interface:
self.interface.OpenDragonLairRanking(int(type))
def AddDragonLairRanking(self, type, data):
if self.interface:
line = int(data.split("#")[1])
guildname = str(data.split("#")[2])
membercount = int(data.split("#")[3])
sec = int(data.split("#")[4])
min = int(sec / 60)
sec %= 60
self.interface.AddDragonLairRanking(int(type), guildname, membercount, min, sec)
if app.ENABLE_FISH_EVENT_SYSTEM:
def MiniGameFishEvent(self, isEnable, lasUseCount):
if self.interface:
self.interface.SetFishEventStatus(isEnable)
self.interface.MiniGameFishCount(lasUseCount)
def MiniGameFishUse(self, shape, useCount):
self.interface.MiniGameFishUse(shape, useCount)
def MiniGameFishAdd(self, pos, shape):
self.interface.MiniGameFishAdd(pos, shape)
def MiniGameFishReward(self, vnum):
self.interface.MiniGameFishReward(vnum)
def AddRankMeleyRanking(self, data):
if self.interface:
line = int(data.split("#")[1])
name = str(data.split("#")[2])
members = int(data.split("#")[3])
seconds = int(data.split("#")[4])
minutes = seconds // 60
seconds %= 60
if seconds > 0:
time = localeInfo.TIME_MIN_SEC % (minutes, seconds)
else:
time = localeInfo.TIME_MIN % (minutes)
self.interface.RankMeleyRanking(line, name, members, time)
if app.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)
if app.ENABLE_CHANGELOOK_SYSTEM:
if app.ENABLE_MOUNT_CHANGELOOK_SYSTEM:
def ActChangeLook(self, iAct, bMount):
if self.interface:
self.interface.ActChangeLook(iAct, bMount)
else:
def ActChangeLook(self, iAct):
if self.interface:
self.interface.ActChangeLook(iAct)
def AlertChangeLook(self):
self.PopupMessage(localeInfo.CHANGE_LOOK_DEL_ITEM)
# END_OF_WEDDING
if app.ENABLE_TARGET_INFORMATION_SYSTEM:
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()
if app.ENABLE_SKILL_SELECT_SYSTEM:
def __BecSystem1(self):
self.black = uiskillselect.Savacci()
self.black.OpenWindow()
def __BecSystem2(self):
self.black = uiskillselect.Sura()
self.black.OpenWindow()
def __BecSystem3(self):
self.black = uiskillselect.Ninja()
self.black.OpenWindow()
def __BecSystem4(self):
self.black = uiskillselect.Shaman()
self.black.OpenWindow()
def __BecSystem5(self):
self.black = uiskillselect.Lycan()
self.black.OpenWindow()
def zihinsel_oto_bec(self,qid):
constInfo.zihinsel_oto_bec = int(qid)
def bedensel_oto_bec(self,qid):
constInfo.bedensel_oto_bec = int(qid)
def karabuyu_oto_bec(self,qid):
constInfo.karabuyu_oto_bec = int(qid)
def buyulusilah_oto_bec(self,qid):
constInfo.buyulusilah_oto_bec = int(qid)
def yakin_oto_bec(self,qid):
constInfo.yakin_oto_bec = int(qid)
def uzak_oto_bec(self,qid):
constInfo.uzak_oto_bec = int(qid)
def ejderha_oto_bec(self,qid):
constInfo.ejderha_oto_bec = int(qid)
def iyilestirme_oto_bec(self,qid):
constInfo.iyilestirme_oto_bec = int(qid)
def lycany_oto_bec(self,qid):
constInfo.lycany_oto_bec = int(qid)
def BINARY_OpenKeyboardSettings(self):
if self.dlgKeyboardSettings.IsShow():
self.dlgKeyboardSettings.Close()
else:
self.dlgKeyboardSettings.Open()
if app.ENABLE_MAIL_BOX_SYSTEM:
def BINARY_RecvMailBox(self, mail_id, sender_name, title, pos, type):
if self.interface:
self.interface.RecvMailBox(mail_id, sender_name, title, pos, type)
def BINARY_RecvMailBoxGold(self, mail_id, gold):
if self.interface:
self.interface.RecvMailBoxGold(mail_id, gold)
def BINARY_RecvMailBoxCheque(self, mail_id, cheque):
if self.interface:
self.interface.RecvMailBoxCheque(mail_id, cheque)
def BINARY_RecvMailBoxItem(self, mail_id, item_vnum, item_count, item_socket0, item_socket1, item_socket2, item_socket3, item_transmutation, item_attrtype0, item_attrvalue0, item_attrtype1, item_attrvalue1, item_attrtype2\
,item_attrvalue2, item_attrtype3, item_attrvalue3, item_attrtype4, item_attrvalue4, item_attrtype5, item_attrvalue5, item_attrtype6, item_attrvalue6, item_attrtype7, item_attrvalue7, item_attrtype8, item_attrvalue8\
,item_attrtype9, item_attrvalue9, item_attrtype10, item_attrvalue10, item_attrtype11, item_attrvalue11, item_attrtype12, item_attrvalue12, item_attrtype13, item_attrvalue13, item_attrtype14, item_attrvalue14):
if self.interface:
self.interface.RecvMailBoxItem(mail_id, item_vnum, item_count, item_socket0, item_socket1, item_socket2, item_socket3, item_transmutation, item_attrtype0, item_attrvalue0, item_attrtype1, item_attrvalue1, item_attrtype2, item_attrvalue2, item_attrtype3, item_attrvalue3, item_attrtype4, item_attrvalue4, item_attrtype5, item_attrvalue5, item_attrtype6, item_attrvalue6, item_attrtype7, item_attrvalue7, item_attrtype8, item_attrvalue8, item_attrtype9, item_attrvalue9, item_attrtype10, item_attrvalue10, item_attrtype11, item_attrvalue11, item_attrtype12, item_attrvalue12, item_attrtype13, item_attrvalue13, item_attrtype14, item_attrvalue14)
def MailBoxRefresh(self):
if self.interface:
self.interface.MailBoxRefresh()
def MailBoxOpen(self):
if app.GetTime() > self.MailBoxOpenT:
if self.interface:
self.interface.OpenmMailBox()
self.MailBoxOpenT = app.GetTime() + 10
else:
NewGetTime = self.MailBoxOpenT - app.GetTime()
chat.AppendChat(chat.CHAT_TYPE_INFO, "Tekrar a�abilmek i�in %d saniye beklemelisin." % (NewGetTime))
def MailBoxMiniMap(self, read, unread):
self.interface.SetMailBoxMiniMap(read, unread)
if app.ENABLE_SHOW_CHEST_DROP:
def BINARY_AddChestDropInfo(self, chestVnum, pageIndex, slotIndex, itemVnum, itemCount):
if self.interface:
self.interface.AddChestDropInfo(chestVnum, pageIndex, slotIndex, itemVnum, itemCount)
def BINARY_RefreshChestDropInfo(self, chestVnum):
if self.interface:
self.interface.RefreshChestDropInfo(chestVnum)
if app.ENABLE_DUNGEON_INFO_SYSTEM:
def DungeonInfo(self, questindex):
constInfo.dungeonData["quest_index"] = questindex
def CleanDungeonInfo(self):
constInfo.dungeonInfo = []
def CleanDungeonRanking(self):
constInfo.dungeonRanking["ranking_list"] = []
constInfo.dungeonRanking["my_ranking"] = []
def GetDungeonInfo(self, cmd):
cmd = cmd.split("#")
if cmd[0] == "INPUT":
constInfo.INPUT_IGNORE = int(cmd[1])
elif cmd[0] == "CMD":
net.SendQuestInputStringPacket(constInfo.dungeonData["quest_cmd"])
constInfo.dungeonData["quest_cmd"] = ""
else:
pass
def UpdateDungeonInfo(self, status, waitTime, type, organization, levelMinLimit, levelMaxLimit, partyMemberMinLimit, partyMemberMaxLimit, mapIndex, mapCoordX, mapCoordY, cooldown, duration, entranceMapIndex, strengthBonusName, resistanceBonusName, itemVnum, itemCount, finished, fastestTime, highestDamage):
status = int(status)
waitTime = int(waitTime)
type = int(type)
organization = int(organization)
levelMinLimit = int(levelMinLimit)
levelMaxLimit = int(levelMaxLimit)
partyMemberMinLimit = int(partyMemberMinLimit)
partyMemberMaxLimit = int(partyMemberMaxLimit)
mapIndex = int(mapIndex)
mapCoordX = int(mapCoordX)
mapCoordY = int(mapCoordY)
cooldown = int(cooldown)
duration = int(duration)
entranceMapIndex = int(entranceMapIndex)
strengthBonusName = str(strengthBonusName).replace("_", " ")
resistanceBonusName = str(resistanceBonusName).replace("_", " ")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
finished = int(finished)
fastestTime = int(fastestTime)
highestDamage = int(highestDamage)
constInfo.dungeonInfo.append(
{
"status" : status,
"wait_time" : waitTime,
"type" : type,
"organization" : organization,
"level_limit" : [levelMinLimit, levelMaxLimit],
"party_member_limit" : [partyMemberMinLimit, partyMemberMaxLimit],
"map_index" : mapIndex,
"map_coords" : [mapCoordX, mapCoordY],
"cooldown" : cooldown,
"duration" : duration,
"entrance_map_index" : entranceMapIndex,
"strength_bonus" : strengthBonusName,
"resistance_bonus" : resistanceBonusName,
"required_item" : [itemVnum, itemCount],
"finished" : finished,
"fastest_time" : fastestTime,
"highest_damage" : highestDamage,
},
)
def UpdateDungeonRanking(self, name, level, rankType):
name = str(name)
level = int(level)
rankType = int(rankType)
constInfo.dungeonRanking["ranking_list"].append([name, level, rankType],)
def UpdateMyDungeonRanking(self, position, name, level, rankType):
position = int(position)
name = str(name)
level = int(level)
rankType = int(rankType)
constInfo.dungeonRanking["my_ranking"].append([position, name, level, rankType],)
def OpenDungeonRanking(self):
import uiDungeonInfo
self.DungeonRank = uiDungeonInfo.DungeonRank()
self.DungeonRank.Open()
if app.ENABLE_HIDE_COSTUME_SYSTEM:
def SetBodyCostumeHidden(self, hidden):
constInfo_new.HIDDEN_BODY_COSTUME = int(hidden)
self.interface.RefreshVisibleCostume()
def SetHairCostumeHidden(self, hidden):
constInfo_new.HIDDEN_HAIR_COSTUME = int(hidden)
self.interface.RefreshVisibleCostume()
def SetSashCostumeHidden(self, hidden):
if app.ENABLE_SASH_SYSTEM:
constInfo_new.HIDDEN_SASH_COSTUME = int(hidden)
self.interface.RefreshVisibleCostume()
else:
pass
def SetWeaponCostumeHidden(self, hidden):
if app.ENABLE_COSTUME_WEAPON_SYSTEM:
constInfo_new.HIDDEN_WEAPON_COSTUME = int(hidden)
self.interface.RefreshVisibleCostume()
else:
pass
def SetAuraCostumeHidden(self, hidden):
if app.ENABLE_AURA_SYSTEM:
constInfo_new.HIDDEN_AURA_COSTUME = int(hidden)
self.interface.RefreshVisibleCostume()
else:
pass
if app.ENABLE_AURA_SYSTEM:
def ActAura(self, iAct, bWindow):
if self.interface:
self.interface.ActAura(iAct, bWindow)
def AlertAura(self, bWindow):
snd.PlaySound("sound/ui/make_soket.wav")
if app.ENABLE_CHEQUE_COUPON_SYSTEM:
def __OpenChequeTicket(self, itemPos):
self.interface.OpenChequeTicket(int(itemPos))
if app.ENABLE_GAYA_TICKET_SYSTEM:
def __OpenGemTicket(self, itemPos):
self.interface.OpenGemTicket(int(itemPos))
if app.ENABLE_BIO_SYSTEM:
def __BiyologMission(self, mission, missionState, givenCount, needCount, remainingTime):
self.interface.SetBiyologMission(mission, missionState, givenCount, needCount, remainingTime)
def BiyologOpen(self):
if self.interface:
self.interface.OpenBiyologDialog()
def BiyologLvBildirim(self, veri):
self.bildirim = uiCommon.Bildirim()
self.bildirim.SetUserName(str(veri) + localeInfo.BIYOLOG_BILDIRIM)
self.bildirim.SlideIn()
if app.ENABLE_HALLOWEEN_EVENT_SYSTEM:
def SHalounRewards(self, index, item_vnum, item_count):
constInfo_new.haloun_rewards[int(index)]={"iVnum":int(item_vnum),"iCount":int(item_count)}
def SHalounLevel(self, nivel):
constInfo_new.haloun_lvl = nivel
def SHalloweenStatus(self, status):
constInfo_new.IsHaloun = int(status)
def SPointsHaloun(self, points):
constInfo_new.haloun_points = points
if app.ENABLE_CUBE_RENEWAL:
def BINARY_CUBE_RENEWAL_OPEN(self):
if self.interface:
self.interface.BINARY_CUBE_RENEWAL_OPEN()
if app.ENABLE_PRIVATE_SHOP_SEARCH_SYSTEM:
def OpenPrivateShopSearch(self, type):
if self.interface:
self.interface.OpenPrivateShopSearch(type)
def RefreshShopSearch(self):
self.interface.RefreshShopSearch()
def BuyShopSearch(self):
self.interface.RefreshShopSearch()
if app.ENABLE_SWITCHBOT:
def RefreshSwitchbotWindow(self):
self.interface.RefreshSwitchbotWindow()
def RefreshSwitchbotItem(self, slot):
self.interface.RefreshSwitchbotItem(slot)
if app.ENABLE_PACKET_INFO_SYSTEM:
def SwitchBotMessage(self, count):
self.bildirim = uiCommon.Bildirim()
self.bildirim.SetUserName(item.GetItemName() + translate.BILDIRIM_1)
# self.bildirim.SetUserName (str(count) + translate.BILDIRIM_1)
self.bildirim.SlideIn()
def BattlePassMessage(self):
self.bildirim = uiCommon.Bildirim()
self.bildirim.SetUserName (translate.BILDIRIM_2)
self.bildirim.SlideIn()
def BattlePassMessageFull(self):
self.bildirim = uiCommon.Bildirim()
self.bildirim.SetUserName (translate.BILDIRIM_3)
self.bildirim.SlideIn()
if app.ENABLE_BATTLE_PASS:
def BINARY_BattlePassOpen(self):
if self.interface:
self.interface.OpenBattlePass()
def BINARY_BattlePassAddMission(self, missionType, missionInfo1, missionInfo2, missionInfo3):
if self.interface:
self.interface.AddBattlePassMission(missionType, missionInfo1, missionInfo2, missionInfo3)
def BINARY_BattlePassAddMissionReward(self, missionType, itemVnum, itemCount):
if self.interface:
self.interface.AddBattlePassMissionReward(missionType, itemVnum, itemCount)
def BINARY_BattlePassUpdate(self, missionType, newProgress):
if self.interface:
self.interface.UpdateBattlePassMission(missionType, newProgress)
def BINARY_BattlePassAddReward(self, itemVnum, itemCount):
if self.interface:
self.interface.AddBattlePassReward(itemVnum, itemCount)
def BINARY_BattlePassAddRanking(self, pos, playerName, finishTime):
if self.interface:
self.interface.AddBattlePassRanking(pos, playerName, finishTime)
def BINARY_BattlePassRefreshRanking(self):
if self.interface:
self.interface.RefreshBattlePassRanking()
def BINARY_BattlePassOpenRanking(self):
if self.interface:
self.interface.OpenBattlePassRanking()
if app.ENABLE_LUCKY_BOX:
def OpenLuckyBox(self, pos, itemVnum, trys, start_gold, reward_vnum):
self.uiLuckyBox = uiLuckyBox.LuckyBoxWindow()
self.uiLuckyBox.OpenLuckyBoxWindow(pos, itemVnum, trys, start_gold, reward_vnum)
def CloseLuckyBox(self):
self.uiLuckyBox = uiLuckyBox.LuckyBoxWindow()
self.uiLuckyBox.Close()
if app.ENABLE_SOUL_ROULETTE_SYSTEM:
def BINARY_ROULETTE_OPEN(self, price, soul):
if self.interface:
self.interface.Roulette_Open(price, soul)
def BINARY_ROULETTE_CLOSE(self):
if self.interface:
self.interface.Roulette_Close()
def BINARY_ROULETTE_TURN(self, spin, idx):
if self.interface:
self.interface.Roulette_TurnWheel(spin, idx)
def BINARY_ROULETTE_ICON(self, idx, vnum, count):
if self.interface:
self.interface.Roulette_SetIcons(idx, vnum, count)
if app.ENABLE_HALLOWEEN_EVENT_SYSTEM:
def ShowHaloun(self):
self.interface.ShowHaloun()
if app.ENABLE_EVENT_SYSTEM:
def OnRecvEventInformation(self):
if self.interface:
self.interface.RefreshEventWindowDialog()

game.py