Skocz do zawartości

  • 👋 Witaj na MPCForum!

    Przeglądasz forum jako gość, co oznacza, że wiele świetnych funkcji jest jeszcze przed Tobą! 😎

    • ✅ Pełny dostęp do działów i ukrytych treści
    • ✅ Możliwość pisania i odpowiadania w tematach
    • ✅ System prywatnych wiadomości
    • ✅ Zbieranie reputacji i rozwijanie swojego profilu
    • ✅ Członkostwo w jednej z największych społeczności graczy

    👉 Dołączenie zajmie Ci mniej niż minutę – a zyskasz znacznie więcej!

    Zarejestruj się teraz

Radio w grze.

Pegas©

Przez Pegas©
w Kosz

Rekomendowane odpowiedzi

LesIOO Bywalec

LesIOO

Opublikowano
Bywalec

LesIOO

Opublikowano

Kto dokładnie wytłumaczy mi jak i gdzie zastąpić spacje tabulatorem bo nie ogarniam tego , ponieważ właśnie ładuje mi sie pasek do końca i nic się nie dzieje a nie moge podmienić tych plikczków

od robo ponieważ repacker moustik wtedy mi ich nie spakuje prosze o pomoc nagrodzę +

  • Odpowiedzi 60
  • Dodano
  • Ostatniej odpowiedzi
  • 2 tygodnie później...
Sparow Specjalista

Sparow

Opublikowano
Specjalista

Sparow

Opublikowano

Gdzie to trzeba poprawic by bylo pod F8

 

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 uievo2radio

 

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 locale

 

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

 

if locale.IsEUROPE():

SCREENSHOT_CWDSAVE = TRUE

# END_OF_SCREENSHOT_CWDSAVE

 

cameraDistance = 1550.0

cameraPitch = 27.0

cameraRotation = 0.0

cameraHeight = 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_F8] = lambda : self.__Radio()

 

onPressKeyDict[app.DIK_LALT] = lambda : self.ShowName()

onPressKeyDict[app.DIK_LCONTROL] = lambda : self.ShowMouseImage()

onPressKeyDict[app.DIK_SYSRQ] = lambda : self.SaveScreen()

onPressKeyDict[app.DIK_SPACE] = lambda : self.StartAttack()

 

#Äł¸ŻĹÍ Ŕ̵żĹ°

onPressKeyDict[app.DIK_UP] = lambda : self.MoveUp()

onPressKeyDict[app.DIK_DOWN] = lambda : self.MoveDown()

onPressKeyDict[app.DIK_LEFT] = lambda : self.MoveLeft()

onPressKeyDict[app.DIK_RIGHT] = lambda : self.MoveRight()

onPressKeyDict[app.DIK_W] = lambda : self.MoveUp()

onPressKeyDict[app.DIK_S] = lambda : self.MoveDown()

onPressKeyDict[app.DIK_A] = lambda : self.MoveLeft()

onPressKeyDict[app.DIK_D] = lambda : self.MoveRight()

 

onPressKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_TO_NEGATIVE)

#onPressKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_G] = self.__PressGKey

onPressKeyDict[app.DIK_Q] = self.__PressQKey

 

onPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()

onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)

onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)

onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()

onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()

onPressKeyDict[app.DIK_C] = lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)

onPressKeyDict[app.DIK_V] = lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)

#onPressKeyDict[app.DIK_B] = lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)

onPressKeyDict[app.DIK_N] = lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)

onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()

onPressKeyDict[app.DIK_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, str):

if locale.WHISPER_ERROR.has_key(mode):

chat.AppendWhisper(chat.WHISPER_TYPE_INFO, name, locale.WHISPER_ERROR[mode](name))

elif mode == 4:

chat.AppendWhisper(chat.WHISPER_TYPE_INFO, name, str)

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):

#

# Äł¸ŻĹÍ ÁÂÇĄ ą× 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

 

 

 

 

bez YT

watus Mentor

watus

Opublikowano
Mentor

watus

Opublikowano

ja na koncu pliku bym dodal

# RADIO_NA_F8
def __Radio(self):
               import uievo2radio
               import snd
               snd.PlaySound("sound/ui/money.wav")
               self.evo2radioDlg = uievo2radio.RadioDialog()
               self.evo2radioDlg.Show()
               self.__ResetChat()
               return
