X-Git-Url: https://mudpy.org/gitweb?a=blobdiff_plain;f=mudpy.py;h=af61429a6148383e86e13bc8240f645b34711d16;hb=ab7fb385d9b58cd6ca9b0156e8f1780f5ce3e750;hp=5cdb508fc1ddc8a1f1efca38d1bd1731c4cf2eee;hpb=962927973044e667caa1d9b15ea4826df7562530;p=mudpy.git

diff --git a/mudpy.py b/mudpy.py
index 5cdb508..af61429 100644
--- a/mudpy.py
+++ b/mudpy.py
@@ -11,6 +11,8 @@ from os.path import abspath, dirname, exists, isabs, join as path_join
 from random import choice, randrange
 from socket import AF_INET, SO_REUSEADDR, SOCK_STREAM, SOL_SOCKET, socket
 from stat import S_IMODE, ST_MODE
+from syslog import LOG_PID, LOG_INFO, LOG_DAEMON, closelog, openlog, syslog
+from telnetlib import DO, DONT, ECHO, EOR, GA, IAC, LINEMODE, SB, SE, SGA, WILL, WONT
 from time import asctime, sleep
 
 class Element:
@@ -34,45 +36,56 @@ class Element:
 			DataFile(self.origin, universe)
 		if not universe.files[self.origin].data.has_section(self.key):
 			universe.files[self.origin].data.add_section(self.key)
-	def delete(self):
-		log("Deleting: " + self.key + ".")
+	def destroy(self):
+		"""Remove an element from the universe and destroy it."""
+		log("Destroying: " + self.key + ".")
 		universe.files[self.origin].data.remove_section(self.key)
 		del universe.categories[self.category][self.subkey]
 		del universe.contents[self.key]
 		del self
+	def delete(self, facet):
+		"""Delete a facet from the element."""
+		if universe.files[self.origin].data.has_option(self.key, facet):
+			universe.files[self.origin].data.remove_option(self.key, facet)
 	def facets(self):
 		"""Return a list of facets for this element."""
 		return universe.files[self.origin].data.options(self.key)
-	def get(self, facet, default=""):
+	def get(self, facet, default=None):
 		"""Retrieve values."""
+		if default is None: default = ""
 		if universe.files[self.origin].data.has_option(self.key, facet):
 			return universe.files[self.origin].data.get(self.key, facet)
 		else: return default
-	def getboolean(self, facet, default=False):
+	def getboolean(self, facet, default=None):
 		"""Retrieve values as boolean type."""
+		if default is None: default=False
 		if universe.files[self.origin].data.has_option(self.key, facet):
 			return universe.files[self.origin].data.getboolean(self.key, facet)
 		else: return default
-	def getint(self, facet, default=0):
+	def getint(self, facet, default=None):
 		"""Return values as int/long type."""
+		if default is None: default = 0
 		if universe.files[self.origin].data.has_option(self.key, facet):
 			return universe.files[self.origin].data.getint(self.key, facet)
 		else: return default
-	def getfloat(self, facet, default=0.0):
+	def getfloat(self, facet, default=None):
 		"""Return values as float type."""
+		if default is None: default = 0.0
 		if universe.files[self.origin].data.has_option(self.key, facet):
 			return universe.files[self.origin].data.getfloat(self.key, facet)
 		else: return default
-	def getlist(self, facet, default=[]):
+	def getlist(self, facet, default=None):
 		"""Return values as list type."""
+		if default is None: default = []
 		value = self.get(facet)
-		if not value: return default
-		else: return makelist(value)
-	def getdict(self, facet, default={}):
+		if value: return makelist(value)
+		else: return default
+	def getdict(self, facet, default=None):
 		"""Return values as dict type."""
+		if default is None: default = {}
 		value = self.get(facet)
-		if not value: return default
-		else: return makedict(value)
+		if value: return makedict(value)
+		else: return default
 	def set(self, facet, value):
 		"""Set values."""
 		if type(value) is long: value = str(value)
@@ -111,8 +124,8 @@ class DataFile:
 				include_file = path_join(dirname(filename), include_file)
 			DataFile(include_file, universe)
 	def save(self):
