[Official Block] System Problem

Reco · 28. Juli 2017

Guten Tag Leute,

ich habe Gestern das Bitte melden Sie sich an, um diesen Link zu sehen. eingebaut.

Nun habe ich mehrere Probleme:

- Als normaler Spieler sehe ich bei einem GM Die obere "leiste" mit Freund , Handeln, Duel, Emotionen etc.
Als Gm sehe ich von normalen spielern diese leiste nicht.
Auch als normaler spieler zu normaler spiele sehe ich diese leiste nicht.

- Desweiteren kann ich Spieler zwar Blocken jedoch nicht entblocken.

Client Sysser:

Code

0728 12:41:09526 :: Traceback (most recent call last):
0728 12:41:09526 :: File "game.py", line 833, in SetPCTargetBoard
0728 12:41:09526 :: File "uiTarget.py", line 203, in Open
0728 12:41:09526 :: File "uiTarget.py", line 442, in RefreshButton
0728 12:41:09526 :: AttributeError
0728 12:41:09526 :: :
0728 12:41:09526 :: 'module' object has no attribute 'IsBlockByName'
0728 12:41:09526 ::
0728 12:41:27344 :: Traceback (most recent call last):
0728 12:41:27344 :: File "ui.py", line 1021, in CallEvent
0728 12:41:27344 :: File "ui.py", line 87, in __call__
0728 12:41:27345 :: File "ui.py", line 69, in __call__
0728 12:41:27345 :: File "uiMessenger.py", line 734, in OnRemove
0728 12:41:27345 :: File "uiMessenger.py", line 289, in OnRemove
0728 12:41:27345 :: AttributeError
0728 12:41:27345 :: :
0728 12:41:27345 :: 'module' object has no attribute 'RemoveBlock'
0728 12:41:27345 ::

Alles anzeigen

Hier ist meine Bearbeitete uitarget.py & uimessenger.py

uitarget.py

Python