# KONIEC_RADIO_NA_F8

ale nie wiem czy to zadziała

Sparow Specjalista

Sparow

Opublikowano
Specjalista

Sparow

Opublikowano

ja na koncu pliku bym dodal

# RADIO_NA_F8
def __Radio(self):
               import uievo2radio
               import snd
               snd.PlaySound("sound/ui/money.wav")
               self.evo2radioDlg = uievo2radio.RadioDialog()
               self.evo2radioDlg.Show()
               self.__ResetChat()
               return
# KONIEC_RADIO_NA_F8

ale nie wiem czy to zadziała

 

a nie powinno byc czasami to co wyzej podano a nie jak ty podajesz? chodzi o to ze tu trzeba w odpowiednim miejscu raczej umiescic a nie napisali gdzie dokladnie.

 

 def __Radio(self):
               import uievo2radio
               import snd
               snd.PlaySound("sound/ui/money.wav")
               self.evo2radioDlg = uievo2radio.RadioDialog()
               self.evo2radioDlg.Show()
               self.__ResetChat()
               return

 

moze ktos co juz to ma poda gotowca:

bez YT

sebbo14 Pomocnik

sebbo14

Opublikowano
Pomocnik

sebbo14

Opublikowano

Właśnie przy ładowaniu pasek się zatrzymuje i można tak czekać w nieskończoność, gdy dodam to na F8 do game.py huh.gif. Odpowie ktoś może jak to zrobić poprawnie żeby było na F8 i normalnie działało? rolleyes.gif

21278_03_06_11_2_06_12_0.png

SEBBO14

 

Naciśnij

add.png

old_kwiatosz Arcymistrz

old_kwiatosz

Opublikowano
Arcymistrz

old_kwiatosz

Opublikowano

Łap od robo113:

Down:

http://www.sendspace.com/file/3ocht5
lub ten
http://www.sendspace.com/file/nhj9lw

Skan:

http://www.virustotal.com/file-scan/report.html?id=93935895030d1c1b31d5f385a157abd57c7903cdf95d7aa008a96a07d4a35010-1306781770
http://www.virustotal.com/file-scan/report.html?id=908456f21f615e06aba21f92290abb899fa26b53f3e8ddcf99125c0ae874c7ff-1306783215

Sparow Specjalista

Sparow

Opublikowano
Specjalista

Sparow

Opublikowano

Łap od robo113:

Down:

http://www.sendspace.com/file/3ocht5
lub ten
http://www.sendspace.com/file/nhj9lw

Skan:

http://www.virustotal.com/file-scan/report.html?id=93935895030d1c1b31d5f385a157abd57c7903cdf95d7aa008a96a07d4a35010-1306781770
http://www.virustotal.com/file-scan/report.html?id=908456f21f615e06aba21f92290abb899fa26b53f3e8ddcf99125c0ae874c7ff-1306783215

 

 

Te od robo nie dziala

po wyborze postaci pasek sie laduje do konca i tak w nieskonczonosc.

brakuje tam wpisow.

 

Ja to uruchomilem ale jak sie uruchomi jakies radio to jest chwilowy lag i wywala blad skryptu.

Wiec by takie radio zadzialalo trzeba bedzie raczej czegos innego sprobowac.

bez YT

sebbo14 Pomocnik

sebbo14

Opublikowano
Pomocnik

sebbo14

Opublikowano

Dobra, teraz mam kolejny problem.... Wybieram stację i pojawia się strona z IE "Ten program nie może wyświetlić strony sieci web"huh.gif. Dodam, że to samo jest, gdy klikam na złotą monetę (IS).

Co może być tego przyczyną?

21278_03_06_11_2_06_12_0.png

SEBBO14

 

Naciśnij

add.png

  • 1 miesiąc temu...
ZorQ Bywalec

ZorQ

Opublikowano
Bywalec

ZorQ

Opublikowano

@Up okienko się zamyka ESC ;P

Poszukuje pluginu Gr2 do 3Ds max 2012.

haac.jpg

 

Jestem jaki jestem i tego NIE zmienię!

 

 

 

Moje Tut'y

 

