Run Migrate. Implemented a full separation between Player and Character - Players (OOC entities) can now also hold cmdsets and execute commands. This means that "disconnecting" from a Character becomes possible, putting the Player in an "OOC" state outside the game. This overall makes the game much more stable since there used to be issues if the character was destroyed. Having an OOC set also avoids the previous problem of @puppeting into an object that didn't have any cmdset of its own - you couldn't get back out! A new default OOC-Cmdset handles commands available to a player while OOC. Commands in this set are applied with a low priority, allowing "IC" mode to give precedence if desired.

This change meant several changes to the lock and permission functionality, since it becomes important if permissions are assigned on the Player or on their Character (lock functions pperm() and pid() etc check on Player rather than Character). This has the boon of allowing Admins to switch and play/test the game as a "Low access" character as they like.

Plenty of bug fixes and adjustments. Migrations should make sure to move over all data properly.

src/commands/cmdparser.py

@@ -174,3 +174,128 @@ def cmdparser(raw_string):
     wordlist = raw_string.split(" ")           
     candidates.extend(produce_candidates(nr_candidates, wordlist))
     return candidates
+
+
+#------------------------------------------------------------
+# Search parsers and support methods 
+#------------------------------------------------------------
+#
+# Default functions for formatting and processing searches.
+#
+# This is in its own module due to them being possible to
+# replace from the settings file by setting the variables
+#
+# SEARCH_AT_RESULTERROR_HANDLER
+# SEARCH_MULTIMATCH_PARSER 
+#
+# The the replacing modules must have the same inputs and outputs as
+# those in this module.
+#
+
+def at_search_result(msg_obj, ostring, results, global_search=False):
+    """
+    Called by search methods after a result of any type has been found.
+    
+    Takes a search result (a list) and
+    formats eventual errors.
+
+    msg_obj - object to receive feedback. 
+    ostring - original search string 
+    results - list of found matches (0, 1 or more)
+    global_search - if this was a global_search or not
+            (if it is, there might be an idea of supplying
+            dbrefs instead of only numbers)
+
+    Multiple matches are returned to the searching object
+    as 
+     1-object
+     2-object 
+     3-object 
+       etc
+
+    """
+    string = ""
+    if not results: 
+        # no results. 
+        string = "Could not find '%s'." % ostring
+        results = None         
+
+    elif len(results) > 1:
+        # we have more than one match. We will display a
+        # list of the form 1-objname, 2-objname etc.        
+
+        # check if the msg_object may se dbrefs
+        show_dbref = global_search
+
+        string += "More than one match for '%s'" % ostring
+        string += " (please narrow target):" 
+        for num, result in enumerate(results):
+            invtext = ""            
+            dbreftext = ""
+            if hasattr(result, "location") and result.location == msg_obj:
+                invtext = " (carried)"                    
+            if show_dbref:
+                dbreftext = "(#%i)" % result.id 
+            string += "\n %i-%s%s%s" % (num+1, result.name, 
+                                        dbreftext, invtext)        
+        results = None 
+    else:
+        # we have exactly one match.
+        results = results[0]
+
+    if string: 
+        msg_obj.msg(string.strip())
+    return results 
+
+def at_multimatch_input(ostring):
+    """
+    Parse number-identifiers.
+
+    This parser will be called by the engine when a user supplies
+    a search term. The search term must be analyzed to determine
+    if the user wants to differentiate between multiple matches
+    (usually found during a previous search).
+
+    This method should separate out any identifiers from the search
+    string used to differentiate between same-named objects. The
+    result should be a tuple (index, search_string) where the index
+    gives which match among multiple matches should be used (1 being
+    the lowest number, rather than 0 as in Python).
+
+    This parser version will identify search strings on the following
+    forms 
+
+      2-object 
+
+    This will be parsed to (2, "object") and, if applicable, will tell
+    the engine to pick the second from a list of same-named matches of
+    objects called "object".
+
+    Ex for use in a game session:
+
+     > look
+    You see: ball, ball, ball and ball. 
+     > get ball
+    There where multiple matches for ball:
+        1-ball
+        2-ball
+        3-ball
+        4-ball
+     > get 3-ball
+     You get the ball. 
+
+    """
+
+    if not isinstance(ostring, basestring):
+        return (None, ostring)
+    if not '-' in ostring:
+        return (None, ostring)
+    try: 
+        index  = ostring.find('-')
+        number = int(ostring[:index])-1
+        return (number, ostring[index+1:])
+    except ValueError:
+        #not a number; this is not an identifier.
+        return (None, ostring)
+    except IndexError:
+        return (None, ostring)