import app
import ui
import player
import net
import wndMgr
import messenger
import guild
import chr
import nonplayer
import localeInfo
import constInfo
class TargetBoard(ui.ThinBoard):
BUTTON_NAME_LIST = (
localeInfo.TARGET_BUTTON_WHISPER,
localeInfo.TARGET_BUTTON_EXCHANGE,
localeInfo.TARGET_BUTTON_FIGHT,
localeInfo.TARGET_BUTTON_ACCEPT_FIGHT,
localeInfo.TARGET_BUTTON_AVENGE,
localeInfo.TARGET_BUTTON_FRIEND,
localeInfo.TARGET_BUTTON_INVITE_PARTY,
localeInfo.TARGET_BUTTON_LEAVE_PARTY,
localeInfo.TARGET_BUTTON_EXCLUDE,
localeInfo.TARGET_BUTTON_INVITE_GUILD,
localeInfo.TARGET_BUTTON_DISMOUNT,
localeInfo.TARGET_BUTTON_EXIT_OBSERVER,
localeInfo.TARGET_BUTTON_VIEW_EQUIPMENT,
localeInfo.TARGET_BUTTON_REQUEST_ENTER_PARTY,
localeInfo.TARGET_BUTTON_BUILDING_DESTROY,
localeInfo.TARGET_BUTTON_EMOTION_ALLOW,
localeInfo.TARGET_BUTTON_BLOCK,
localeInfo.TARGET_BUTTON_UNBLOCK,
"VOTE_BLOCK_CHAT",
)
GRADE_NAME = {
nonplayer.PAWN : localeInfo.TARGET_LEVEL_PAWN,
nonplayer.S_PAWN : localeInfo.TARGET_LEVEL_S_PAWN,
nonplayer.KNIGHT : localeInfo.TARGET_LEVEL_KNIGHT,
nonplayer.S_KNIGHT : localeInfo.TARGET_LEVEL_S_KNIGHT,
nonplayer.BOSS : localeInfo.TARGET_LEVEL_BOSS,
nonplayer.KING : localeInfo.TARGET_LEVEL_KING,
}
EXCHANGE_LIMIT_RANGE = 3000
def __init__(self):
ui.ThinBoard.__init__(self)
name = ui.TextLine()
name.SetParent(self)
name.SetDefaultFontName()
name.SetOutline()
name.Show()
hpGauge = ui.Gauge()
hpGauge.SetParent(self)
hpGauge.MakeGauge(130, "red")
hpGauge.Hide()
##TP_ANZEIGE_MONSTER
hpPercenttxt = ui.TextLine()
hpPercenttxt.SetParent(self)
hpPercenttxt.SetPosition(160, 13)
hpPercenttxt.SetText("")
hpPercenttxt.Hide()
##TP_ANZEIGE_MONSTER
hpText = ui.TextLine()
hpText.SetPosition(0, -17)
hpText.SetWindowHorizontalAlignCenter()
hpText.SetHorizontalAlignCenter()
hpText.Hide()
closeButton = ui.Button()
closeButton.SetParent(self)
closeButton.SetUpVisual("d:/ymir work/ui/public/close_button_01.sub")
closeButton.SetOverVisual("d:/ymir work/ui/public/close_button_02.sub")
closeButton.SetDownVisual("d:/ymir work/ui/public/close_button_03.sub")
closeButton.SetPosition(30, 13)
if localeInfo.IsARABIC():
hpGauge.SetPosition(55, 17)
hpGauge.SetWindowHorizontalAlignLeft()
closeButton.SetWindowHorizontalAlignLeft()
else:
hpGauge.SetPosition(175, 17)
hpGauge.SetWindowHorizontalAlignRight()
closeButton.SetWindowHorizontalAlignRight()
closeButton.SetEvent(ui.__mem_func__(self.OnPressedCloseButton))
closeButton.Show()
self.buttonDict = {}
self.showingButtonList = []
for buttonName in self.BUTTON_NAME_LIST:
button = ui.Button()
button.SetParent(self)
if localeInfo.IsARABIC():
button.SetUpVisual("d:/ymir work/ui/public/Small_Button_01.sub")
button.SetOverVisual("d:/ymir work/ui/public/Small_Button_02.sub")
button.SetDownVisual("d:/ymir work/ui/public/Small_Button_03.sub")
else:
button.SetUpVisual("d:/ymir work/ui/public/small_thin_button_01.sub")
button.SetOverVisual("d:/ymir work/ui/public/small_thin_button_02.sub")
button.SetDownVisual("d:/ymir work/ui/public/small_thin_button_03.sub")
button.SetWindowHorizontalAlignCenter()
button.SetText(buttonName)
button.Hide()
self.buttonDict[buttonName] = button
self.showingButtonList.append(button)
self.buttonDict[localeInfo.TARGET_BUTTON_WHISPER].SetEvent(ui.__mem_func__(self.OnWhisper))
self.buttonDict[localeInfo.TARGET_BUTTON_EXCHANGE].SetEvent(ui.__mem_func__(self.OnExchange))
self.buttonDict[localeInfo.TARGET_BUTTON_FIGHT].SetEvent(ui.__mem_func__(self.OnPVP))
self.buttonDict[localeInfo.TARGET_BUTTON_ACCEPT_FIGHT].SetEvent(ui.__mem_func__(self.OnPVP))
self.buttonDict[localeInfo.TARGET_BUTTON_AVENGE].SetEvent(ui.__mem_func__(self.OnPVP))
self.buttonDict[localeInfo.TARGET_BUTTON_FRIEND].SetEvent(ui.__mem_func__(self.OnAppendToMessenger))
self.buttonDict[localeInfo.TARGET_BUTTON_FRIEND].SetEvent(ui.__mem_func__(self.OnAppendToMessenger))
self.buttonDict[localeInfo.TARGET_BUTTON_INVITE_PARTY].SetEvent(ui.__mem_func__(self.OnPartyInvite))
self.buttonDict[localeInfo.TARGET_BUTTON_LEAVE_PARTY].SetEvent(ui.__mem_func__(self.OnPartyExit))
self.buttonDict[localeInfo.TARGET_BUTTON_EXCLUDE].SetEvent(ui.__mem_func__(self.OnPartyRemove))
if app.ENABLE_MESSENGER_BLOCK:
self.buttonDict[localeInfo.TARGET_BUTTON_BLOCK].SetEvent(ui.__mem_func__(self.OnAppendToBlockMessenger))
self.buttonDict[localeInfo.TARGET_BUTTON_UNBLOCK].SetEvent(ui.__mem_func__(self.OnRemoveToBlockMessenger))
self.buttonDict[localeInfo.TARGET_BUTTON_INVITE_GUILD].SAFE_SetEvent(self.__OnGuildAddMember)
self.buttonDict[localeInfo.TARGET_BUTTON_DISMOUNT].SAFE_SetEvent(self.__OnDismount)
self.buttonDict[localeInfo.TARGET_BUTTON_EXIT_OBSERVER].SAFE_SetEvent(self.__OnExitObserver)
self.buttonDict[localeInfo.TARGET_BUTTON_VIEW_EQUIPMENT].SAFE_SetEvent(self.__OnViewEquipment)
self.buttonDict[localeInfo.TARGET_BUTTON_REQUEST_ENTER_PARTY].SAFE_SetEvent(self.__OnRequestParty)
self.buttonDict[localeInfo.TARGET_BUTTON_BUILDING_DESTROY].SAFE_SetEvent(self.__OnDestroyBuilding)
self.buttonDict[localeInfo.TARGET_BUTTON_EMOTION_ALLOW].SAFE_SetEvent(self.__OnEmotionAllow)
self.buttonDict["VOTE_BLOCK_CHAT"].SetEvent(ui.__mem_func__(self.__OnVoteBlockChat))
self.name = name
self.hpGauge = hpGauge
self.hpPercenttxt = hpPercenttxt
self.hpText = hpText
hpText.SetParent(hpGauge)
self.closeButton = closeButton
self.nameString = 0
self.nameLength = 0
self.vid = 0
self.eventWhisper = None
self.isShowButton = FALSE
self.__Initialize()
self.ResetTargetBoard()
def __del__(self):
ui.ThinBoard.__del__(self)
print "===================================================== DESTROYED TARGET BOARD"
def __Initialize(self):
self.nameString = ""
self.nameLength = 0
self.vid = 0
self.isShowButton = FALSE
def Destroy(self):
self.eventWhisper = None
self.closeButton = None
self.showingButtonList = None
self.buttonDict = None
self.name = None
self.hpGauge = None
self.__Initialize()
self.hpText = None
self.hpPercenttxt = None
def OnPressedCloseButton(self):
player.ClearTarget()
self.Close()
def Close(self):
self.__Initialize()
self.Hide()
def Open(self, vid, name):
if vid:
if not constInfo.GET_VIEW_OTHER_EMPIRE_PLAYER_TARGET_BOARD():
if not player.IsSameEmpire(vid):
self.Hide()
return
if vid != self.GetTargetVID():
self.ResetTargetBoard()
self.SetTargetVID(vid)
self.SetTargetName(name)
if player.IsMainCharacterIndex(vid):
self.__ShowMainCharacterMenu()
elif chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(self.vid):
self.Hide()
else:
self.RefreshButton()
self.Show()
else:
self.HideAllButton()
self.__ShowButton(localeInfo.TARGET_BUTTON_WHISPER)
self.__ShowButton("VOTE_BLOCK_CHAT")
self.__ArrangeButtonPosition()
self.SetTargetName(name)
self.Show()
def Refresh(self):
if self.IsShow():
if self.IsShowButton():
self.RefreshButton()
def RefreshByVID(self, vid):
if vid == self.GetTargetVID():
self.Refresh()
def RefreshByName(self, name):
if name == self.GetTargetName():
self.Refresh()
def __ShowMainCharacterMenu(self):
canShow=0
self.HideAllButton()
if player.IsMountingHorse():
self.__ShowButton(localeInfo.TARGET_BUTTON_DISMOUNT)
canShow=1
if player.IsObserverMode():
self.__ShowButton(localeInfo.TARGET_BUTTON_EXIT_OBSERVER)
canShow=1
if canShow:
self.__ArrangeButtonPosition()
self.Show()
else:
self.Hide()
def __ShowNameOnlyMenu(self):
self.HideAllButton()
def SetWhisperEvent(self, event):
self.eventWhisper = event
def UpdatePosition(self):
self.SetPosition(wndMgr.GetScreenWidth()/2 - self.GetWidth()/2, 10)
def ResetTargetBoard(self):
for btn in self.buttonDict.values():
btn.Hide()
self.__Initialize()
self.name.SetPosition(0, 13)
self.name.SetHorizontalAlignCenter()
self.name.SetWindowHorizontalAlignCenter()
self.hpGauge.Hide()
self.SetSize(250, 40)
def SetTargetVID(self, vid):
self.vid = vid
def SetEnemyVID(self, vid):
self.SetTargetVID(vid)
name = chr.GetNameByVID(vid)
level = nonplayer.GetLevelByVID(vid)
grade = nonplayer.GetGradeByVID(vid)
nameFront = ""
EXP = ""
if -1 != level:
nameFront += "Lv." + str(level) + " "
EXP += " " + "EXP:" + str(nonplayer.GetMonsterEXP(self.vid))
if self.GRADE_NAME.has_key(grade):
nameFront += "(" + self.GRADE_NAME[grade] + ") "
self.SetTargetName(nameFront + name + EXP)
def GetTargetVID(self):
return self.vid
def GetTargetName(self):
return self.nameString
def SetTargetName(self, name):
self.nameString = name
self.nameLength = len(name)
self.name.SetText(name)
def SetHP(self, hpPercentage):
if not self.hpGauge.IsShow():
self.SetSize(200 + 7*self.nameLength, self.GetHeight())
self.name.SetPosition(23, 13)
self.name.SetWindowHorizontalAlignLeft()
self.name.SetHorizontalAlignLeft()
self.hpGauge.Show()
self.hpText.Show()
self.UpdatePosition()
self.hpPercenttxt.SetPosition(200 + 7*self.nameLength-205, 13)
self.hpPercenttxt.Show()
self.hpGauge.SetPercentage(hpPercentage, 100)
self.hpPercenttxt.SetText("%d%%" % (hpPercentage))
self.hpText.SetText(str(int(float(hpPercentage)/100.00*float(nonplayer.GetMonsterMaxHp(self.vid)))) + "/" + str(nonplayer.GetMonsterMaxHp(self.vid)) )
chr.SelectInstance(self.vid)
def ShowDefaultButton(self):
self.isShowButton = TRUE
self.showingButtonList.append(self.buttonDict[localeInfo.TARGET_BUTTON_WHISPER])
self.showingButtonList.append(self.buttonDict[localeInfo.TARGET_BUTTON_EXCHANGE])
self.showingButtonList.append(self.buttonDict[localeInfo.TARGET_BUTTON_FIGHT])
self.showingButtonList.append(self.buttonDict[localeInfo.TARGET_BUTTON_EMOTION_ALLOW])
for button in self.showingButtonList:
button.Show()
def HideAllButton(self):
self.isShowButton = FALSE
for button in self.showingButtonList:
button.Hide()
self.showingButtonList = []
def __ShowButton(self, name):
if not self.buttonDict.has_key(name):
return
self.buttonDict[name].Show()
self.showingButtonList.append(self.buttonDict[name])
def __HideButton(self, name):
if not self.buttonDict.has_key(name):
return
button = self.buttonDict[name]
button.Hide()
for btnInList in self.showingButtonList:
if btnInList == button:
self.showingButtonList.remove(button)
break
def OnWhisper(self):
if None != self.eventWhisper:
self.eventWhisper(self.nameString)
def OnExchange(self):
net.SendExchangeStartPacket(self.vid)
def OnPVP(self):
net.SendChatPacket("/pvp %d" % (self.vid))
def OnAppendToMessenger(self):
net.SendMessengerAddByVIDPacket(self.vid)
if app.ENABLE_MESSENGER_BLOCK:
def OnAppendToBlockMessenger(self):
net.SendMessengerAddBlockByVIDPacket(self.vid)
def OnRemoveToBlockMessenger(self):
messenger.RemoveBlock(constInfo.ME_KEY)
net.SendMessengerRemoveBlockPacket(constInfo.ME_KEY, chr.GetNameByVID(self.vid))
def OnPartyInvite(self):
net.SendPartyInvitePacket(self.vid)
def OnPartyExit(self):
net.SendPartyExitPacket()
def OnPartyRemove(self):
net.SendPartyRemovePacket(self.vid)
def __OnGuildAddMember(self):
net.SendGuildAddMemberPacket(self.vid)
def __OnDismount(self):
net.SendChatPacket("/unmount")
def __OnExitObserver(self):
net.SendChatPacket("/observer_exit")
def __OnViewEquipment(self):
net.SendChatPacket("/view_equip " + str(self.vid))
def __OnRequestParty(self):
net.SendChatPacket("/party_request " + str(self.vid))
def __OnDestroyBuilding(self):
net.SendChatPacket("/build d %d" % (self.vid))
def __OnEmotionAllow(self):
net.SendChatPacket("/emotion_allow %d" % (self.vid))
def __OnVoteBlockChat(self):
cmd = "/vote_block_chat %s" % (self.nameString)
net.SendChatPacket(cmd)
def OnPressEscapeKey(self):
self.OnPressedCloseButton()
return TRUE
def IsShowButton(self):
return self.isShowButton
def RefreshButton(self):
self.HideAllButton()
if chr.INSTANCE_TYPE_BUILDING == chr.GetInstanceType(self.vid):
#self.__ShowButton(localeInfo.TARGET_BUTTON_BUILDING_DESTROY)
#self.__ArrangeButtonPosition()
return
if player.IsPVPInstance(self.vid) or player.IsObserverMode():
# PVP_INFO_SIZE_BUG_FIX
self.SetSize(200 + 7*self.nameLength, 40)
self.UpdatePosition()
# END_OF_PVP_INFO_SIZE_BUG_FIX
return
self.ShowDefaultButton()
if guild.MainPlayerHasAuthority(guild.AUTH_ADD_MEMBER):
if not guild.IsMemberByName(self.nameString):
if 0 == chr.GetGuildID(self.vid):
self.__ShowButton(localeInfo.TARGET_BUTTON_INVITE_GUILD)
if not messenger.IsFriendByName(self.nameString):
self.__ShowButton(localeInfo.TARGET_BUTTON_FRIEND)
if app.ENABLE_MESSENGER_BLOCK and not str(self.nameString)[0] == "[":
if not messenger.IsBlockByName(self.nameString):
self.__ShowButton(localeInfo.TARGET_BUTTON_BLOCK)
self.__HideButton(localeInfo.TARGET_BUTTON_UNBLOCK)
else:
self.__ShowButton(localeInfo.TARGET_BUTTON_UNBLOCK)
self.__HideButton(localeInfo.TARGET_BUTTON_BLOCK)
if player.IsPartyMember(self.vid):
self.__HideButton(localeInfo.TARGET_BUTTON_FIGHT)
if player.IsPartyLeader(self.vid):
self.__ShowButton(localeInfo.TARGET_BUTTON_LEAVE_PARTY)
elif player.IsPartyLeader(player.GetMainCharacterIndex()):
self.__ShowButton(localeInfo.TARGET_BUTTON_EXCLUDE)
else:
if player.IsPartyMember(player.GetMainCharacterIndex()):
if player.IsPartyLeader(player.GetMainCharacterIndex()):
self.__ShowButton(localeInfo.TARGET_BUTTON_INVITE_PARTY)
else:
if chr.IsPartyMember(self.vid):
self.__ShowButton(localeInfo.TARGET_BUTTON_REQUEST_ENTER_PARTY)
else:
self.__ShowButton(localeInfo.TARGET_BUTTON_INVITE_PARTY)
if player.IsRevengeInstance(self.vid):
self.__HideButton(localeInfo.TARGET_BUTTON_FIGHT)
self.__ShowButton(localeInfo.TARGET_BUTTON_AVENGE)
elif player.IsChallengeInstance(self.vid):
self.__HideButton(localeInfo.TARGET_BUTTON_FIGHT)
self.__ShowButton(localeInfo.TARGET_BUTTON_ACCEPT_FIGHT)
elif player.IsCantFightInstance(self.vid):
self.__HideButton(localeInfo.TARGET_BUTTON_FIGHT)
if not player.IsSameEmpire(self.vid):
self.__HideButton(localeInfo.TARGET_BUTTON_INVITE_PARTY)
self.__HideButton(localeInfo.TARGET_BUTTON_FRIEND)
self.__HideButton(localeInfo.TARGET_BUTTON_FIGHT)
distance = player.GetCharacterDistance(self.vid)
if distance > self.EXCHANGE_LIMIT_RANGE:
self.__HideButton(localeInfo.TARGET_BUTTON_EXCHANGE)
self.__ArrangeButtonPosition()
self.__ArrangeButtonPosition()
def __ArrangeButtonPosition(self):
showingButtonCount = len(self.showingButtonList)
pos = -(showingButtonCount / 2) * 68
if 0 == showingButtonCount % 2:
pos += 34
for button in self.showingButtonList:
button.SetPosition(pos, 33)
pos += 68
self.SetSize(max(150, showingButtonCount * 75), 65)
self.UpdatePosition()
def OnUpdate(self):
if self.isShowButton:
exchangeButton = self.buttonDict[localeInfo.TARGET_BUTTON_EXCHANGE]
distance = player.GetCharacterDistance(self.vid)
if distance < 0:
return
if exchangeButton.IsShow():
if distance > self.EXCHANGE_LIMIT_RANGE:
self.RefreshButton()
else:
if distance < self.EXCHANGE_LIMIT_RANGE:
self.RefreshButton()

