evennia/cmdhandler.py

from traceback import format_exc
import time

import defines_global
import cmdtable
import functions_db
import functions_general
import functions_comsys

"""
This is the command processing module. It is instanced once in the main
server module and the handle() function is hit every time a player sends
something.
"""

class UnknownCommand(Exception):
    """
    Throw this when a user enters an an invalid command.
    """

def match_exits(pobject, searchstr):
    """
    See if we can find an input match to exits.
    """
    exits = pobject.get_location().get_contents(filter_type=4)
    return functions_db.list_search_object_namestr(exits, searchstr, match_type="exact")

def parse_command(command_string):
    """
    Tries to handle the most common command strings and returns a dictionary with various data.
    Common command types:
    - Complex:
        @pemit[/option] <target>[/option]=<data>
    - Simple:
        look
        look <target>

    I'm not married to either of these terms, but I couldn't think of anything better.  If you can, lets change it :)

    The only cases that I haven't handled is if someone enters something like:
        @pemit <target> <target>/<switch>=<data>
            - Ends up considering both targets as one with a space between them, and the switch as a switch.
        @pemit <target>/<switch> <target>=<data>
            - Ends up considering the first target a target, and the second target as part of the switch.


    """
    # Each of the bits of data starts off as None, except for the raw, original
    # command
    parsed_command = dict(
            raw_command=command_string,
            data=None,
            original_command=None,
            original_targets=None,
            base_command=None,
            command_switches=None,
            targets=None,
            target_switches=None
            )
    try:
        # If we make it past this next statement, then this is what we 
        # consider a complex command
        (command_parts, data) = command_string.split('=', 1)
        parsed_command['data'] = data
        # First we deal with the command part of the command and break it
        # down into the base command, along with switches
        # If we make it past the next statement, then they must have
        # entered a command like:
        #     p =<data>
        # So we should probably just let it get caught by the ValueError
        # again and consider it a simple command
        (total_command, total_targets) = command_parts.split(' ', 1)
        parsed_command['original_command'] = total_command
        parsed_command['original_targets'] = total_targets
        split_command = total_command.split('/')
        parsed_command['base_command'] = split_command[0]
        parsed_command['command_switches'] = split_command[1:]
        # Now we move onto the target data
        try:
            # Look for switches- if they give target switches, then we don't
            # accept multiple targets
            (target, switch_string) = total_targets.split('/', 1)
            parsed_command['targets'] = [target]
            parsed_command['target_switches'] = switch_string.split('/')
        except ValueError:
            # Alright, no switches, so lets consider multiple targets
            parsed_command['targets'] = total_targets.split()
    except ValueError:
        # Ok, couldn't find an =, so not a complex command
        try:
            (command, data) = command_string.split(' ', 1)
            parsed_command['base_command'] = command
            parsed_command['data'] = data
        except ValueError:
            # No arguments
            # ie:
            #   - look
            parsed_command['base_command'] = command_string
    return parsed_command

