def cmd_add(self, targetname): player = self.player target = match(targetname, exact=True) if hasattr(target, 'get_owner'): target = target.get_owner() if not target: self.msg('{R[Player not found]') return # Check if this player is already a friend if target in player.get_friend_players(): self.msg('{R["%s" is already your friend]' % target.key) return # Ensure they're not trying to befriend themselves if target == player: self.msg('{G[You befriend yourself {m<3 <3 <3{G]') return # Add the player to the friend list if needed if player in target.db.friends_list: # Already in the target's friend list. Mutual friendship begins! Bunnies and rainbows. player.db.friends_list.add(target) self.msg('{G[Added "%s" as a friend!]' % target.key) target.msg('{G["%s" added you as a friend!]' % player.key) else: # Alert the target user # Construct message header sender = None # Get the recipients receivers = [target] # Collect the message from the user message = "{Y[You've received a friend request from %s. To accept the request, use {y%s/add %s{Y]" % (player.key, self.key, player.key) # Generate message header, to store the 'to' and 'from' as provided. (The recievers and sender field of the Msg object will be the player, and never a character) header = { 'from' : 'Latitude MUD', 'to' : [target.key], } header = pickle.dumps(header) # Create the message object msg_object = create_message(sender, message, receivers=receivers, header=header) # Display the message to the user, or mark it as unseen if they're offline so it can be read later for receiver in receivers: if receiver.sessions: receiver.msg(message) else: if not receiver.db.msg_unseen: receiver.db.msg_unseen = [] receiver.db.msg_unseen.append(msg_object) # Actually add the friend to this player's list player.db.friends_list.add(target) # Not already in the target's friend list, so let them know this is only a 'friend request' state. self.msg('{Y[Friend request sent. In order for this player to appear in your friend list, they will have to add you as well. Use {y%s/del %s{Y to cancel the request if needed.]' % (self.key, targetname))
def func(self): """ Create a new message and send it to the channel """ player = self.player # Check arguments channelkey, message = self.args if not message: self.msg("{R[Say what?]") return channel = Channel.objects.get_channel(channelkey) if not channel: self.msg("{R[Channel '%s' not found]" % channelkey) return # Verify permissions if not channel.has_connection(player): self.msg("{R[You are not connected to channel '%s']" % channelkey) return if not channel.access(player, 'send'): self.msg("{R[You are not permitted to send to channel '%s']" % channelkey) return # Format the message if self.character: # If we have a character, then we can use the 'say' routines to format the message. if message.startswith(':'): message = self.character.speech_pose(message[1:]) elif message.startswith('"'): message = self.character.speech_say(message[1:]) else: message = self.character.speech_say(message) else: # If we have no character, we'll have to take care of the formatting if message.startswith(':'): message = '{b' + player.key + '{n ' + message[1:].replace('{', '{{').replace('%', '%%') elif message.startswith('"'): message = '{b' + player.key + '{n: ' + message[1:].replace('{', '{{').replace('%', '%%') else: message = '{b' + player.key + '{n: ' + message.replace('{', '{{').replace('%', '%%') message = "{Y[ {g%s {Y| {n%s {Y]" % (channel.key, message) # Send it msgobj = create_message(player, message, channels=[channel]) channel.msg(msgobj)
def send_message_run(self): # Determine the sender object (Won't actually be seen in the message. The header is used for that.) sender = self.caller if hasattr(sender, 'player'): sender = sender.player # Get the recipients receivers = managers.players.all() # Collect the message from the user message = self.editor.get_buffer() # Generate message header, to store the 'to' and 'from' as provided. (The recievers and sender field of the Msg object will be the player, and never a character) header = { 'from' : 'Latitude MUD', 'to' : ['All Users'], } header = pickle.dumps(header) # Create the message object msg_object = create_message(sender, message, receivers=receivers, header=header) # Mark the message as 'unseen' so it can be read later if desired for receiver in receivers: if not receiver.db.msg_unseen: receiver.db.msg_unseen = [] receiver.db.msg_unseen.append(msg_object) for receiver in receivers: receiver.msg("{Y[You've received a page mail. Use \"{y@page{Y\" to view it]")
def cmd_page(self, targetstr, message, mail=False): player = self.player sender = player.get_puppet(self.sessid) or player # Identify the recipients if not targetstr: # Grab the last page that we sent to lastpages = Msg.objects.get_messages_by_sender(player, exclude_channel_messages=True) if not lastpages: self.msg('{R[Could not re-send to previous recipient: No pages sent]') lastpages.sort(cmp=lambda x, y: cmp(x.date_sent, y.date_sent)) # Extract the header header = lastpages[-1].header if not header: self.msg("{R[Could not re-send to previous recipient: Your last page didn't have any sender information]") return header = pickle.loads(header) if not 'from' in header or not 'to' in header: self.msg("{R[Could not re-send to previous recipient: Your last page didn't have any sender/recipients]") return new_targets = set(header['to']) targetstr = ','.join(new_targets) elif targetstr.lower() == '#r': # Grab the last received page lastpages = Msg.objects.get_messages_by_receiver(player) if not lastpages: self.msg('{R[Could not reply: No pages received]') lastpages.sort(cmp=lambda x, y: cmp(x.date_sent, y.date_sent)) # Extract the header header = lastpages[-1].header if not header: self.msg("{R[Could not reply: Your last page didn't have any sender information]") return header = pickle.loads(header) if not 'from' in header or not 'to' in header: self.msg("{R[Could not reply: Your last page didn't have any sender/recipients]") return new_targets = set() if targetstr == '#R': # Append the recipients of the previous messages, then strip out yourself, if applicable. new_targets |= set(header['to']) if sender.key in new_targets: new_targets.remove(sender.key) # Append the sender of the previous message, whether it's yourself or not. new_targets |= set([header['from']]) targetstr = ','.join(new_targets) # Convert the requested names into character/player objects receivers = set() for targetname in targetstr.split(','): targetname = targetname.strip() receiver = match(targetname, prioritize_players=True) if receiver: receivers.add(receiver) else: self.msg('{R[Could not find "%s", cancelling message]' % (targetname)) return # Verify that everyone is online if not mail: for receiver in receivers: if not receiver.status_online(): self.msg('{R["%s" is not currently online, cancelling message]' % (receiver.key)) self.msg("{R[If you want to send a message to someone who's offline, use '{r%s/mail{R', and they will be alerted the next time they log in]" % (self.key)) self.msg("{R[See {rhelp %s{R for details]" % (self.key)) return # Generate message header, to store the 'to' and 'from' as provided. (The recievers and sender field of the Msg object will be the player, and never a character) header = { 'from' : sender.key, 'to' : [obj.key for obj in receivers], } header = pickle.dumps(header) # Construct the message text itself. Must be called before the sender and receiver are converted into players. message = self.gen_message_text(sender, receivers, message) # Create the persistent message object receiver_players = set() for receiver in receivers: if utils.inherits_from(receiver, "src.objects.objects.Character"): receiver_players.add(receiver.get_owner()) else: receiver_players.add(receiver) msg_object = create_message(player, message, receivers=receiver_players, header=header) # If this is a 'mail' then deliver the message into their 'unseen' list. if mail: for receiver_player in receiver_players: if not receiver_player.db.msg_unseen: receiver_player.db.msg_unseen = [] receiver_player.db.msg_unseen.append(msg_object) # Tell the players they got a message. if mail: for receiver_player in receiver_players: receiver_player.msg("{Y[You've received a page mail. Use \"{y@page{Y\" to view it]") if player not in receiver_players: self.msg('{G[Page mail sent]') else: # To eliminate duplicates, produce a set() of sessid/player pairs. msg_targets = set() msg_targets.add((player, self.sessid)) for receiver in receivers: if utils.inherits_from(receiver, "src.objects.objects.Character"): msg_targets.add((receiver.player, receiver.sessid)) else: # Player for session in receiver.get_all_sessions(): msg_targets.add((receiver, session.sessid)) for msg_target in msg_targets: msg_target[0].msg('{Y[ {bPage {Y| {n%s {Y]' % (message), sessid=msg_target[1])