コード例 #1
0
 def receiveGuildTalk(self,
                      senderAvId,
                      fromAC,
                      avatarName,
                      message,
                      scrubbed=0):
     error = None
     if not self.isThought(message):
         accountName = self.findName(fromAC, 1)
         newMessage = TalkMessage(self.countMessage(), self.stampTime(),
                                  message, senderAvId, avatarName, fromAC,
                                  accountName, None, None, None, None,
                                  TALK_GUILD, None)
         reject = self.addToHistoryDoId(newMessage, senderAvId)
         if reject == 1:
             newMessage.setBody(OTPLocalizer.AntiSpamInChat)
         if reject != 2:
             isSpam = self.spamDictByDoId.get(senderAvId) and reject
             if not isSpam:
                 self.historyComplete.append(newMessage)
                 self.historyGuild.append(newMessage)
                 messenger.send('NewOpenMessage', [newMessage])
             if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
                 self.spamDictByDoId[senderAvId] = 1
             else:
                 self.spamDictByDoId[senderAvId] = 0
     return error
コード例 #2
0
 def receiveThought(self,
                    avatarId,
                    avatarName,
                    accountId,
                    accountName,
                    message,
                    scrubbed=0):
     error = None
     if not avatarName and avatarId:
         avatarName = self.findAvatarName(avatarId)
     if not accountName and accountId:
         accountName = self.findPlayerName(accountId)
     newMessage = TalkMessage(self.countMessage(), self.stampTime(),
                              message, avatarId, avatarName, accountId,
                              accountName, None, None, None, None,
                              AVATAR_THOUGHT, None)
     if avatarId != localAvatar.doId:
         self.addHandle(avatarId, newMessage)
     reject = 0
     if avatarId:
         reject = self.addToHistoryDoId(newMessage, avatarId, scrubbed)
     if accountId:
         self.addToHistoryDISLId(newMessage, accountId)
     if reject == 1:
         newMessage.setBody(OTPLocalizer.AntiSpamInChat)
     if reject != 2:
         self.historyComplete.append(newMessage)
         self.historyOpen.append(newMessage)
         messenger.send('NewOpenMessage', [newMessage])
     return error
コード例 #3
0
 def receiveOpenTalk(self, senderAvId, avatarName, accountId, accountName, message, scrubbed = 0):
     error = None
     if not avatarName and senderAvId:
         localAvatar.sendUpdate('logSuspiciousEvent', ['receiveOpenTalk: invalid avatar name (%s)' % senderAvId])
         avatarName = self.findAvatarName(senderAvId)
     if not accountName and accountId:
         accountName = self.findPlayerName(accountId)
     newMessage = TalkMessage(self.countMessage(), self.stampTime(), message, senderAvId, avatarName, accountId, accountName, None, None, None, None, TALK_OPEN, None)
     if senderAvId != localAvatar.doId:
         self.addHandle(senderAvId, newMessage)
     reject = 0
     if senderAvId:
         reject = self.addToHistoryDoId(newMessage, senderAvId, scrubbed)
     if accountId:
         self.addToHistoryDISLId(newMessage, accountId)
     if reject == 1:
         newMessage.setBody(OTPLocalizer.AntiSpamInChat)
     if reject != 2:
         isSpam = self.spamDictByDoId.get(senderAvId) and reject
         if not isSpam:
             self.historyComplete.append(newMessage)
             self.historyOpen.append(newMessage)
             messenger.send('NewOpenMessage', [newMessage])
         if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
             self.spamDictByDoId[senderAvId] = 1
         else:
             self.spamDictByDoId[senderAvId] = 0
     return error
コード例 #4
0
 def receivePartyMessage(self, message, senderAvId, senderName):
     error = None
     if not self.isThought(message):
         newMessage = TalkMessage(self.countMessage(), self.stampTime(), message, senderAvId, senderName, None, None, None, None, None, None, TALK_PARTY, None)
         reject = self.addToHistoryDoId(newMessage, senderAvId)
         if reject == 1:
             newMessage.setBody(OTPLocalizer.AntiSpamInChat)
         
         if reject != 2:
             if self.spamDictByDoId.get(senderAvId):
                 pass
             isSpam = reject
             if not isSpam:
                 self.historyComplete.append(newMessage)
                 self.historyParty.append(newMessage)
                 messenger.send('NewOpenMessage', [
                     newMessage])
             
             if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
                 self.spamDictByDoId[senderAvId] = 1
             else:
                 self.spamDictByDoId[senderAvId] = 0
         
     
     return error