Alles anzeigen

uimessenger.py

Code

import app
import ui
import grp
import net
import guild
import messenger
import localeInfo
import constInfo
import uiToolTip
import uiGameOption
import uiCommon
from _weakref import proxy
FRIEND = 0
GUILD = 1
BLOCK = 2
class MessengerItem(ui.Window):
def __init__(self, getParentEvent):
ui.Window.__init__(self)
self.SetParent(getParentEvent())
self.AddFlag("float")
self.name = ""
self.image = ui.ImageBox()
self.image.AddFlag("not_pick")
self.image.SetParent(self)
self.image.Show()
self.text = ui.TextLine()
self.text.SetParent(self)
self.text.SetPosition(20, 2)
self.text.Show()
self.lovePoint = -1
self.lovePointToolTip = None
self.isSelected = FALSE
self.getParentEvent = getParentEvent
def SetName(self, name):
self.name = name
if name:
self.text.SetText(name)
self.SetSize(20 + 6*len(name) + 4, 16)
if localeInfo.IsARABIC():
self.text.SetPosition(20 + 6*len(name) + 4, 2)
def SetLovePoint(self, lovePoint):
self.lovePoint = lovePoint
def Select(self):
self.isSelected = TRUE
def UnSelect(self):
self.isSelected = FALSE
def GetName(self):
return self.name
def GetStepWidth(self):
return 0
# Whisper
def CanWhisper(self):
return FALSE
def IsOnline(self):
return FALSE
def IsMobile(self):
return FALSE
def OnWhisper(self):
pass
def OnMobileMessage(self):
pass
# Remove
def CanRemove(self):
return FALSE
def OnRemove(self):
return FALSE
# Warp
def CanWarp(self):
return FALSE
def OnWarp(self):
pass
def OnMouseOverIn(self):
if -1 != self.lovePoint:
if not self.lovePointToolTip:
self.lovePointToolTip = uiToolTip.ToolTip(100)
self.lovePointToolTip.SetTitle(self.name)
self.lovePointToolTip.AppendTextLine(localeInfo.AFF_LOVE_POINT % (self.lovePoint))
self.lovePointToolTip.ResizeToolTip()
self.lovePointToolTip.ShowToolTip()
def OnMouseOverOut(self):
if self.lovePointToolTip:
self.lovePointToolTip.HideToolTip()
def OnMouseLeftButtonDown(self):
self.getParentEvent().OnSelectItem(self)
def OnMouseLeftButtonDoubleClick(self):
self.getParentEvent().OnDoubleClickItem(self)
def OnRender(self):
if self.isSelected:
x, y = self.GetGlobalPosition()
grp.SetColor(grp.GenerateColor(0.0, 0.0, 0.7, 0.7))
grp.RenderBar(x+16, y, self.GetWidth()-16, self.GetHeight())
class MessengerMemberItem(MessengerItem):
STATE_OFFLINE = 0
STATE_ONLINE = 1
STATE_MOBILE = 2
IMAGE_FILE_NAME = { "ONLINE" : "d:/ymir work/ui/game/windows/messenger_list_online.sub",
"OFFLINE" : "d:/ymir work/ui/game/windows/messenger_list_offline.sub",
"MOBILE" : "d:/ymir work/ui/game/windows/messenger_list_mobile.sub", }
def __init__(self, getParentEvent):
MessengerItem.__init__(self, getParentEvent)
self.key = None
self.state = self.STATE_OFFLINE
self.mobileFlag = FALSE
self.Offline()
def GetStepWidth(self):
return 15
def SetKey(self, key):
self.key = key
if app.ENABLE_MESSENGER_BLOCK:
constInfo.ME_KEY = key
def IsSameKey(self, key):
return self.key == key
def IsOnline(self):
if self.STATE_ONLINE == self.state:
return TRUE
return FALSE
def IsMobile(self):
if self.STATE_MOBILE == self.state:
return TRUE
return FALSE
def Online(self):
self.image.LoadImage(self.IMAGE_FILE_NAME["ONLINE"])
self.state = self.STATE_ONLINE
def Offline(self):
if self.mobileFlag:
self.image.LoadImage(self.IMAGE_FILE_NAME["MOBILE"])
self.state = self.STATE_MOBILE
else:
self.image.LoadImage(self.IMAGE_FILE_NAME["OFFLINE"])
self.state = self.STATE_OFFLINE
def SetMobile(self, flag):
self.mobileFlag = flag
if not self.IsOnline():
self.Offline()
def CanWhisper(self):
if self.IsOnline():
return TRUE
return FALSE
def OnWhisper(self):
if self.IsOnline():
self.getParentEvent().whisperButtonEvent(self.GetName())
def OnMobileMessage(self):
if not uiGameOption.MOBILE:
return
if not self.IsMobile():
return
self.getParentEvent().SendMobileMessage(self.GetName())
def Select(self):
MessengerItem.Select(self)
class MessengerGroupItem(MessengerItem):
IMAGE_FILE_NAME = { "OPEN" : "d:/ymir work/ui/game/windows/messenger_list_open.sub",
"CLOSE" : "d:/ymir work/ui/game/windows/messenger_list_close.sub", }
def __init__(self, getParentEvent):
self.isOpen = FALSE
self.memberList = []
MessengerItem.__init__(self, getParentEvent)
def AppendMember(self, member, key, name):
member.SetKey(key)
member.SetName(name)
self.memberList.append(member)
return member
def RemoveMember(self, item):
for i in xrange(len(self.memberList)):
if item == self.memberList[i]:
del self.memberList[i]
return
def ClearMember(self):
self.memberList = []
def FindMember(self, key):
list = filter(lambda argMember, argKey=key: argMember.IsSameKey(argKey), self.memberList)
if list:
return list[0]
return None
def GetLoginMemberList(self):
return filter(MessengerMemberItem.IsOnline, self.memberList)
def GetLogoutMemberList(self):
return filter(lambda arg: not arg.IsOnline(), self.memberList)
def IsOpen(self):
return self.isOpen
def Open(self):
self.image.LoadImage(self.IMAGE_FILE_NAME["OPEN"])
self.isOpen = TRUE
def Close(self):
self.image.LoadImage(self.IMAGE_FILE_NAME["CLOSE"])
self.isOpen = FALSE
map(ui.Window.Hide, self.memberList)
def Select(self):
if self.IsOpen():
self.Close()
else:
self.Open()
MessengerItem.Select(self)
self.getParentEvent().OnRefreshList()
class MessengerFriendItem(MessengerMemberItem):
def __init__(self, getParentEvent):
MessengerMemberItem.__init__(self, getParentEvent)
def CanRemove(self):
return TRUE
def OnRemove(self):
messenger.RemoveFriend(self.key)
net.SendMessengerRemovePacket(self.key, self.name)
return TRUE
if app.ENABLE_MESSENGER_BLOCK:
class MessengerBlockItem(MessengerMemberItem):
def __init__(self, getParentEvent):
MessengerMemberItem.__init__(self, getParentEvent)
def CanRemove(self):
return TRUE
def OnRemove(self):
messenger.RemoveBlock(self.key)
net.SendMessengerRemoveBlockPacket(self.key, self.name)
return TRUE
class MessengerGuildItem(MessengerMemberItem):
def __init__(self, getParentEvent):
MessengerMemberItem.__init__(self, getParentEvent)
def CanWarp(self):
if not self.IsOnline():
return FALSE
return TRUE
def OnWarp(self):
net.SendGuildUseSkillPacket(155, self.key)
def CanRemove(self):
for i in xrange(guild.ENEMY_GUILD_SLOT_MAX_COUNT):
if guild.GetEnemyGuildName(i) != "":
return FALSE
if guild.MainPlayerHasAuthority(guild.AUTH_REMOVE_MEMBER):
if guild.IsMemberByName(self.name):
return TRUE
return FALSE
def OnRemove(self):
net.SendGuildRemoveMemberPacket(self.key)
return TRUE
class MessengerFriendGroup(MessengerGroupItem):
def __init__(self, getParentEvent):
MessengerGroupItem.__init__(self, getParentEvent)
self.SetName(localeInfo.MESSENGER_FRIEND)
def AppendMember(self, key, name):
item = MessengerFriendItem(self.getParentEvent)
return MessengerGroupItem.AppendMember(self, item, key, name)
if app.ENABLE_MESSENGER_BLOCK:
class MessengerBlockGroup(MessengerGroupItem):
def __init__(self, getParentEvent):
MessengerGroupItem.__init__(self, getParentEvent)
self.SetName(localeInfo.MESSENGER_BLOCK)
def AppendMember(self, key, name):
item = MessengerBlockItem(self.getParentEvent)
return MessengerGroupItem.AppendMember(self, item, key, name)
class MessengerGuildGroup(MessengerGroupItem):
def __init__(self, getParentEvent):
MessengerGroupItem.__init__(self, getParentEvent)
self.SetName(localeInfo.MESSENGER_GUILD)
self.AddFlag("float")
def AppendMember(self, key, name):
item = MessengerGuildItem(self.getParentEvent)
return MessengerGroupItem.AppendMember(self, item, key, name)
class MessengerFamilyGroup(MessengerGroupItem):
def __init__(self, getParentEvent):
MessengerGroupItem.__init__(self, getParentEvent)
self.SetName(localeInfo.MESSENGER_FAMILY)
self.AddFlag("float")
self.lover = None
def AppendMember(self, key, name):
item = MessengerGuildItem(self.getParentEvent)
self.lover = item
return MessengerGroupItem.AppendMember(self, item, key, name)
def GetLover(self):
return self.lover
###################################################################################################
###################################################################################################
###################################################################################################
class MessengerWindow(ui.ScriptWindow):
START_POSITION = 40
class ResizeButton(ui.DragButton):
def OnMouseOverIn(self):
app.SetCursor(app.VSIZE)
def OnMouseOverOut(self):
app.SetCursor(app.NORMAL)
def __init__(self):
ui.ScriptWindow.__init__(self)
messenger.SetMessengerHandler(self)
self.board = None
self.groupList = []
self.showingItemList = []
self.selectedItem = None
self.whisperButtonEvent = lambda *arg: None
self.familyGroup = None
self.guildButtonEvent = None
self.showingPageSize = 0
self.startLine = 0
self.hasMobilePhoneNumber = TRUE
self.isLoaded = 0
self.__AddGroup()
messenger.RefreshGuildMember()
def Show(self):
if self.isLoaded==0:
self.isLoaded=1
self.__LoadWindow()
self.OnRefreshList()
self.OnResizeDialog()
ui.ScriptWindow.Show(self)
def __LoadWindow(self):
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/MessengerWindow.py")
try:
self.board = self.GetChild("board")
self.scrollBar = self.GetChild("ScrollBar")
self.whisperButton = self.GetChild("WhisperButton")
self.mobileButton = self.GetChild("MobileButton")
self.removeButton = self.GetChild("RemoveButton")
self.addFriendButton = self.GetChild("AddFriendButton")
self.addBlockButton = self.GetChild("BlockFriendButton")
self.guildButton = self.GetChild("GuildButton")
except:
import exception
exception.Abort("MessengerWindow.__LoadWindow.__Bind")
self.board.SetCloseEvent(ui.__mem_func__(self.Close))
self.scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
self.whisperButton.SetEvent(ui.__mem_func__(self.OnPressWhisperButton))
self.mobileButton.SetEvent(ui.__mem_func__(self.OnPressMobileButton))
self.removeButton.SetEvent(ui.__mem_func__(self.OnPressRemoveButton))
self.addFriendButton.SetEvent(ui.__mem_func__(self.OnPressAddFriendButton))
self.guildButton.SetEvent(ui.__mem_func__(self.OnPressGuildButton))
if app.ENABLE_MESSENGER_BLOCK:
self.addBlockButton.SetEvent(ui.__mem_func__(self.OnPressAddBlockButton))
if not uiGameOption.MOBILE: #constInfo.SEND_MOBILE_PHONE_MESSAGE_ENABLE:
self.mobileButton.Hide()
width = self.GetWidth()
height = self.GetHeight()
if not app.ENABLE_MESSENGER_BLOCK:
self.addFriendButton.SetPosition(-60, 30)
self.whisperButton.SetPosition(-20, 30)
self.removeButton.SetPosition(20, 30)
self.guildButton.SetPosition(60, 30)
self.whisperButton.Disable()
self.mobileButton.Disable()
self.removeButton.Disable()
resizeButton = self.ResizeButton()
resizeButton.AddFlag("restrict_x")
resizeButton.SetParent(self)
resizeButton.SetSize(self.GetWidth(), 10)
resizeButton.SetWindowVerticalAlignBottom()
resizeButton.SetPosition(0, 0)
resizeButton.Show()
self.resizeButton = resizeButton
self.resizeButton.SetMoveEvent(ui.__mem_func__(self.OnResizeDialog))
self.resizeButton.SetPosition(0, 300)
for list in self.groupList:
list.SetTop()
def __del__(self):
messenger.SetMessengerHandler(None)
ui.ScriptWindow.__del__(self)
def Destroy(self):
self.board = None
self.scrollBar = None
self.resizeButton = None
self.friendNameBoard = None
self.questionDialog = None
self.popupDialog = None
self.inputDialog = None
self.familyGroup = None
self.whisperButton = None
self.mobileButton = None
self.removeButton = None
def OnCloseQuestionDialog(self):
self.questionDialog.Close()
self.questionDialog = None
return TRUE
def Close(self):
self.questionDialog = None
self.Hide()
def SetSize(self, width, height):
ui.ScriptWindow.SetSize(self, width, height)
if self.board:
self.board.SetSize(width, height)
def OnResizeDialog(self):
x, y = self.resizeButton.GetLocalPosition()
if y < 140:
self.resizeButton.SetPosition(x, 140)
return
self.SetSize(self.GetWidth(), y + self.resizeButton.GetHeight())
self.showingPageSize = y - (self.START_POSITION + 26)
self.scrollBar.SetScrollBarSize(self.showingPageSize)
self.__LocateMember()
self.resizeButton.TurnOffCallBack()
self.UpdateRect()
self.resizeButton.TurnOnCallBack()
def __LocateMember(self):
if self.isLoaded==0:
return
if self.showingPageSize/20 >= len(self.showingItemList):
self.scrollBar.Hide()
self.startLine = 0
else:
if self.showingItemList:
self.scrollBar.SetMiddleBarSize(float(self.showingPageSize/20) / float(len(self.showingItemList)))
self.scrollBar.Show()
#####
yPos = self.START_POSITION
heightLimit = self.GetHeight() - (self.START_POSITION + 13)
map(ui.Window.Hide, self.showingItemList)
for item in self.showingItemList[self.startLine:]:
item.SetPosition(20 + item.GetStepWidth(), yPos)
item.SetTop()
item.Show()
yPos += 20
if yPos > heightLimit:
break
def __AddGroup(self):
member = MessengerFriendGroup(ui.__mem_func__(self.GetSelf))
member.Open()
member.Show()
self.groupList.append(member)
member = MessengerGuildGroup(ui.__mem_func__(self.GetSelf))
member.Open()
member.Show()
self.groupList.append(member)
if app.ENABLE_MESSENGER_BLOCK:
member = MessengerBlockGroup(ui.__mem_func__(self.GetSelf))
member.Open()
member.Show()
self.groupList.append(member)
def __AddFamilyGroup(self):
member = MessengerFamilyGroup(ui.__mem_func__(self.GetSelf))
member.Open()
member.Show()
self.familyGroup = member
def ClearGuildMember(self):
self.groupList[GUILD].ClearMember()
def SetWhisperButtonEvent(self, event):
self.whisperButtonEvent=event
def SetGuildButtonEvent(self, event):
self.guildButtonEvent=event
def SendMobileMessage(self, name):
if not uiGameOption.MOBILE:
return
if not self.hasMobilePhoneNumber:
questionDialog = uiCommon.QuestionDialog2()
questionDialog.SetText1(localeInfo.MESSENGER_INPUT_MOBILE_PHONE_NUMBER_1)
questionDialog.SetText2(localeInfo.MESSENGER_INPUT_MOBILE_PHONE_NUMBER_2)
questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnAcceptInputMobilePhoneNumber))
questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCancelInputMobilePhoneNumber))
questionDialog.SetWidth(400)
questionDialog.Open()
self.questionDialog = questionDialog
return
## Input Sending Mobile Message
inputDialog = uiCommon.InputDialog()
inputDialog.SetTitle(localeInfo.MESSENGER_SEND_MOBILE_MESSAGE_TITLE)
inputDialog.SetMaxLength(50)
inputDialog.SetAcceptEvent(ui.__mem_func__(self.OnInputMobileMessage))
inputDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseInputDialog))
inputDialog.name = name
inputDialog.Open()
self.inputDialog = inputDialog
def OnAcceptInputMobilePhoneNumber(self):
if not uiGameOption.MOBILE:
return
## Input Mobile Phone Number
inputDialog = uiCommon.InputDialog()
inputDialog.SetTitle(localeInfo.MESSENGER_INPUT_MOBILE_PHONE_NUMBER_TITLE)
inputDialog.SetMaxLength(13)
inputDialog.SetAcceptEvent(ui.__mem_func__(self.OnInputMobilePhoneNumber))
inputDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseInputDialog))
inputDialog.Open()
self.inputDialog = inputDialog
self.OnCancelInputMobilePhoneNumber()
def OnCancelInputMobilePhoneNumber(self):
if not uiGameOption.MOBILE:
return
self.questionDialog.Close()
self.questionDialog = None
return TRUE
def OnInputMobilePhoneNumber(self):
if not uiGameOption.MOBILE:
return
text = self.inputDialog.GetText()
if not text:
return
text.replace('-', '')
net.SendChatPacket("/mobile " + text)
self.OnCloseInputDialog()
return TRUE
def OnInputMobileMessage(self):
if not uiGameOption.MOBILE:
return
text = self.inputDialog.GetText()
if not text:
return
net.SendMobileMessagePacket(self.inputDialog.name, text)
self.OnCloseInputDialog()
return TRUE
def OnCloseInputDialog(self):
self.inputDialog.Close()
self.inputDialog = None
return TRUE
def OnPressGuildButton(self):
self.guildButtonEvent()
def OnPressAddFriendButton(self):
friendNameBoard = uiCommon.InputDialog()
friendNameBoard.SetTitle(localeInfo.MESSENGER_ADD_FRIEND)
friendNameBoard.SetAcceptEvent(ui.__mem_func__(self.OnAddFriend))
friendNameBoard.SetCancelEvent(ui.__mem_func__(self.OnCancelAddFriend))
friendNameBoard.Open()
self.friendNameBoard = friendNameBoard
def OnAddFriend(self):
text = self.friendNameBoard.GetText()
if text:
net.SendMessengerAddByNamePacket(text)
self.friendNameBoard.Close()
self.friendNameBoard = None
return TRUE
def OnCancelAddFriend(self):
self.friendNameBoard.Close()
self.friendNameBoard = None
return TRUE
if app.ENABLE_MESSENGER_BLOCK:
def OnPressAddBlockButton(self):
blockNameBoard = uiCommon.InputDialog()
blockNameBoard.SetTitle(localeInfo.MESSENGER_ADD_BLOCK_FRIEND)
blockNameBoard.SetAcceptEvent(ui.__mem_func__(self.OnAddBlock))
blockNameBoard.SetCancelEvent(ui.__mem_func__(self.OnCancelAddBlock))
blockNameBoard.Open()
self.blockNameBoard = blockNameBoard
def OnAddBlock(self):
text2 = self.blockNameBoard.GetText()
if text2:
net.SendMessengerAddBlockByNamePacket(text2)
self.blockNameBoard.Close()
self.blockNameBoard = None
return TRUE
def OnCancelAddBlock(self):
self.blockNameBoard.Close()
self.blockNameBoard = None
return TRUE
def OnPressWhisperButton(self):
if self.selectedItem:
self.selectedItem.OnWhisper()
def OnPressMobileButton(self):
if self.selectedItem:
self.selectedItem.OnMobileMessage()
def OnPressRemoveButton(self):
if self.selectedItem:
if self.selectedItem.CanRemove():
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(localeInfo.MESSENGER_DO_YOU_DELETE)
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnRemove))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
def OnRemove(self):
if self.selectedItem:
if self.selectedItem.CanRemove():
map(lambda arg, argDeletingItem=self.selectedItem: arg.RemoveMember(argDeletingItem), self.groupList)
self.selectedItem.OnRemove()
self.selectedItem.UnSelect()
self.selectedItem = None
self.OnRefreshList()
self.OnCloseQuestionDialog()
def OnScroll(self):
scrollLineCount = len(self.showingItemList) - (self.showingPageSize/20)
startLine = int(scrollLineCount * self.scrollBar.GetPos())
if startLine != self.startLine:
self.startLine = startLine
self.__LocateMember()
def OnPressEscapeKey(self):
self.Close()
return TRUE
## CallBack
def OnSelectItem(self, item):
if self.selectedItem:
if item != self.selectedItem:
self.selectedItem.UnSelect()
self.selectedItem = item
if self.selectedItem:
self.selectedItem.Select()
if self.selectedItem.CanWhisper():
self.whisperButton.Enable()
else:
self.whisperButton.Disable()
if self.selectedItem.IsMobile():
self.mobileButton.Enable()
else:
self.mobileButton.Disable()
if self.selectedItem.CanRemove():
self.removeButton.Enable()
else:
self.removeButton.Disable()
def OnDoubleClickItem(self, item):
if not self.selectedItem:
return
if self.selectedItem.IsOnline():
self.OnPressWhisperButton()
elif self.selectedItem.IsMobile():
self.OnPressMobileButton()
def GetSelf(self):
return self
def OnRefreshList(self):
self.showingItemList = []
if self.familyGroup:
self.showingItemList.append(self.familyGroup)
if self.familyGroup.GetLover():
self.showingItemList.append(self.familyGroup.GetLover())
for group in self.groupList:
self.showingItemList.append(group)
if group.IsOpen():
loginMemberList = group.GetLoginMemberList()
logoutMemberList = group.GetLogoutMemberList()
if loginMemberList or logoutMemberList:
for member in loginMemberList:
self.showingItemList.append(member)
for member in logoutMemberList:
self.showingItemList.append(member)
else:
item = MessengerItem(ui.__mem_func__(self.GetSelf))
item.SetName(localeInfo.MESSENGER_EMPTY_LIST)
self.showingItemList.append(item)
self.__LocateMember()
def RefreshMessenger(self):
self.OnRefreshList()
## EventHandler
def __AddList(self, groupIndex, key, name):
group = self.groupList[groupIndex]
member = group.FindMember(key)
if not member:
member = group.AppendMember(key, name)
self.OnSelectItem(None)
return member
def OnRemoveList(self, groupIndex, key):
group = self.groupList[groupIndex]
group.RemoveMember(group.FindMember(key))
self.OnRefreshList()
def OnRemoveAllList(self, groupIndex):
group = self.groupList[groupIndex]
group.ClearMember()
self.OnRefreshList()
def OnLogin(self, groupIndex, key, name=None):
if not name:
name = key
group = self.groupList[groupIndex]
member = self.__AddList(groupIndex, key, name)
member.SetName(name)
member.Online()
self.OnRefreshList()
def OnLogout(self, groupIndex, key, name=None):
group = self.groupList[groupIndex]
member = self.__AddList(groupIndex, key, name)
if not name:
name = key
member.SetName(name)
member.Offline()
self.OnRefreshList()
def OnMobile(self, groupIndex, key, mobileFlag):
group = self.groupList[groupIndex]
member = group.FindMember(key)
if not member:
return
member.SetMobile(mobileFlag)
self.OnRefreshList()
def OnAddLover(self, name, lovePoint):
if not self.familyGroup:
self.__AddFamilyGroup()
member = self.familyGroup.AppendMember(0, name)
member.SetName(name)
member.SetLovePoint(lovePoint)
member.Offline()
self.OnRefreshList()
def OnUpdateLovePoint(self, lovePoint):
if not self.familyGroup:
return
lover = self.familyGroup.GetLover()
if not lover:
return
lover.SetLovePoint(lovePoint)
def OnLoginLover(self):
if not self.familyGroup:
return
lover = self.familyGroup.GetLover()
if not lover:
return
lover.Online()
def OnLogoutLover(self):
if not self.familyGroup:
return
lover = self.familyGroup.GetLover()
if not lover:
return
lover.Offline()
def ClearLoverInfo(self):
if not self.familyGroup:
return
self.familyGroup.ClearMember()
self.familyGroup = None
self.OnRefreshList()

