Bienvenidos a Metin2 Broken.

 

En este servidor le espera un mundo lleno de aventuras y fantasias. Los [GM] mas amigables que jamas pueda encontrar estan aqui. Cosas nuevas, armas y armaduras esperan a ser estrenadas por ti, donde le esperan infinidades de aventuras y esperanzas. Te esperamos en Metin2 Broken, ahora mas que nunca...

Reglas del chat...

-No spam

-No flood

-No copiar nombres (tanto de GM como de otros usuarios)

-No anunciar otros Metin.

-No insultar

 

Solo hay 5 reglas asi que porfavor respeten.

 

[Staff] Metin2 Broken

 

[SGA]Kyurem


[SGM]Alucard

[GM]Craker

 

[MOD]Gato

[MOD]PrinzeAle

 



          Mozila Firefox

 

Les recomendamos que para tener una mejor navegacion tanto por nuestra pagina web como por cualquier otra pagina, usen uno de los siguientes dos navegadores, ya que no se arrepentiran.

 

http://www.mozilla.org/es-ES/firefox/new/

 

Link 100% libre de virus.

        Google Chrome

Tambien pueden usar el famoso Google Chrome ya que gracias a sus nuevas funciones de memoria, de navegacion mas facil y muchas otras utilidades (entre ellas) unas descargas mas rapidas y faciles y mejor calidad en navegacion le resultara mucho mas atractivo y facil de usar.

 

http://www.google.com/chrome/eula.html?hl=es

 

Link 100% libre de virus.

