def clean_to(self):
data = self.cleaned_data
recipients = data.get('to', None)
targets = []
MAIN = 0
if recipients:
for recipient in [
target.strip() for target in recipients.split(',')
]:
if not recipient:
continue
try:
recipient = ev.search_player(recipient)[MAIN].db.avatar
except IndexError:
raise ValidationError('Player %s does not exist' %
recipient)
if recipient.check_list(self._user, 'ignoring', ignores=False):
raise ValidationError('Player %s is ignoring you.' %
recipient.name)
targets.append(recipient)
else:
raise ValidationError('You must specify recipients.')
if not targets:
raise ValidationError('You must specify recipients.')
return targets
def get_settings(request, character):
"""
Get settings needed for toggles.
"""
player = ev.search_player(character)[0]
character = player.db.avatar
my_character = request.user.get_profile().db.avatar
return player, character, my_character
def get_settings(request, character):
"""
Get settings needed for toggles.
"""
player = ev.search_player(character)[0]
character = player.db.avatar
my_character = request.user.db.avatar
return player, character, my_character
def func(self):
player = self.player
args = self.args
if not args:
self.msg("Usage: @boot[/switches] <player> [:reason]")
return
if ':' in args:
args, reason = [a.strip() for a in args.split(':', 1)]
else:
args, reason = args, ""
boot_list = []
if 'port' in self.switches:
# Boot a particular port.
sessions = SESSIONS.get_session_list(True)
for sess in sessions:
# Find the session with the matching port number.
if sess.getClientAddress()[1] == int(args):
boot_list.append(sess)
break
else:
# Boot by player object
pobj = search_player(args)
if not pobj:
self.msg("Player %s was not found." % pobj.key)
return
# we have a bootable object with a connected user
matches = SESSIONS.sessions_from_player(pobj)
for match in matches:
boot_list.append(match)
if not boot_list:
self.msg("No matching sessions found. The Player does not seem to be online.")
return
# Carry out the booting of the sessions in the boot list.
feedback = None
if not 'quiet' in self.switches:
feedback = "You have been disconnected by %s.\n" % player.name
if reason:
feedback += "\nReason given: %s" % reason
for session in boot_list:
session.msg(feedback)
pobj.disconnect_session_from_player(session.sessid)
def get_owner(self):
# Do some security checks to prevent messed up characters from having an official owner
owner = self.db.owner
if not owner:
return None
# Verify that the player data also shows ownership
if not self in owner.db.characters:
return None
# Verify that, among character objects, this one has a unique name
if len([char for char in search_object(self.key, attribute_name='key') if isinstance(char, Character)]) != 1:
return None
# Verify this doesn't match the name of any player, unless that player is our own
if self.key.lower() != owner.key.lower() and search_player(self.key):
return None
# Looks good, return the owner.
return self.db.owner
def clean_to(self):
data = self.cleaned_data
recipients = data.get('to', None)
targets = []
MAIN = 0
if recipients:
for recipient in [ target.strip() for target in recipients.split(',') ]:
if not recipient:
continue
try:
recipient = ev.search_player(recipient)[MAIN].db.avatar
except IndexError:
raise ValidationError('Player %s does not exist' % recipient)
if recipient.check_list(self._user, 'ignoring', ignores=False):
raise ValidationError('Player %s is ignoring you.' % recipient.name)
targets.append(recipient)
else:
raise ValidationError('You must specify recipients.')
if not targets:
raise ValidationError('You must specify recipients.')
return targets
def cmd_new(self):
player = self.player
key = self.args
# Verify that the account has a free character slot
max_characters = player.max_characters()
playable_characters = player.get_characters()
if len(playable_characters) >= player.max_characters():
self.msg("{RYou may only create a maximum of %i characters." % max_characters)
return
# Check the character name
if re.search('[^a-zA-Z0-9._ -]', key) or not (3 <= len(key) <= 20):
self.msg('{R[Character names must be between 3 and 20 characters, and only contain english letters, numbers, dot (.), underscore (_), or dash(-), or space ( )]')
return
# Verify that the character name is not already taken
for existing_object in search_object(key, attribute_name='key'):
if utils.inherits_from(existing_object, "src.objects.objects.Character"):
self.msg("{R[That character name is already taken]")
return
# Verify that this is not the name of a player, unless it's your own
if key.lower() != player.key.lower():
if search_player(key):
self.msg("{R[That name is already taken by a player account]")
return
# create the character
from src.objects.models import ObjectDB
default_home = ObjectDB.objects.get_id(settings.CHARACTER_DEFAULT_HOME)
typeclass = settings.BASE_CHARACTER_TYPECLASS
permissions = settings.PERMISSION_PLAYER_DEFAULT
new_character = create_object(typeclass, key=key, location=default_home, home=default_home, permissions=permissions)
# only allow creator (and admins) to puppet this char
new_character.locks.add("puppet:id(%i) or pid(%i) or perm(Janitors)" % (new_character.id, player.id))
# Set this new character as owned by this player
new_character.set_owner(player)
# Configure the character as a new character in the world
new_character.db.desc = "This is a Player."
# Inform the user that we're done.
self.msg("{G[Created new character %s. Use {g%s/ic %s{G to enter the game as this character]" % (new_character.key, self.key, new_character.key))
def func(self):
player_names = shlex.split(self.args)
if len(player_names) < 2:
self.msg('Usage: @merge <to account> <from account> [<from account> ...]')
return
# Convert the requested account names into players
players = []
for player_name in player_names:
player = search_player(player_name)
if not player:
return # The player search should drop an error message
players.append(player[0])
# Ensure none of the players are the same
if len(players) != len(set(players)):
self.msg("Each player must be different")
return
# Ensure that only 'Players' level accounts are involved in the merge
for player in players:
if player.permissions != ['Players']:
self.msg("Each player must be in the 'Players' permissions group")
# Perform the merge
to_player = players.pop(0)
for from_player in players:
self.merge_players(to_player, from_player)