-		if self.data.sections() and ( not self.data.has_option("control", "read_only") or not self.data.getboolean("control", "read_only") ):
-			if not exists(dirname(self.filename)): makedirs(dirname)
+		if ( self.data.sections() or exists(self.filename) ) and not ( self.data.has_option("control", "read_only") and self.data.getboolean("control", "read_only") ):
+			if not exists(dirname(self.filename)): makedirs(dirname(self.filename))
 			file_descriptor = file(self.filename, "w")
 			if self.filename in universe.private_files and oct(S_IMODE(stat(self.filename)[ST_MODE])) != 0600:
 				chmod(self.filename, 0600)
@@ -187,13 +200,15 @@ class User:
 		self.connection = None
 		self.authenticated = False
 		self.password_tries = 0
-		self.state = "entering_account_name"
+		self.state = "initial"
 		self.menu_seen = False
 		self.error = ""
 		self.input_queue = []
 		self.output_queue = []
 		self.partial_input = ""
 		self.echoing = True
+		self.terminator = IAC+GA
+		self.negotiation_pause = 0
 		self.avatar = None
 		self.account = None
 
@@ -287,7 +302,7 @@ class User:
 		"""Send the user their current menu."""
 		if not self.menu_seen:
 			self.menu_choices = get_menu_choices(self)
-			self.send(get_menu(self.state, self.error, self.echoing, self.menu_choices), "")
+			self.send(get_menu(self.state, self.error, self.echoing, self.terminator, self.menu_choices), "")
 			self.menu_seen = True
 			self.error = False
 			self.adjust_echoing()
@@ -301,37 +316,34 @@ class User:
 		"""Remove a user from the list of connected users."""
 		universe.userlist.remove(self)
 
-	def send(self, output, eol="$(eol)"):
+	def send(self, output, eol="$(eol)", raw=False):
 		"""Send arbitrary text to a connected user."""
 
-		# only when there is actual output
-		#if output:
+		# unless raw mode is on, clean it up all nice and pretty
+		if not raw:
 
-		# start with a newline, append the message, then end
-		# with the optional eol string passed to this function
-		# and the ansi escape to return to normal text
-		output = "\r\n" + output + eol + chr(27) + "[0m"
+			# we'll take out GA or EOR and add them back on the end
+			if output.endswith(IAC+GA) or output.endswith(IAC+EOR):
+				terminate = True
+				output = output[:-2]
+			else: terminate = False
 
-		# find and replace macros in the output
-		output = replace_macros(self, output)
+			# start with a newline, append the message, then end
+			# with the optional eol string passed to this function
+			# and the ansi escape to return to normal text
+			output = "\r\n" + output + eol + chr(27) + "[0m"
 
-		# wrap the text at 80 characters
-		# TODO: prompt user for preferred wrap width
-		output = wrap_ansi_text(output, 80)
+			# find and replace macros in the output
+			output = replace_macros(self, output)
 
-		# drop the formatted output into the output queue
-		self.output_queue.append(output)
+			# wrap the text at 80 characters
+			output = wrap_ansi_text(output, 80)
 
-		# try to send the last item in the queue, remove it and
-		# flag that menu display is not needed
-		try:
-			self.connection.send(self.output_queue[0])
-			self.output_queue.remove(self.output_queue[0])
-			self.menu_seen = False
+			# tack the terminator back on
+			if terminate: output += self.terminator
 
-		# but if we can't, that's okay too
-		except:
-			pass
+		# drop the output into the user's output queue
+		self.output_queue.append(output)
 
 	def pulse(self):
 		"""All the things to do to the user per increment."""
@@ -341,16 +353,30 @@ class User:
 			self.state = "disconnecting"
 			self.menu_seen = False
 
+		# if output is paused, decrement the counter
+		if self.state == "initial":
+			if self.negotiation_pause: self.negotiation_pause -= 1
+			else: self.state = "entering_account_name"
+
 		# show the user a menu as needed
-		self.show_menu()
+		else: self.show_menu()
 
 		# disconnect users with the appropriate state
-		if self.state == "disconnecting":
-			self.quit()
+		if self.state == "disconnecting": self.quit()
 
 		# the user is unique and not flagged to disconnect
 		else:
 		
+			# try to send the last item in the queue and remove it
+			if self.output_queue:
+				try:
+					self.connection.send(self.output_queue[0])
+					del self.output_queue[0]
+
+				# but if we can't, that's okay too
+				except:
+					pass
+
 			# check for input and add it to the queue
 			self.enqueue_input()
 
