2178 lines
65 KiB
Python
2178 lines
65 KiB
Python
import os
|
||
import app
|
||
import dbg
|
||
import grp
|
||
import item
|
||
import background
|
||
import chr
|
||
import chrmgr
|
||
import player
|
||
import snd
|
||
import chat
|
||
import textTail
|
||
import snd
|
||
import net
|
||
import effect
|
||
import wndMgr
|
||
import fly
|
||
import systemSetting
|
||
import quest
|
||
import guild
|
||
import skill
|
||
import messenger
|
||
import locale
|
||
import constInfo
|
||
import exchange
|
||
import ime
|
||
|
||
import ui
|
||
import uiCommon
|
||
import uiPhaseCurtain
|
||
import uiMapNameShower
|
||
import uiAffectShower
|
||
import uiPlayerGauge
|
||
import uiCharacter
|
||
import uiTarget
|
||
|
||
# PRIVATE_SHOP_PRICE_LIST
|
||
import uiPrivateShopBuilder
|
||
# END_OF_PRIVATE_SHOP_PRICE_LIST
|
||
|
||
import mouseModule
|
||
import consoleModule
|
||
|
||
import playerSettingModule
|
||
import interfaceModule
|
||
|
||
import musicInfo
|
||
import debugInfo
|
||
import stringCommander
|
||
|
||
from _weakref import proxy
|
||
|
||
# TEXTTAIL_LIVINGTIME_CONTROL
|
||
#if locale.IsJAPAN():
|
||
# app.SetTextTailLivingTime(8.0)
|
||
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL
|
||
|
||
# SCREENSHOT_CWDSAVE
|
||
SCREENSHOT_CWDSAVE = FALSE
|
||
SCREENSHOT_DIR = None
|
||
|
||
if locale.IsEUROPE():
|
||
SCREENSHOT_CWDSAVE = TRUE
|
||
|
||
if locale.IsCIBN10():
|
||
SCREENSHOT_CWDSAVE = FALSE
|
||
SCREENSHOT_DIR = "YT2W"
|
||
|
||
cameraDistance = 1550.0
|
||
cameraPitch = 27.0
|
||
cameraRotation = 0.0
|
||
cameraHeight = 100.0
|
||
|
||
testAlignment = 0
|
||
|
||
class GameWindow(ui.ScriptWindow):
|
||
def __init__(self, stream):
|
||
ui.ScriptWindow.__init__(self, "GAME")
|
||
self.SetWindowName("game")
|
||
net.SetPhaseWindow(net.PHASE_WINDOW_GAME, self)
|
||
player.SetGameWindow(self)
|
||
|
||
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
|
||
|
||
self.stream=stream
|
||
self.interface = interfaceModule.Interface()
|
||
self.interface.MakeInterface()
|
||
self.interface.ShowDefaultWindows()
|
||
|
||
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()
|
||
|
||
self.playerGauge = uiPlayerGauge.PlayerGauge(self)
|
||
self.playerGauge.Hide()
|
||
|
||
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
|
||
|
||
global cameraDistance, cameraPitch, cameraRotation, cameraHeight
|
||
|
||
app.SetCamera(cameraDistance, cameraPitch, cameraRotation, cameraHeight)
|
||
|
||
constInfo.SET_DEFAULT_CAMERA_MAX_DISTANCE()
|
||
constInfo.SET_DEFAULT_CHRNAME_COLOR()
|
||
constInfo.SET_DEFAULT_FOG_LEVEL()
|
||
constInfo.SET_DEFAULT_CONVERT_EMPIRE_LANGUAGE_ENABLE()
|
||
constInfo.SET_DEFAULT_USE_ITEM_WEAPON_TABLE_ATTACK_BONUS()
|
||
constInfo.SET_DEFAULT_USE_SKILL_EFFECT_ENABLE()
|
||
|
||
# TWO_HANDED_WEAPON_ATTACK_SPEED_UP
|
||
constInfo.SET_TWO_HANDED_WEAPON_ATT_SPEED_DECREASE_VALUE()
|
||
# END_OF_TWO_HANDED_WEAPON_ATTACK_SPEED_UP
|
||
|
||
import event
|
||
event.SetLeftTimeString(locale.UI_LEFT_TIME)
|
||
|
||
textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)
|
||
|
||
if constInfo.PVPMODE_TEST_ENABLE:
|
||
self.testPKMode = ui.TextLine()
|
||
self.testPKMode.SetFontName(locale.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(locale.UI_DEF_FONT)
|
||
self.testAlignment.SetPosition(0, 35)
|
||
self.testAlignment.SetWindowHorizontalAlignCenter()
|
||
self.testAlignment.SetHorizontalAlignCenter()
|
||
self.testAlignment.SetFeather()
|
||
self.testAlignment.SetOutline()
|
||
self.testAlignment.Show()
|
||
|
||
self.__BuildKeyDict()
|
||
self.__BuildDebugInfo()
|
||
|
||
# PRIVATE_SHOP_PRICE_LIST
|
||
uiPrivateShopBuilder.Clear()
|
||
# END_OF_PRIVATE_SHOP_PRICE_LIST
|
||
|
||
# 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()
|
||
|
||
# START_GAME_ERROR_EXIT
|
||
try:
|
||
self.StartGame()
|
||
except:
|
||
import exception
|
||
exception.Abort("GameWindow.Open")
|
||
# END_OF_START_GAME_ERROR_EXIT
|
||
|
||
# NPC<50><43> ť<><C5A5><EFBFBD>ý<EFBFBD><C3BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>۵<EFBFBD><DBB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ij<><C4B3>
|
||
# ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
|
||
self.cubeInformation = {}
|
||
self.currentCubeNPC = 0
|
||
|
||
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 self.interface:
|
||
self.interface.HideAllWindows()
|
||
self.interface.Close()
|
||
self.interface=None
|
||
|
||
player.ClearSkillDict()
|
||
player.ResetCameraRotation()
|
||
|
||
self.KillFocus()
|
||
app.HideCursor()
|
||
|
||
print "---------------------------------------------------------------------------- CLOSE GAME WINDOW"
|
||
|
||
def __BuildKeyDict(self):
|
||
onPressKeyDict = {}
|
||
|
||
##PressKey <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> Ű<>̴<EFBFBD>.
|
||
|
||
## <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ű <20><><EFBFBD><EFBFBD><EFBFBD>Կ<EFBFBD> <20>̿<EFBFBD><CCBF>ȴ<EFBFBD>.(<28><><EFBFBD><EFBFBD> <20><><EFBFBD>ڵ鵵 <20><> <20><><EFBFBD>Կ<EFBFBD> <20><><EFBFBD><EFBFBD>)
|
||
## F12 <20><> Ŭ<><C5AC> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ű<>̹Ƿ<CCB9> <20><><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD>.
|
||
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()
|
||
|
||
#ij<><C4B3><EFBFBD><EFBFBD> <20>̵<EFBFBD>Ű
|
||
onPressKeyDict[app.DIK_UP] = lambda : self.MoveUp()
|
||
onPressKeyDict[app.DIK_DOWN] = lambda : self.MoveDown()
|
||
onPressKeyDict[app.DIK_LEFT] = lambda : self.MoveLeft()
|
||
onPressKeyDict[app.DIK_RIGHT] = lambda : self.MoveRight()
|
||
onPressKeyDict[app.DIK_W] = lambda : self.MoveUp()
|
||
onPressKeyDict[app.DIK_S] = lambda : self.MoveDown()
|
||
onPressKeyDict[app.DIK_A] = lambda : self.MoveLeft()
|
||
onPressKeyDict[app.DIK_D] = lambda : self.MoveRight()
|
||
|
||
onPressKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_TO_POSITIVE)
|
||
onPressKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_TO_NEGATIVE)
|
||
#onPressKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)
|
||
onPressKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_TO_NEGATIVE)
|
||
onPressKeyDict[app.DIK_G] = self.__PressGKey
|
||
onPressKeyDict[app.DIK_Q] = self.__PressQKey
|
||
|
||
onPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()
|
||
onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
|
||
onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
|
||
onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
|
||
onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
|
||
onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
|
||
onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)
|
||
onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()
|
||
onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()
|
||
onPressKeyDict[app.DIK_C] = lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)
|
||
onPressKeyDict[app.DIK_V] = lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)
|
||
#onPressKeyDict[app.DIK_B] = lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)
|
||
onPressKeyDict[app.DIK_N] = lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)
|
||
onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()
|
||
onPressKeyDict[app.DIK_O] = lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
|
||
onPressKeyDict[app.DIK_M] = lambda : self.interface.PressMKey()
|
||
#onPressKeyDict[app.DIK_H] = lambda : self.interface.OpenHelpWindow()
|
||
onPressKeyDict[app.DIK_ADD] = lambda : self.interface.MiniMapScaleUp()
|
||
onPressKeyDict[app.DIK_SUBTRACT] = lambda : self.interface.MiniMapScaleDown()
|
||
onPressKeyDict[app.DIK_L] = lambda : self.interface.ToggleChatLogWindow()
|
||
onPressKeyDict[app.DIK_COMMA] = lambda : self.ShowConsole() # "`" key
|
||
onPressKeyDict[app.DIK_LSHIFT] = lambda : self.__SetQuickPageMode()
|
||
|
||
onPressKeyDict[app.DIK_J] = lambda : self.__PressJKey()
|
||
onPressKeyDict[app.DIK_H] = lambda : self.__PressHKey()
|
||
onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()
|
||
onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()
|
||
|
||
# CUBE_TEST
|
||
#onPressKeyDict[app.DIK_K] = lambda : self.interface.OpenCubeWindow()
|
||
# CUBE_TEST_END
|
||
|
||
self.onPressKeyDict = onPressKeyDict
|
||
|
||
onClickKeyDict = {}
|
||
onClickKeyDict[app.DIK_UP] = lambda : self.StopUp()
|
||
onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()
|
||
onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()
|
||
onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()
|
||
onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()
|
||
|
||
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 constInfo.PVPMODE_ACCELKEY_ENABLE:
|
||
# onClickKeyDict[app.DIK_B] = lambda: self.ChangePKMode()
|
||
|
||
self.onClickKeyDict=onClickKeyDict
|
||
|
||
def __PressNumKey(self,num):
|
||
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
||
|
||
if num >= 1 and num <= 9:
|
||
if(chrmgr.IsPossibleEmoticon(-1)):
|
||
chrmgr.SetEmoticon(-1,int(num)-1)
|
||
net.SendEmoticon(int(num)-1)
|
||
else:
|
||
if num >= 1 and num <= 4:
|
||
self.pressNumber(num-1)
|
||
|
||
def __ClickBKey(self):
|
||
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
||
return
|
||
else:
|
||
if constInfo.PVPMODE_ACCELKEY_ENABLE:
|
||
self.ChangePKMode()
|
||
|
||
|
||
def __PressJKey(self):
|
||
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
||
if player.IsMountingHorse():
|
||
net.SendChatPacket("/unmount")
|
||
else:
|
||
#net.SendChatPacket("/user_horse_ride")
|
||
if not uiPrivateShopBuilder.IsBuildingPrivateShop():
|
||
for i in xrange(player.INVENTORY_PAGE_SIZE):
|
||
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)
|
||
|
||
def __PressQKey(self):
|
||
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
|
||
if 0==interfaceModule.IsQBHide:
|
||
interfaceModule.IsQBHide = 1
|
||
self.interface.HideAllQuestButton()
|
||
else:
|
||
interfaceModule.IsQBHide = 0
|
||
self.interface.ShowAllQuestButton()
|
||
else:
|
||
app.RotateCamera(app.CAMERA_TO_NEGATIVE)
|
||
|
||
def __SetQuickSlotMode(self):
|
||
self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)
|
||
|
||
def __SetQuickPageMode(self):
|
||
self.pressNumber=ui.__mem_func__(self.__SelectQuickPage)
|
||
|
||
def __PressQuickSlot(self, localSlotIndex):
|
||
if locale.IsARABIC():
|
||
if 0 <= localSlotIndex and localSlotIndex < 4:
|
||
player.RequestUseLocalQuickSlot(3-localSlotIndex)
|
||
else:
|
||
player.RequestUseLocalQuickSlot(11-localSlotIndex)
|
||
else:
|
||
player.RequestUseLocalQuickSlot(localSlotIndex)
|
||
|
||
def __SelectQuickPage(self, pageIndex):
|
||
self.quickSlotPageIndex = pageIndex
|
||
player.SetQuickPage(pageIndex)
|
||
|
||
def ToggleDebugInfo(self):
|
||
self.isShowDebugInfo = not self.isShowDebugInfo
|
||
|
||
if self.isShowDebugInfo:
|
||
self.PrintCoord.Show()
|
||
self.FrameRate.Show()
|
||
self.Pitch.Show()
|
||
self.Splat.Show()
|
||
self.TextureNum.Show()
|
||
self.ObjectNum.Show()
|
||
self.ViewDistance.Show()
|
||
self.PrintMousePos.Show()
|
||
else:
|
||
self.PrintCoord.Hide()
|
||
self.FrameRate.Hide()
|
||
self.Pitch.Hide()
|
||
self.Splat.Hide()
|
||
self.TextureNum.Hide()
|
||
self.ObjectNum.Hide()
|
||
self.ViewDistance.Hide()
|
||
self.PrintMousePos.Hide()
|
||
|
||
def __BuildDebugInfo(self):
|
||
## Character Position Coordinate
|
||
self.PrintCoord = ui.TextLine()
|
||
self.PrintCoord.SetFontName(locale.UI_DEF_FONT)
|
||
self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)
|
||
|
||
## Frame Rate
|
||
self.FrameRate = ui.TextLine()
|
||
self.FrameRate.SetFontName(locale.UI_DEF_FONT)
|
||
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20)
|
||
|
||
## Camera Pitch
|
||
self.Pitch = ui.TextLine()
|
||
self.Pitch.SetFontName(locale.UI_DEF_FONT)
|
||
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40)
|
||
|
||
## Splat
|
||
self.Splat = ui.TextLine()
|
||
self.Splat.SetFontName(locale.UI_DEF_FONT)
|
||
self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60)
|
||
|
||
##
|
||
self.PrintMousePos = ui.TextLine()
|
||
self.PrintMousePos.SetFontName(locale.UI_DEF_FONT)
|
||
self.PrintMousePos.SetPosition(wndMgr.GetScreenWidth() - 270, 80)
|
||
|
||
# TextureNum
|
||
self.TextureNum = ui.TextLine()
|
||
self.TextureNum.SetFontName(locale.UI_DEF_FONT)
|
||
self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)
|
||
|
||
# <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><EFBFBD><D7B8><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
self.ObjectNum = ui.TextLine()
|
||
self.ObjectNum.SetFontName(locale.UI_DEF_FONT)
|
||
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)
|
||
|
||
# <20>þ߰Ÿ<DFB0>
|
||
self.ViewDistance = ui.TextLine()
|
||
self.ViewDistance.SetFontName(locale.UI_DEF_FONT)
|
||
self.ViewDistance.SetPosition(0, 0)
|
||
|
||
def __NotifyError(self, msg):
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, msg)
|
||
|
||
def ChangePKMode(self):
|
||
|
||
if not app.IsPressed(app.DIK_LCONTROL):
|
||
return
|
||
|
||
if player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
|
||
self.__NotifyError(locale.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, locale.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(locale.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) + " (" + locale.TITLE_NAME_LIST[grade] + ")")
|
||
|
||
###############################################################################################
|
||
###############################################################################################
|
||
## Game Callback Functions
|
||
|
||
# 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 RefreshQuest(self):
|
||
self.interface.RefreshQuest()
|
||
|
||
def RefreshMessenger(self):
|
||
self.interface.RefreshMessenger()
|
||
|
||
def RefreshGuildInfoPage(self):
|
||
self.interface.RefreshGuildInfoPage()
|
||
|
||
def RefreshGuildBoardPage(self):
|
||
self.interface.RefreshGuildBoardPage()
|
||
|
||
def RefreshGuildMemberPage(self):
|
||
self.interface.RefreshGuildMemberPage()
|
||
|
||
def RefreshGuildMemberPageGradeComboBox(self):
|
||
self.interface.RefreshGuildMemberPageGradeComboBox()
|
||
|
||
def RefreshGuildSkillPage(self):
|
||
self.interface.RefreshGuildSkillPage()
|
||
|
||
def RefreshGuildGradePage(self):
|
||
self.interface.RefreshGuildGradePage()
|
||
|
||
def RefreshMobile(self):
|
||
if self.interface:
|
||
self.interface.RefreshMobile()
|
||
|
||
def OnMobileAuthority(self):
|
||
self.interface.OnMobileAuthority()
|
||
|
||
def OnBlockMode(self, mode):
|
||
self.interface.OnBlockMode(mode)
|
||
|
||
def OpenQuestWindow(self, skin, idx):
|
||
self.interface.OpenQuestWindow(skin, idx)
|
||
|
||
def AskGuildName(self):
|
||
|
||
guildNameBoard = uiCommon.InputDialog()
|
||
guildNameBoard.SetTitle(locale.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(locale.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, locale.UI_OK)
|
||
|
||
def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, type=0):
|
||
self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, type)
|
||
|
||
def AppendMaterialToRefineDialog(self, vnum, count):
|
||
self.interface.AppendMaterialToRefineDialog(vnum, count)
|
||
|
||
def RunUseSkillEvent(self, slotIndex, coolTime):
|
||
self.interface.OnUseSkill(slotIndex, coolTime)
|
||
|
||
def ClearAffects(self):
|
||
self.affectShower.ClearAffects()
|
||
|
||
def SetAffect(self, affect):
|
||
self.affectShower.SetAffect(affect)
|
||
|
||
def ResetAffect(self, affect):
|
||
self.affectShower.ResetAffect(affect)
|
||
|
||
# UNKNOWN_UPDATE
|
||
def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
|
||
self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)
|
||
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
|
||
self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
|
||
elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
|
||
self.BINARY_DragonSoulGiveQuilification()
|
||
|
||
def BINARY_NEW_RemoveAffect(self, type, pointIdx):
|
||
self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)
|
||
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
|
||
self.interface.DragonSoulDeactivate()
|
||
|
||
|
||
|
||
# END_OF_UNKNOWN_UPDATE
|
||
|
||
def ActivateSkillSlot(self, slotIndex):
|
||
if self.interface:
|
||
self.interface.OnActivateSkill(slotIndex)
|
||
|
||
def DeactivateSkillSlot(self, slotIndex):
|
||
if self.interface:
|
||
self.interface.OnDeactivateSkill(slotIndex)
|
||
|
||
def RefreshEquipment(self):
|
||
if self.interface:
|
||
self.interface.RefreshInventory()
|
||
|
||
def RefreshInventory(self):
|
||
if self.interface:
|
||
self.interface.RefreshInventory()
|
||
|
||
def RefreshCharacter(self):
|
||
if self.interface:
|
||
self.interface.RefreshCharacter()
|
||
|
||
def OnGameOver(self):
|
||
self.CloseTargetBoard()
|
||
self.OpenRestartDialog()
|
||
|
||
def OpenRestartDialog(self):
|
||
self.interface.OpenRestartDialog()
|
||
|
||
def ChangeCurrentSkill(self, skillSlotNumber):
|
||
self.interface.OnChangeCurrentSkill(skillSlotNumber)
|
||
|
||
## 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()
|
||
|
||
def SetHPTargetBoard(self, vid, hpPercentage):
|
||
if vid != self.targetBoard.GetTargetVID():
|
||
self.targetBoard.ResetTargetBoard()
|
||
self.targetBoard.SetEnemyVID(vid)
|
||
|
||
self.targetBoard.SetHP(hpPercentage)
|
||
self.targetBoard.Show()
|
||
|
||
def CloseTargetBoardIfDifferent(self, vid):
|
||
if vid != self.targetBoard.GetTargetVID():
|
||
self.targetBoard.Close()
|
||
|
||
def CloseTargetBoard(self):
|
||
self.targetBoard.Close()
|
||
|
||
## View Equipment
|
||
def OpenEquipmentDialog(self, vid):
|
||
self.interface.OpenEquipmentDialog(vid)
|
||
|
||
def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
|
||
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count)
|
||
|
||
def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
|
||
self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value)
|
||
|
||
def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
|
||
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value)
|
||
|
||
# SHOW_LOCAL_MAP_NAME
|
||
def ShowMapName(self, mapName, x, y):
|
||
|
||
if self.mapNameShower:
|
||
self.mapNameShower.ShowMapName(mapName, x, y)
|
||
|
||
if self.interface:
|
||
self.interface.SetMapName(mapName)
|
||
# END_OF_SHOW_LOCAL_MAP_NAME
|
||
|
||
def BINARY_OpenAtlasWindow(self):
|
||
self.interface.BINARY_OpenAtlasWindow()
|
||
|
||
## Chat
|
||
def OnRecvWhisper(self, mode, name, line):
|
||
if 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 locale.WHISPER_ERROR.has_key(mode):
|
||
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, locale.WHISPER_ERROR[mode](name))
|
||
else:
|
||
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))
|
||
self.interface.RecvWhisper(name)
|
||
|
||
def RecvWhisper(self, name):
|
||
self.interface.RecvWhisper(name)
|
||
|
||
def OnPickMoney(self, money):
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GAME_PICK_MONEY % (money))
|
||
|
||
def OnShopError(self, type):
|
||
try:
|
||
self.PopupMessage(locale.SHOP_ERROR_DICT[type])
|
||
except KeyError:
|
||
self.PopupMessage(locale.SHOP_ERROR_UNKNOWN % (type))
|
||
|
||
def OnSafeBoxError(self):
|
||
self.PopupMessage(locale.SAFEBOX_ERROR)
|
||
|
||
def OnFishingSuccess(self, isFish, fishName):
|
||
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, locale.FISHING_SUCCESS(isFish, fishName), 2000)
|
||
|
||
# ADD_FISHING_MESSAGE
|
||
def OnFishingNotifyUnknown(self):
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_UNKNOWN)
|
||
|
||
def OnFishingWrongPlace(self):
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_WRONG_PLACE)
|
||
# END_OF_ADD_FISHING_MESSAGE
|
||
|
||
def OnFishingNotify(self, isFish, fishName):
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.FISHING_NOTIFY(isFish, fishName))
|
||
|
||
def OnFishingFailure(self):
|
||
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, locale.FISHING_FAILURE, 2000)
|
||
|
||
def OnCannotPickItem(self):
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GAME_CANNOT_PICK_ITEM)
|
||
|
||
# MINING
|
||
def OnCannotMining(self):
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.GAME_CANNOT_MINING)
|
||
# END_OF_MINING
|
||
|
||
def OnCannotUseSkill(self, vid, type):
|
||
if locale.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
|
||
textTail.RegisterInfoTail(vid, locale.USE_SKILL_ERROR_TAIL_DICT[type])
|
||
|
||
if locale.USE_SKILL_ERROR_CHAT_DICT.has_key(type):
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.USE_SKILL_ERROR_CHAT_DICT[type])
|
||
|
||
def OnCannotShotError(self, vid, type):
|
||
textTail.RegisterInfoTail(vid, locale.SHOT_ERROR_TAIL_DICT.get(type, locale.SHOT_ERROR_UNKNOWN % (type)))
|
||
|
||
## PointReset
|
||
def StartPointReset(self):
|
||
self.interface.OpenPointResetDialog()
|
||
|
||
## Shop
|
||
def StartShop(self, vid):
|
||
self.interface.OpenShopDialog(vid)
|
||
|
||
def EndShop(self):
|
||
self.interface.CloseShopDialog()
|
||
|
||
def RefreshShop(self):
|
||
self.interface.RefreshShopDialog()
|
||
|
||
def SetShopSellingPrice(self, Price):
|
||
pass
|
||
|
||
## Exchange
|
||
def StartExchange(self):
|
||
self.interface.StartExchange()
|
||
|
||
def EndExchange(self):
|
||
self.interface.EndExchange()
|
||
|
||
def RefreshExchange(self):
|
||
self.interface.RefreshExchange()
|
||
|
||
## Party
|
||
def RecvPartyInviteQuestion(self, leaderVID, leaderName):
|
||
partyInviteQuestionDialog = uiCommon.QuestionDialog()
|
||
partyInviteQuestionDialog.SetText(leaderName + locale.PARTY_DO_YOU_JOIN)
|
||
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerPartyInvite(arg))
|
||
partyInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerPartyInvite(arg))
|
||
partyInviteQuestionDialog.Open()
|
||
partyInviteQuestionDialog.partyLeaderVID = leaderVID
|
||
self.partyInviteQuestionDialog = partyInviteQuestionDialog
|
||
|
||
def AnswerPartyInvite(self, answer):
|
||
|
||
if not self.partyInviteQuestionDialog:
|
||
return
|
||
|
||
partyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID
|
||
|
||
distance = player.GetCharacterDistance(partyLeaderVID)
|
||
if distance < 0.0 or distance > 5000:
|
||
answer = FALSE
|
||
|
||
net.SendPartyInviteAnswerPacket(partyLeaderVID, answer)
|
||
|
||
self.partyInviteQuestionDialog.Close()
|
||
self.partyInviteQuestionDialog = None
|
||
|
||
def AddPartyMember(self, pid, name):
|
||
self.interface.AddPartyMember(pid, name)
|
||
|
||
def UpdatePartyMemberInfo(self, pid):
|
||
self.interface.UpdatePartyMemberInfo(pid)
|
||
|
||
def RemovePartyMember(self, pid):
|
||
self.interface.RemovePartyMember(pid)
|
||
self.__RefreshTargetBoard()
|
||
|
||
def LinkPartyMember(self, pid, vid):
|
||
self.interface.LinkPartyMember(pid, vid)
|
||
|
||
def UnlinkPartyMember(self, pid):
|
||
self.interface.UnlinkPartyMember(pid)
|
||
|
||
def UnlinkAllPartyMember(self):
|
||
self.interface.UnlinkAllPartyMember()
|
||
|
||
def ExitParty(self):
|
||
self.interface.ExitParty()
|
||
self.RefreshTargetBoardByVID(self.targetBoard.GetTargetVID())
|
||
|
||
def ChangePartyParameter(self, distributionMode):
|
||
self.interface.ChangePartyParameter(distributionMode)
|
||
|
||
## Messenger
|
||
def OnMessengerAddFriendQuestion(self, name):
|
||
messengerAddFriendQuestion = uiCommon.QuestionDialog2()
|
||
messengerAddFriendQuestion.SetText1(locale.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
|
||
messengerAddFriendQuestion.SetText2(locale.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 + locale.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 + locale.SCREENSHOT_SAVE1)
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.SCREENSHOT_SAVE2)
|
||
"""
|
||
else:
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.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)
|
||
|
||
# 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
|
||
|
||
constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)
|
||
|
||
try:
|
||
self.onPressKeyDict[key]()
|
||
except KeyError:
|
||
pass
|
||
except:
|
||
raise
|
||
|
||
return TRUE
|
||
|
||
def OnKeyUp(self, key):
|
||
try:
|
||
self.onClickKeyDict[key]()
|
||
except KeyError:
|
||
pass
|
||
except:
|
||
raise
|
||
|
||
return TRUE
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
if self.interface.BUILD_OnMouseLeftButtonDown():
|
||
return
|
||
|
||
if mouseModule.mouseController.isAttached():
|
||
self.CheckFocus()
|
||
else:
|
||
hyperlink = ui.GetHyperlink()
|
||
if hyperlink:
|
||
return
|
||
else:
|
||
self.CheckFocus()
|
||
player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);
|
||
|
||
return TRUE
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
|
||
if self.interface.BUILD_OnMouseLeftButtonUp():
|
||
return
|
||
|
||
if mouseModule.mouseController.isAttached():
|
||
|
||
attachedType = mouseModule.mouseController.GetAttachedType()
|
||
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
|
||
attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
|
||
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
|
||
|
||
## QuickSlot
|
||
if player.SLOT_TYPE_QUICK_SLOT == attachedType:
|
||
player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)
|
||
|
||
## Inventory
|
||
elif player.SLOT_TYPE_INVENTORY == attachedType:
|
||
|
||
if player.ITEM_MONEY == attachedItemIndex:
|
||
self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
|
||
else:
|
||
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
|
||
|
||
## DragonSoul
|
||
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
|
||
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
|
||
|
||
mouseModule.mouseController.DeattachObject()
|
||
|
||
else:
|
||
hyperlink = ui.GetHyperlink()
|
||
if hyperlink:
|
||
if app.IsPressed(app.DIK_LALT):
|
||
link = chat.GetLinkFromHyperlink(hyperlink)
|
||
ime.PasteString(link)
|
||
else:
|
||
self.interface.MakeHyperlinkTooltip(hyperlink)
|
||
return
|
||
else:
|
||
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)
|
||
|
||
#player.EndMouseWalking()
|
||
return TRUE
|
||
|
||
def __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
|
||
if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
|
||
attachedInvenType = player.SlotTypeToInvenType(attachedType)
|
||
if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
|
||
if player.IsEquipmentSlot(attachedItemSlotPos):
|
||
self.stream.popupWindow.Close()
|
||
self.stream.popupWindow.Open(locale.EXCHANGE_FAILURE_EQUIP_ITEM, 0, locale.UI_OK)
|
||
else:
|
||
if chr.IsNPC(dstChrID):
|
||
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
|
||
else:
|
||
net.SendExchangeStartPacket(dstChrID)
|
||
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
|
||
else:
|
||
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)
|
||
|
||
def __PutMoney(self, attachedType, attachedMoney, dstChrID):
|
||
if TRUE == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:
|
||
net.SendExchangeStartPacket(dstChrID)
|
||
net.SendExchangeElkAddPacket(attachedMoney)
|
||
else:
|
||
self.__DropMoney(attachedType, attachedMoney)
|
||
|
||
def __DropMoney(self, attachedType, attachedMoney):
|
||
# PRIVATESHOP_DISABLE_ITEM_DROP - <20><><EFBFBD>λ<EFBFBD><CEBB><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
if uiPrivateShopBuilder.IsBuildingPrivateShop():
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP)
|
||
return
|
||
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
||
|
||
if attachedMoney>=1000:
|
||
self.stream.popupWindow.Close()
|
||
self.stream.popupWindow.Open(locale.DROP_MONEY_FAILURE_1000_OVER, 0, locale.UI_OK)
|
||
return
|
||
|
||
itemDropQuestionDialog = uiCommon.QuestionDialog()
|
||
itemDropQuestionDialog.SetText(locale.DO_YOU_DROP_MONEY % (attachedMoney))
|
||
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
|
||
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
|
||
itemDropQuestionDialog.Open()
|
||
itemDropQuestionDialog.dropType = attachedType
|
||
itemDropQuestionDialog.dropCount = attachedMoney
|
||
itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
|
||
self.itemDropQuestionDialog = itemDropQuestionDialog
|
||
|
||
def __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
|
||
# PRIVATESHOP_DISABLE_ITEM_DROP - <20><><EFBFBD>λ<EFBFBD><CEBB><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
if uiPrivateShopBuilder.IsBuildingPrivateShop():
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP)
|
||
return
|
||
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
||
|
||
if player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):
|
||
self.stream.popupWindow.Close()
|
||
self.stream.popupWindow.Open(locale.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, locale.UI_OK)
|
||
|
||
else:
|
||
if player.SLOT_TYPE_INVENTORY == attachedType:
|
||
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)
|
||
|
||
item.SelectItem(dropItemIndex)
|
||
dropItemName = item.GetItemName()
|
||
|
||
## Question Text
|
||
questionText = locale.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)
|
||
|
||
## Dialog
|
||
itemDropQuestionDialog = uiCommon.QuestionDialog()
|
||
itemDropQuestionDialog.SetText(questionText)
|
||
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
|
||
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
|
||
itemDropQuestionDialog.Open()
|
||
itemDropQuestionDialog.dropType = attachedType
|
||
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
|
||
itemDropQuestionDialog.dropCount = attachedItemCount
|
||
self.itemDropQuestionDialog = itemDropQuestionDialog
|
||
|
||
constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(1)
|
||
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
|
||
dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)
|
||
|
||
item.SelectItem(dropItemIndex)
|
||
dropItemName = item.GetItemName()
|
||
|
||
## Question Text
|
||
questionText = locale.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)
|
||
|
||
## Dialog
|
||
itemDropQuestionDialog = uiCommon.QuestionDialog()
|
||
itemDropQuestionDialog.SetText(questionText)
|
||
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
|
||
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
|
||
itemDropQuestionDialog.Open()
|
||
itemDropQuestionDialog.dropType = attachedType
|
||
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
|
||
itemDropQuestionDialog.dropCount = attachedItemCount
|
||
self.itemDropQuestionDialog = itemDropQuestionDialog
|
||
|
||
constInfo.SET_ITEM_DROP_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:
|
||
if dropNumber == player.ITEM_MONEY:
|
||
net.SendGoldDropPacketNew(dropCount)
|
||
snd.PlaySound("sound/ui/money.wav")
|
||
else:
|
||
# PRIVATESHOP_DISABLE_ITEM_DROP
|
||
self.__SendDropItemPacket(dropNumber, dropCount)
|
||
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
||
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
|
||
# PRIVATESHOP_DISABLE_ITEM_DROP
|
||
self.__SendDropItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
|
||
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
||
|
||
self.itemDropQuestionDialog.Close()
|
||
self.itemDropQuestionDialog = None
|
||
|
||
constInfo.SET_ITEM_DROP_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, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP)
|
||
return
|
||
|
||
net.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
|
||
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
|
||
|
||
def OnMouseRightButtonDown(self):
|
||
|
||
self.CheckFocus()
|
||
|
||
if TRUE == mouseModule.mouseController.isAttached():
|
||
mouseModule.mouseController.DeattachObject()
|
||
|
||
else:
|
||
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)
|
||
|
||
return TRUE
|
||
|
||
def OnMouseRightButtonUp(self):
|
||
if TRUE == mouseModule.mouseController.isAttached():
|
||
return TRUE
|
||
|
||
player.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
|
||
return TRUE
|
||
|
||
def OnMouseMiddleButtonDown(self):
|
||
player.SetMouseMiddleButtonState(player.MBS_PRESS)
|
||
|
||
def OnMouseMiddleButtonUp(self):
|
||
player.SetMouseMiddleButtonState(player.MBS_CLICK)
|
||
|
||
def OnUpdate(self):
|
||
app.UpdateGame()
|
||
|
||
if self.mapNameShower.IsShow():
|
||
self.mapNameShower.Update()
|
||
|
||
if self.isShowDebugInfo:
|
||
self.UpdateDebugInfo()
|
||
|
||
if self.enableXMasBoom:
|
||
self.__XMasBoom_Update()
|
||
|
||
self.interface.BUILD_OnUpdate()
|
||
|
||
|
||
def UpdateDebugInfo(self):
|
||
#
|
||
# ij<><C4B3><EFBFBD><EFBFBD> <20><>ǥ <20><> FPS <20><><EFBFBD><EFBFBD>
|
||
(x, y, z) = player.GetMainCharacterPosition()
|
||
nUpdateTime = app.GetUpdateTime()
|
||
nUpdateFPS = app.GetUpdateFPS()
|
||
nRenderFPS = app.GetRenderFPS()
|
||
nFaceCount = app.GetFaceCount()
|
||
fFaceSpeed = app.GetFaceSpeed()
|
||
nST=background.GetRenderShadowTime()
|
||
(fAveRT, nCurRT) = app.GetRenderTime()
|
||
(iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo()
|
||
(iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum()
|
||
if iPatch == 0:
|
||
iPatch = 1
|
||
|
||
#(dwRenderedThing, dwRenderedCRC) = background.GetRenderedGraphicThingInstanceNum()
|
||
|
||
self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
|
||
xMouse, yMouse = wndMgr.GetMousePosition()
|
||
self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))
|
||
|
||
self.FrameRate.SetText("UFPS: %3d UT: %3d FS %.2f" % (nUpdateFPS, nUpdateTime, fFaceSpeed))
|
||
|
||
if fAveRT>1.0:
|
||
self.Pitch.SetText("RFPS: %3d RT:%.2f(%3d) FC: %d(%.2f) " % (nRenderFPS, fAveRT, nCurRT, nFaceCount, nFaceCount/fAveRT))
|
||
|
||
self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))
|
||
#self.Pitch.SetText("Pitch: %.2f" % (app.GetCameraPitch())
|
||
#self.TextureNum.SetText("TN : %s" % (sTextureNum))
|
||
#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))
|
||
self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))
|
||
|
||
def OnRender(self):
|
||
app.RenderGame()
|
||
|
||
if self.console.Console.collision:
|
||
background.RenderCollision()
|
||
chr.RenderCollision()
|
||
|
||
(x, y) = app.GetCursorPosition()
|
||
|
||
########################
|
||
# Picking
|
||
########################
|
||
textTail.UpdateAllTextTail()
|
||
|
||
if TRUE == wndMgr.IsPickedWindow(self.hWnd):
|
||
|
||
self.PickingCharacterIndex = chr.Pick()
|
||
|
||
if -1 != self.PickingCharacterIndex:
|
||
textTail.ShowCharacterTextTail(self.PickingCharacterIndex)
|
||
if 0 != self.targetBoard.GetTargetVID():
|
||
textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())
|
||
|
||
# ADD_ALWAYS_SHOW_NAME
|
||
if not self.__IsShowName():
|
||
self.PickingItemIndex = item.Pick()
|
||
if -1 != self.PickingItemIndex:
|
||
textTail.ShowItemTextTail(self.PickingItemIndex)
|
||
# END_OF_ADD_ALWAYS_SHOW_NAME
|
||
|
||
## Show all name in the range
|
||
|
||
# ADD_ALWAYS_SHOW_NAME
|
||
if self.__IsShowName():
|
||
textTail.ShowAllTextTail()
|
||
self.PickingItemIndex = textTail.Pick(x, y)
|
||
# END_OF_ADD_ALWAYS_SHOW_NAME
|
||
|
||
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.Open(msg, timeout)
|
||
confirmDialog.SetAcceptEvent(lambda answer=TRUE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
|
||
confirmDialog.SetCancelEvent(lambda answer=FALSE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
|
||
self.confirmDialog = confirmDialog
|
||
# END_OF_QUEST_CONFIRM
|
||
|
||
# GIFT command
|
||
def Gift_Show(self):
|
||
self.interface.ShowGift()
|
||
|
||
# CUBE
|
||
def BINARY_Cube_Open(self, npcVNUM):
|
||
self.currentCubeNPC = npcVNUM
|
||
|
||
self.interface.OpenCubeWindow()
|
||
|
||
|
||
if npcVNUM not in self.cubeInformation:
|
||
net.SendChatPacket("/cube r_info")
|
||
else:
|
||
cubeInfoList = self.cubeInformation[npcVNUM]
|
||
|
||
i = 0
|
||
for cubeInfo in cubeInfoList:
|
||
self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"])
|
||
|
||
j = 0
|
||
for materialList in cubeInfo["materialList"]:
|
||
for materialInfo in materialList:
|
||
itemVnum, itemCount = materialInfo
|
||
self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount)
|
||
j = j + 1
|
||
|
||
i = i + 1
|
||
|
||
self.interface.wndCube.Refresh()
|
||
|
||
def BINARY_Cube_Close(self):
|
||
self.interface.CloseCubeWindow()
|
||
|
||
# <20><><EFBFBD>ۿ<EFBFBD> <20>ʿ<EFBFBD><CABF><EFBFBD> <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD>Ǵ<EFBFBD> <20>ϼ<EFBFBD>ǰ<EFBFBD><C7B0> VNUM<55><4D> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> update
|
||
def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
|
||
self.interface.UpdateCubeInfo(gold, itemVnum, count)
|
||
|
||
def BINARY_Cube_Succeed(self, itemVnum, count):
|
||
print "ť<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>"
|
||
self.interface.SucceedCubeWork(itemVnum, count)
|
||
pass
|
||
|
||
def BINARY_Cube_Failed(self):
|
||
print "ť<EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>"
|
||
self.interface.FailedCubeWork()
|
||
pass
|
||
|
||
def BINARY_Cube_ResultList(self, npcVNUM, listText):
|
||
# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 <20>̷<EFBFBD><CCB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> "/" <20><><EFBFBD>ڷ<EFBFBD> <20><><EFBFBD>е<EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><>
|
||
#print listText
|
||
|
||
if npcVNUM == 0:
|
||
npcVNUM = self.currentCubeNPC
|
||
|
||
self.cubeInformation[npcVNUM] = []
|
||
|
||
try:
|
||
for eachInfoText in listText.split("/"):
|
||
eachInfo = eachInfoText.split(",")
|
||
itemVnum = int(eachInfo[0])
|
||
itemCount = int(eachInfo[1])
|
||
|
||
self.cubeInformation[npcVNUM].append({"vnum": itemVnum, "count": itemCount})
|
||
self.interface.wndCube.AddCubeResultItem(itemVnum, itemCount)
|
||
|
||
resultCount = len(self.cubeInformation[npcVNUM])
|
||
requestCount = 7
|
||
modCount = resultCount % requestCount
|
||
splitCount = resultCount / requestCount
|
||
for i in xrange(splitCount):
|
||
#print("/cube r_info %d %d" % (i * requestCount, requestCount))
|
||
net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount))
|
||
|
||
if 0 < modCount:
|
||
#print("/cube r_info %d %d" % (splitCount * requestCount, modCount))
|
||
net.SendChatPacket("/cube r_info %d %d" % (splitCount * requestCount, modCount))
|
||
|
||
except RuntimeError, msg:
|
||
dbg.TraceError(msg)
|
||
return 0
|
||
|
||
pass
|
||
|
||
def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText):
|
||
# Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000
|
||
try:
|
||
#print listText
|
||
|
||
if 3 > len(listText):
|
||
dbg.TraceError("Wrong Cube Material Infomation")
|
||
return 0
|
||
|
||
|
||
|
||
eachResultList = listText.split("@")
|
||
|
||
cubeInfo = self.cubeInformation[self.currentCubeNPC]
|
||
|
||
itemIndex = 0
|
||
for eachResultText in eachResultList:
|
||
cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]
|
||
materialList = cubeInfo[startIndex + itemIndex]["materialList"]
|
||
|
||
gold = 0
|
||
splitResult = eachResultText.split("/")
|
||
if 1 < len(splitResult):
|
||
gold = int(splitResult[1])
|
||
|
||
#print "splitResult : ", splitResult
|
||
eachMaterialList = splitResult[0].split("&")
|
||
|
||
i = 0
|
||
for eachMaterialText in eachMaterialList:
|
||
complicatedList = eachMaterialText.split("|")
|
||
|
||
if 0 < len(complicatedList):
|
||
for complicatedText in complicatedList:
|
||
(itemVnum, itemCount) = complicatedText.split(",")
|
||
itemVnum = int(itemVnum)
|
||
itemCount = int(itemCount)
|
||
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)
|
||
|
||
materialList[i].append((itemVnum, itemCount))
|
||
|
||
else:
|
||
itemVnum, itemCount = eachMaterialText.split(",")
|
||
itemVnum = int(itemVnum)
|
||
itemCount = int(itemCount)
|
||
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)
|
||
|
||
materialList[i].append((itemVnum, itemCount))
|
||
|
||
i = i + 1
|
||
|
||
|
||
|
||
itemIndex = itemIndex + 1
|
||
|
||
self.interface.wndCube.Refresh()
|
||
|
||
|
||
except RuntimeError, msg:
|
||
dbg.TraceError(msg)
|
||
return 0
|
||
|
||
pass
|
||
|
||
# END_OF_CUBE
|
||
|
||
# <20><>ȥ<EFBFBD><C8A5>
|
||
def BINARY_Highlight_Item(self, inven_type, inven_pos):
|
||
self.interface.Highligt_Item(inven_type, inven_pos)
|
||
|
||
def BINARY_DragonSoulGiveQuilification(self):
|
||
self.interface.DragonSoulGiveQuilification()
|
||
|
||
def BINARY_DragonSoulRefineWindow_Open(self):
|
||
self.interface.OpenDragonSoulRefineWindow()
|
||
|
||
def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos):
|
||
self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)
|
||
|
||
def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
|
||
self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)
|
||
|
||
# END of DRAGON SOUL REFINE WINDOW
|
||
|
||
def BINARY_SetBigMessage(self, message):
|
||
self.interface.bigBoard.SetTip(message)
|
||
|
||
def BINARY_SetTipMessage(self, message):
|
||
self.interface.tipBoard.SetTip(message)
|
||
|
||
def BINARY_AppendNotifyMessage(self, type):
|
||
if not type in locale.NOTIFY_MESSAGE:
|
||
return
|
||
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.NOTIFY_MESSAGE[type])
|
||
|
||
def BINARY_Guild_EnterGuildArea(self, areaID):
|
||
self.interface.BULID_EnterGuildArea(areaID)
|
||
|
||
def BINARY_Guild_ExitGuildArea(self, areaID):
|
||
self.interface.BULID_ExitGuildArea(areaID)
|
||
|
||
def BINARY_GuildWar_OnSendDeclare(self, guildID):
|
||
pass
|
||
|
||
def BINARY_GuildWar_OnRecvDeclare(self, guildID, warType):
|
||
mainCharacterName = player.GetMainCharacterName()
|
||
masterName = guild.GetGuildMasterName()
|
||
if mainCharacterName == masterName:
|
||
self.__GuildWar_OpenAskDialog(guildID, warType)
|
||
|
||
def BINARY_GuildWar_OnRecvPoint(self, gainGuildID, opponentGuildID, point):
|
||
self.interface.OnRecvGuildWarPoint(gainGuildID, opponentGuildID, point)
|
||
|
||
def BINARY_GuildWar_OnStart(self, guildSelf, guildOpp):
|
||
self.interface.OnStartGuildWar(guildSelf, guildOpp)
|
||
|
||
def BINARY_GuildWar_OnEnd(self, guildSelf, guildOpp):
|
||
self.interface.OnEndGuildWar(guildSelf, guildOpp)
|
||
|
||
def BINARY_BettingGuildWar_SetObserverMode(self, isEnable):
|
||
self.interface.BINARY_SetObserverMode(isEnable)
|
||
|
||
def BINARY_BettingGuildWar_UpdateObserverCount(self, observerCount):
|
||
self.interface.wndMiniMap.UpdateObserverCount(observerCount)
|
||
|
||
def __GuildWar_UpdateMemberCount(self, guildID1, memberCount1, guildID2, memberCount2, observerCount):
|
||
guildID1 = int(guildID1)
|
||
guildID2 = int(guildID2)
|
||
memberCount1 = int(memberCount1)
|
||
memberCount2 = int(memberCount2)
|
||
observerCount = int(observerCount)
|
||
|
||
self.interface.UpdateMemberCount(guildID1, memberCount1, guildID2, memberCount2)
|
||
self.interface.wndMiniMap.UpdateObserverCount(observerCount)
|
||
|
||
def __GuildWar_OpenAskDialog(self, guildID, warType):
|
||
|
||
guildName = guild.GetGuildName(guildID)
|
||
|
||
# REMOVED_GUILD_BUG_FIX
|
||
if "Noname" == guildName:
|
||
return
|
||
# END_OF_REMOVED_GUILD_BUG_FIX
|
||
|
||
import uiGuild
|
||
questionDialog = uiGuild.AcceptGuildWarDialog()
|
||
questionDialog.SAFE_SetAcceptEvent(self.__GuildWar_OnAccept)
|
||
questionDialog.SAFE_SetCancelEvent(self.__GuildWar_OnDecline)
|
||
questionDialog.Open(guildName, warType)
|
||
|
||
self.guildWarQuestionDialog = questionDialog
|
||
|
||
def __GuildWar_CloseAskDialog(self):
|
||
self.guildWarQuestionDialog.Close()
|
||
self.guildWarQuestionDialog = None
|
||
|
||
def __GuildWar_OnAccept(self):
|
||
|
||
guildName = self.guildWarQuestionDialog.GetGuildName()
|
||
|
||
net.SendChatPacket("/war " + guildName)
|
||
self.__GuildWar_CloseAskDialog()
|
||
|
||
return 1
|
||
|
||
def __GuildWar_OnDecline(self):
|
||
|
||
guildName = self.guildWarQuestionDialog.GetGuildName()
|
||
|
||
net.SendChatPacket("/nowar " + guildName)
|
||
self.__GuildWar_CloseAskDialog()
|
||
|
||
return 1
|
||
## BINARY CALLBACK
|
||
######################################################################################
|
||
|
||
def __ServerCommand_Build(self):
|
||
serverCommandList={
|
||
"ConsoleEnable" : self.__Console_Enable,
|
||
"DayMode" : self.__DayMode_Update,
|
||
"PRESERVE_DayMode" : self.__PRESERVE_DayMode_Update,
|
||
"CloseRestartWindow" : self.__RestartDialog_Close,
|
||
"OpenPrivateShop" : self.__PrivateShop_Open,
|
||
"PartyHealReady" : self.PartyHealReady,
|
||
"ShowMeSafeboxPassword" : self.AskSafeboxPassword,
|
||
"CloseSafebox" : self.CommandCloseSafebox,
|
||
|
||
# ITEM_MALL
|
||
"CloseMall" : self.CommandCloseMall,
|
||
"ShowMeMallPassword" : self.AskMallPassword,
|
||
"item_mall" : self.__ItemMall_Open,
|
||
# END_OF_ITEM_MALL
|
||
|
||
"RefineSuceeded" : self.RefineSuceededMessage,
|
||
"RefineFailed" : self.RefineFailedMessage,
|
||
"xmas_snow" : self.__XMasSnow_Enable,
|
||
"xmas_boom" : self.__XMasBoom_Enable,
|
||
"xmas_song" : self.__XMasSong_Enable,
|
||
"xmas_tree" : self.__XMasTree_Enable,
|
||
"newyear_boom" : self.__XMasBoom_Enable,
|
||
"PartyRequest" : self.__PartyRequestQuestion,
|
||
"PartyRequestDenied" : self.__PartyRequestDenied,
|
||
"horse_state" : self.__Horse_UpdateState,
|
||
"hide_horse_state" : self.__Horse_HideState,
|
||
"WarUC" : self.__GuildWar_UpdateMemberCount,
|
||
"test_server" : self.__EnableTestServerFlag,
|
||
"mall" : self.__InGameShop_Show,
|
||
|
||
# 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
|
||
|
||
# PRIVATE_SHOP_PRICE_LIST
|
||
"MyShopPriceList" : self.__PrivateShop_PriceList,
|
||
# END_OF_PRIVATE_SHOP_PRICE_LIST
|
||
}
|
||
|
||
self.serverCommander=stringCommander.Analyzer()
|
||
for serverCommandItem in serverCommandList.items():
|
||
self.serverCommander.SAFE_RegisterCallBack(
|
||
serverCommandItem[0], serverCommandItem[1]
|
||
)
|
||
|
||
def BINARY_ServerCommand_Run(self, line):
|
||
#dbg.TraceError(line)
|
||
try:
|
||
#print " BINARY_ServerCommand_Run", line
|
||
return self.serverCommander.Run(line)
|
||
except RuntimeError, msg:
|
||
dbg.TraceError(msg)
|
||
return 0
|
||
|
||
def __ProcessPreservedServerCommand(self):
|
||
try:
|
||
command = net.GetPreservedServerCommand()
|
||
while command:
|
||
print " __ProcessPreservedServerCommand", command
|
||
self.serverCommander.Run(command)
|
||
command = net.GetPreservedServerCommand()
|
||
except RuntimeError, msg:
|
||
dbg.TraceError(msg)
|
||
return 0
|
||
|
||
def PartyHealReady(self):
|
||
self.interface.PartyHealReady()
|
||
|
||
def AskSafeboxPassword(self):
|
||
self.interface.AskSafeboxPassword()
|
||
|
||
# ITEM_MALL
|
||
def AskMallPassword(self):
|
||
self.interface.AskMallPassword()
|
||
|
||
def __ItemMall_Open(self):
|
||
self.interface.OpenItemMall();
|
||
|
||
def CommandCloseMall(self):
|
||
self.interface.CommandCloseMall()
|
||
# END_OF_ITEM_MALL
|
||
|
||
def RefineSuceededMessage(self):
|
||
snd.PlaySound("sound/ui/make_soket.wav")
|
||
self.PopupMessage(locale.REFINE_SUCCESS)
|
||
|
||
def RefineFailedMessage(self):
|
||
snd.PlaySound("sound/ui/jaeryun_fail.wav")
|
||
self.PopupMessage(locale.REFINE_FAILURE)
|
||
|
||
def CommandCloseSafebox(self):
|
||
self.interface.CommandCloseSafebox()
|
||
|
||
# PRIVATE_SHOP_PRICE_LIST
|
||
def __PrivateShop_PriceList(self, itemVNum, itemPrice):
|
||
uiPrivateShopBuilder.SetPrivateShopItemPrice(itemVNum, itemPrice)
|
||
# END_OF_PRIVATE_SHOP_PRICE_LIST
|
||
|
||
def __Horse_HideState(self):
|
||
self.affectShower.SetHorseState(0, 0, 0)
|
||
|
||
def __Horse_UpdateState(self, level, health, battery):
|
||
self.affectShower.SetHorseState(int(level), int(health), int(battery))
|
||
|
||
def __IsXMasMap(self):
|
||
mapDict = ( "metin2_map_n_flame_01",
|
||
"metin2_map_n_desert_01",
|
||
"metin2_map_spiderdungeon",
|
||
"metin2_map_deviltower1", )
|
||
|
||
if background.GetCurrentMapName() in mapDict:
|
||
return FALSE
|
||
|
||
return TRUE
|
||
|
||
def __XMasSnow_Enable(self, mode):
|
||
|
||
self.__XMasSong_Enable(mode)
|
||
|
||
if "1"==mode:
|
||
|
||
if not self.__IsXMasMap():
|
||
return
|
||
|
||
print "XMAS_SNOW ON"
|
||
background.EnableSnow(1)
|
||
|
||
else:
|
||
print "XMAS_SNOW OFF"
|
||
background.EnableSnow(0)
|
||
|
||
def __XMasBoom_Enable(self, mode):
|
||
if "1"==mode:
|
||
|
||
if not self.__IsXMasMap():
|
||
return
|
||
|
||
print "XMAS_BOOM ON"
|
||
self.__DayMode_Update("dark")
|
||
self.enableXMasBoom = TRUE
|
||
self.startTimeXMasBoom = app.GetTime()
|
||
else:
|
||
print "XMAS_BOOM OFF"
|
||
self.__DayMode_Update("light")
|
||
self.enableXMasBoom = FALSE
|
||
|
||
def __XMasTree_Enable(self, grade):
|
||
|
||
print "XMAS_TREE ", grade
|
||
background.SetXMasTree(int(grade))
|
||
|
||
def __XMasSong_Enable(self, mode):
|
||
if "1"==mode:
|
||
print "XMAS_SONG ON"
|
||
|
||
XMAS_BGM = "xmas.mp3"
|
||
|
||
if app.IsExistFile("BGM/" + XMAS_BGM)==1:
|
||
if musicInfo.fieldMusic != "":
|
||
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)
|
||
|
||
musicInfo.fieldMusic=XMAS_BGM
|
||
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
|
||
|
||
else:
|
||
print "XMAS_SONG OFF"
|
||
|
||
if musicInfo.fieldMusic != "":
|
||
snd.FadeOutMusic("BGM/" + musicInfo.fieldMusic)
|
||
|
||
musicInfo.fieldMusic=musicInfo.METIN2THEMA
|
||
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
|
||
|
||
def __RestartDialog_Close(self):
|
||
self.interface.CloseRestartDialog()
|
||
|
||
def __Console_Enable(self):
|
||
constInfo.CONSOLE_ENABLE = TRUE
|
||
self.consoleEnable = TRUE
|
||
app.EnableSpecialCameraMode()
|
||
ui.EnablePaste(TRUE)
|
||
|
||
## PrivateShop
|
||
def __PrivateShop_Open(self):
|
||
self.interface.OpenPrivateShopInputNameDialog()
|
||
|
||
def BINARY_PrivateShop_Appear(self, vid, text):
|
||
self.interface.AppearPrivateShop(vid, text)
|
||
|
||
def BINARY_PrivateShop_Disappear(self, vid):
|
||
self.interface.DisappearPrivateShop(vid)
|
||
|
||
## DayMode
|
||
def __PRESERVE_DayMode_Update(self, mode):
|
||
if "light"==mode:
|
||
background.SetEnvironmentData(0)
|
||
elif "dark"==mode:
|
||
|
||
if not self.__IsXMasMap():
|
||
return
|
||
|
||
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
|
||
background.SetEnvironmentData(1)
|
||
|
||
def __DayMode_Update(self, mode):
|
||
if "light"==mode:
|
||
self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToLight)
|
||
elif "dark"==mode:
|
||
|
||
if not self.__IsXMasMap():
|
||
return
|
||
|
||
self.curtain.SAFE_FadeOut(self.__DayMode_OnCompleteChangeToDark)
|
||
|
||
def __DayMode_OnCompleteChangeToLight(self):
|
||
background.SetEnvironmentData(0)
|
||
self.curtain.FadeIn()
|
||
|
||
def __DayMode_OnCompleteChangeToDark(self):
|
||
background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)
|
||
background.SetEnvironmentData(1)
|
||
self.curtain.FadeIn()
|
||
|
||
## XMasBoom
|
||
def __XMasBoom_Update(self):
|
||
|
||
self.BOOM_DATA_LIST = ( (2, 5), (5, 2), (7, 3), (10, 3), (20, 5) )
|
||
if self.indexXMasBoom >= len(self.BOOM_DATA_LIST):
|
||
return
|
||
|
||
boomTime = self.BOOM_DATA_LIST[self.indexXMasBoom][0]
|
||
boomCount = self.BOOM_DATA_LIST[self.indexXMasBoom][1]
|
||
|
||
if app.GetTime() - self.startTimeXMasBoom > boomTime:
|
||
|
||
self.indexXMasBoom += 1
|
||
|
||
for i in xrange(boomCount):
|
||
self.__XMasBoom_Boom()
|
||
|
||
def __XMasBoom_Boom(self):
|
||
x, y, z = player.GetMainCharacterPosition()
|
||
randX = app.GetRandom(-150, 150)
|
||
randY = app.GetRandom(-150, 150)
|
||
|
||
snd.PlaySound3D(x+randX, -y+randY, z, "sound/common/etc/salute.mp3")
|
||
|
||
def __PartyRequestQuestion(self, vid):
|
||
vid = int(vid)
|
||
partyRequestQuestionDialog = uiCommon.QuestionDialog()
|
||
partyRequestQuestionDialog.SetText(chr.GetNameByVID(vid) + locale.PARTY_DO_YOU_ACCEPT)
|
||
partyRequestQuestionDialog.SetAcceptText(locale.UI_ACCEPT)
|
||
partyRequestQuestionDialog.SetCancelText(locale.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(locale.PARTY_REQUEST_DENIED)
|
||
|
||
def __EnableTestServerFlag(self):
|
||
app.EnableTestServerFlag()
|
||
|
||
def __InGameShop_Show(self, url):
|
||
if constInfo.IN_GAME_SHOP_ENABLE:
|
||
self.interface.OpenWebWindow(url)
|
||
|
||
# WEDDING
|
||
def __LoginLover(self):
|
||
if self.interface.wndMessenger:
|
||
self.interface.wndMessenger.OnLoginLover()
|
||
|
||
def __LogoutLover(self):
|
||
if self.interface.wndMessenger:
|
||
self.interface.wndMessenger.OnLogoutLover()
|
||
if self.affectShower:
|
||
self.affectShower.HideLoverState()
|
||
|
||
def __LoverNear(self):
|
||
if self.affectShower:
|
||
self.affectShower.ShowLoverState()
|
||
|
||
def __LoverFar(self):
|
||
if self.affectShower:
|
||
self.affectShower.HideLoverState()
|
||
|
||
def __LoverDivorce(self):
|
||
if self.interface.wndMessenger:
|
||
self.interface.wndMessenger.ClearLoverInfo()
|
||
if self.affectShower:
|
||
self.affectShower.ClearLoverState()
|
||
|
||
def __PlayMusic(self, flag, filename):
|
||
flag = int(flag)
|
||
if flag:
|
||
snd.FadeOutAllMusic()
|
||
musicInfo.SaveLastPlayFieldMusic()
|
||
snd.FadeInMusic("BGM/" + filename)
|
||
else:
|
||
snd.FadeOutAllMusic()
|
||
musicInfo.LoadLastPlayFieldMusic()
|
||
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)
|
||
|
||
# END_OF_WEDDING
|
||
|
||
|