Pliki do nowego wyglądu ekwipunku.

teusz0724k · 20 Kwietnia 2014

Witam, robię nowy wygląd ekwipunku, 50% mam już za sobą teraz tylko musze podmienić/wrzucić te pliki lecz nie wiem gdzie. Oto one:

1.tga

1close.tga

1v.tga

2.tga

2close.tga

2v.tga

3.tga

3v.tga

inventar3r.tga

inventar.tga

inventar_2.tga

inventar_backup.tga

inventtar3.tga

x.tga

yang.tga

inwentorywindow.py podmieniłem ale nie wiem gdzie te.

Pisząc w pliku game.py z tematu epvp była taka lokalizacja jak np. ("locale/ae/ui/pattern/titlebar_left.tga")

Lecz nie mam żadnego folderu o nazwie ae, pattern. Gdzie wgrać/podmienić te pliki ?

Zagrajmarek · 20 Kwietnia 2014

Ale to są ikony broni/zbroi czy czego?

Tutaj masz poradnik:

http://www.mpcforum.pl/topic/580343-megatut-jak-poprawnie-dodac-zbroje-bronie-i-moby-na-serwerclient/

teusz0724k · 20 Kwietnia 2014

Tzn. nie robie zbrojek/broni tylko nowy wygląd ekwipunku,

xxx

po pobraniu tego downloadu mam pliki

diff game 2089

locale / ro

root

Zagrajmarek · 20 Kwietnia 2014

Wrzuć je do:

extracted\icon\icon\item

I sprawdź czy zadziała.

teusz0724k · 20 Kwietnia 2014

Czyli rozpakować plik icon i poszukać folderu item ?

I jeszcze gdzie wrzucić pliki z foderu diff game 2089 plik inventar oraz z folderu root plik uiinventory

LikeWeed · 20 Kwietnia 2014

Hmm.. w pliku zawierającym "nazwy" tych plików powinien być też adres gdzie go masz zamieścić :p

teusz0724k · 20 Kwietnia 2014

no właśnie nie ma :P zrobiłem tylko wpisy w game.py z TuT'a epvp oraz podmieniłem plik z folderu locale / ro / ui a reszte plików + foldery game diff 2089 locale i root nwm gdzie

LikeWeed · 20 Kwietnia 2014

Wrzuć mi inventorywindow jeśli możesz

teusz0724k · 20 Kwietnia 2014

http://speedy.sh/MwMnA/inventorywindow.py

https://www.virustotal.com/pl/file/a64042b1d6d1e4f14397c3fa647d92b3bb4559761e3f58c9bbf467db4186436d/analysis/

LikeWeed · 20 Kwietnia 2014

Ja tu nic nowego nie widze. Same standardowe pliczki

teusz0724k · 20 Kwietnia 2014

To dam Ci inventorywindow.py z tamtego tematu:

http://speedy.sh/GdGfH/inventorywindow.py

http://pl.tinypic.com/r/11ke3vk/8

LikeWeed · 20 Kwietnia 2014

Wszystko ma być w locale. i nie rób locale/ro/ tylko wrzuć do locale/pl/ i przeczyta.

obrazki: locale/ :p

teusz0724k · 20 Kwietnia 2014

obrazki ? mam tylko foldery z plikami

warnox · 20 Kwietnia 2014

te all pliki co wymieniłeś wrzucasz do locale_pl

aby Ścieszka bo pliku była taka np :

locale/yang.tga

teusz0724k · 20 Kwietnia 2014

~~dobra to ostatnia rzecz, co zrobić z folderem game diff 2089 ? w nim jest plik inventar, pobrałem game diff od terenza, wklejam go do files, daje wgraj diff jednak nic sie nie dzieje~~

Pobrałem już game, wgrałem diffa, jednak gdy odpalam serwer to wyskakuje błąd:

Sysser:

0420 14:30:19109 :: ============================================================================================================

0420 14:30:19109 :: Abort!!!!