@@ -372,6 +398,9 @@ class User:
 			# tack this on to any previous partial
 			self.partial_input += input_data
 
+			# reply to and remove any IAC negotiation codes
+			self.negotiate_telnet_options()
+
 			# separate multiple input lines
 			new_input_lines = self.partial_input.split("\n")
 
@@ -389,8 +418,20 @@ class User:
 			# iterate over the remaining lines
 			for line in new_input_lines:
 
+				# remove a trailing carriage return
+				if line.endswith("\r"): line = line.rstrip("\r")
+
+				# log non-printable characters remaining
+				removed = filter(lambda x: (x < " " or x > "~"), line)
+				if removed:
+					logline = "Non-printable characters from "
+					if self.account and self.account.get("name"): logline += self.account.get("name") + ": "
+					else: logline += "unknown user: "
+					logline += repr(removed)
+					log(logline)
+
 				# filter out non-printables
-				line = filter(lambda x: x>=' ' and x<='~', line)
+				line = filter(lambda x: " " <= x <= "~", line)
 
 				# strip off extra whitespace
 				line = line.strip()
@@ -398,24 +439,113 @@ class User:
 				# put on the end of the queue
 				self.input_queue.append(line)
 
+	def negotiate_telnet_options(self):
+		"""Reply to/remove partial_input telnet negotiation options."""
+
+		# start at the begining of the input
+		position = 0
+
+		# make a local copy to play with
+		text = self.partial_input
+
+		# as long as we haven't checked it all
+		while position < len(text):
+
+			# jump to the first IAC you find
+			position = text.find(IAC, position)
+
+			# if there wasn't an IAC in the input, skip to the end
+			if position < 0: position = len(text)
+
+			# replace a double (literal) IAC if there's an LF later
+			elif len(text) > position+1 and text[position+1] == IAC:
+				if text.find("\n", position) > 0: text = text.replace(IAC+IAC, IAC)
+				else: position += 1
+				position += 1
+
+			# this must be an option negotiation
+			elif len(text) > position+2 and text[position+1] in (DO, DONT, WILL, WONT):
+
+				negotiation = text[position+1:position+3]
+
+				# if we turned echo off, ignore the confirmation
+				if not self.echoing and negotiation == DO+ECHO: pass
+
+				# allow LINEMODE
+				elif negotiation == WILL+LINEMODE: self.send(IAC+DO+LINEMODE, raw=True)
+
+				# if the client likes EOR instead of GA, make a note of it
+				elif negotiation == DO+EOR: self.terminator = IAC+EOR
+				elif negotiation == DONT+EOR and self.terminator == IAC+EOR:
+					self.terminator = IAC+GA
+
+				# if the client doesn't want GA, oblige
+				elif negotiation == DO+SGA and self.terminator == IAC+GA:
+					self.terminator = ""
+					self.send(IAC+WILL+SGA, raw=True)
+
+				# we don't want to allow anything else
+				elif text[position+1] == DO: self.send(IAC+WONT+text[position+2], raw=True)
+				elif text[position+1] == WILL: self.send(IAC+DONT+text[position+2], raw=True)
+
+				# strip the negotiation from the input
+				text = text.replace(text[position:position+3], "")
+
+			# get rid of IAC SB .* IAC SE
+			elif len(text) > position+4 and text[position:position+2] == IAC+SB:
+				end_subnegotiation = text.find(IAC+SE, position)
+				if end_subnegotiation > 0: text = text[:position] + text[end_subnegotiation+2:]
+				else: position += 1
+
+			# otherwise, strip out a two-byte IAC command
+			elif len(text) > position+2: text = text.replace(text[position:position+2], "")
+
+			# and this means we got the begining of an IAC
+			else: position += 1
+
+		# replace the input with our cleaned-up text
+		self.partial_input = text
+
+	def can_run(self, command):
+		"""Check if the user can run this command object."""
+
+		# has to be in the commands category
+		if command not in universe.categories["command"].values(): result = False
+
+		# administrators can run any command
+		elif self.account.getboolean("administrator"): result = True
+
+		# everyone can run non-administrative commands
+		elif not command.getboolean("administrative"): result = True
+
+		# otherwise the command cannot be run by this user
+		else: result = False
+
+		# pass back the result
+		return result
+
 	def new_avatar(self):
 		"""Instantiate a new, unconfigured avatar for this user."""