コード例 #5
0
 def receiveGuildTalk(self, senderAvId, fromAC, avatarName, message, scrubbed=0):
     error = None
     if not self.isThought(message):
         accountName = self.findName(fromAC, 1)
         newMessage = TalkMessage(
             self.countMessage(),
             self.stampTime(),
             message,
             senderAvId,
             avatarName,
             fromAC,
             accountName,
             None,
             None,
             None,
             None,
             TALK_GUILD,
             None,
         )
         reject = self.addToHistoryDoId(newMessage, senderAvId)
         if reject == 1:
             newMessage.setBody(OTPLocalizer.AntiSpamInChat)
         if reject != 2:
             isSpam = self.spamDictByDoId.get(senderAvId) and reject
             if not isSpam:
                 self.historyComplete.append(newMessage)
                 self.historyGuild.append(newMessage)
                 messenger.send("NewOpenMessage", [newMessage])
             if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
                 self.spamDictByDoId[senderAvId] = 1
             else:
                 self.spamDictByDoId[senderAvId] = 0
     return error
コード例 #6
0
 def receiveThought(self, avatarId, avatarName, accountId, accountName, message, scrubbed=0):
     error = None
     if not avatarName and avatarId:
         avatarName = self.findAvatarName(avatarId)
     if not accountName and accountId:
         accountName = self.findPlayerName(accountId)
     newMessage = TalkMessage(
         self.countMessage(),
         self.stampTime(),
         message,
         avatarId,
         avatarName,
         accountId,
         accountName,
         None,
         None,
         None,
         None,
         AVATAR_THOUGHT,
         None,
     )
     if avatarId != localAvatar.doId:
         self.addHandle(avatarId, newMessage)
     reject = 0
     if avatarId:
         reject = self.addToHistoryDoId(newMessage, avatarId, scrubbed)
     if accountId:
         self.addToHistoryDISLId(newMessage, accountId)
     if reject == 1:
         newMessage.setBody(OTPLocalizer.AntiSpamInChat)
     if reject != 2:
         self.historyComplete.append(newMessage)
         self.historyOpen.append(newMessage)
         messenger.send("NewOpenMessage", [newMessage])
     return error
コード例 #7
0
    def receiveGuildTalk(self,
                         fromAv,
                         fromAC,
                         avatarName,
                         message,
                         scrubbed=0):
        error = None
        if not self.isThought(message):

            accountName = self.findName(fromAC, 1)
            newMessage = TalkMessage(
                self.countMessage(),  #messageNumber
                self.stampTime(),  #timeStamp
                message,  #message Body
                fromAv,  #senderAvatarId
                avatarName,  #senderAvatarName
                fromAC,  #senderAccountId
                accountName,  #senderAccountName
                None,  #receiverAvatarId
                None,  #receiverAvatarName
                None,  #receiverAccountId
                None,  #receiverAccountName
                TALK_GUILD,  #talkType
                None)  #typeInfo

            reject = self.addToHistoryDoId(newMessage, fromAv, scrubbed)
            if reject == 1:
                newMessage.setBody(OTPLocalizer.AntiSpamInChat)
            if reject != 2:
                self.historyComplete.append(newMessage)
                self.historyGuild.append(newMessage)
                messenger.send("NewOpenMessage", [newMessage])

        return error