def handle(cdat):
    """
    Use the spliced (list) uinput variable to retrieve the correct
    command, or return an invalid command error.

    We're basically grabbing the player's command by tacking
    their input on to 'cmd_' and looking it up in the GenCommands
    class.
    """
    session = cdat['session']
    server = cdat['server']
    
    try:
        # TODO: Protect against non-standard characters.
        if cdat['uinput'] == '':
            return

        parsed_input = {}
        parsed_input['parsed_command'] = parse_command(cdat['uinput'])

        # First we split the input up by spaces.
        parsed_input['splitted'] = cdat['uinput'].split()
        # Now we find the root command chunk (with switches attached).
        parsed_input['root_chunk'] = parsed_input['splitted'][0].split('/')
        # And now for the actual root command. It's the first entry in root_chunk.
        parsed_input['root_cmd'] = parsed_input['root_chunk'][0].lower()
        # Keep around the full, raw input in case a command needs it
        cdat['raw_input'] = cdat['uinput']

        # Now we'll see if the user is using an alias. We do a dictionary lookup,
        # if the key (the player's root command) doesn't exist on the dict, we
        # don't replace the existing root_cmd. If the key exists, its value
        # replaces the previously splitted root_cmd. For example, sa -> say.
        alias_list = server.cmd_alias_list
        parsed_input['root_cmd'] = alias_list.get(parsed_input['root_cmd'],parsed_input['root_cmd'])

        # This will hold the reference to the command's function.
        cmd = None

        if session.logged_in:
            # Store the timestamp of the user's last command.
            session.cmd_last = time.time()

            # Lets the users get around badly configured NAT timeouts.
            if parsed_input['root_cmd'] == 'idle':
                return

            # Increment our user's command counter.
            session.cmd_total += 1
            # Player-visible idle time, not used in idle timeout calcs.
            session.cmd_last_visible = time.time()

            # Just in case. Prevents some really funky-case crashes.
            if len(parsed_input['root_cmd']) == 0:
                raise UnknownCommand

            # Shortened say alias.
            if parsed_input['root_cmd'][0] == '"':
                parsed_input['splitted'].insert(0, "say")
                parsed_input['splitted'][1] = parsed_input['splitted'][1][1:]
                parsed_input['root_cmd'] = 'say'
            # Shortened pose alias.
            elif parsed_input['root_cmd'][0] == ':':
                parsed_input['splitted'].insert(0, "pose")
                parsed_input['splitted'][1] = parsed_input['splitted'][1][1:]
                parsed_input['root_cmd'] = 'pose'
            # Pose without space alias.
            elif parsed_input['root_cmd'][0] == ';':
                parsed_input['splitted'].insert(0, "pose/nospace")
                parsed_input['root_chunk'] = ['pose', 'nospace']
                parsed_input['splitted'][1] = parsed_input['splitted'][1][1:]
                parsed_input['root_cmd'] = 'pose'
            # Channel alias match.
            elif functions_comsys.plr_has_channel(session, 
                parsed_input['root_cmd'], 
                alias_search=True, 
                return_muted=True):
                
                calias = parsed_input['root_cmd']
                cname = functions_comsys.plr_cname_from_alias(session, calias)
                cmessage = ' '.join(parsed_input['splitted'][1:])
                
                if cmessage == "who":
                    functions_comsys.msg_cwho(session, cname)
                    return
                elif cmessage == "on":
                    functions_comsys.plr_chan_on(session, calias)
                    return
                elif cmessage == "off":
                    functions_comsys.plr_chan_off(session, calias)
                    return
                elif cmessage == "last":
                    functions_comsys.msg_chan_hist(session, cname)
                    return
                    
                second_arg = "%s=%s" % (cname, cmessage)
                parsed_input['splitted'] = ["@cemit/sendername", second_arg]
                parsed_input['root_chunk'] = ['@cemit', 'sendername', 'quiet']
                parsed_input['root_cmd'] = '@cemit'

            # Get the command's function reference (Or False)
            cmdtuple = cmdtable.return_cmdtuple(parsed_input['root_cmd'])
            if cmdtuple:
                # If there is a permissions element to the entry, check perms.
                if cmdtuple[1]:
                    if not session.get_pobject().user_has_perm_list(cmdtuple[1]):
                        session.msg(defines_global.NOPERMS_MSG)
                        return
                # If flow reaches this point, user has perms and command is ready.
                cmd = cmdtuple[0]
                    
        else:
            # Not logged in, look through the unlogged-in command table.
            cmdtuple = cmdtable.return_cmdtuple(parsed_input['root_cmd'], unlogged_cmd=True)
            if cmdtuple:
                cmd = cmdtuple[0]

        # Debugging stuff.
        #session.msg("ROOT : %s" % (parsed_input['root_cmd'],))
        #session.msg("SPLIT: %s" % (parsed_input['splitted'],))
        
        if callable(cmd):
            cdat['uinput'] = parsed_input
            try:
                cmd(cdat)
            except:
                session.msg("Untrapped error, please file a bug report:\n%s" % (format_exc(),))
                functions_general.log_errmsg("Untrapped error, evoker %s: %s" %
                    (session, format_exc()))
            return

        if session.logged_in:
            # If we're not logged in, don't check exits.
            pobject = session.get_pobject()
            exit_matches = match_exits(pobject, ' '.join(parsed_input['splitted']))
            if exit_matches:
                targ_exit = exit_matches[0]
                if targ_exit.get_home():
                    cdat['uinput'] = parsed_input
                    
                    # SCRIPT: See if the player can traverse the exit
                    if not targ_exit.get_scriptlink().default_lock({
                        "pobject": pobject
                    }):
                        session.msg("You can't traverse that exit.")
                    else:
                        pobject.move_to(targ_exit.get_home())
                        session.execute_cmd("look")
                else:
                    session.msg("That exit leads to nowhere.")
                return

        # If we reach this point, we haven't matched anything.    
        raise UnknownCommand

    except UnknownCommand:
        session.msg("Huh?  (Type \"help\" for help.)")