-		counter = universe.categories["internal"]["counters"].getint("next_avatar")
-		while "avatar:" + str(counter + 1) in universe.categories["actor"].keys(): counter += 1
-		universe.categories["internal"]["counters"].set("next_avatar", counter + 1)
-		self.avatar = Element("actor:avatar:" + str(counter), universe)
+		counter = 0
+		while "avatar:" + self.account.get("name") + ":" + str(counter) in universe.categories["actor"].keys(): counter += 1
+		self.avatar = Element("actor:avatar:" + self.account.get("name") + ":" + str(counter), universe)
 		avatars = self.account.getlist("avatars")
 		avatars.append(self.avatar.key)
 		self.account.set("avatars", avatars)
 
-	def delete_avatar(self, avatar, universe):
+	def delete_avatar(self, avatar):
 		"""Remove an avatar from the world and from the user's list."""
 		if self.avatar is universe.contents[avatar]: self.avatar = None
-		universe.contents[avatar].delete()
+		universe.contents[avatar].destroy()
 		avatars = self.account.getlist("avatars")
 		avatars.remove(avatar)
 		self.account.set("avatars", avatars)
 
+	def destroy(self):
+		"""Destroy the user and associated avatars."""
+		for avatar in self.account.getlist("avatars"): self.delete_avatar(avatar)
+		self.account.destroy()
+
 	def list_avatar_names(self):
 		"""List names of assigned avatars."""
 		return [ universe.contents[avatar].get("name") for avatar in self.account.getlist("avatars") ]
@@ -444,6 +574,11 @@ def log(message):
 	# send the timestamp and message to standard output
 	print(timestamp + " " + message)
 
+	# send the message to the system log
+	openlog("mudpy", LOG_PID, LOG_INFO | LOG_DAEMON)
+	syslog(message)
+	closelog()
+
 def wrap_ansi_text(text, width):
 	"""Wrap text with arbitrary width while ignoring ANSI colors."""
 
@@ -606,6 +741,10 @@ def replace_macros(user, text, is_input=False):
 
 	return text
 
+def escape_macros(text):
+	"""Escapes replacement macros in text."""
+	return text.replace("$(", "$_(")
+
 def check_time(frequency):
 	"""Check for a factor of the current increment count."""
 	if type(frequency) is str:
@@ -670,12 +809,19 @@ def check_for_connection(listening_socket):
 	# set the user's ipa from the connection's ipa
 	user.address = address[0]
 
+	# let the client know we WILL EOR
+	user.send(IAC+WILL+EOR, raw=True)
+	user.negotiation_pause = 2
+
 	# return the new user object
 	return user
 
-def get_menu(state, error=None, echoing=True, choices={}):
+def get_menu(state, error=None, echoing=True, terminator="", choices=None):
 	"""Show the correct menu text to a user."""
 
+	# make sure we don't reuse a mutable sequence by default
+	if choices is None: choices = {}
+
 	# begin with a telnet echo command sequence if needed
 	message = get_echo_sequence(state, echoing)
 
@@ -694,6 +840,9 @@ def get_menu(state, error=None, echoing=True, choices={}):
 	# display a message indicating if echo is off
 	message += get_echo_message(state)
 
+	# tack on EOR or GA to indicate the prompt will not be followed by CRLF
+	message += terminator
+
 	# return the assembly of various strings defined above
 	return message
 
@@ -702,15 +851,15 @@ def menu_echo_on(state):
 	return universe.categories["menu"][state].getboolean("echo", True)
 
 def get_echo_sequence(state, echoing):
-	"""Build the appropriate IAC ECHO sequence as needed."""
+	"""Build the appropriate IAC WILL/WONT ECHO sequence as needed."""
 
 	# if the user has echo on and the menu specifies it should be turned
 	# off, send: iac + will + echo + null
-	if echoing and not menu_echo_on(state): return chr(255) + chr(251) + chr(1) + chr(0)
+	if echoing and not menu_echo_on(state): return IAC+WILL+ECHO
 
 	# if echo is not set to off in the menu and the user curently has echo
 	# off, send: iac + wont + echo + null