コード例 #8
0
 def receiveOpenTalk(self, senderAvId, avatarName, accountId, accountName, message, scrubbed = 0):
     error = None
     if not avatarName and senderAvId:
         localAvatar.sendUpdate('logSuspiciousEvent', ['receiveOpenTalk: invalid avatar name (%s)' % senderAvId])
         avatarName = self.findAvatarName(senderAvId)
     if not accountName and accountId:
         accountName = self.findPlayerName(accountId)
     newMessage = TalkMessage(self.countMessage(), self.stampTime(), message, senderAvId, avatarName, accountId, accountName, None, None, None, None, TALK_OPEN, None)
     if senderAvId != localAvatar.doId:
         self.addHandle(senderAvId, newMessage)
     reject = 0
     if senderAvId:
         reject = self.addToHistoryDoId(newMessage, senderAvId, scrubbed)
     if accountId:
         self.addToHistoryDISLId(newMessage, accountId)
     if reject == 1:
         newMessage.setBody(OTPLocalizer.AntiSpamInChat)
     if reject != 2:
         isSpam = self.spamDictByDoId.get(senderAvId) and reject
         if not isSpam:
             self.historyComplete.append(newMessage)
             self.historyOpen.append(newMessage)
             messenger.send('NewOpenMessage', [newMessage])
         if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
             self.spamDictByDoId[senderAvId] = 1
         else:
             self.spamDictByDoId[senderAvId] = 0
     return error
コード例 #9
0
    def receiveThought(self, avatarId, avatarName, accountId, accountName, message, scrubbed = 0):
        error = None
        if not avatarName and avatarId:
            avatarName = self.findAvatarName(avatarId)
        if not accountName and accountId:
            accountName = self.findPlayerName(accountId)
        newMessage = TalkMessage(self.countMessage(), self.stampTime(), message, avatarId, avatarName, accountId, accountName, None, None, None, None, AVATAR_THOUGHT, None)
        if avatarId != localAvatar.doId:
            self.addHandle(avatarId, newMessage)
        reject = 0
        if avatarId:
            reject = self.addToHistoryDoId(newMessage, avatarId, scrubbed)
        if accountId:
            self.addToHistoryDISLId(newMessage, accountId)
        if reject == 1:
            newMessage.setBody(OTPLocalizer.AntiSpamInChat)
        if reject != 2:
            self.historyComplete.append(newMessage)
            self.historyOpen.append(newMessage)
            messenger.send('NewOpenMessage', [newMessage])
        if hasattr(base.cr, 'chatLog'):
            if base.localAvatar.getAdminAccess() >= 375:
                avatarName = "\1WLEnter\1(%s)\2%s" %(accountId, avatarName)

            base.cr.chatLog.addToLog("\1playerGreen\1%s thinks\2: %s" %(avatarName, message), avatarId)
        return error
コード例 #10
0
ファイル: PTalkAssistant.py プロジェクト: TTGhost/POTCOR-src
    def receiveOpenSpeedChat(self, msgType, messageIndex, senderAvId, name=None):
        error = None
        if not name and senderAvId:
            name = self.findName(senderAvId, 0)

        messageType = TALK_OPEN
        message = None
        if msgType == SPEEDCHAT_NORMAL:
            message = self.SCDecoder.decodeSCStaticTextMsg(messageIndex)
        elif msgType == SPEEDCHAT_EMOTE:
            message = self.SCDecoder.decodeSCEmoteWhisperMsg(messageIndex, name)
            if not message:
                if senderAvId == localAvatar.doId:
                    message = PLocalizer.EmoteMessagesSelf.get(messageIndex)
                    messageType = INFO_OPEN
                else:
                    message = PLocalizer.EmoteMessagesThirdPerson.get(messageIndex)
                    messageType = INFO_OPEN

        elif msgType == SPEEDCHAT_CUSTOM:
            message = self.SCDecoder.decodeSCCustomMsg(messageIndex)

        if message in (None, ""):
            return None

        newMessage = TalkMessage(
            self.countMessage(),
            self.stampTime(),
            message,
            senderAvId,
            name,
            None,
            None,
            None,
            None,
            None,
            None,
            messageType,
            None,
        )
        reject = self.addToHistoryDoId(newMessage, senderAvId)
        if reject == 1:
            newMessage.setBody(OTPLocalizer.AntiSpamInChat)

        if reject != 2:
            if self.spamDictByDoId.get(senderAvId):
                pass
            isSpam = reject
            if not isSpam:
                self.historyComplete.append(newMessage)
                self.historyOpen.append(newMessage)
                messenger.send("NewOpenMessage", [newMessage])

            if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
                self.spamDictByDoId[senderAvId] = 1
            else:
                self.spamDictByDoId[senderAvId] = 0

        return error