Video tut jak dodać mapę na swój serwer: 

http://www.mpcforum.pl/topic/416201-videotut-jak-dodac-mape-na-wlasny-serwer/page__gopid__2960589#entry2960589

Texture Mod: 

http://www.mpcforum.pl/topic/406659-download-texture-mod/page__p__2892270__fromsearch__1#entry2892270

Znaczek GM: 

http://www.mpcforum.pl/topic/367597-dl-znaczek-gm/page__p__2603024__fromsearch__1#entry2603024

Nowe Zbroje By Baso:

http://www.mpcforum.pl/topic/478940-dltutzbroje-by-baso/

 

ZorQ Bywalec

ZorQ

Opublikowano
Bywalec

ZorQ

Opublikowano

Sorki, źle zrozumiałem twój post ;] Jak chcesz mieć okienko żeby Ci nie przeszkadzało w grze przesuń je w niewidoczne miejsce ;d

Poszukuje pluginu Gr2 do 3Ds max 2012.

haac.jpg

 

Jestem jaki jestem i tego NIE zmienię!

 

 

 

Moje Tut'y

 

Video tut jak dodać mapę na swój serwer: 

http://www.mpcforum.pl/topic/416201-videotut-jak-dodac-mape-na-wlasny-serwer/page__gopid__2960589#entry2960589

Texture Mod: 

http://www.mpcforum.pl/topic/406659-download-texture-mod/page__p__2892270__fromsearch__1#entry2892270

Znaczek GM: 

http://www.mpcforum.pl/topic/367597-dl-znaczek-gm/page__p__2603024__fromsearch__1#entry2603024

Nowe Zbroje By Baso:

http://www.mpcforum.pl/topic/478940-dltutzbroje-by-baso/

 

dominikczek Specjalista

dominikczek

Opublikowano
Specjalista

dominikczek

Opublikowano

Mógł by ktos mi zrobic takie radio ale wsadzić do plików kamer moda ?? bo ja próbuje ale na próżno. Jak by mi ktos zrobil pod pliki kmr moda to dał bym limit + albo - przez tydzien

f82adac946184c36574a8521c877970c.gif

  • 5 miesięcy temu...
profilus=) Znawca

profilus=)

Opublikowano
Znawca

profilus=)

Opublikowano

@up zrob sobie..

 

chyba umiesz wypakować root a jak nie to wypakuje CI ale tak po 21 bo na silke teraz jade. jak cos pw

Nigdy nie trać czasu dla kogoś, kto nie ma go dla Ciebie ! :))

  • 1 miesiąc temu...
FreakySilver Uczeń

FreakySilver

Opublikowano
Uczeń

FreakySilver

Opublikowano

Mam root i locale_pl z klienta 2010 a mój cały klient jest z 2012_PL

Wywala do pulpitu po załadowaniu paska...

Wszystko dodaję dobrze na 99%

HELP!

  • 1 miesiąc temu...
  • 2 miesiące temu...
groky02 Pomocnik

groky02

Opublikowano
Pomocnik

groky02

Opublikowano

upload na epvp dziala.

 

Radio bardzo proste, sam kod wrzucenia przyciskow i tablicy to 99,9% calosci, wlasciwa linijka kodu ktory odtworzy muzyke to:

app.ShowWebPage("http://www.sourcetunes.com/multiplayer/play.php?page=start&station_id=9&title=Player", (sx, sy, ex, ey))

gdzie sx,sy,ex,ey to pozycje rogow okna web w ktorym otwiera sie strona z playerem, zeby to ukryc starczy wrzucic pozycje na minusie.

Unbanned :]

Wszelkie pytania/wiadomości kierować na

Misiekantos253

  • 4 miesiące temu...
Silver™ Mentor

Silver™

Opublikowano
Mentor

Silver™

Opublikowano

@UP nie opłaca sie tego robić .. Czemu? Bo przy jednej osobie na serwie zużywa się ilość ramu + radio przy każdym graczu = większe lagi , nie ma po co tego instalować.

Dłuższej grafiki się nie dało?
 

Zarchiwizowany

Ten temat przebywa obecnie w archiwum. Dodawanie nowych odpowiedzi zostało zablokowane.

Tematy
×
×
  • Dodaj nową pozycję...