-	elif not echoing and menu_echo_on(state): return chr(255) + chr(252) + chr(1) + chr(0)
+	elif not echoing and menu_echo_on(state): return IAC+WONT+ECHO
 
 	# default is not to send an echo control sequence at all
 	else: return ""
@@ -726,8 +875,8 @@ def get_default_menu_choice(state):
 
 def get_formatted_default_menu_choice(state):
 	"""Default menu choice foratted for inclusion in a prompt string."""
-	default = get_default_menu_choice(state)
-	if default: return "[$(red)" + default + "$(nrm)] "
+	default_choice = get_default_menu_choice(state)
+	if default_choice: return "[$(red)" + default_choice + "$(nrm)] "
 	else: return ""
 
 def get_menu_description(state, error):
@@ -807,7 +956,6 @@ def get_default_branch(state):
 def get_choice_branch(user, choice):
 	"""Returns the new state matching the given choice."""
 	branches = get_menu_branches(user.state)
-	if not choice: choice = get_default_menu_choice(user.state)
 	if choice in branches.keys(): return branches[choice]
 	elif choice in user.menu_choices.keys(): return get_default_branch(user.state)
 	else: return ""
@@ -827,7 +975,6 @@ def get_default_action(state):
 def get_choice_action(user, choice):
 	"""Run any indicated script for the given choice."""
 	actions = get_menu_actions(user.state)
-	if not choice: choice = get_default_menu_choice(user.state)
 	if choice in actions.keys(): return actions[choice]
 	elif choice in user.menu_choices.keys(): return get_default_action(user.state)
 	else: return ""
@@ -855,7 +1002,7 @@ def generic_menu_handler(user):
 		choice = user.input_queue.pop(0)
 		if choice: choice = choice.lower()
 	else: choice = ""
-
+	if not choice: choice = get_default_menu_choice(user.state)
 	if choice in user.menu_choices:
 		exec(get_choice_action(user, choice))
 		new_state = get_choice_branch(user, choice)
@@ -940,7 +1087,7 @@ def handler_entering_new_password(user):
 	# too many tries, so adios
 	else:
 		user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)")
-		user.account.delete()
+		user.account.destroy()
 		user.state = "disconnecting"
 
 def handler_verifying_new_password(user):
@@ -966,7 +1113,7 @@ def handler_verifying_new_password(user):
 	# otherwise, sayonara
 	else:
 		user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)")
-		user.account.delete()
+		user.account.destroy()
 		user.state = "disconnecting"
 
 def handler_active(user):
@@ -977,22 +1124,26 @@ def handler_active(user):
 
 	# split out the command (first word) and parameters (everything else)
 	if input_data.find(" ") > 0:
-		command, parameters = input_data.split(" ", 1)
+		command_name, parameters = input_data.split(" ", 1)
 	else:
-		command = input_data
+		command_name = input_data
 		parameters = ""
 
 	# lowercase the command
-	command = command.lower()
+	command_name = command_name.lower()
 
 	# the command matches a command word for which we have data
-	if command in universe.categories["command"]:
-		exec(universe.categories["command"][command].get("action"))
+	if command_name in universe.categories["command"]:
+		command = universe.categories["command"][command_name]
+	else: command = None
 
-	# no data matching the entered command word
-	elif command: command_error(user, command, parameters)
+	# if it's allowed, do it
+	if user.can_run(command): exec(command.get("action"))
 
-def command_halt(user, command="", parameters=""):
+	# otherwise, give an error
+	elif command_name: command_error(user, input_data)
+
+def command_halt(user, parameters):
 	"""Halt the world."""
 
 	# see if there's a message or use a generic one
@@ -1006,7 +1157,7 @@ def command_halt(user, command="", parameters=""):
 	# set a flag to terminate the world
 	universe.terminate_world = True
 
-def command_reload(user, command="", parameters=""):
+def command_reload(user):
 	"""Reload all code modules, configs and data."""
 
 	# let the user know and log
@@ -1016,11 +1167,7 @@ def command_reload(user, command="", parameters=""):
 	# set a flag to reload
 	universe.reload_modules = True
 
-def command_quit(user, command="", parameters=""):
-	"""Quit the world."""
-	user.state = "main_utility"
-
-def command_help(user, command="", parameters=""):
+def command_help(user, parameters):
 	"""List available commands and provide help for commands."""
 
 	# did the user ask for help on a specific command word?