##################### Mt2Rayo by [SGA]Arthur ####################import osimport appimport dbgimport grpimport itemimport backgroundimport chrimport chrmgrimport playerimport sndimport chatimport textTailimport sndimport netimport effectimport wndMgrimport flyimport systemSettingimport questimport guildimport skillimport messengerimport localeimport constInfoimport exchangeimport ime
import uiimport uiCommonimport uiPhaseCurtainimport uiMapNameShowerimport uiAffectShowerimport uiPlayerGaugeimport uiCharacterimport uiTarget
# PRIVATE_SHOP_PRICE_LISTimport uiPrivateShopBuilder# END_OF_PRIVATE_SHOP_PRICE_LIST
import mouseModuleimport consoleModuleimport locale
import playerSettingModuleimport interfaceModule
import musicInfoimport debugInfoimport stringCommander
from _weakref import proxy
# TEXTTAIL_LIVINGTIME_CONTROLif locale.IsJAPAN(): app.SetTextTailLivingTime(8.0)# END_OF_TEXTTAIL_LIVINGTIME_CONTROL
# SCREENSHOT_CWDSAVESCREENSHOT_CWDSAVE = FALSE
if locale.IsEUROPE(): SCREENSHOT_CWDSAVE = TRUE# END_OF_SCREENSHOT_CWDSAVE
cameraDistance = 1550.0cameraPitch = 27.0cameraRotation = 0.0cameraHeight = 100.0
testAlignment = 0
class GameWindow(ui.ScriptWindow): canQuestLettersShow = 1 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.SetMusicVolumef(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
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.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 ´Â ´©¸£°í ÀÖ´Â µ¿¾È °è¼Ó Àû¿ëµÇ´Â Å°ÀÌ´Ù. ## ¼ýÀÚ ´ÜÃàÅ° Äü½½·Ô¿¡ ÀÌ¿ëµÈ´Ù.(ÀÌÈÄ ¼ýÀڵ鵵 Äü ½½·Ô¿ë ¿¹¾à) ## F12 ´Â Ŭ¶ó µð¹ö±×¿ë Å°À̹ǷΠ¾²Áö ¾Ê´Â °Ô ÁÁ´Ù. onPressKeyDict[app.DIK_1] = lambda : self.__PressNumKey(1) onPressKeyDict[app.DIK_2] = lambda : self.__PressNumKey(2) onPressKeyDict[app.DIK_3] = lambda : self.__PressNumKey(3) onPressKeyDict[app.DIK_4] = lambda : self.__PressNumKey(4) onPressKeyDict[app.DIK_5] = lambda : self.__PressNumKey(5) onPressKeyDict[app.DIK_6] = lambda : self.__PressNumKey(6) onPressKeyDict[app.DIK_7] = lambda : self.__PressNumKey(7) onPressKeyDict[app.DIK_8] = lambda : self.__PressNumKey(8) onPressKeyDict[app.DIK_9] = lambda : self.__PressNumKey(9) onPressKeyDict[app.DIK_F1] = lambda : self.__PressQuickSlot(4) onPressKeyDict[app.DIK_F2] = lambda : self.__PressQuickSlot(5) onPressKeyDict[app.DIK_F3] = lambda : self.__PressQuickSlot(6) onPressKeyDict[app.DIK_F4] = lambda : self.__PressQuickSlot(7)
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¸¯ÅÍ À̵¿Å° 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_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): if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL): pass else: app.PitchCamera(app.CAMERA_STOP)
def __PressQKey(self): if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL): if 0!=self.canQuestLettersShow: self.interface.HideAllQuestButton() self.canQuestLettersShow = 0 else: self.interface.ShowAllQuestButton() self.canQuestLettersShow = 1 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): 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() else: self.PrintCoord.Hide() self.FrameRate.Hide() self.Pitch.Hide() self.Splat.Hide() self.TextureNum.Hide() self.ObjectNum.Hide() self.ViewDistance.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)
# TextureNum self.TextureNum = ui.TextLine() self.TextureNum.SetFontName(locale.UI_DEF_FONT) self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 80)
# ¿ÀºêÁ§Æ® ±×¸®´Â °³¼ö self.ObjectNum = ui.TextLine() self.ObjectNum.SetFontName(locale.UI_DEF_FONT) self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)
# ½Ã¾ß°Å¸® 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)
def BINARY_NEW_RemoveAffect(self, type, pointIdx): self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx) # 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)
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, name, line): chat.AppendWhisper(chat.WHISPER_TYPE_CHAT, name, line) self.interface.RecvWhisper(name)
def OnRecvWhisperSystemMessage(self, name, line): chat.AppendWhisper(chat.WHISPER_TYPE_INFO, name, line) self.interface.RecvWhisper(name)
def OnRecvWhisperError(self, mode, name): if locale.WHISPER_ERROR.has_key(mode): chat.AppendWhisper(chat.WHISPER_TYPE_INFO, name, locale.WHISPER_ERROR[mode](name)) else: chat.AppendWhisper(chat.WHISPER_TYPE_INFO, 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) 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 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)
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 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, attachedItemSlotPos, attachedItemCount) else: net.SendExchangeStartPacket(dstChrID) net.SendExchangeItemAddPacket(attachedItemSlotPos, 0) else: self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)
def __PutMoney(self, attachedType, attachedMoney, dstChrID): if TRUE == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID: net.SendExchangeStartPacket(dstChrID) net.SendExchangeElkAddPacket(attachedMoney) else: self.__DropMoney(attachedType, attachedMoney)
def __DropMoney(self, attachedType, attachedMoney): # PRIVATESHOP_DISABLE_ITEM_DROP - °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö if uiPrivateShopBuilder.IsBuildingPrivateShop(): chat.AppendChat(chat.CHAT_TYPE_INFO, 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 - °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ ¹ö¸² ¹æÁö if uiPrivateShopBuilder.IsBuildingPrivateShop(): chat.AppendChat(chat.CHAT_TYPE_INFO, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP) return # END_OF_PRIVATESHOP_DISABLE_ITEM_DROP if player.IsEquipmentSlot(attachedItemSlotPos): self.stream.popupWindow.Close() self.stream.popupWindow.Open(locale.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, locale.UI_OK)
else: 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
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
self.itemDropQuestionDialog.Close() self.itemDropQuestionDialog = None
# PRIVATESHOP_DISABLE_ITEM_DROP def __SendDropItemPacket(self, itemVNum, itemCount): if uiPrivateShopBuilder.IsBuildingPrivateShop(): chat.AppendChat(chat.CHAT_TYPE_INFO, locale.DROP_ITEM_FAILURE_PRIVATE_SHOP) return
net.SendItemDropPacketNew(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¸¯ÅÍ ÁÂÇ¥ ¹× FPS Ãâ·Â (x, y, z) = player.GetMainCharacterPosition() nUpdateTime = app.GetUpdateTime() nUpdateFPS = app.GetUpdateFPS() nRenderFPS = app.GetRenderFPS() nFaceCount = app.GetFaceCount() fFaceSpeed = app.GetFaceSpeed() nST=background.GetRenderShadowTime() (fAveRT, nCurRT) =  app.GetRenderTime() (iNum, fFogStart, fFogEnd, fFarCilp) = background.GetDistanceSetInfo() (iPatch, iSplat, fSplatRatio, sTextureNum) = background.GetRenderedSplatNum() if iPatch == 0: iPatch = 1
#(dwRenderedThing, dwRenderedCRC) = background.GetRenderedGraphicThingInstanceNum()
self.PrintCoord.SetText("Coordinate: %.2f %.2f %.2f ATM: %d" % (x, y, z, app.GetAvailableTextureMemory()/(1024*1024)))
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
# CUBE def BINARY_Cube_Open(self): self.interface.OpenCubeWindow()
def BINARY_Cube_Close(self): self.interface.CloseCubeWindow()
def BINARY_Cube_Succeed(self, itemVnum, count): print "Å¥ºê Á¦ÀÛ ¼º°ø" self.interface.SucceedCubeWork(itemVnum, count) pass
def BINARY_Cube_Failed(self): print "Å¥ºê Á¦ÀÛ ½ÇÆÐ" #self.PopupMessage(locale.CUBE_FAILURE) pass
# END_OF_CUBE 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

Hora (España)

Ipod y...a bailar!


MusicPlaylist

Visitas

free counters

 

  Redes sociales de Internet