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