Alles anzeigen

In dem How2 ordner gibt es noch änderung die ich leider nicht durchführen konnte da ich nicht wusste
wo genau diese eingetragen werden sollte. Ich hatte vermutungen danach kamen mir die errors entgegen

C

//In Server-Side:
if (MessengerManager::instance().IsBlocked(player1name, player2name))
{
ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BLOKLANDIN"));
return;
}
if (MessengerManager::instance().IsFriend(player1name, player2name))
{
ChatPacket(CHAT_TYPE_INFO, "This is your friend.");
return;
}
//In Client:
if messenger.IsBlockByName(player2name) or messenger.IsBlockByName(player1name):
return
//In Quest
if pc.is_blocked(targetname) == true then
say("This player blocked")
if pc.is_friend(targetname) == true then
say("This is your friend")

Alles anzeigen

Für eine Lösung oder Lösungsansätze bin ich jederzeit Dankbar.

Gruß
Reco

[Official Block] System Problem

KanekiiArts | Design | Recoloring | Effects

Arrow target bug

Fliege files Source code exe

⛰️ 𝐌𝐚𝐩𝐝𝐞𝐬𝐢𝐠𝐧 𝐒𝐞𝐫𝐯𝐢𝐜𝐞

Luminus2.io - International OldSchool & Innovative | Launch: December 6, 2024

NEYURA - Looking for Team members

NEYURA.COM | NEWSCHOOL | INTERNATIONAL | LV. 35-150 | LAUNCH: 29.11.2024

Neue Topliste

PIXARTS STUDIO [PREMIUM DESIGNS & ANIMATIONS & CODE]

Realis3D.xyz - Character designs, weapons, costumes, and more.