0420 14:30:19124 :: granny_shared_vbs:

0420 14:30:19124 :: 0: 0

0420 14:30:19124 :: 1: 0

0420 14:30:19124 :: 2: 0

0420 14:30:19124 :: 3: 0

0420 14:30:19124 :: 4: 0

0420 14:30:19124 :: 5: 0

0420 14:30:19124 :: 6: 0

0420 14:30:19124 :: 7: 0

0420 14:30:19124 :: 8: 0

Dodam jeszcze mój plik Game.py w którym podejrzewam że źle wpisałem linijki.

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 time

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

czas = time.strftime("%H%M", time.localtime())

czas = int(czas)

if 2000<=czas<=2359 or 0000<=czas<=0630:

background.RegisterEnvironmentData(1, constInfo.ENVIRONMENT_NIGHT)

background.SetEnvironmentData(1)

# START_GAME_ERROR_EXIT

try:

self.StartGame()

except:

import exception

exception.Abort("GameWindow.Open")

# END_OF_START_GAME_ERROR_EXIT

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

#Äł¸ŻĹÍ ŔĚµżĹ°

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

constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)

try:

self.onPressKeyDict[key]()

except KeyError:

pass

except:

raise

return TRUE

def OnKeyUp(self, key):

try:

self.onClickKeyDict[key]()

except KeyError:

pass

except:

raise

return TRUE

def OnMouseLeftButtonDown(self):

if self.interface.BUILD_OnMouseLeftButtonDown():

return

if mouseModule.mouseController.isAttached():

self.CheckFocus()

else:

hyperlink = ui.GetHyperlink()

if hyperlink:

return

else:

self.CheckFocus()

player.SetMouseState(player.MBT_LEFT, player.MBS_PRESS);

return TRUE

def OnMouseLeftButtonUp(self):

if self.interface.BUILD_OnMouseLeftButtonUp():

return

if mouseModule.mouseController.isAttached():

attachedType = mouseModule.mouseController.GetAttachedType()

attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()

## QuickSlot

if player.SLOT_TYPE_QUICK_SLOT == attachedType:

player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)

## Inventory

elif player.SLOT_TYPE_INVENTORY == attachedType:

if player.ITEM_MONEY == attachedItemIndex:

self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)

else:

self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)

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

constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(1)

def RequestDropItem(self, answer):

if not self.itemDropQuestionDialog:

return

if answer:

dropType = self.itemDropQuestionDialog.dropType

dropCount = self.itemDropQuestionDialog.dropCount

dropNumber = self.itemDropQuestionDialog.dropNumber

if player.SLOT_TYPE_INVENTORY == dropType:

if dropNumber == player.ITEM_MONEY:

net.SendGoldDropPacketNew(dropCount)

snd.PlaySound("sound/ui/money.wav")

else:

self.__SendDropItemPacket(dropNumber, dropCount)

self.itemDropQuestionDialog.Close()

self.itemDropQuestionDialog = None

constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)

# 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_desert_01", )

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

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

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

teusz0724k · 21 Kwietnia 2014

@Ref

teusz0724k · 23 Kwietnia 2014

@Ref

Zaloguj się

👋 Witaj na MPCForum!

Pliki do nowego wyglądu ekwipunku.

Rekomendowane odpowiedzi

teusz0724k

teusz0724k

Zagrajmarek

Zagrajmarek

teusz0724k

teusz0724k

Zagrajmarek

Zagrajmarek

teusz0724k

teusz0724k

LikeWeed

LikeWeed

teusz0724k

teusz0724k

LikeWeed

LikeWeed

teusz0724k

teusz0724k

LikeWeed

LikeWeed

teusz0724k

teusz0724k

LikeWeed

LikeWeed

teusz0724k

teusz0724k

warnox

warnox

teusz0724k

teusz0724k

teusz0724k

teusz0724k

teusz0724k

teusz0724k

Zarchiwizowany