コード例 #11
0
 def receiveOpenTalk(self,
                     senderAvId,
                     avatarName,
                     accountId,
                     accountName,
                     message,
                     scrubbed=0):
     error = None
     if not avatarName and senderAvId:
         localAvatar.sendUpdate(
             'logSuspiciousEvent',
             ['receiveOpenTalk: invalid avatar name (%s)' % senderAvId])
         avatarName = self.findAvatarName(senderAvId)
     if not accountName and accountId:
         accountName = self.findPlayerName(accountId)
     newMessage = TalkMessage(self.countMessage(), self.stampTime(),
                              message, senderAvId, avatarName, accountId,
                              accountName, None, None, None, None,
                              TALK_OPEN, None)
     if senderAvId != localAvatar.doId:
         self.addHandle(senderAvId, newMessage)
     reject = 0
     if senderAvId:
         reject = self.addToHistoryDoId(newMessage, senderAvId, scrubbed)
     if accountId:
         self.addToHistoryDISLId(newMessage, accountId)
     if reject == 1:
         newMessage.setBody(OTPLocalizer.AntiSpamInChat)
         if senderAvId == localAvatar.doId:
             localAvatar.setSystemMessage(
                 0, 'Spam detected! Please slow down your chat!')
     if reject != 2:
         isSpam = self.spamDictByDoId.get(senderAvId) and reject
         if not isSpam:
             self.historyComplete.append(newMessage)
             self.historyOpen.append(newMessage)
             messenger.send('NewOpenMessage', [newMessage])
             if hasattr(base.cr, 'chatLog'):
                 if base.localAvatar.getAdminAccess() >= 375:
                     avatarName = '\x01WLEnter\x01(%s)\x02%s' % (accountId,
                                                                 avatarName)
                 if self.isThought(message):
                     base.cr.chatLog.addToLog(
                         '\x01playerGreen\x01%s thinks\x02: %s' %
                         (avatarName, message), senderAvId)
                 else:
                     base.cr.chatLog.addToLog(
                         '\x01playerGreen\x01%s\x02: %s' %
                         (avatarName, message), senderAvId)
         if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
             self.spamDictByDoId[senderAvId] = 1
         else:
             self.spamDictByDoId[senderAvId] = 0
     return error
コード例 #12
0
 def receiveOpenSpeedChat(self,
                          msgType,
                          messageIndex,
                          senderAvId,
                          name=None):
     error = None
     if not name:
         if senderAvId:
             name = self.findName(senderAvId, 0)
         messageType = TALK_OPEN
         message = None
         message = msgType == SPEEDCHAT_NORMAL and self.SCDecoder.decodeSCStaticTextMsg(
             messageIndex)
     else:
         if msgType == SPEEDCHAT_EMOTE:
             message = self.SCDecoder.decodeSCEmoteWhisperMsg(
                 messageIndex, name)
             if not message:
                 if senderAvId == localAvatar.doId:
                     message = PLocalizer.EmoteMessagesSelf.get(
                         messageIndex)
                     messageType = INFO_OPEN
                 else:
                     message = PLocalizer.EmoteMessagesThirdPerson.get(
                         messageIndex)
                     messageType = INFO_OPEN
         else:
             if msgType == SPEEDCHAT_CUSTOM:
                 message = self.SCDecoder.decodeSCCustomMsg(messageIndex)
     if message in (None, ''):
         return
     newMessage = TalkMessage(self.countMessage(), self.stampTime(),
                              message, senderAvId, name, None, None, None,
                              None, None, None, messageType, None)
     reject = self.addToHistoryDoId(newMessage, senderAvId)
     if reject == 1:
         newMessage.setBody(OTPLocalizer.AntiSpamInChat)
     if reject != 2:
         isSpam = self.spamDictByDoId.get(senderAvId) and reject
         if not isSpam:
             self.historyComplete.append(newMessage)
             self.historyOpen.append(newMessage)
             messenger.send('NewOpenMessage', [newMessage])
         if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
             self.spamDictByDoId[senderAvId] = 1
         else:
             self.spamDictByDoId[senderAvId] = 0
     return error
