lukino2803
-
Posts
4 -
Joined
-
Last visited
-
Feedback
0%
Content Type
Forums
Store
Third Party - Providers Directory
Feature Plan
Release Notes
Docs
Events
Posts posted by lukino2803
-
-
Ou sorry ... 1,uicube.py:
Quoteimport ui
import net
import mouseModule
import player
import snd
import localeInfo
import item
import grp
import uiScriptLocale
import uiToolTipclass CubeResultWindow(ui.ScriptWindow):
def __init__(self):
ui.ScriptWindow.__init__(self)def __del__(self):
ui.ScriptWindow.__del__(self)def LoadWindow(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/CubeResultWindow.py")
except:
import exception
exception.Abort("CubeResultWindow.LoadDialog.LoadScript")try:
GetObject=self.GetChild
self.titleBar = GetObject("TitleBar")
self.btnClose = GetObject("CloseButton")
self.cubeSlot = GetObject("CubeSlot")except:
import exception
exception.Abort("CubeWindow.LoadDialog.BindObject")self.cubeSlot.SetOverInItemEvent(ui.__mem_func__(self.__OnOverInItem))
self.cubeSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OnOverOutItem))
self.titleBar.SetCloseEvent(ui.__mem_func__(self.__OnCloseButtonClick))
self.btnClose.SetEvent(ui.__mem_func__(self.__OnCloseButtonClick))
self.itemVnum = 0def Destroy(self):
self.ClearDictionary()
self.titleBar = None
self.btnClose = None
self.cubeSlot = None
self.tooltipItem = None
self.itemVnum = 0def SetItemToolTip(self, tooltipItem):
self.tooltipItem = tooltipItemdef SetCubeResultItem(self, itemVnum, count):
self.itemVnum = itemVnumif 0 == count:
count = 1self.cubeSlot.SetItemSlot(0, itemVnum, count)
def Open(self):
self.Show()def Close(self):
self.Hide()def __OnCloseButtonClick(self):
self.Close()def __OnOverInItem(self, slotIndex):
if self.tooltipItem:
if 0 != self.itemVnum:
self.tooltipItem.SetItemToolTip(self.itemVnum)def __OnOverOutItem(self):
if self.tooltipItem:
self.tooltipItem.HideToolTip()def OnPressEscapeKey(self):
if 0 != self.eventClose:
self.eventClose()
return TRUE
class CubeWindow(ui.ScriptWindow):def __init__(self):
ui.ScriptWindow.__init__(self)
self.xShopStart = 0
self.yShopStart = 0
self.isUsable = FALSEdef __del__(self):
ui.ScriptWindow.__del__(self)def LoadWindow(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/CubeWindow.py")
except:
import exception
exception.Abort("CubeWindow.LoadDialog.LoadScript")try:
GetObject=self.GetChild
if localeInfo.IsARABIC():
self.board = GetObject("board")
self.board.SetScale(-1.0, 1.0)
self.board.SetRenderingRect(-1.0, 0.0, 1.0, 0.0)
self.titleBar = GetObject("TitleBar")
self.btnAccept = GetObject("AcceptButton")
self.btnCancel = GetObject("CancelButton")
self.cubeSlot = GetObject("CubeSlot")
self.needMoney = GetObject("NeedMoney")
self.contentScrollbar = GetObject("contentScrollbar")
self.resultSlots = [GetObject("result1"), GetObject("result2"), GetObject("result3")]
self.materialSlots = [
[GetObject("material11"), GetObject("material12"), GetObject("material13"), GetObject("material14"), GetObject("material15")],
[GetObject("material21"), GetObject("material22"), GetObject("material23"), GetObject("material24"), GetObject("material25")],
[GetObject("material31"), GetObject("material32"), GetObject("material33"), GetObject("material34"), GetObject("material35")],
]
row = 0
for materialRow in self.materialSlots:
j = 0
for material in materialRow:
material.SetOverInItemEvent(lambda trash = 0, rowIndex = row, col = j: self.__OverInMaterialSlot(trash, rowIndex, col))
material.SetSelectItemSlotEvent(lambda trash = 0, rowIndex = row, col = j: self.__OnSelectMaterialSlot(trash, rowIndex, col))
material.SetOverOutItemEvent(lambda : self.__OverOutMaterialSlot())
j = j + 1
row = row + 1row = 0
for resultSlot in self.resultSlots:
resultSlot.SetOverInItemEvent(lambda trash = 0, rowIndex = row: self.__OverInCubeResultSlot(trash, rowIndex))
resultSlot.SetOverOutItemEvent(lambda : self.__OverOutMaterialSlot())
row = row + 1except:
import exception
exception.Abort("CubeWindow.LoadDialog.BindObject")self.contentScrollbar.SetScrollStep(0.15)
self.contentScrollbar.SetScrollEvent(ui.__mem_func__(self.OnScrollResultList))
self.cubeSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.__OnSelectEmptySlot))
self.cubeSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.__OnSelectItemSlot))
self.cubeSlot.SetOverInItemEvent(ui.__mem_func__(self.__OnOverInItem))
self.cubeSlot.SetOverOutItemEvent(ui.__mem_func__(self.__OnOverOutItem))
self.titleBar.SetCloseEvent(ui.__mem_func__(self.__OnCloseButtonClick))
self.btnCancel.SetEvent(ui.__mem_func__(self.__OnCloseButtonClick))
self.btnAccept.SetEvent(ui.__mem_func__(self.__OnAcceptButtonClick))self.cubeItemInfo = {}
self.cubeResultInfos = []
self.cubeMaterialInfos = {}self.tooltipItem = None
self.firstSlotIndex = 0
self.RESULT_SLOT_COUNT = len(self.resultSlots)
self.SLOT_SIZEX = 32
self.SLOT_SIZEY = 32
self.CUBE_SLOT_COUNTX = 8
self.CUBE_SLOT_COUNTY = 3def SetItemToolTip(self, itemTooltip):
self.tooltipItem = itemTooltipdef GetResultCount(self):
return len(self.cubeResultInfos)def OnScrollResultList(self):
count = self.GetResultCount()
scrollLineCount = max(0, count - self.RESULT_SLOT_COUNT)
startIndex = int(scrollLineCount * self.contentScrollbar.GetPos())if startIndex != self.firstSlotIndex:
self.firstSlotIndex = startIndex
self.Refresh()def AddCubeResultItem(self, itemVnum, count):
self.cubeResultInfos.append((itemVnum, count))
#self.Refresh()def AddMaterialInfo(self, itemIndex, orderIndex, itemVnum, itemCount):
if itemIndex not in self.cubeMaterialInfos:
self.cubeMaterialInfos[itemIndex] = [[], [], [], [], []]self.cubeMaterialInfos[itemIndex][orderIndex].append((itemVnum, itemCount))
#print "AddMaterialInfo", itemIndex, orderIndex, itemVnum, itemCount, self.cubeMaterialInfosdef ClearCubeResultItem(self):
self.cubeResultInfos = []
self.Refresh()def Destroy(self):
self.ClearDictionary()
self.titleBar = None
self.btnAccept = None
self.btnCancel = None
self.cubeSlot = None
self.tooltipItem = None
self.needMoney = Nonedef __OverOutMaterialSlot(self):
self.tooltipItem.SetCannotUseItemForceSetDisableColor(TRUE)
self.tooltipItem.HideToolTip()def __OverInCubeResultSlot(self, trash, resultIndex):
self.tooltipItem.ClearToolTip()
self.tooltipItem.SetCannotUseItemForceSetDisableColor(TRUE)metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(0)
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append((0, 0))#print "resultIndex, firstSlotIndex", resultIndex, self.firstSlotIndex
resultIndex = resultIndex + self.firstSlotIndex
itemVnum, itemCount = self.cubeResultInfos[resultIndex]self.tooltipItem.AddItemData(itemVnum, metinSlot, attrSlot)
# 재료를 클릭하면 인벤토리에서 해당 아이템을 찾아서 등록함.
def __OnSelectMaterialSlot(self, trash, resultIndex, materialIndex):
resultIndex = resultIndex + self.firstSlotIndex
if resultIndex not in self.cubeMaterialInfos:
returnmaterialInfo = self.cubeMaterialInfos[resultIndex]
materialCount = len(materialInfo[materialIndex])if 0 == materialCount:
returnfor itemVnum, itemCount in materialInfo[materialIndex]:
bAddedNow = FALSE # 이번에 클릭함으로써 아이템이 추가되었나?
item.SelectItem(itemVnum)
itemSizeX, itemSizeY = item.GetItemSize()# 제조에 필요한 만큼의 재료를 가지고 있는가?
if player.GetItemCountByVnum(itemVnum) >= itemCount:
for i in xrange(player.INVENTORY_SLOT_COUNT):
vnum = player.GetItemIndex(i)
count= player.GetItemCount(i)if vnum == itemVnum and count >= itemCount:
# 이미 같은 아이템이 등록되어 있는지 검사하고, 없다면 추가함
bAlreadyExists = FALSE
for slotPos, invenPos in self.cubeItemInfo.items():
if invenPos == i:
bAlreadyExists = TRUEif TRUE == bAlreadyExists:
continue #continue inventory iterating#print "Cube Status : ", self.cubeItemInfo
# 여기 진입하면 큐브에 등록되지 않은 아이템이므로, 빈 큐브 슬롯에 해당 아이템 추가
bCanAddSlot = FALSE
for slotPos in xrange(self.cubeSlot.GetSlotCount()):
# 이 큐브 슬롯이 비어있는가?
if not slotPos in self.cubeItemInfo:
upperColumnItemSizeY = -1
currentSlotLine = int(slotPos / self.CUBE_SLOT_COUNTX)
cubeColumn = int(slotPos % self.CUBE_SLOT_COUNTX)
# 만약 큐브에 3칸짜리 아이템이 등록되어 있다면, 이 열(column)은 더 이상 볼 것도 없이 넘어간다
if cubeColumn in self.cubeItemInfo:
columnVNUM = player.GetItemIndex(self.cubeItemInfo[cubeColumn])
item.SelectItem(columnVNUM)
columnItemSizeX, columnItemSizeY = item.GetItemSize()if 3 == columnItemSizeY:
continue #continue cube slot iteratingif 0 < currentSlotLine and slotPos - self.CUBE_SLOT_COUNTX in self.cubeItemInfo:
upperColumnVNUM = player.GetItemIndex(self.cubeItemInfo[slotPos - self.CUBE_SLOT_COUNTX])
item.SelectItem(upperColumnVNUM)
columnItemSizeX, upperColumnItemSizeY = item.GetItemSize()
# 1칸짜리 아이템은 바로 윗줄에 한칸짜리 아이템이 있어야 함
if 1 == itemSizeY:
if 0 == currentSlotLine:
bCanAddSlot = TRUE
elif 1 == currentSlotLine and 1 == upperColumnItemSizeY:
bCanAddSlot = TRUE
elif 2 == currentSlotLine:
bCanAddSlot = TRUE
# 2칸짜리 아이템은 위아래가 비어있어야 함
elif 2 == itemSizeY:
if 0 == currentSlotLine and not cubeColumn + self.CUBE_SLOT_COUNTX in self.cubeItemInfo:
bCanAddSlot = TRUE
elif 1 == currentSlotLine and 1 == upperColumnItemSizeY and not cubeColumn + (self.CUBE_SLOT_COUNTX * 2) in self.cubeItemInfo:
bCanAddSlot = TRUE
# 3칸짜리 아이템은 해당 Column 자체가 모두 비어있어야 함
else:
if not cubeColumn in self.cubeItemInfo and not cubeColumn + self.CUBE_SLOT_COUNTX in self.cubeItemInfo and not cubeColumn + (self.CUBE_SLOT_COUNTX * 2) in self.cubeItemInfo:
bCanAddSlot = TRUEif TRUE == bCanAddSlot:
self.cubeItemInfo[slotPos] = i
self.cubeSlot.SetItemSlot(slotPos, vnum, count)
net.SendChatPacket("/cube add %d %d" % (slotPos, i))
bAddedNow = TRUEif TRUE == bAddedNow:
break #break cube slot iteratingif TRUE == bAddedNow:
break #break inventory iteratingif TRUE == bAddedNow:
break #break material iteratingdef __OverInMaterialSlot(self, trash, resultIndex, col):
self.tooltipItem.ClearToolTip()
self.tooltipItem.SetCannotUseItemForceSetDisableColor(FALSE)resultIndex = resultIndex + self.firstSlotIndex
if resultIndex not in self.cubeMaterialInfos:
returni = 0
materialInfo = self.cubeMaterialInfos[resultIndex]
materialCount = len(materialInfo[col])for itemVnum, count in materialInfo[col]:
item.SelectItem(itemVnum)
if player.GetItemCountByVnum(itemVnum) >= count:
self.tooltipItem.AppendTextLine("%s" % (item.GetItemName()), grp.GenerateColor(0.5411, 0.7254, 0.5568, 1.0)).SetFeather()
else:
self.tooltipItem.AppendTextLine("%s" % (item.GetItemName()), grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)).SetFeather()
if i < materialCount - 1:
self.tooltipItem.AppendTextLine(uiScriptLocale.CUBE_REQUIRE_MATERIAL_OR)
i = i + 1self.tooltipItem.Show()
def Open(self):
self.cubeItemInfo = {}
self.cubeResultInfos = []
self.cubeMaterialInfos = {}self.Refresh()
self.Show()self.isUsable = TRUE
(self.xShopStart, self.yShopStart, z) = player.GetMainCharacterPosition()def UpdateInfo(self, gold, itemVnum, count):
if self.needMoney:
self.needMoney.SetText(localeInfo.NumberToMoneyString(gold))self.Refresh()
def OnPressEscapeKey(self):
self.__OnCloseButtonClick()
return TRUE
def Close(self):
if self.tooltipItem:
self.tooltipItem.HideToolTip()self.Hide()
self.cubeItemInfo = {}
self.cubeMaterialInfos = {}
self.cubeResultInfos = {}
self.firstSlotIndex = 0
self.contentScrollbar.SetPos(0)if self.needMoney:
self.needMoney.SetText("0")def Clear(self):
self.Refresh()def Refresh(self):
for slotPos in xrange(self.cubeSlot.GetSlotCount()):if not slotPos in self.cubeItemInfo:
self.cubeSlot.ClearSlot(slotPos)
continueinvenPos = self.cubeItemInfo[slotPos]
itemCount = player.GetItemCount(invenPos)
if itemCount > 0:
self.cubeSlot.SetItemSlot(slotPos, player.GetItemIndex(invenPos), itemCount)
else:
del self.cubeItemInfo[slotPos]
self.cubeSlot.ClearSlot(slotPos)i = 0
for itemVnum, count in self.cubeResultInfos[self.firstSlotIndex:]:
currentSlot = self.resultSlotsitem.SelectItem(itemVnum)
currentSlot.SetItemSlot(0, itemVnum, count)
currentSlot.Show()# Center Align
item.SelectItem(itemVnum)
sizeX, sizeY = item.GetItemSize()
localX, localY = currentSlot.GetLocalPosition()currentSlot.SetSize(self.SLOT_SIZEX, self.SLOT_SIZEY * sizeY)
adjustLocalY = 0
if sizeY < 3:
adjustLocalY = int(32 / sizeY)currentSlot.SetPosition(localX, 0 + adjustLocalY)
i = i + 1
if 3 <= i:
break#print "self.cubeMaterialInfos : ", self.cubeMaterialInfos
if self.firstSlotIndex in self.cubeMaterialInfos:
for i in xrange(self.RESULT_SLOT_COUNT):
materialList = self.cubeMaterialInfos[self.firstSlotIndex + i]
#print "Refresh ::: ", materialList
j = 0
for materialInfo in materialList:
if 0 < len(materialInfo):
currentSlot = self.materialSlots[j]
itemVnum, itemCount = materialInfo[0]
currentSlot.SetItemSlot(0, itemVnum, itemCount)
j = j + 1# Center Align
item.SelectItem(itemVnum)
sizeX, sizeY = item.GetItemSize()
localX, localY = currentSlot.GetLocalPosition()currentSlot.SetSize(self.SLOT_SIZEX, self.SLOT_SIZEY * sizeY)
adjustLocalY = 0
if sizeY < 3:
adjustLocalY = int(32 / sizeY)currentSlot.SetPosition(localX, 0 + adjustLocalY)
for k in xrange(5):
if k >= j:
self.materialSlots[k].ClearSlot(0)if self.RESULT_SLOT_COUNT <= i:
breakself.cubeSlot.RefreshSlot()
def __OnCloseButtonClick(self):
if self.isUsable:
self.isUsable = FALSEprint "큐브 닫기"
net.SendChatPacket("/cube close")self.Close()
def __OnAcceptButtonClick(self):
if len(self.cubeItemInfo) == 0:
"빈 큐브"
return
print "큐브 제작 시작"
#for invenPos in self.cubeItemInfo.values():
# net.SendChatPacket("/cube add " + str(invenPos))
net.SendChatPacket("/cube make")
def __OnSelectEmptySlot(self, selectedSlotPos):isAttached = mouseModule.mouseController.isAttached()
if isAttached:
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
mouseModule.mouseController.DeattachObject()if player.SLOT_TYPE_INVENTORY != attachedSlotType:
returnfor slotPos, invenPos in self.cubeItemInfo.items():
if invenPos == attachedSlotPos:
del self.cubeItemInfo[slotPos]
self.cubeItemInfo[selectedSlotPos] = attachedSlotPos
net.SendChatPacket("/cube add %d %d" % (selectedSlotPos, attachedSlotPos))self.Refresh()
def __OnSelectItemSlot(self, selectedSlotPos):
isAttached = mouseModule.mouseController.isAttached()
if isAttached:
snd.PlaySound("sound/ui/loginfail.wav")
mouseModule.mouseController.DeattachObject()else:
if not selectedSlotPos in self.cubeItemInfo:
returnsnd.PlaySound("sound/ui/drop.wav")
net.SendChatPacket("/cube del %d " % selectedSlotPos)
del self.cubeItemInfo[selectedSlotPos]self.Refresh()
def __OnOverInItem(self, slotIndex):
if self.tooltipItem:
if self.cubeItemInfo.has_key(slotIndex):
self.tooltipItem.SetInventoryItem(self.cubeItemInfo[slotIndex])def __OnOverOutItem(self):
if self.tooltipItem:
self.tooltipItem.HideToolTip()def OnUpdate(self):
USE_SHOP_LIMIT_RANGE = 1000(x, y, z) = player.GetMainCharacterPosition()
if abs(x - self.xShopStart) > USE_SHOP_LIMIT_RANGE or abs(y - self.yShopStart) > USE_SHOP_LIMIT_RANGE:
self.__OnCloseButtonClick()if __name__ == "__main__":
import app
import wndMgr
import systemSetting
import mouseModule
import grp
import ui
import uiToolTip
import localeInfoapp.SetMouseHandler(mouseModule.mouseController)
app.SetHairColorEnable(TRUE)
wndMgr.SetMouseHandler(mouseModule.mouseController)
wndMgr.SetScreenSize(systemSetting.GetWidth(), systemSetting.GetHeight())
app.Create(localeInfo.APP_TITLE, systemSetting.GetWidth(), systemSetting.GetHeight(), 1)
mouseModule.mouseController.Create()class TestGame(ui.Window):
def __init__(self):
ui.Window.__init__(self)localeInfo.LoadLocaleData()
self.tooltipItem = uiToolTip.ItemToolTip()
self.tooltipItem.Hide()self.cubeWindow = CubeWindow()
self.cubeWindow.LoadWindow()
self.cubeWindow.SetItemToolTip(self.tooltipItem)
self.cubeWindow.Open()self.cubeResultWindow = CubeResultWindow()
self.cubeResultWindow.LoadWindow()
self.cubeResultWindow.SetItemToolTip(self.tooltipItem)
self.cubeResultWindow.SetCubeResultItem(27001, 1)
self.cubeResultWindow.Open()def __del__(self):
ui.Window.__del__(self)def OnUpdate(self):
app.UpdateGame()def OnRender(self):
app.RenderGame()
grp.PopState()
grp.SetInterfaceRenderState()game = TestGame()
game.SetSize(systemSetting.GetWidth(), systemSetting.GetHeight())
game.Show()app.Loop()
game.py :
Quoteimport 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 uireport
import net
import effect
import event
import wndMgr
import fly
import systemSetting
import quest
import guild
import skill
import config
import messenger
import localeInfo
import constInfo
import exchange
import ime
import uiTaskbar
import uisidebarimport ui
import uiCommon
import uiPhaseCurtain
import uiMapNameShower
import uiAffectShower
import uiPlayerGauge
import uiCharacter
import uiTarget
from switchbot import Bot# PRIVATE_SHOP_PRICE_LIST
import uiPrivateShopBuilder
# END_OF_PRIVATE_SHOP_PRICE_LISTimport mouseModule
import consoleModuleimport playerSettingModule
import interfaceModuleimport musicInfo
import debugInfo
import stringCommanderfrom _weakref import proxy
# TEXTTAIL_LIVINGTIME_CONTROL
#if localeInfo.IsJAPAN():
# app.SetTextTailLivingTime(8.0)
# END_OF_TEXTTAIL_LIVINGTIME_CONTROL# SCREENSHOT_CWDSAVE
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = Noneif localeInfo.IsEUROPE():
SCREENSHOT_CWDSAVE = TRUEif localeInfo.IsCIBN10():
SCREENSHOT_CWDSAVE = FALSE
SCREENSHOT_DIR = "YT2W"cameraDistance = 1550.0
cameraPitch = 27.0
cameraRotation = 0.0
cameraHeight = 100.0testAlignment = 0
class GameWindow(ui.ScriptWindow):
def __init__(self, stream):
## Autopickup
self.PickUp1 = 0
self.PickUp2 = 0
## Autopickup
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.LastBoniSwitcherId = 0
self.pressNumber = Noneself.guildWarQuestionDialog = None
self.interface = None
self.targetBoard = None
self.console = None
self.mapNameShower = None
self.affectShower = None
self.playerGauge = None
self.itemShopWnd = None
self.boniSwitcherWnd = []
constInfo.BONI_SWITCHER_LOAD = FALSEself.stream=stream
self.interface = interfaceModule.Interface()
self.interface.MakeInterface()
self.interface.ShowDefaultWindows()
self.interface.wndTaskBar.SetMallShowEvent(self.__ItemShopShow)
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()
self.antiExpQID = 0
self.switchbot = Bot()
self.switchbot.Hide()
if config.SystemSettings['SideBar'] == 1:
self.sideBar = uisidebar.SideBar()
self.sideBar.AddButton("Switchbot", self.__toggleSwitchbot)
self.sideBar.AddButton("EQ Changer", self.__OnClickEQButton)
self.sideBar.AddButton("Change CH", self.__switch_channel)
self.sideBar.AddButton("Anti EXP", self.ToggleAntiEXP)
self.sideBar.AddButton("Pickup", self.Pickup)
self.sideBar.Show()
def __toggleSwitchbot(self):
if self.switchbot.bot_shown == 1:
self.switchbot.Hide()
else:
self.switchbot.Show()
def __OnClickEQButton(self):
import uifastequip
self.uuifastequipDlg = uifastequip.changeequip()
self.uuifastequipDlg.Show()
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 = FALSEself.enableXMasBoom = FALSE
self.startTimeXMasBoom = 0.0
self.indexXMasBoom = 0global 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_UPimport event
event.SetLeftTimeString(localeInfo.UI_LEFT_TIME)textTail.EnablePKTitle(constInfo.PVPMODE_ENABLE)
if constInfo.PVPMODE_TEST_ENABLE:
self.testPKMode = ui.TextLine()
self.testPKMode.SetFontName(localeInfo.UI_DEF_FONT)
self.testPKMode.SetPosition(0, 15)
self.testPKMode.SetWindowHorizontalAlignCenter()
self.testPKMode.SetHorizontalAlignCenter()
self.testPKMode.SetFeather()
self.testPKMode.SetOutline()
self.testPKMode.Show()self.testAlignment = ui.TextLine()
self.testAlignment.SetFontName(localeInfo.UI_DEF_FONT)
self.testAlignment.SetPosition(0, 35)
self.testAlignment.SetWindowHorizontalAlignCenter()
self.testAlignment.SetHorizontalAlignCenter()
self.testAlignment.SetFeather()
self.testAlignment.SetOutline()
self.testAlignment.Show()self.__BuildKeyDict()
self.__BuildDebugInfo()# PRIVATE_SHOP_PRICE_LIST
uiPrivateShopBuilder.Clear()
# END_OF_PRIVATE_SHOP_PRICE_LIST# UNKNOWN_UPDATE
exchange.InitTrading()
# END_OF_UNKNOWN_UPDATE
## Sound
snd.SetMusicVolume(systemSetting.GetMusicVolume()*net.GetFieldMusicVolume())
snd.SetSoundVolume(systemSetting.GetSoundVolume())netFieldMusicFileName = net.GetFieldMusicFileName()
if netFieldMusicFileName:
snd.FadeInMusic("BGM/" + netFieldMusicFileName)
elif musicInfo.fieldMusic != "":
snd.FadeInMusic("BGM/" + musicInfo.fieldMusic)self.__SetQuickSlotMode()
self.__SelectQuickPage(self.quickSlotPageIndex)self.SetFocus()
self.Show()
app.ShowCursor()net.SendEnterGamePacket()
# START_GAME_ERROR_EXIT
try:
self.StartGame()
except:
import exception
exception.Abort("GameWindow.Open")
# END_OF_START_GAME_ERROR_EXIT
# NPC가 큐브시스템으로 만들 수 있는 아이템들의 목록을 캐싱
# ex) cubeInformation[20383] = [ {"rewordVNUM": 72723, "rewordCount": 1, "materialInfo": "101,1&102,2", "price": 999 }, ... ]
self.cubeInformation = {}
self.currentCubeNPC = 0
def Close(self):
self.Hide()global cameraDistance, cameraPitch, cameraRotation, cameraHeight
(cameraDistance, cameraPitch, cameraRotation, cameraHeight) = app.GetCamera()if musicInfo.fieldMusic != "":
snd.FadeOutMusic("BGM/"+ musicInfo.fieldMusic)self.onPressKeyDict = None
self.onClickKeyDict = Nonechat.Close()
snd.StopAllSound()
grp.InitScreenEffect()
chr.Destroy()
textTail.Clear()
quest.Clear()
background.Destroy()
guild.Destroy()
if config.SystemSettings['SideBar'] == 1:
self.sideBar.Destroy()
self.sideBar = None
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_CONFIRMself.PrintCoord = None
self.FrameRate = None
self.Pitch = None
self.Splat = None
self.TextureNum = None
self.ObjectNum = None
self.ViewDistance = None
self.PrintMousePos = Noneself.ClearDictionary()
self.playerGauge = None
self.mapNameShower = None
self.affectShower = Noneif self.console:
self.console.BindGameClass(0)
self.console.Close()
self.console=None
if self.targetBoard:
self.targetBoard.Destroy()
self.targetBoard = None
if self.itemShopWnd:
self.itemShopWnd.Destroy()
self.itemShopWnd = None
if self.interface:
self.interface.HideAllWindows()
self.interface.Close()
self.interface=Nonefor i in xrange(len(self.boniSwitcherWnd)):
if self.boniSwitcherWnd:
self.boniSwitcherWnd.Destroy()
self.boniSwitcherWnd = Noneplayer.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_F5] = lambda : self.BINARY_DragonSoulGiveQuilification()#packen
onPressKeyDict[app.DIK_F6] = lambda : self.__Channel()#packen
onPressKeyDict[app.DIK_F7] = lambda : self.__switch_channel()
onPressKeyDict[app.DIK_F8] = lambda : self.ToggleAntiEXP()#Anti exponPressKeyDict[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_P] = self.__PressPKeyonPressKeyDict[app.DIK_NUMPAD9] = lambda: app.MovieResetCamera()
onPressKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_TO_NEGATIVE)
onPressKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_TO_POSITIVE)
onPressKeyDict[app.DIK_GRAVE] = lambda : self.PickUpItem()
onPressKeyDict[app.DIK_Z] = lambda : self.PickUpItem()
onPressKeyDict[app.DIK_C] = lambda state = "STATUS": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_V] = lambda state = "SKILL": self.interface.ToggleCharacterWindow(state)
#onPressKeyDict[app.DIK_B] = lambda state = "EMOTICON": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_N] = lambda state = "QUEST": self.interface.ToggleCharacterWindow(state)
onPressKeyDict[app.DIK_I] = lambda : self.interface.ToggleInventoryWindow()
onPressKeyDict[app.DIK_O] = lambda : self.interface.ToggleDragonSoulWindowWithNoInfo()
onPressKeyDict[app.DIK_M] = lambda : self.interface.PressMKey()
#onPressKeyDict[app.DIK_H] = lambda : self.interface.OpenHelpWindow()
onPressKeyDict[app.DIK_ADD] = lambda : self.interface.MiniMapScaleUp()
onPressKeyDict[app.DIK_SUBTRACT] = lambda : self.interface.MiniMapScaleDown()
onPressKeyDict[app.DIK_L] = lambda : self.interface.ToggleChatLogWindow()
onPressKeyDict[app.DIK_COMMA] = lambda : self.ShowConsole() # "`" key
onPressKeyDict[app.DIK_LSHIFT] = lambda : self.__SetQuickPageMode()onPressKeyDict[app.DIK_J] = lambda : self.__PressJKey()
onPressKeyDict[app.DIK_H] = lambda : self.__PressHKey()
onPressKeyDict[app.DIK_B] = lambda : self.__PressBKey()
onPressKeyDict[app.DIK_F] = lambda : self.__PressFKey()self.onPressKeyDict = onPressKeyDict
onClickKeyDict = {}
onClickKeyDict[app.DIK_UP] = lambda : self.StopUp()
onClickKeyDict[app.DIK_DOWN] = lambda : self.StopDown()
onClickKeyDict[app.DIK_LEFT] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_RIGHT] = lambda : self.StopRight()
onClickKeyDict[app.DIK_SPACE] = lambda : self.EndAttack()onClickKeyDict[app.DIK_W] = lambda : self.StopUp()
onClickKeyDict[app.DIK_S] = lambda : self.StopDown()
onClickKeyDict[app.DIK_A] = lambda : self.StopLeft()
onClickKeyDict[app.DIK_D] = lambda : self.StopRight()
onClickKeyDict[app.DIK_Q] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_E] = lambda: app.RotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_R] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_F] = lambda: app.ZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_T] = lambda: app.PitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_G] = lambda: self.__ReleaseGKey()
onClickKeyDict[app.DIK_NUMPAD4] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD6] = lambda: app.MovieRotateCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGUP] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_PGDN] = lambda: app.MovieZoomCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD8] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_NUMPAD2] = lambda: app.MoviePitchCamera(app.CAMERA_STOP)
onClickKeyDict[app.DIK_LALT] = lambda: self.HideName()
onClickKeyDict[app.DIK_LCONTROL] = lambda: self.HideMouseImage()
onClickKeyDict[app.DIK_LSHIFT] = lambda: self.__SetQuickSlotMode()#if constInfo.PVPMODE_ACCELKEY_ENABLE:
# onClickKeyDict[app.DIK_B] = lambda: self.ChangePKMode()self.onClickKeyDict=onClickKeyDict
def __PressNumKey(self,num):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if num >= 1 and num <= 9:
if(chrmgr.IsPossibleEmoticon(-1)):
chrmgr.SetEmoticon(-1,int(num)-1)
net.SendEmoticon(int(num)-1)
else:
if num >= 1 and num <= 4:
self.pressNumber(num-1)def __ClickBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
return
else:
if constInfo.PVPMODE_ACCELKEY_ENABLE:
self.ChangePKMode()
def __PressJKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if player.IsMountingHorse():
net.SendChatPacket("/unmount")
else:
#net.SendChatPacket("/user_horse_ride")
if not uiPrivateShopBuilder.IsBuildingPrivateShop():
for i in xrange(player.INVENTORY_PAGE_SIZE):
if player.GetItemIndex(i) in (71114, 71116, 71118, 71120):
net.SendItemUsePacket(i)
break
def __PressHKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_ride")
else:
self.interface.OpenHelpWindow()def __PressBKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_back")
else:
state = "EMOTICON"
self.interface.ToggleCharacterWindow(state)def __PressFKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/user_horse_feed")
else:
app.ZoomCamera(app.CAMERA_TO_POSITIVE)def __PressGKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
net.SendChatPacket("/ride")
else:
if self.ShowNameFlag:
self.interface.ToggleGuildWindow()
else:
app.PitchCamera(app.CAMERA_TO_POSITIVE)def __ReleaseGKey(self):
app.PitchCamera(app.CAMERA_STOP)def __PressQKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if 0==interfaceModule.IsQBHide:
interfaceModule.IsQBHide = 1
self.interface.HideAllQuestButton()
else:
interfaceModule.IsQBHide = 0
self.interface.ShowAllQuestButton()
else:
app.RotateCamera(app.CAMERA_TO_NEGATIVE)def __SetQuickSlotMode(self):
self.pressNumber=ui.__mem_func__(self.__PressQuickSlot)def __SetQuickPageMode(self):
self.pressNumber=ui.__mem_func__(self.__SelectQuickPage)def __PressQuickSlot(self, localSlotIndex):
if localeInfo.IsARABIC():
if 0 <= localSlotIndex and localSlotIndex < 4:
player.RequestUseLocalQuickSlot(3-localSlotIndex)
else:
player.RequestUseLocalQuickSlot(11-localSlotIndex)
else:
player.RequestUseLocalQuickSlot(localSlotIndex)def __SelectQuickPage(self, pageIndex):
self.quickSlotPageIndex = pageIndex
player.SetQuickPage(pageIndex)def ToggleDebugInfo(self):
self.isShowDebugInfo = not self.isShowDebugInfoif self.isShowDebugInfo:
self.PrintCoord.Show()
self.FrameRate.Show()
self.Pitch.Show()
self.Splat.Show()
self.TextureNum.Show()
self.ObjectNum.Show()
self.ViewDistance.Show()
self.PrintMousePos.Show()
else:
self.PrintCoord.Hide()
self.FrameRate.Hide()
self.Pitch.Hide()
self.Splat.Hide()
self.TextureNum.Hide()
self.ObjectNum.Hide()
self.ViewDistance.Hide()
self.PrintMousePos.Hide()def __BuildDebugInfo(self):
## Character Position Coordinate
self.PrintCoord = ui.TextLine()
self.PrintCoord.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintCoord.SetPosition(wndMgr.GetScreenWidth() - 270, 0)
## Frame Rate
self.FrameRate = ui.TextLine()
self.FrameRate.SetFontName(localeInfo.UI_DEF_FONT)
self.FrameRate.SetPosition(wndMgr.GetScreenWidth() - 270, 20)## Camera Pitch
self.Pitch = ui.TextLine()
self.Pitch.SetFontName(localeInfo.UI_DEF_FONT)
self.Pitch.SetPosition(wndMgr.GetScreenWidth() - 270, 40)## Splat
self.Splat = ui.TextLine()
self.Splat.SetFontName(localeInfo.UI_DEF_FONT)
self.Splat.SetPosition(wndMgr.GetScreenWidth() - 270, 60)
##
self.PrintMousePos = ui.TextLine()
self.PrintMousePos.SetFontName(localeInfo.UI_DEF_FONT)
self.PrintMousePos.SetPosition(wndMgr.GetScreenWidth() - 270, 80)# TextureNum
self.TextureNum = ui.TextLine()
self.TextureNum.SetFontName(localeInfo.UI_DEF_FONT)
self.TextureNum.SetPosition(wndMgr.GetScreenWidth() - 270, 100)# 오브젝트 그리는 개수
self.ObjectNum = ui.TextLine()
self.ObjectNum.SetFontName(localeInfo.UI_DEF_FONT)
self.ObjectNum.SetPosition(wndMgr.GetScreenWidth() - 270, 120)# 시야거리
self.ViewDistance = ui.TextLine()
self.ViewDistance.SetFontName(localeInfo.UI_DEF_FONT)
self.ViewDistance.SetPosition(0, 0)def __NotifyError(self, msg):
chat.AppendChat(chat.CHAT_TYPE_INFO, msg)def ChangePKMode(self):
if not app.IsPressed(app.DIK_LCONTROL):
returnif player.GetStatus(player.LEVEL)<constInfo.PVPMODE_PROTECTED_LEVEL:
self.__NotifyError(localeInfo.OPTION_PVPMODE_PROTECT % (constInfo.PVPMODE_PROTECTED_LEVEL))
returncurTime = app.GetTime()
if curTime - self.lastPKModeSendedTime < constInfo.PVPMODE_ACCELKEY_DELAY:
returnself.lastPKModeSendedTime = curTime
curPKMode = player.GetPKMode()
nextPKMode = curPKMode + 1
if nextPKMode == player.PK_MODE_PROTECT:
if 0 == player.GetGuildID():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OPTION_PVPMODE_CANNOT_SET_GUILD_MODE)
nextPKMode = 0
else:
nextPKMode = player.PK_MODE_GUILDelif nextPKMode == player.PK_MODE_MAX_NUM:
nextPKMode = 0net.SendChatPacket("/PKMode " + str(nextPKMode))
print "/PKMode " + str(nextPKMode)def OnChangePKMode(self):
self.interface.OnChangePKMode()
try:
self.__NotifyError(localeInfo.OPTION_PVPMODE_MESSAGE_DICT[player.GetPKMode()])
except KeyError:
print "UNKNOWN PVPMode[%d]" % (player.GetPKMode())if constInfo.PVPMODE_TEST_ENABLE:
curPKMode = player.GetPKMode()
alignment, grade = chr.testGetPKData()
self.pkModeNameDict = { 0 : "PEACE", 1 : "REVENGE", 2 : "FREE", 3 : "PROTECT", }
self.testPKMode.SetText("Current PK Mode : " + self.pkModeNameDict.get(curPKMode, "UNKNOWN"))
self.testAlignment.SetText("Current Alignment : " + str(alignment) + " (" + localeInfo.TITLE_NAME_LIST[grade] + ")")###############################################################################################
###############################################################################################
## 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):
import constInfo
if constInfo.INPUT_IGNORE == 1:
return
if constInfo.CApiSetHide == 1:
net.SendQuestInputStringPacket(str(constInfo.SendString))
constInfo.CApiSetHide = 0
return
self.interface.OpenQuestWindow(skin, idx)def AskGuildName(self):
guildNameBoard = uiCommon.InputDialog()
guildNameBoard.SetTitle(localeInfo.GUILD_NAME)
guildNameBoard.SetAcceptEvent(ui.__mem_func__(self.ConfirmGuildName))
guildNameBoard.SetCancelEvent(ui.__mem_func__(self.CancelGuildName))
guildNameBoard.Open()self.guildNameBoard = guildNameBoard
def ConfirmGuildName(self):
guildName = self.guildNameBoard.GetText()
if not guildName:
returnif net.IsInsultIn(guildName):
self.PopupMessage(localeInfo.GUILD_CREATE_ERROR_INSULT_NAME)
returnnet.SendAnswerMakeGuildPacket(guildName)
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUEdef CancelGuildName(self):
self.guildNameBoard.Close()
self.guildNameBoard = None
return TRUE## Refine
def PopupMessage(self, msg):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(msg, 0, localeInfo.UI_OK)def OpenRefineDialog(self, targetItemPos, nextGradeItemVnum, cost, prob, type=0):
self.interface.OpenRefineDialog(targetItemPos, nextGradeItemVnum, cost, prob, type)def AppendMaterialToRefineDialog(self, vnum, count):
self.interface.AppendMaterialToRefineDialog(vnum, count)def RunUseSkillEvent(self, slotIndex, coolTime):
self.interface.OnUseSkill(slotIndex, coolTime)def ClearAffects(self):
self.affectShower.ClearAffects()def SetAffect(self, affect):
self.affectShower.SetAffect(affect)def ResetAffect(self, affect):
self.affectShower.ResetAffect(affect)# UNKNOWN_UPDATE
def BINARY_NEW_AddAffect(self, type, pointIdx, value, duration):
self.affectShower.BINARY_NEW_AddAffect(type, pointIdx, value, duration)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulActivate(type - chr.NEW_AFFECT_DRAGON_SOUL_DECK1)
elif chr.NEW_AFFECT_DRAGON_SOUL_QUALIFIED == type:
self.BINARY_DragonSoulGiveQuilification()def BINARY_NEW_RemoveAffect(self, type, pointIdx):
self.affectShower.BINARY_NEW_RemoveAffect(type, pointIdx)
if chr.NEW_AFFECT_DRAGON_SOUL_DECK1 == type or chr.NEW_AFFECT_DRAGON_SOUL_DECK2 == type:
self.interface.DragonSoulDeactivate()
# END_OF_UNKNOWN_UPDATEdef 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):
if constInfo.GUILDSTORAGE["open"] == 1:
return
self.targetBoard.Open(vid, name)
if app.IsPressed(app.DIK_LCONTROL):
if not player.IsSameEmpire(vid):
returnif player.IsMainCharacterIndex(vid):
return
elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(vid):
returnself.interface.OpenWhisperDialog(name)
def RefreshTargetBoardByVID(self, vid):
self.targetBoard.RefreshByVID(vid)def RefreshTargetBoardByName(self, name):
self.targetBoard.RefreshByName(name)
def __RefreshTargetBoard(self):
self.targetBoard.Refresh()
def SetHPTargetBoard(self, vid, hpPercentage):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.ResetTargetBoard()
self.targetBoard.SetEnemyVID(vid)self.targetBoard.SetHP(hpPercentage)
self.targetBoard.Show()def CloseTargetBoardIfDifferent(self, vid):
if vid != self.targetBoard.GetTargetVID():
self.targetBoard.Close()def CloseTargetBoard(self):
self.targetBoard.Close()## View Equipment
def OpenEquipmentDialog(self, vid):
self.interface.OpenEquipmentDialog(vid)def SetEquipmentDialogItem(self, vid, slotIndex, vnum, count):
self.interface.SetEquipmentDialogItem(vid, slotIndex, vnum, count)def SetEquipmentDialogSocket(self, vid, slotIndex, socketIndex, value):
self.interface.SetEquipmentDialogSocket(vid, slotIndex, socketIndex, value)def SetEquipmentDialogAttr(self, vid, slotIndex, attrIndex, type, value):
self.interface.SetEquipmentDialogAttr(vid, slotIndex, attrIndex, type, value)# SHOW_LOCAL_MAP_NAME
def ShowMapName(self, mapName, x, y):if self.mapNameShower:
self.mapNameShower.ShowMapName(mapName, x, y)if self.interface:
self.interface.SetMapName(mapName)
# END_OF_SHOW_LOCAL_MAP_NAMEdef BINARY_OpenAtlasWindow(self):
self.interface.BINARY_OpenAtlasWindow()## Chat
def OnRecvWhisper(self, mode, name, line):
if mode == chat.WHISPER_TYPE_GM:
self.interface.RegisterGameMasterName(name)
chat.AppendWhisper(mode, name, line)
self.interface.RecvWhisper(name)def OnRecvWhisperSystemMessage(self, mode, name, line):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, line)
self.interface.RecvWhisper(name)def OnRecvWhisperError(self, mode, name, line):
if localeInfo.WHISPER_ERROR.has_key(mode):
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, localeInfo.WHISPER_ERROR[mode](name))
else:
chat.AppendWhisper(chat.WHISPER_TYPE_SYSTEM, name, "Whisper Unknown Error(mode=%d, name=%s)" % (mode, name))
self.interface.RecvWhisper(name)def RecvWhisper(self, name):
self.interface.RecvWhisper(name)def OnPickMoney(self, money):
if constInfo.pickInfo == 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_PICK_MONEY % (money))
else:
returndef OnShopError(self, type):
try:
self.PopupMessage(localeInfo.SHOP_ERROR_DICT[type])
except KeyError:
self.PopupMessage(localeInfo.SHOP_ERROR_UNKNOWN % (type))def OnSafeBoxError(self):
self.PopupMessage(localeInfo.SAFEBOX_ERROR)def OnFishingSuccess(self, isFish, fishName):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_SUCCESS(isFish, fishName), 2000)# ADD_FISHING_MESSAGE
def OnFishingNotifyUnknown(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_UNKNOWN)def OnFishingWrongPlace(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_WRONG_PLACE)
# END_OF_ADD_FISHING_MESSAGEdef OnFishingNotify(self, isFish, fishName):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.FISHING_NOTIFY(isFish, fishName))def OnFishingFailure(self):
chat.AppendChatWithDelay(chat.CHAT_TYPE_INFO, localeInfo.FISHING_FAILURE, 2000)def OnCannotPickItem(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_PICK_ITEM)# MINING
def OnCannotMining(self):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.GAME_CANNOT_MINING)
# END_OF_MININGdef OnCannotUseSkill(self, vid, type):
if localeInfo.USE_SKILL_ERROR_TAIL_DICT.has_key(type):
textTail.RegisterInfoTail(vid, localeInfo.USE_SKILL_ERROR_TAIL_DICT[type])if localeInfo.USE_SKILL_ERROR_CHAT_DICT.has_key(type):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_SKILL_ERROR_CHAT_DICT[type])def OnCannotShotError(self, vid, type):
textTail.RegisterInfoTail(vid, localeInfo.SHOT_ERROR_TAIL_DICT.get(type, localeInfo.SHOT_ERROR_UNKNOWN % (type)))## PointReset
def StartPointReset(self):
self.interface.OpenPointResetDialog()## Shop
def StartShop(self, vid):
if constInfo.GUILDSTORAGE["open"] == 1:
return
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):
if constInfo.GUILDSTORAGE["open"] == 1:
net.SendExchangeExitPacket()
chat.AppendChat(chat.CHAT_TYPE_INFO, "Du kannst nicht Handeln, solange das Gildenlager offen ist.")
return
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 + localeInfo.PARTY_DO_YOU_JOIN)
partyInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerPartyInvite(arg))
partyInviteQuestionDialog.Open()
partyInviteQuestionDialog.partyLeaderVID = leaderVID
self.partyInviteQuestionDialog = partyInviteQuestionDialogdef AnswerPartyInvite(self, answer):
if not self.partyInviteQuestionDialog:
returnpartyLeaderVID = self.partyInviteQuestionDialog.partyLeaderVID
distance = player.GetCharacterDistance(partyLeaderVID)
if distance < 0.0 or distance > 5000:
answer = FALSEnet.SendPartyInviteAnswerPacket(partyLeaderVID, answer)
self.partyInviteQuestionDialog.Close()
self.partyInviteQuestionDialog = None
def __PressPKey(self):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
if 0==interfaceModule.IsWisperHide:
interfaceModule.IsWisperHide = 1
self.interface.HideAllWhisperButton()
else:
interfaceModule.IsWisperHide= 0
self.interface.ShowAllWhisperButton()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(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_1 % (name))
messengerAddFriendQuestion.SetText2(localeInfo.MESSENGER_DO_YOU_ACCEPT_ADD_FRIEND_2)
messengerAddFriendQuestion.SetAcceptEvent(ui.__mem_func__(self.OnAcceptAddFriend))
messengerAddFriendQuestion.SetCancelEvent(ui.__mem_func__(self.OnDenyAddFriend))
messengerAddFriendQuestion.Open()
messengerAddFriendQuestion.name = name
self.messengerAddFriendQuestion = messengerAddFriendQuestiondef OnAcceptAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth y " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUEdef OnDenyAddFriend(self):
name = self.messengerAddFriendQuestion.name
net.SendChatPacket("/messenger_auth n " + name)
self.OnCloseAddFriendQuestionDialog()
return TRUEdef OnCloseAddFriendQuestionDialog(self):
self.messengerAddFriendQuestion.Close()
self.messengerAddFriendQuestion = None
return TRUE## SafeBox
def OpenSafeboxWindow(self, size):
self.interface.OpenSafeboxWindow(size)def RefreshSafebox(self):
self.interface.RefreshSafebox()def RefreshSafeboxMoney(self):
self.interface.RefreshSafeboxMoney()# ITEM_MALL
def OpenMallWindow(self, size):
self.interface.OpenMallWindow(size)def RefreshMall(self):
self.interface.RefreshMall()
# END_OF_ITEM_MALL## Guild
def RecvGuildInviteQuestion(self, guildID, guildName):
guildInviteQuestionDialog = uiCommon.QuestionDialog()
guildInviteQuestionDialog.SetText(guildName + localeInfo.GUILD_DO_YOU_JOIN)
guildInviteQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.AnswerGuildInvite(arg))
guildInviteQuestionDialog.Open()
guildInviteQuestionDialog.guildID = guildID
self.guildInviteQuestionDialog = guildInviteQuestionDialogdef AnswerGuildInvite(self, answer):
if not self.guildInviteQuestionDialog:
returnguildLeaderVID = 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 Functionsdef CheckFocus(self):
if FALSE == self.IsFocus():
if TRUE == self.interface.IsOpenChat():
self.interface.ToggleChat()self.SetFocus()
def SaveScreen(self):
print "save screen"# SCREENSHOT_CWDSAVE
if SCREENSHOT_CWDSAVE:
if not os.path.exists(os.getcwd()+os.sep+"screenshot"):
os.mkdir(os.getcwd()+os.sep+"screenshot")(succeeded, name) = grp.SaveScreenShotToPath(os.getcwd()+os.sep+"screenshot"+os.sep)
elif SCREENSHOT_DIR:
(succeeded, name) = grp.SaveScreenShot(SCREENSHOT_DIR)
else:
(succeeded, name) = grp.SaveScreenShot()
# END_OF_SCREENSHOT_CWDSAVEif succeeded:
pass
"""
chat.AppendChat(chat.CHAT_TYPE_INFO, name + localeInfo.SCREENSHOT_SAVE1)
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE2)
"""
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SCREENSHOT_SAVE_FAILURE)def ShowConsole(self):
passdef ShowName(self):
self.ShowNameFlag = TRUE
self.playerGauge.EnableShowAlways()
player.SetQuickPage(self.quickSlotPageIndex+1)# ADD_ALWAYS_SHOW_NAME
def __IsShowName(self):if systemSetting.IsAlwaysShowName():
return TRUEif self.ShowNameFlag:
return TRUEreturn 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.PickTheItem()###############################################################################################
###############################################################################################
## Event Handlerdef OnKeyDown(self, key):
if self.interface.wndWeb and self.interface.wndWeb.IsShow():
returnif key == app.DIK_ESC:
constInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)#### Fixxed by OverFlow
try:
self.onPressKeyDict[key]()
except KeyError:
pass
except:
raisereturn True
def OnKeyUp(self, key):
try:
self.onClickKeyDict[key]()
except KeyError:
pass
except:
raisereturn TRUE
def OnMouseLeftButtonDown(self):
if self.interface.BUILD_OnMouseLeftButtonDown():
returnif 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():
returnif mouseModule.mouseController.isAttached():
attachedType = mouseModule.mouseController.GetAttachedType()
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
attachedItemSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()## QuickSlot
if player.SLOT_TYPE_QUICK_SLOT == attachedType:
player.RequestDeleteGlobalQuickSlot(attachedItemSlotPos)## Inventory
elif player.SLOT_TYPE_INVENTORY == attachedType:if player.ITEM_MONEY == attachedItemIndex:
self.__PutMoney(attachedType, attachedItemCount, self.PickingCharacterIndex)
else:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)## DragonSoul
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
self.__PutItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, self.PickingCharacterIndex)
mouseModule.mouseController.DeattachObject()else:
hyperlink = ui.GetHyperlink()
if hyperlink:
if app.IsPressed(app.DIK_LALT):
link = chat.GetLinkFromHyperlink(hyperlink)
ime.PasteString(link)
else:
self.interface.MakeHyperlinkTooltip(hyperlink)
return
else:
player.SetMouseState(player.MBT_LEFT, player.MBS_CLICK)#player.EndMouseWalking()
return TRUEdef __PutItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount, dstChrID):
if player.SLOT_TYPE_INVENTORY == attachedType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
attachedInvenType = player.SlotTypeToInvenType(attachedType)
if TRUE == chr.HasInstance(self.PickingCharacterIndex) and player.GetMainCharacterIndex() != dstChrID:
if player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.EXCHANGE_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)
else:
if chr.IsNPC(dstChrID):
net.SendGiveItemPacket(dstChrID, attachedInvenType, attachedItemSlotPos, attachedItemCount)
else:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeItemAddPacket(attachedInvenType, attachedItemSlotPos, 0)
else:
self.__DropItem(attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount)def __PutMoney(self, attachedType, attachedMoney, dstChrID):
if TRUE == chr.HasInstance(dstChrID) and player.GetMainCharacterIndex() != dstChrID:
net.SendExchangeStartPacket(dstChrID)
net.SendExchangeElkAddPacket(attachedMoney)
else:
self.__DropMoney(attachedType, attachedMoney)def __DropMoney(self, attachedType, attachedMoney):
# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
if attachedMoney>=1000:
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_MONEY_FAILURE_1000_OVER, 0, localeInfo.UI_OK)
returnitemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(localeInfo.DO_YOU_DROP_MONEY % (attachedMoney))
itemDropQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=TRUE: self.RequestDestroyItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.RequestDropItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropCount = attachedMoney
itemDropQuestionDialog.dropNumber = player.ITEM_MONEY
self.itemDropQuestionDialog = itemDropQuestionDialogdef __DropItem(self, attachedType, attachedItemIndex, attachedItemSlotPos, attachedItemCount):
# PRIVATESHOP_DISABLE_ITEM_DROP - 개인상점 열고 있는 동안 아이템 버림 방지
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
return
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
if player.SLOT_TYPE_INVENTORY == attachedType and player.IsEquipmentSlot(attachedItemSlotPos):
self.stream.popupWindow.Close()
self.stream.popupWindow.Open(localeInfo.DROP_ITEM_FAILURE_EQUIP_ITEM, 0, localeInfo.UI_OK)else:
if player.SLOT_TYPE_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(attachedItemSlotPos)item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
itemDropQuestionDialog.SetText(questionText)
itemDropQuestionDialog.SetAcceptEvent(lambda arg=True: self.RequestDropItem(arg))
itemDropQuestionDialog.SetCancelEvent(lambda arg=False: self.RequestDropItem(arg))
itemDropQuestionDialog.SetDestroyEvent(lambda arg=True: self.RequestDestroyItem(arg))
itemDropQuestionDialog.Open()
itemDropQuestionDialog.dropType = attachedType
itemDropQuestionDialog.dropNumber = attachedItemSlotPos
itemDropQuestionDialog.dropCount = attachedItemCount
self.itemDropQuestionDialog = itemDropQuestionDialogconstInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(1)
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedType:
dropItemIndex = player.GetItemIndex(player.DRAGON_SOUL_INVENTORY, attachedItemSlotPos)item.SelectItem(dropItemIndex)
dropItemName = item.GetItemName()## Question Text
questionText = localeInfo.HOW_MANY_ITEM_DO_YOU_DROP(dropItemName, attachedItemCount)## Dialog
itemDropQuestionDialog = uiCommon.QuestionDialogItem()
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 = itemDropQuestionDialogconstInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(1)
def RequestDropItem(self, answer):
if not self.itemDropQuestionDialog:
returnif answer:
dropType = self.itemDropQuestionDialog.dropType
dropCount = self.itemDropQuestionDialog.dropCount
dropNumber = self.itemDropQuestionDialog.dropNumberif player.SLOT_TYPE_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
net.SendGoldDropPacketNew(dropCount)
snd.PlaySound("sound/ui/money.wav")
else:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
elif player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == dropType:
# PRIVATESHOP_DISABLE_ITEM_DROP
self.__SendDropItemPacket(dropNumber, dropCount, player.DRAGON_SOUL_INVENTORY)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROPself.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = NoneconstInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)
def RequestDestroyItem(self, answer):
if not self.itemDropQuestionDialog:
returnif answer:
dropType = self.itemDropQuestionDialog.dropType
dropNumber = self.itemDropQuestionDialog.dropNumberif player.SLOT_TYPE_INVENTORY == dropType:
if dropNumber == player.ITEM_MONEY:
return
else:
self.__SendDestroyItemPacket(dropNumber)
self.itemDropQuestionDialog.Close()
self.itemDropQuestionDialog = NoneconstInfo.SET_ITEM_DROP_QUESTION_DIALOG_STATUS(0)
# PRIVATESHOP_DISABLE_ITEM_DROP
def __SendDropItemPacket(self, itemVNum, itemCount, itemInvenType = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
returnnet.SendItemDropPacketNew(itemInvenType, itemVNum, itemCount)
# END_OF_PRIVATESHOP_DISABLE_ITEM_DROP
def __SendDestroyItemPacket(self, itemVNum, itemInvenType = player.INVENTORY):
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.DROP_ITEM_FAILURE_PRIVATE_SHOP)
returnnet.SendItemDestroyPacket(itemVNum)
def OnMouseRightButtonDown(self):
self.CheckFocus()
if TRUE == mouseModule.mouseController.isAttached():
mouseModule.mouseController.DeattachObject()else:
player.SetMouseState(player.MBT_RIGHT, player.MBS_PRESS)return TRUE
def OnMouseRightButtonUp(self):
if TRUE == mouseModule.mouseController.isAttached():
return TRUEplayer.SetMouseState(player.MBT_RIGHT, player.MBS_CLICK)
return TRUEdef OnMouseMiddleButtonDown(self):
player.SetMouseMiddleButtonState(player.MBS_PRESS)def OnMouseMiddleButtonUp(self):
player.SetMouseMiddleButtonState(player.MBS_CLICK)def OnUpdate(self):
app.UpdateGame()
##Autopickup
if constInfo.PickUP == 1:
if app.GetGlobalTimeStamp() - self.PickUp1 < 0:
self.PickUp1 = app.GetGlobalTimeStamp()
if app.GetGlobalTimeStamp() - self.PickUp2 < 0:
self.PickUp2 = app.GetGlobalTimeStamp()
if self.PickUp1 == 0:
self.PickUp1 = app.GetGlobalTimeStamp()
if app.GetGlobalTimeStamp() - self.PickUp1 >= 1:
self.PickUp1 = app.GetGlobalTimeStamp()
self.PickUpItem()
##Autopickupif 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)))
xMouse, yMouse = wndMgr.GetMousePosition()
self.PrintMousePos.SetText("MousePosition: %d %d" % (xMouse, yMouse))self.FrameRate.SetText("UFPS: %3d UT: %3d FS %.2f" % (nUpdateFPS, nUpdateTime, fFaceSpeed))
if fAveRT>1.0:
self.Pitch.SetText("RFPS: %3d RT:%.2f(%3d) FC: %d(%.2f) " % (nRenderFPS, fAveRT, nCurRT, nFaceCount, nFaceCount/fAveRT))self.Splat.SetText("PATCH: %d SPLAT: %d BAD(%.2f)" % (iPatch, iSplat, fSplatRatio))
#self.Pitch.SetText("Pitch: %.2f" % (app.GetCameraPitch())
#self.TextureNum.SetText("TN : %s" % (sTextureNum))
#self.ObjectNum.SetText("GTI : %d, CRC : %d" % (dwRenderedThing, dwRenderedCRC))
self.ViewDistance.SetText("Num : %d, FS : %f, FE : %f, FC : %f" % (iNum, fFogStart, fFogEnd, fFarCilp))def OnRender(self):
app.RenderGame()
if self.console.Console.collision:
background.RenderCollision()
chr.RenderCollision()(x, y) = app.GetCursorPosition()
########################
# Picking
########################
textTail.UpdateAllTextTail()if TRUE == wndMgr.IsPickedWindow(self.hWnd):
self.PickingCharacterIndex = chr.Pick()
if -1 != self.PickingCharacterIndex:
textTail.ShowCharacterTextTail(self.PickingCharacterIndex)
if 0 != self.targetBoard.GetTargetVID():
textTail.ShowCharacterTextTail(self.targetBoard.GetTargetVID())# ADD_ALWAYS_SHOW_NAME
if not self.__IsShowName():
self.PickingItemIndex = item.Pick()
if -1 != self.PickingItemIndex:
textTail.ShowItemTextTail(self.PickingItemIndex)
# END_OF_ADD_ALWAYS_SHOW_NAME
## Show all name in the range
# ADD_ALWAYS_SHOW_NAME
if self.__IsShowName():
textTail.ShowAllTextTail()
self.PickingItemIndex = textTail.Pick(x, y)
# END_OF_ADD_ALWAYS_SHOW_NAMEtextTail.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 TRUEdef 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
if app.ENABLE_SEND_TARGET_INFO:
def BINARY_AddTargetMonsterDropInfo(self, raceNum, itemVnum, itemCount):
if not raceNum in constInfo.MONSTER_INFO_DATA:
constInfo.MONSTER_INFO_DATA.update({raceNum : {}})
constInfo.MONSTER_INFO_DATA[raceNum].update({"items" : []})
curList = constInfo.MONSTER_INFO_DATA[raceNum]["items"]isUpgradeable = False
isMetin = False
item.SelectItem(itemVnum)
if item.GetItemType() == item.ITEM_TYPE_WEAPON or item.GetItemType() == item.ITEM_TYPE_ARMOR:
isUpgradeable = True
elif item.GetItemType() == item.ITEM_TYPE_METIN:
isMetin = Truefor curItem in curList:
if isUpgradeable:
if curItem.has_key("vnum_list") and curItem["vnum_list"][0] / 10 * 10 == itemVnum / 10 * 10:
if not (itemVnum in curItem["vnum_list"]):
curItem["vnum_list"].append(itemVnum)
return
elif isMetin:
if curItem.has_key("vnum_list"):
baseVnum = curItem["vnum_list"][0]
if curItem.has_key("vnum_list") and (baseVnum - baseVnum%1000) == (itemVnum - itemVnum%1000):
if not (itemVnum in curItem["vnum_list"]):
curItem["vnum_list"].append(itemVnum)
return
else:
if curItem.has_key("vnum") and curItem["vnum"] == itemVnum and curItem["count"] == itemCount:
returnif isUpgradeable or isMetin:
curList.append({"vnum_list":[itemVnum], "count":itemCount})
else:
curList.append({"vnum":itemVnum, "count":itemCount})def BINARY_RefreshTargetMonsterDropInfo(self, raceNum):
self.targetBoard.RefreshMonsterInfoBoard()
# QUEST_CONFIRM
def BINARY_OnQuestConfirm(self, msg, timeout, pid):
confirmDialog = uiCommon.QuestionDialogWithTimeLimit()
confirmDialog.Open(msg, timeout)
confirmDialog.SetAcceptEvent(lambda answer=TRUE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
confirmDialog.SetCancelEvent(lambda answer=FALSE, pid=pid: net.SendQuestConfirmPacket(answer, pid) or self.confirmDialog.Hide())
self.confirmDialog = confirmDialog
# END_OF_QUEST_CONFIRM# GIFT command
def Gift_Show(self):
self.interface.ShowGift()# CUBE
def BINARY_Cube_Open(self, npcVNUM):
self.currentCubeNPC = npcVNUM
self.interface.OpenCubeWindow()
if npcVNUM not in self.cubeInformation:
net.SendChatPacket("/cube r_info")
else:
cubeInfoList = self.cubeInformation[npcVNUM]
i = 0
for cubeInfo in cubeInfoList:
self.interface.wndCube.AddCubeResultItem(cubeInfo["vnum"], cubeInfo["count"])
j = 0
for materialList in cubeInfo["materialList"]:
for materialInfo in materialList:
itemVnum, itemCount = materialInfo
self.interface.wndCube.AddMaterialInfo(i, j, itemVnum, itemCount)
j = j + 1
i = i + 1
self.interface.wndCube.Refresh()def BINARY_Cube_Close(self):
self.interface.CloseCubeWindow()# 제작에 필요한 골드, 예상되는 완성품의 VNUM과 개수 정보 update
def BINARY_Cube_UpdateInfo(self, gold, itemVnum, count):
self.interface.UpdateCubeInfo(gold, itemVnum, count)
def BINARY_Cube_Succeed(self, itemVnum, count):
print "큐브 제작 성공"
self.interface.SucceedCubeWork(itemVnum, count)
passdef BINARY_Cube_Failed(self):
print "큐브 제작 실패"
self.interface.FailedCubeWork()
passdef BINARY_Cube_ResultList(self, npcVNUM, listText):
# ResultList Text Format : 72723,1/72725,1/72730.1/50001,5 이런식으로 "/" 문자로 구분된 리스트를 줌
#print listText
if npcVNUM == 0:
npcVNUM = self.currentCubeNPC
self.cubeInformation[npcVNUM] = []
try:
for eachInfoText in listText.split("/"):
eachInfo = eachInfoText.split(",")
itemVnum = int(eachInfo[0])
itemCount = int(eachInfo[1])self.cubeInformation[npcVNUM].append({"vnum": itemVnum, "count": itemCount})
self.interface.wndCube.AddCubeResultItem(itemVnum, itemCount)
resultCount = len(self.cubeInformation[npcVNUM])
requestCount = 7
modCount = resultCount % requestCount
splitCount = resultCount / requestCount
for i in xrange(splitCount):
#print("/cube r_info %d %d" % (i * requestCount, requestCount))
net.SendChatPacket("/cube r_info %d %d" % (i * requestCount, requestCount))
if 0 < modCount:
#print("/cube r_info %d %d" % (splitCount * requestCount, modCount))
net.SendChatPacket("/cube r_info %d %d" % (splitCount * requestCount, modCount))except RuntimeError, msg:
dbg.TraceError(msg)
return 0
pass
def BINARY_Cube_MaterialInfo(self, startIndex, listCount, listText):
# Material Text Format : 125,1|126,2|127,2|123,5&555,5&555,4/120000
try:
#print listText
if 3 > len(listText):
dbg.TraceError("Wrong Cube Material Infomation")
return 0
eachResultList = listText.split("@")cubeInfo = self.cubeInformation[self.currentCubeNPC]
itemIndex = 0
for eachResultText in eachResultList:
cubeInfo[startIndex + itemIndex]["materialList"] = [[], [], [], [], []]
materialList = cubeInfo[startIndex + itemIndex]["materialList"]
gold = 0
splitResult = eachResultText.split("/")
if 1 < len(splitResult):
gold = int(splitResult[1])
#print "splitResult : ", splitResult
eachMaterialList = splitResult[0].split("&")
i = 0
for eachMaterialText in eachMaterialList:
complicatedList = eachMaterialText.split("|")
if 0 < len(complicatedList):
for complicatedText in complicatedList:
(itemVnum, itemCount) = complicatedText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)
materialList.append((itemVnum, itemCount))
else:
itemVnum, itemCount = eachMaterialText.split(",")
itemVnum = int(itemVnum)
itemCount = int(itemCount)
self.interface.wndCube.AddMaterialInfo(itemIndex + startIndex, i, itemVnum, itemCount)
materialList.append((itemVnum, itemCount))
i = i + 1
itemIndex = itemIndex + 1
self.interface.wndCube.Refresh()
except RuntimeError, msg:
dbg.TraceError(msg)
return 0
pass
# END_OF_CUBE
# 용혼석
def BINARY_Highlight_Item(self, inven_type, inven_pos):
self.interface.Highligt_Item(inven_type, inven_pos)
def BINARY_Cards_UpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points):
self.interface.UpdateCardsInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, hand_4, hand_4_v, hand_5, hand_5_v, cards_left, points)
def BINARY_Cards_FieldUpdateInfo(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):
self.interface.UpdateCardsFieldInfo(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)
def BINARY_Cards_PutReward(self, hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points):
self.interface.CardsPutReward(hand_1, hand_1_v, hand_2, hand_2_v, hand_3, hand_3_v, points)
def BINARY_Cards_ShowIcon(self):
self.interface.CardsShowIcon()
def BINARY_Cards_Open(self, safemode):
self.interface.OpenCardsWindow(safemode)
def BINARY_DragonSoulGiveQuilification(self):
self.interface.DragonSoulGiveQuilification()
def BINARY_DragonSoulRefineWindow_Open(self):
self.interface.OpenDragonSoulRefineWindow()def BINARY_DragonSoulRefineWindow_RefineFail(self, reason, inven_type, inven_pos):
self.interface.FailDragonSoulRefine(reason, inven_type, inven_pos)def BINARY_DragonSoulRefineWindow_RefineSucceed(self, inven_type, inven_pos):
self.interface.SucceedDragonSoulRefine(inven_type, inven_pos)
# END of DRAGON SOUL REFINE WINDOW
def BINARY_SetBigMessage(self, message):
self.interface.bigBoard.SetTip(message)def BINARY_SetTipMessage(self, message):
self.interface.tipBoard.SetTip(message)def BINARY_AppendNotifyMessage(self, type):
if not type in localeInfo.NOTIFY_MESSAGE:
return
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.NOTIFY_MESSAGE[type])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):
passdef 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_FIXimport 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 = Nonedef __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,
"usuario_id" : self.__Usuario_ID,
"SetISLoadButtonIndex" : self.__ISSetLoadButtonIndex,
"SetISBuyButtonIndex" : self.__ISSetBuyButtonIndex,
"GetISBuyID" : self.__ISGetBuyID,
"GetISBuyID2" : self.__ISGetBuyID2,
"AddISCategory" : self.__ISAddCategory,
"SelectISCategory" : self.__ISSelectCategory,
"ClearISItems" : self.__ISClearItems,
"AddISItem" : self.__ISAddItem,
"AddISItemDesc" : self.__ISAddItemDesc,
"SetISLoadSuccess" : self.__ISSetLoadSuccess,
"SetISLoadFail" : self.__ISSetLoadFail,
"SetISBuySuccess" : self.__ISSetBuySuccess,
"SetISBuyFail" : self.__ISSetBuyFail,
"SetISCoins" : self.__ISSetCoins,
"SetISMarks" : self.__ISSetMarks,
"input0" : self.__Input0,
"input1" : self.__Input1,# 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
"BORRAR" : self.ManagerBorrar,
"antiExpQID" : self.SetAntiEXPQID,
"Teleport" : self.__Teleport,
"getinputend" : self.getinputend,
"getinput" : self.getinput,
"getinputbegin" : self.getinput,
"GUILDSTORAGE" : self._GuildStorageCMD,
"GUILDSTORAGE_ADDITEM" : self._GuildStorageAddItem,
"GUILDSTORAGE_ADDITEMSLOT" : self._GuildStorageAddItemSlot,
"GUILDSTORAGE_ADDMEMBER" : self._GuildStorageAddMemberToList,
"GUILDSTORAGE_ADDTEMPSLOT" : self._GuildStorageTempSlotsAdd,
"GUILDSTORAGE_ADDLOG" : self._GuildStorageAddLog,# 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 0def __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 0def 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_MALLdef RefineSuceededMessage(self):
snd.PlaySound("sound/ui/make_soket.wav")
self.PopupMessage(localeInfo.REFINE_SUCCESS)def RefineFailedMessage(self):
snd.PlaySound("sound/ui/jaeryun_fail.wav")
self.PopupMessage(localeInfo.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_LISTdef __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_feuerland",
"metin2_map_wueste",
"metin2_map_spinnendungeon",
"metin2_map_daemonenturm", )if background.GetCurrentMapName() in mapDict:
return FALSEreturn TRUE
def __XMasSnow_Enable(self, mode):
self.__XMasSong_Enable(mode)
if "1"==mode:
if not self.__IsXMasMap():
returnprint "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():
returnprint "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 = FALSEdef __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():
returnbackground.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():
returnself.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):
returnboomTime = 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) + localeInfo.PARTY_DO_YOU_ACCEPT)
partyRequestQuestionDialog.SetAcceptText(localeInfo.UI_ACCEPT)
partyRequestQuestionDialog.SetCancelText(localeInfo.UI_DENY)
partyRequestQuestionDialog.SetAcceptEvent(lambda arg=TRUE: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.SetCancelEvent(lambda arg=FALSE: self.__AnswerPartyRequest(arg))
partyRequestQuestionDialog.Open()
partyRequestQuestionDialog.vid = vid
self.partyRequestQuestionDialog = partyRequestQuestionDialogdef __AnswerPartyRequest(self, answer):
if not self.partyRequestQuestionDialog:
returnvid = 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 = Nonedef __PartyRequestDenied(self):
self.PopupMessage(localeInfo.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
## Item del Funktion
def ManagerBorrar(self, cmd):
cmd = cmd.split("|")
if cmd[0] == "QID":
constInfo.BorrarItems["QID"] = int(cmd[1])
elif cmd[0] == "SEND":
net.SendQuestInputStringPacket(str(constInfo.BorrarItems["BORRAR"]))
constInfo.BorrarItems["BORRAR"] = ""
elif cmd[0] == "INPUT":
constInfo.INPUT_IGNORE = int(cmd[1])
## END of Item DELdef __Teleport(self, cmd):
cmd = cmd.split('|')
if cmd[0] == 'Teleport':
constInfo.TeleportSystem['Teleport'] = int(cmd[1])
elif cmd[0] == 'Block':
constInfo.TeleportSystem['Block'] = int(cmd[1])
def getinput(self):
constInfo.INPUT_IGNORE = 1
def getinputend(self):
constInfo.INPUT_IGNORE = 0
def __Usuario_ID(self, id):
constInfo.usuario_id = int(id)def __ItemShopShow(self):
returndef __ISSetLoadButtonIndex(self, index):
constInfo.ITEM_SHOP_LOAD_BUTTON_INDEX = int(index)def __ISSetBuyButtonIndex(self, index):
constInfo.ITEM_SHOP_BUY_BUTTON_INDEX = int(index)def __ISGetBuyID(self):
if self.itemShopWnd:
net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString())
else:
net.SendQuestInputStringPacket("ERROR")
def __ISGetBuyID2(self):
if self.itemShopWnd:
net.SendQuestInputStringPacket(self.itemShopWnd.GetBuyItemString2())
else:
net.SendQuestInputStringPacket("ERROR")
def __Input0(self):
constInfo.INPUT_IGNORE = 0
def __Input1(self):
constInfo.INPUT_IGNORE = 1
def __ISAddCategory(self, catId, catName):
self.itemShopWnd.AddCategory(catId, catName.replace("[_]", " "))def __ISSelectCategory(self, catId):
self.itemShopWnd.SelectCategory(catId)def __ISClearItems(self):
self.itemShopWnd.Clear()def __ISAddItem(self, catId, itemId, itemVnum, itemCount, itemCost, itemCostType, attr1, val1, attr2, val2, attr3, val3, attr4, val4, attr5, val5, attr6, val6, attr7, val7, sock1, sock2, sock3):
itemAttr = [[attr1, val1], [attr2, val2], [attr3, val3], [attr4, val4], [attr5, val5], [attr6, val6], [attr7, val7]]
for attr in itemAttr:
attr[0] = int(attr[0])
attr[1] = int(attr[1])
itemSocket = [int(sock1), int(sock2), int(sock3)]
self.curIsItem = {
"cat" : catId,
"id" : itemId,
"vnum" : itemVnum,
"count" : itemCount,
"desc" : "",
"cost" : itemCost,
"cost_type" : itemCostType,
"attr" : itemAttr,
"socket" : itemSocket,
}
def __ISAddItemDesc(self, itemDesc):
obj = self.curIsItem
if not obj:
return
obj["desc"] += itemDesc.replace("[_]", " ")
self.itemShopWnd.AddItem(obj["cat"], obj["id"], obj["vnum"], obj["count"], obj["desc"], obj["cost"], obj["cost_type"], obj["attr"], obj["socket"])
self.curIsItem = Nonedef __ISSetLoadSuccess(self):
self.itemShopWnd.SetLoadSuccess()def __ISSetLoadFail(self):
self.itemShopWnd.SetLoadFail()def __ISSetBuySuccess(self):
self.itemShopWnd.SetItemBuySuccess()def __ISSetBuyFail(self):
self.itemShopWnd.SetItemBuyFail()def __ISSetCoins(self, coins):
self.itemShopWnd.SetCoins(coins)def __ISSetMarks(self, marks):
self.itemShopWnd.SetMarks(marks)
def SetAntiEXPQID(self, qid):
self.antiExpQID = int(qid)
def _GuildStorageCMD(self, command):
cmd = command.split("/")
if cmd[0] == "OPEN":
self.interface.GuildStorageWindow.Open(int(cmd[1]))
elif cmd[0] == "REFRESH":
self.interface.GuildStorageWindow.RefreshSlots()
elif cmd[0] == "REFRESH_MONEY":
self.interface.GuildStorageWindow.SetMoney(cmd[1])
elif cmd[0] == "REFRESH_MEMBERS":
self.interface.GuildStorageWindow.Adminpanel["board"].RefreshMembers(0)
elif cmd[0] == "CLEAR_TEMPSLOTS":
constInfo.GUILDSTORAGE["tempslots"] = {"TAB0" : {},"TAB1" : {},"TAB2" : {}, "TAB3" : {}, "TAB4" : {}, "TAB5" : {}}
elif cmd[0] == "COMPARE_TEMPSLOTS":
for i in range(6):
if constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)] != constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)]:
constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = {}
constInfo.GUILDSTORAGE["slots"]["TAB"+str(i)] = constInfo.GUILDSTORAGE["tempslots"]["TAB"+str(i)]
self.interface.GuildStorageWindow.RefreshSlots()
elif cmd[0] == "QID":
self.GuildStorageQID(cmd[1])
elif cmd[0] == "QUESTCMD":
self._GuildStorageQuestCMD()
elif cmd[0] == "MEMBER_COMPLETE":
constInfo.GUILDSTORAGE["members"] = {}
self.interface.GuildStorageWindow.ClearMembers()
constInfo.GUILDSTORAGE["questCMD"] = "GETMEMBERLIST"
event.QuestButtonClick(int(constInfo.GUILDSTORAGE["qid"]))
def _GuildStorageAddItemSlot(self, slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
self.interface.GuildStorageWindow.AddItemSlot(slot, tab ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6)
def _GuildStorageAddItem(self, slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
slotsWidth = 15
slotsHeight = 8
slot = int(slot)
if slot <= 120:
constInfo.GUILDSTORAGE["slots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 120 and slot <= 240:
constInfo.GUILDSTORAGE["slots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 240 and slot <= 360:
constInfo.GUILDSTORAGE["slots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 360 and slot <= 480:
constInfo.GUILDSTORAGE["slots"]["TAB3"][slot-360] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 480 and slot <= 600:
constInfo.GUILDSTORAGE["slots"]["TAB4"][slot-480] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 600 and slot <= 720:
constInfo.GUILDSTORAGE["slots"]["TAB5"][slot-600] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
def _GuildStorageTempSlotsAdd(self,slot ,itemVnum, count, socket0, socket1, socket2, socket3, socket4, socket5, attrtype0,attrvalue0, attrtype1,attrvalue1, attrtype2, attrvalue2, attrtype3, attrvalue3, attrtype4, attrvalue4, attrtype5, attrvalue5, attrtype6, attrvalue6):
slot = int(slot)
if slot <= 120:
constInfo.GUILDSTORAGE["tempslots"]["TAB0"][slot] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 120 and slot <= 240:
constInfo.GUILDSTORAGE["tempslots"]["TAB1"][slot-120] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 240 and slot <= 360:
constInfo.GUILDSTORAGE["tempslots"]["TAB2"][slot-240] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 360 and slot <= 480:
constInfo.GUILDSTORAGE["tempslots"]["TAB3"][slot-360] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 480 and slot <= 600:
constInfo.GUILDSTORAGE["tempslots"]["TAB4"][slot-480] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
elif slot > 600 and slot <= 720:
constInfo.GUILDSTORAGE["tempslots"]["TAB5"][slot-600] = [int(itemVnum),int(count), int(socket0), int(socket1), int(socket2), int(socket3), int(socket4), int(socket5), int(attrtype0),int(attrvalue0), int(attrtype1),int(attrvalue1), int(attrtype2), int(attrvalue2), int(attrtype3), int(attrvalue3), int(attrtype4), int(attrvalue4), int(attrtype5), int(attrvalue5), int(attrtype6), int(attrvalue6)]
def _GuildStorageAddLog(self,id,name,date,type,do,desc):
date = date.replace("+-+"," ")
desc = desc.replace("+-+"," ")
self.interface.GuildStorageWindow.LogsInsert(id,name,date,type,do,desc)
constInfo.GUILDSTORAGE["logs"][int(id)] = [name,date,type,do,desc]
def _GuildStorageQuestCMD(self):
net.SendQuestInputStringPacket(str(constInfo.GUILDSTORAGE["questCMD"]))
constInfo.GUILDSTORAGE["questCMD"] = "NULL#"
def GuildStorageQID(self, qid):
constInfo.GUILDSTORAGE["qid"] = int(qid)
def _GuildStorageAddMemberToList(self,memberId,member,authority0,authority1,authority2,authority3):
constInfo.GUILDSTORAGE["members"]["member"+memberId] = [member,int(authority0),int(authority1),int(authority2),int(authority3)]
def __switch_channel(self):
import uiChannel
a = uiChannel.ChannelChanger()
a.Show()def ToggleAntiEXP(self):
if self.antiExpQID == 0:
return
event.QuestButtonClick(self.antiExpQID)##Autopickup
def Pickup(self):
Pickupdialog = uiCommon.QuestionDialog()
Pickupdialog.SetText("Pickup Aktivieren ?")
Pickupdialog.SetAcceptEvent(lambda arg=2: self.PickupSetting(arg))
Pickupdialog.SetCancelEvent(lambda arg=1: self.PickupSetting(arg))
Pickupdialog.Open()
self.PickupbotDialog = Pickupdialog
def PickupSetting(self, arg):
if arg == 1:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Pickup Deaktiviert.")
constInfo.PickUP = 0
self.PickupbotDialog.Close()
elif arg == 2:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Pickup Aktiviert.")
constInfo.PickUP = 1
self.PickupbotDialog.Close()
##Autopickup
def __Mds(self, coins):
import constInfo
constInfo.mds = int(coins)
-
-
Hi guys plss help me ... i add to my server cube system ... but when i start my game in syserr i have this :
0219 11:26:32906 :: CMapOutdoor::Load - LoadMonsterAreaInfo ERROR
0219 11:27:30835 :: Traceback (most recent call last):0219 11:27:30836 :: File "game.py", line 1887, in BINARY_Cube_MaterialInfo
0219 11:27:30837 :: File "uiCube.py", line 442, in Refresh
0219 11:27:30837 :: KeyError
0219 11:27:30838 :: :
0219 11:27:30838 :: 1
0219 11:27:30838 ::0219 11:27:34645 :: Traceback (most recent call last):
0219 11:27:34645 :: File "ui.py", line 1523, in OnMove
0219 11:27:34646 :: File "ui.py", line 87, in __call__
0219 11:27:34647 :: File "ui.py", line 69, in __call__
0219 11:27:34648 :: File "ui.py", line 2675, in OnMove
0219 11:27:34649 :: File "ui.py", line 87, in __call__
0219 11:27:34650 :: File "ui.py", line 69, in __call__
0219 11:27:34651 :: File "uiCube.py", line 186, in OnScrollResultList
0219 11:27:34652 :: File "uiCube.py", line 442, in Refresh
0219 11:27:34652 :: KeyError
0219 11:27:34652 :: :
0219 11:27:34652 :: 1
0219 11:27:34652 ::
Pls help me ... a thanks to all who answer
Cube problem
in Community Support - Questions & Answers
Posted
Man sorry again here :