X-Git-Url: https://mudpy.org/gitweb?a=blobdiff_plain;f=lib%2Fmuff%2Fmuffcmds.py;h=8f1562c90d686010e5deec8310915b3ece654587;hb=724736a86ae223448f90a6d3a15adacd035feaa5;hp=a9df0327302b26894aefcbba67a4546d5abf5302;hpb=d49d19d943672b3cea1b2e43802f4b5eca6c81b5;p=mudpy.git diff --git a/lib/muff/muffcmds.py b/lib/muff/muffcmds.py index a9df032..8f1562c 100644 --- a/lib/muff/muffcmds.py +++ b/lib/muff/muffcmds.py @@ -1,226 +1,384 @@ """Command objects for the MUFF Engine""" -# Copyright (c) 2005 mudpy, Jeremy Stanley -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions -# are met: -# -# - Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# - Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following -# disclaimer in the documentation and/or other materials provided -# with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS -# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE -# COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, -# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, -# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN -# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. +# Copyright (c) 2005 mudpy, Jeremy Stanley , all rights reserved. +# Licensed per terms in the LICENSE file distributed with this software. +# command data like descriptions, help text, limits, et cetera, are stored in +# ini-style configuration files supported by the ConfigParser module import ConfigParser + +# md5 hashing is used for verification of account passwords import md5 + +# the os module is used to we can get a directory listing and build lists of +# multiple config files in one directory import os + +# the random module is useful for creating random conditional output import random + +# string.split is used extensively to tokenize user input (break up command +# names and parameters) import string +# bit of a hack to load all modules in the muff package import muff for module in muff.__all__: exec("import " + module) -try: - if muffconf.config_data.get("general", "command_path"): - pass -except AttributeError: - reload(muffconf) -command_path = muffconf.config_data.get("general", "command_path") -command_files = [] -for each_file in os.listdir(command_path): - command_files.append(command_path + "/" + each_file) -command_data = ConfigParser.SafeConfigParser() -command_data.read(command_files) -command_list = command_data.sections() - -def handle_user_input(user, input): - if user.state == "active": handler_active(user, input) - elif user.state == "entering account name": handler_entering_account_name(user, input) - elif user.state == "checking password": handler_checking_password(user, input) - elif user.state == "checking new account name": handler_checking_new_account_name(user, input) - elif user.state == "entering new password": handler_entering_new_password(user, input) - elif user.state == "verifying new password": handler_verifying_new_password(user, input) - else: handler_fallthrough(user, input) +def handle_user_input(user): + """The main handler, branches to a state-specific handler.""" + + # check to make sure the state is expected, then call that handler + if "handler_" + user.state in globals(): + exec("handler_" + user.state + "(user)") + else: + generic_menu_handler(user) + + # since we got input, flag that the menu/prompt needs to be redisplayed user.menu_seen = False -def handler_entering_account_name(user, input): - if input: - user.proposed_name = string.split(input)[0].lower() - user.get_passhash() - if user.passhash: - user.state = "checking password" + # if the user's client echo is off, send a blank line for aesthetics + if not user.echoing: user.send("", "") + +def generic_menu_handler(user): + """A generic menu choice handler.""" + + # get a lower-case representation of the next line of input + if user.input_queue: + choice = user.input_queue.pop(0) + if choice: choice = choice.lower() + else: choice = "" + + # run any script related to this choice + exec(muffmenu.get_choice_action(user, choice)) + + # move on to the next state or return an error + new_state = muffmenu.get_choice_branch(user, choice) + if new_state: user.state = new_state + else: user.error = "default" + +def handler_entering_account_name(user): + """Handle the login account name.""" + + # get the next waiting line of input + input_data = user.input_queue.pop(0) + + # did the user enter anything? + if input_data: + + # keep only the first word and convert to lower-case + user.proposed_name = string.split(input_data)[0].lower() + + # if we have a password hash, time to request a password + if user.get_passhash(): + user.state = "checking_password" + + # otherwise, this could be a brand new user else: user.name = user.proposed_name user.proposed_name = None user.load() - user.state = "checking new account name" + muffmisc.log("New user: " + user.name) + user.state = "checking_new_account_name" + + # if the user entered nothing for a name, then buhbye else: - command_quit(user) + user.state = "disconnecting" + +def handler_checking_password(user): + """Handle the login account password.""" + + # get the next waiting line of input + input_data = user.input_queue.pop(0) -def handler_checking_password(user, input): - if md5.new(user.proposed_name + input).hexdigest() == user.passhash: + # does the hashed input equal the stored hash? + if md5.new(user.proposed_name + input_data).hexdigest() == user.passhash: + + # if so, set the username and load from cold storage user.name = user.proposed_name - user.proposed_name = None - user.load() - user.state = "active" - elif user.password_tries < muffconf.config_data.getint("general", "password_tries"): + del(user.proposed_name) + if not user.replace_old_connections(): + user.load() + user.authenticate() + user.state = "main_utility" + + # if at first your hashes don't match, try, try again + elif user.password_tries < muffconf.getint("general", "password_tries"): user.password_tries += 1 user.error = "incorrect" + + # we've exceeded the maximum number of password failures, so disconnect else: user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)") - command_quit(user) + user.state = "disconnecting" + +def handler_checking_new_account_name(user): + """Handle input for the new user menu.""" -def handler_checking_new_account_name(user, input): - if input: - choice = input.lower()[0] + # get the next waiting line of input + input_data = user.input_queue.pop(0) + + # if there's input, take the first character and lowercase it + if input_data: + choice = input_data.lower()[0] + + # if there's no input, use the default else: - choice = muffmenu.get_default(user) + choice = muffmenu.get_default_menu_choice(user.state) + + # user selected to disconnect if choice == "d": - command_quit(user) + user.state = "disconnecting" + + # go back to the login screen elif choice == "g": - user.state = "entering account name" + user.state = "entering_account_name" + + # new user, so ask for a password elif choice == "n": - user.state = "entering new password" + user.state = "entering_new_password" + + # user entered a non-existent option else: user.error = "default" -def handler_entering_new_password(user, input): - if len(input) > 6 and len(filter(lambda x: x>="0" and x<="9", input)) and len(filter(lambda x: x>="A" and x<="Z", input)) and len(filter(lambda x: x>="a" and x<="z", input)): - user.passhash = md5.new(user.name + input).hexdigest() - user.state = "verifying new password" - elif user.password_tries < muffconf.config_data.getint("general", "password_tries"): +def handler_entering_new_password(user): + """Handle a new password entry.""" + + # get the next waiting line of input + input_data = user.input_queue.pop(0) + + # make sure the password is strong--at least one upper, one lower and + # one digit, seven or more characters in length + if len(input_data) > 6 and len(filter(lambda x: x>="0" and x<="9", input_data)) and len(filter(lambda x: x>="A" and x<="Z", input_data)) and len(filter(lambda x: x>="a" and x<="z", input_data)): + + # hash and store it, then move on to verification + user.passhash = md5.new(user.name + input_data).hexdigest() + user.state = "verifying_new_password" + + # the password was weak, try again if you haven't tried too many times + elif user.password_tries < muffconf.getint("general", "password_tries"): user.password_tries += 1 user.error = "weak" + + # too many tries, so adios else: user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)") - command_quit(user) + user.state = "disconnecting" + +def handler_verifying_new_password(user): + """Handle the re-entered new password for verification.""" + + # get the next waiting line of input + input_data = user.input_queue.pop(0) + + # hash the input and match it to storage + if md5.new(user.name + input_data).hexdigest() == user.passhash: + user.authenticate() + user.save() -def handler_verifying_new_password(user, input): - if md5.new(user.name + input).hexdigest() == user.passhash: - user.state = "active" - elif user.password_tries < muffconf.config_data.getint("general", "password_tries"): + # the hashes matched, so go active + if not user.replace_old_connections(): user.state = "main_utility" + + # go back to entering the new password as long as you haven't tried + # too many times + elif user.password_tries < muffconf.getint("general", "password_tries"): user.password_tries += 1 user.error = "differs" - user.state = "entering new password" + user.state = "entering_new_password" + + # otherwise, sayonara else: user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)") - command_quit(user) + user.state = "disconnecting" + +def handler_active(user): + """Handle input for active users.""" -def handler_active(user, input): - if not user.authenticated: user.authenticated = True + # get the next waiting line of input + input_data = user.input_queue.pop(0) + + # split out the command (first word) and parameters (everything else) try: - inputlist = string.split(input, None, 1) + inputlist = string.split(input_data, None, 1) command = inputlist[0] except: - command = input + command = input_data try: parameters = inputlist[1] except: parameters = "" + del(inputlist) + + # lowercase the command command = command.lower() - if not command: command_null(user, command, parameters) - elif command in command_list: exec("command_" + command + "(user, command, parameters)") - else: command_error(user, command, parameters) -def handler_fallthrough(user, input): - if input: - print("User \"" + user + "\" entered \"" + input + "\" while in unknown state \"" + user.state + "\".") + # the command matches a command word for which we have data + if command in muffuniv.universe.commands.keys(): + exec(muffuniv.universe.commands[command].get("action")) + + # no data matching the entered command word + elif command: command_error(user, command, parameters) def command_halt(user, command="", parameters=""): - muffmisc.broadcast(user.name + " halts the world.") - for each_user in muffvars.userlist: - each_user.save() + """Halt the world.""" + + # see if there's a message or use a generic one + if parameters: message = "Halting: " + parameters + else: message = "User " + user.name + " halted the world." + + # let everyone know + muffmisc.broadcast(message) + muffmisc.log(message) + + # set a flag to terminate the world muffvars.terminate_world = True def command_reload(user, command="", parameters=""): - user.send("Reloading all code modules.") + """Reload all code modules, configs and data.""" + + # let the user know and log + user.send("Reloading all code modules, configs and data.") + muffmisc.log("User " + user.name + " reloaded the world.") + + # set a flag to reload muffvars.reload_modules = True def command_quit(user, command="", parameters=""): - user.save() - user.connection.close() - user.remove() + """Quit the world.""" + user.state = "disconnecting" + +def command_time(user, command="", parameters=""): + """Show the current world time in elapsed increments.""" + user.send(muffuniv.universe.internals["counters"].get("elapsed") + " increments elapsed since the world was created.") def command_help(user, command="", parameters=""): + """List available commands and provide help for commands.""" + + # did the user ask for help on a specific command word? if parameters: - if parameters in command_list: - if command_data.has_section(parameters): - try: - description = command_data.get(parameters, "description") - except: - description = "(no short description provided)" - output = "$(grn)" + parameters + "$(nrm) - " + command_data.get(parameters, "description") + "$(eol)$(eol)" - try: - help_text = command_data.get(parameters, "help") - except: - help_text = "No help is provided for this command." - output += help_text - else: - output = "There is no information on that command." + + # is the command word one for which we have data? + if parameters in muffuniv.universe.commands.keys(): + + # add a description if provided + description = muffuniv.universe.commands[parameters].get("description") + if not description: + description = "(no short description provided)" + output = "$(grn)" + parameters + "$(nrm) - " + description + "$(eol)$(eol)" + + # add the help text if provided + help_text = muffuniv.universe.commands[parameters].get("help") + if not help_text: + help_text = "No help is provided for this command." + output += help_text + + # no data for the requested command word else: output = "That is not an available command." - + + # no specific command word was indicated else: + + # give a sorted list of commands with descriptions if provided output = "These are the commands available to you:$(eol)$(eol)" - sorted_commands = command_list + sorted_commands = muffuniv.universe.commands.keys() sorted_commands.sort() for item in sorted_commands: - try: - description = command_data.get(item, "description") - except: + description = muffuniv.universe.commands[item].get("description") + if not description: description = "(no short description provided)" - output += " $(grn)" + item + "$(nrm) - " + command_data.get(item, "description") + "$(eol)" + output += " $(grn)" + 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=""): - message = parameters.strip("\"'`").capitalize() - if parameters: - if message[-1] == "!": - action = "exclaim" - elif message[-1] in [ ",", "-", ":", ";" ]: - action = "begin" - elif message[-3:] == "...": - action = "muse" - elif message[-1] == "?": - action = "ask" - else: - action = "say" - message += "." - capitalization = [ "i", "i'd", "i'll" ] - for word in capitalization: + """Speak to others in the same room.""" + + # check for replacement macros + if muffmisc.replace_macros(user, parameters, True) != parameters: + user.send("You cannot speak $_(replacement macros).") + + # the user entered a message + elif parameters: + + # get rid of quote marks on the ends of the message and + # capitalize the first letter + message = parameters.strip("\"'`").capitalize() + + # a dictionary of punctuation:action pairs + actions = {} + for option in muffconf.config_data.options("language"): + if option.startswith("punctuation_"): + action = option.split("_")[1] + for mark in muffconf.config_data.get("language", option).split(): + actions[mark] = action + + # set the default action + action = actions[muffconf.config_data.get("language", "default_punctuation")] + + # match the punctuation used, if any, to an action + default_punctuation = muffconf.config_data.get("language", "default_punctuation") + for mark in actions.keys(): + if message.endswith(mark) and mark != default_punctuation: + action = actions[mark] + break + + # if the action is default and there is no mark, add one + if action == actions[default_punctuation] and not message.endswith(default_punctuation): + message += default_punctuation + + # capitalize a list of words within the message + capitalize = muffconf.get("language", "capitalize").split() + for word in capitalize: message = message.replace(" " + word + " ", " " + word.capitalize() + " ") + + # tell the room + # TODO: we won't be using broadcast once there are actual rooms muffmisc.broadcast(user.name + " " + action + "s, \"" + message + "\"") + + # there was no message else: user.send("What do you want to say?") -def command_null(user, command="", parameters=""): - pass +def command_show(user, command="", 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 = muffuniv.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 = muffuniv.universe.contents.keys() + keys.sort() + for key in keys: message += "$(eol) $(grn)" + key + "$(nrm)" + elif parameters: message = "I don't know what \"" + parameters + "\" is." + else: message = "What do you want to show?" + user.send(message) def command_error(user, command="", parameters=""): - if random.random() > 0.1: + """Generic error for an unrecognized command word.""" + + # 90% of the time use a generic error + if random.randrange(10): message = "I'm not sure what \"" + command if parameters: message += " " + parameters message += "\" means..." + + # 10% of the time use the classic diku error else: message = "Arglebargle, glop-glyf!?!" + + # send the error message user.send(message)