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