X-Git-Url: https://mudpy.org/gitweb?p=mudpy.git;a=blobdiff_plain;f=lib%2Fmuff%2Fmuffcmds.py;h=6ade3b1d62b9797a13de070170323ac70a3e7b0e;hp=033c74c52cb8512292de668e8ad30d88516a5130;hb=1ff00115321d800bec7313a3fdfc97a8b0b006fa;hpb=994d6e52ce3d5c719991e8f798642cdb8a24b7d1 diff --git a/lib/muff/muffcmds.py b/lib/muff/muffcmds.py index 033c74c..6ade3b1 100644 --- a/lib/muff/muffcmds.py +++ b/lib/muff/muffcmds.py @@ -28,16 +28,18 @@ for module in muff.__all__: # does the files:commands setting exist yet? try: - if muffconf.config_data.get("files", "commands"): pass + if muffconf.get("files", "commands"): pass # if not, reload the muffconf module except AttributeError: reload(muffconf) # now we can safely nab the command path setting and build a list of data files -command_path = muffconf.config_data.get("files", "commands") +command_path = muffconf.get("files", "commands") +command_files_index = ConfigParser.SafeConfigParser() +command_files_index.read(command_path + "/index") command_files = [] -for each_file in os.listdir(command_path): +for each_file in command_files_index.get("index", "files").split(): command_files.append(command_path + "/" + each_file) # read the command data files @@ -47,31 +49,21 @@ command_data.read(command_files) # this creates a list of commands mentioned in the data files command_list = command_data.sections() -def handle_user_input(user, input_data): +def handle_user_input(user): """The main handler, branches to a state-specific handler.""" - # the pairings of user state and command to run - handler_dictionary = { - "active": handler_active, - "entering account name": handler_entering_account_name, - "checking password": handler_checking_password, - "checking new account name": handler_checking_new_account_name, - "entering new password": handler_entering_new_password, - "verifying new password": handler_verifying_new_password - } # check to make sure the state is expected, then call that handler - if user.state in handler_dictionary.keys(): - handler_dictionary[user.state](user, input_data) - - # if there's input with an unknown user state, something is wrong - else: handler_fallthrough(user, input_data) + exec("handler_" + user.state.replace(" ", "_") + "(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_data): +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: @@ -87,29 +79,33 @@ def handler_entering_account_name(user, input_data): user.name = user.proposed_name user.proposed_name = None user.load() + muffmisc.log("New user: " + user.name) user.state = "checking new account name" # if the user entered nothing for a name, then buhbye else: user.state = "disconnecting" -def handler_checking_password(user, input_data): +def handler_checking_password(user): """Handle the login account password.""" + # get the next waiting line of input + input_data = user.input_queue.pop(0) + # 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 + # TODO: branch to character creation and selection menus user.name = user.proposed_name del(user.proposed_name) - user.load() - - # now go active - # TODO: branch to character creation and selection menus - user.state = "active" + if not user.replace_old_connections(): + user.load() + user.authenticate() + user.state = "active" # if at first your hashes don't match, try, try again - elif user.password_tries < muffconf.config_data.getint("general", "password_tries"): + elif user.password_tries < muffconf.getint("general", "password_tries"): user.password_tries += 1 user.error = "incorrect" @@ -118,9 +114,20 @@ def handler_checking_password(user, input_data): user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)") user.state = "disconnecting" -def handler_checking_new_account_name(user, input_data): +def handler_disconnecting(user): + """Waiting for the user's connection to close.""" + pass + +def handler_disconnecting_duplicates(user): + """Waiting for duplicate connections to close.""" + pass + +def handler_checking_new_account_name(user): """Handle input for the new user menu.""" + # 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] @@ -131,7 +138,7 @@ def handler_checking_new_account_name(user, input_data): # user selected to disconnect if choice == "d": - user.state == "disconnecting" + user.state = "disconnecting" # go back to the login screen elif choice == "g": @@ -145,9 +152,12 @@ def handler_checking_new_account_name(user, input_data): else: user.error = "default" -def handler_entering_new_password(user, input_data): +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)): @@ -157,7 +167,7 @@ def handler_entering_new_password(user, input_data): user.state = "verifying new password" # the password was weak, try again if you haven't tried too many times - elif user.password_tries < muffconf.config_data.getint("general", "password_tries"): + elif user.password_tries < muffconf.getint("general", "password_tries"): user.password_tries += 1 user.error = "weak" @@ -166,19 +176,24 @@ def handler_entering_new_password(user, input_data): user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)") user.state = "disconnecting" -def handler_verifying_new_password(user, input_data): +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() # the hashes matched, so go active # TODO: branch to character creation and selection menus - user.state = "active" + if not user.replace_old_connections(): user.state = "active" # go back to entering the new password as long as you haven't tried # too many times - elif user.password_tries < muffconf.config_data.getint("general", "password_tries"): + elif user.password_tries < muffconf.getint("general", "password_tries"): user.password_tries += 1 user.error = "differs" user.state = "entering new password" @@ -188,12 +203,11 @@ def handler_verifying_new_password(user, input_data): user.send("$(eol)$(red)Too many failed password attempts...$(nrm)$(eol)") user.state = "disconnecting" -def handler_active(user, input_data): +def handler_active(user): """Handle input for active users.""" - # users reaching this stage should be considered authenticated - # TODO: this should actually happen before or in load() instead - 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: @@ -216,22 +230,16 @@ def handler_active(user, input_data): # no data matching the entered command word elif command: command_error(user, command, parameters) -def handler_fallthrough(user, input_data): - """Input received in an unknown user state.""" - if input_data: - muffmisc.log("User \"" + user + "\" entered \"" + input_data + "\" while in unknown state \"" + user.state + "\".") - def command_halt(user, command="", parameters=""): """Halt the world.""" - # let everyone know - # TODO: optionally take input for the message - muffmisc.broadcast(user.name + " halts 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." - # save everyone - # TODO: probably want a misc function for this - for each_user in muffvars.userlist: - each_user.save() + # let everyone know + muffmisc.broadcast(message) + muffmisc.log(message) # set a flag to terminate the world muffvars.terminate_world = True @@ -239,8 +247,9 @@ def command_halt(user, command="", parameters=""): def command_reload(user, command="", parameters=""): """Reload all code modules, configs and data.""" - # let the user know + # 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 @@ -249,6 +258,11 @@ def command_quit(user, command="", parameters=""): """Quit the world.""" user.state = "disconnecting" +def command_time(user, command="", parameters=""): + """Show the current world time in elapsed increments.""" + user.send(muffmisc.repr_long(muffmisc.getlong(muffvars.variable_data, + "time", "elapsed")) + " increments elapsed since the world was created.") + def command_help(user, command="", parameters=""): """List available commands and provide help for commands.""" @@ -297,40 +311,42 @@ def command_help(user, command="", parameters=""): def command_say(user, command="", parameters=""): """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 - if parameters: + elif parameters: # get rid of quote marks on the ends of the message and # capitalize the first letter message = parameters.strip("\"'`").capitalize() - # exclaim because the message ended in an exclamation mark - # TODO: use the ends() function instead of an index throughout - if message[-1] == "!": - action = "exclaim" + # 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 - # begin because the message ended in miscellaneous punctuation - elif message[-1] in [ ",", "-", ":", ";" ]: - action = "begin" + # set the default action + action = actions[muffconf.config_data.get("language", "default_punctuation")] - # muse because the message ended in an ellipsis - elif message[-3:] == "...": - action = "muse" + # 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 - # ask because the message ended in a question mark - elif message[-1] == "?": - action = "ask" - - # say because the message ended in a singular period - else: - action = "say" - if message.endswith("."): - message += "." + # 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 - # TODO: move this list to the config - capitalization = [ "i", "i'd", "i'll" ] - for word in capitalization: + capitalize = muffconf.get("language", "capitalize").split() + for word in capitalize: message = message.replace(" " + word + " ", " " + word.capitalize() + " ") # tell the room