@@ -1028,15 +1175,22 @@ def command_help(user, command="", parameters=""):
 
 		# is the command word one for which we have data?
 		if parameters in universe.categories["command"]:
+			command = universe.categories["command"][parameters]
+		else: command = None
+
+		# only for allowed commands
+		if user.can_run(command):
 
 			# add a description if provided
-			description = universe.categories["command"][parameters].get("description")
+			description = command.get("description")
 			if not description:
 				description = "(no short description provided)"
-			output = "$(grn)" + parameters + "$(nrm) - " + description + "$(eol)$(eol)"
+			if command.getboolean("administrative"): output = "$(red)"
+			else: output = "$(grn)"
+			output += parameters + "$(nrm) - " + description + "$(eol)$(eol)"
 
 			# add the help text if provided
-			help_text = universe.categories["command"][parameters].get("help")
+			help_text = command.get("help")
 			if not help_text:
 				help_text = "No help is provided for this command."
 			output += help_text
@@ -1053,16 +1207,20 @@ def command_help(user, command="", parameters=""):
 		sorted_commands = universe.categories["command"].keys()
 		sorted_commands.sort()
 		for item in sorted_commands:
-			description = universe.categories["command"][item].get("description")
-			if not description:
-				description = "(no short description provided)"
-			output += "   $(grn)" + item + "$(nrm) - " + description + "$(eol)"
+			command = universe.categories["command"][item]
+			if user.can_run(command):
+				description = command.get("description")
+				if not description:
+					description = "(no short description provided)"
+				if command.getboolean("administrative"): output += "   $(red)"
+				else: output += "   $(grn)"
+				output += item + "$(nrm) - " + description + "$(eol)"
 		output += "$(eol)Enter \"help COMMAND\" for help on a command named \"COMMAND\"."
 
 	# send the accumulated output to the user
 	user.send(output)
 
-def command_say(user, command="", parameters=""):
+def command_say(user, parameters):
 	"""Speak to others in the same room."""
 
 	# check for replacement macros
@@ -1103,44 +1261,120 @@ def command_say(user, command="", parameters=""):
 
 		# tell the room
 		# TODO: we won't be using broadcast once there are actual rooms
-		broadcast(user.account.get("name") + " " + action + "s, \"" + message + "\"")
+		broadcast(user.avatar.get("name") + " " + action + "s, \"" + message + "\"")
 
 	# there was no message
 	else:
 		user.send("What do you want to say?")
 
-def command_show(user, command="", parameters=""):
+def command_show(user, parameters):
 	"""Show program data."""