コード例 #13
0
    def receiveThought(self,
                       avatarId,
                       avatarName,
                       accountId,
                       accountName,
                       message,
                       scrubbed=0):
        error = None
        if (not avatarName) and (avatarId):
            avatarName = self.findAvatarName(avatarId)
        if (not accountName) and (accountId):
            accountName = self.findPlayerName(accountId)

        newMessage = TalkMessage(
            self.countMessage(),  #messageNumber
            self.stampTime(),  #timeStamp
            message,  #message Body
            avatarId,  #senderAvatarId
            avatarName,  #senderAvatarName
            accountId,  #senderAccountId
            accountName,  #senderAccountName
            None,  #receiverAvatarId
            None,  #receiverAvatarName
            None,  #receiverAccountId
            None,  #receiverAccountName
            AVATAR_THOUGHT,  #talkType
            None)  #extraInfo

        if avatarId != localAvatar.doId:
            self.addHandle(avatarId, newMessage)

        reject = 0
        if avatarId:
            reject = self.addToHistoryDoId(newMessage, avatarId, scrubbed)
        if accountId:
            self.addToHistoryDISLId(newMessage, accountId)
        if reject == 1:
            newMessage.setBody(OTPLocalizer.AntiSpamInChat)
        if reject != 2:
            self.historyComplete.append(newMessage)
            self.historyOpen.append(newMessage)

            messenger.send("NewOpenMessage", [newMessage])

        return error
コード例 #14
0
ファイル: PTalkAssistant.py プロジェクト: TTGhost/POTCOR-src
    def receivePartyMessage(self, message, senderAvId, senderName):
        error = None
        if not self.isThought(message):
            newMessage = TalkMessage(
                self.countMessage(),
                self.stampTime(),
                message,
                senderAvId,
                senderName,
                None,
                None,
                None,
                None,
                None,
                None,
                TALK_PARTY,
                None,
            )
            reject = self.addToHistoryDoId(newMessage, senderAvId)
            if reject == 1:
                newMessage.setBody(OTPLocalizer.AntiSpamInChat)

            if reject != 2:
                if self.spamDictByDoId.get(senderAvId):
                    pass
                isSpam = reject
                if not isSpam:
                    self.historyComplete.append(newMessage)
                    self.historyParty.append(newMessage)
                    messenger.send("NewOpenMessage", [newMessage])

                if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
                    self.spamDictByDoId[senderAvId] = 1
                else:
                    self.spamDictByDoId[senderAvId] = 0

        return error
コード例 #15
0
 def receiveExclaim(self,
                    avatarId,
                    avatarName,
                    accountId,
                    accountName,
                    message,
                    scrubbed=0):
     error = None
     if not avatarName and avatarId:
         avatarName = self.findAvatarName(avatarId)
     if not accountName and accountId:
         accountName = self.findPlayerName(accountId)
     newMessage = TalkMessage(self.countMessage(), self.stampTime(),
                              message, avatarId, avatarName, accountId,
                              accountName, None, None, None, None,
                              AVATAR_EXCLAIM, None)
     if avatarId != localAvatar.doId:
         self.addHandle(avatarId, newMessage)
     reject = 0
     if avatarId:
         reject = self.addToHistoryDoId(newMessage, avatarId, scrubbed)
     if accountId:
         self.addToHistoryDISLId(newMessage, accountId)
     if reject == 1:
         newMessage.setBody(OTPLocalizer.AntiSpamInChat)
     if reject != 2:
         isSpam = self.spamDictByDoId.get(avatarId) and reject
         if not isSpam:
             self.historyComplete.append(newMessage)
             self.historyOpen.append(newMessage)
             messenger.send('NewOpenMessage', [newMessage])
         if newMessage.getBody() == OTPLocalizer.AntiSpamInChat:
             self.spamDictByDoId[avatarId] = 1
         else:
             self.spamDictByDoId[avatarId] = 0
     return error