-	if parameters == "avatars":
-		message = "These are the avatars managed by your account:$(eol)"
-		avatars = user.list_avatar_names()
-		avatars.sort()
-		for avatar in avatars: message += "$(eol)   $(grn)" + avatar + "$(nrm)"
-	elif parameters == "files":
-		message = "These are the current files containing the universe:$(eol)"
-		keys = universe.files.keys()
-		keys.sort()
-		for key in keys: message += "$(eol)   $(grn)" + key + "$(nrm)"
-	elif parameters == "universe":
-		message = "These are the current elements in the universe:$(eol)"
-		keys = universe.contents.keys()
-		keys.sort()
-		for key in keys: message += "$(eol)   $(grn)" + key + "$(nrm)"
-	elif parameters == "time":
-		message = universe.categories["internal"]["counters"].get("elapsed") + " increments elapsed since the world was created."
-	elif parameters: message = "I don't know what \"" + parameters + "\" is."
-	else: message = "What do you want to show?"
+	message = ""
+	if parameters.find(" ") < 1:
+		if parameters == "time":
+			message = universe.categories["internal"]["counters"].get("elapsed") + " increments elapsed since the world was created."
+		elif parameters == "categories":
+			message = "These are the element categories:$(eol)"
+			categories = universe.categories.keys()
+			categories.sort()
+			for category in categories: message += "$(eol)   $(grn)" + category + "$(nrm)"
+		elif parameters == "files":
+			message = "These are the current files containing the universe:$(eol)"
+			filenames = universe.files.keys()
+			filenames.sort()
+			for filename in filenames: message += "$(eol)   $(grn)" + filename + "$(nrm)"
+		else: message = ""
+	else:
+		arguments = parameters.split()
+		if arguments[0] == "category":
+			if arguments[1] in universe.categories:
+				message = "These are the elements in the \"" + arguments[1] + "\" category:$(eol)"
+				elements = universe.categories[arguments[1]].keys()
+				elements.sort()
+				for element in elements:
+					message += "$(eol)   $(grn)" + universe.categories[arguments[1]][element].key + "$(nrm)"
+		elif arguments[0] == "element":
+			if arguments[1] in universe.contents:
+				message = "These are the properties of the \"" + arguments[1] + "\" element:$(eol)"
+				element = universe.contents[arguments[1]]
+				facets = element.facets()
+				facets.sort()
+				for facet in facets:
+					message += "$(eol)   $(grn)" + facet + ": $(red)" + escape_macros(element.get(facet)) + "$(nrm)"
+	if not message:
+		if parameters: message = "I don't know what \"" + parameters + "\" is."
+		else: message = "What do you want to show?"
+	user.send(message)
+
+def command_create(user, parameters):
+	"""Create an element if it does not exist."""
+	if not parameters: message = "You must at least specify an element to create."
+	else:
+		arguments = parameters.split()
+		if len(arguments) == 1: arguments.append("")
+		if len(arguments) == 2:
+			element, filename = arguments
+			if element in universe.contents: message = "The \"" + element + "\" element already exists."
+			else:
+				message = "You create \"" + element + "\" within the universe."
+				logline = user.account.get("name") + " created an element: " + element
+				if filename:
+					logline += " in file " + filename
+					if filename not in universe.files:
+						message += " Warning: \"" + filename + "\" is not yet included in any other file and will not be read on startup unless this is remedied."
+				Element(element, universe, filename)
+				log(logline)
+		elif len(arguments) > 2: message = "You can only specify an element and a filename."
+	user.send(message)
+
+def command_destroy(user, parameters):
+	"""Destroy an element if it exists."""
+	if not parameters: message = "You must specify an element to destroy."
+	else:
+		if parameters not in universe.contents: message = "The \"" + parameters + "\" element does not exist."
+		else:
+			universe.contents[parameters].destroy()
+			message = "You destroy \"" + parameters + "\" within the universe."
+			log(user.account.get("name") + " destroyed an element: " + parameters)
+	user.send(message)
+
+def command_set(user, parameters):
+	"""Set a facet of an element."""
+	if not parameters: message = "You must specify an element, a facet and a value."
+	else:
+		arguments = parameters.split(" ", 2)
+		if len(arguments) == 1: message = "What facet of element \"" + arguments[0] + "\" would you like to set?"
+		elif len(arguments) == 2: message = "What value would you like to set for the \"" + arguments[1] + "\" facet of the \"" + arguments[0] + "\" element?"
+		else:
+			element, facet, value = arguments
+			if element not in universe.contents: message = "The \"" + element + "\" element does not exist."
+			else:
+				universe.contents[element].set(facet, value)
+				message = "You have successfully (re)set the \"" + facet + "\" facet of element \"" + element + "\". Try \"show element " + element + "\" for verification."
+	user.send(message)
+
+def command_delete(user, parameters):
+	"""Delete a facet from an element."""
+	if not parameters: message = "You must specify an element and a facet."
+	else:
+		arguments = parameters.split(" ")
+		if len(arguments) == 1: message = "What facet of element \"" + arguments[0] + "\" would you like to delete?"
+		elif len(arguments) != 2: message = "You may only specify an element and a facet."
+		else:
+			element, facet = arguments
+			if element not in universe.contents: message = "The \"" + element + "\" element does not exist."
+			elif facet not in universe.contents[element].facets(): message = "The \"" + element + "\" element has no \"" + facet + "\" facet."
+			else:
+				universe.contents[element].delete(facet)
+				message = "You have successfully deleted the \"" + facet + "\" facet of element \"" + element + "\". Try \"show element " + element + "\" for verification."
 	user.send(message)
 
-def command_error(user, command="", parameters=""):
+def command_error(user, input_data):
 	"""Generic error for an unrecognized command word."""
 
 	# 90% of the time use a generic error
 	if randrange(10):
-		message = "I'm not sure what \"" + command
-		if parameters:
-			message += " " + parameters
-		message += "\" means..."
+		message = "I'm not sure what \"" + input_data + "\" means..."
 
 	# 10% of the time use the classic diku error
 	else: