--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/code.py	Thu Mar 15 16:24:05 2012 +0100
@@ -0,0 +1,283 @@
+"""Utilities needed to emulate Python's interactive interpreter with changes for PARPG
+The original code module is part of pythons standard modules.
+"""
+
+# Inspired by similar code by Jeff Epler and Fredrik Lundh.
+
+# Changed for PARPG to also accept a globals argument
+
+import sys
+import traceback
+from codeop import CommandCompiler, compile_command
+
+__all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact",
+           "compile_command"]
+
+def softspace(file, newvalue):
+    oldvalue = 0
+    try:
+        oldvalue = file.softspace
+    except AttributeError:
+        pass
+    try:
+        file.softspace = newvalue
+    except (AttributeError, TypeError):
+        # "attribute-less object" or "read-only attributes"
+        pass
+    return oldvalue
+
+class InteractiveInterpreter:
+    """Base class for InteractiveConsole.
+
+    This class deals with parsing and interpreter state (the user's
+    namespace); it doesn't deal with input buffering or prompting or
+    input file naming (the filename is always passed in explicitly).
+
+    """
+
+    def __init__(self, globals=None,  locals=None ):
+        """Constructor.
+
+        The optional 'globals' and 'locals' arguments specify the dictionary in
+        which code will be executed; globals defaults to a newly created
+        dictionary with key "__name__" set to "__console__" and key
+        "__doc__" set to None.
+
+        """
+        if globals is None:
+            globals = {"__name__": "__console__", "__doc__": None}
+        self.locals = locals
+        self.globals = globals
+        self.compile = CommandCompiler()
+
+    def runsource(self, source, filename="<input>", symbol="single"):
+        """Compile and run some source in the interpreter.
+
+        Arguments are as for compile_command().
+
+        One several things can happen:
+
+        1) The input is incorrect; compile_command() raised an
+        exception (SyntaxError or OverflowError).  A syntax traceback
+        will be printed by calling the showsyntaxerror() method.
+
+        2) The input is incomplete, and more input is required;
+        compile_command() returned None.  Nothing happens.
+
+        3) The input is complete; compile_command() returned a code
+        object.  The code is executed by calling self.runcode() (which
+        also handles run-time exceptions, except for SystemExit).
+
+        The return value is True in case 2, False in the other cases (unless
+        an exception is raised).  The return value can be used to
+        decide whether to use sys.ps1 or sys.ps2 to prompt the next
+        line.
+
+        """
+        try:
+            code = self.compile(source, filename, symbol)
+        except (OverflowError, SyntaxError, ValueError):
+            # Case 1
+            self.showsyntaxerror(filename)
+            return False
+
+        if code is None:
+            # Case 2
+            return True
+
+        # Case 3
+        self.runcode(code)
+        return False
+
+    def runcode(self, code):
+        """Execute a code object.
+
+        When an exception occurs, self.showtraceback() is called to
+        display a traceback.  All exceptions are caught except
+        SystemExit, which is reraised.
+
+        A note about KeyboardInterrupt: this exception may occur
+        elsewhere in this code, and may not always be caught.  The
+        caller should be prepared to deal with it.
+
+        """
+        try:
+            exec code in self.globals,  self.locals
+        except SystemExit:
+            raise
+        except:
+            self.showtraceback()
+        else:
+            if softspace(sys.stdout, 0):
+                print
+
+    def showsyntaxerror(self, filename=None):
+        """Display the syntax error that just occurred.
+
+        This doesn't display a stack trace because there isn't one.
+
+        If a filename is given, it is stuffed in the exception instead
+        of what was there before (because Python's parser always uses
+        "<string>" when reading from a string).
+
+        The output is written by self.write(), below.
+
+        """
+        type, value, sys.last_traceback = sys.exc_info()
+        sys.last_type = type
+        sys.last_value = value
+        if filename and type is SyntaxError:
+            # Work hard to stuff the correct filename in the exception
+            try:
+                msg, (dummy_filename, lineno, offset, line) = value
+            except:
+                # Not the format we expect; leave it alone
+                pass
+            else:
+                # Stuff in the right filename
+                value = SyntaxError(msg, (filename, lineno, offset, line))
+                sys.last_value = value
+        list = traceback.format_exception_only(type, value)
+        map(self.write, list)
+
+    def showtraceback(self):
+        """Display the exception that just occurred.
+
+        We remove the first stack item because it is our own code.
+
+        The output is written by self.write(), below.
+
+        """
+        try:
+            type, value, tb = sys.exc_info()
+            sys.last_type = type
+            sys.last_value = value
+            sys.last_traceback = tb
+            tblist = traceback.extract_tb(tb)
+            del tblist[:1]
+            list = traceback.format_list(tblist)
+            if list:
+                list.insert(0, "Traceback (most recent call last):\n")
+            list[len(list):] = traceback.format_exception_only(type, value)
+        finally:
+            tblist = tb = None
+        map(self.write, list)
+
+    def write(self, data):
+        """Write a string.
+
+        The base implementation writes to sys.stderr; a subclass may
+        replace this with a different implementation.
+
+        """
+        sys.stderr.write(data)
+
+
+class InteractiveConsole(InteractiveInterpreter):
+    """Closely emulate the behavior of the interactive Python interpreter.
+
+    This class builds on InteractiveInterpreter and adds prompting
+    using the familiar sys.ps1 and sys.ps2, and input buffering.
+
+    """
+
+    def __init__(self, globals=None,  locals=None, filename="<console>"):
+        """Constructor.
+
+        The optional locals and globals argument swill be passed to the
+        InteractiveInterpreter base class.
+
+        The optional filename argument should specify the (file)name
+        of the input stream; it will show up in tracebacks.
+
+        """
+        InteractiveInterpreter.__init__(self, globals,  locals)
+        self.filename = filename
+        self.resetbuffer()
+
+    def resetbuffer(self):
+        """Reset the input buffer."""
+        self.buffer = []
+
+    def interact(self, banner=None):
+        """Closely emulate the interactive Python console.
+
+        The optional banner argument specify the banner to print
+        before the first interaction; by default it prints a banner
+        similar to the one printed by the real Python interpreter,
+        followed by the current class name in parentheses (so as not
+        to confuse this with the real interpreter -- since it's so
+        close!).
+
+        """
+        try:
+            sys.ps1
+        except AttributeError:
+            sys.ps1 = ">>> "
+        try:
+            sys.ps2
+        except AttributeError:
+            sys.ps2 = "... "
+        cprt = 'Type "help", "copyright", "credits" or "license" for more information.'
+        if banner is None:
+            self.write("Python %s on %s\n%s\n(%s)\n" %
+                       (sys.version, sys.platform, cprt,
+                        self.__class__.__name__))
+        else:
+            self.write("%s\n" % str(banner))
+        more = 0
+        while 1:
+            try:
+                if more:
+                    prompt = sys.ps2
+                else:
+                    prompt = sys.ps1
+                try:
+                    line = self.raw_input(prompt)
+                    # Can be None if sys.stdin was redefined
+                    encoding = getattr(sys.stdin, "encoding", None)
+                    if encoding and not isinstance(line, unicode):
+                        line = line.decode(encoding)
+                except EOFError:
+                    self.write("\n")
+                    break
+                else:
+                    more = self.push(line)
+            except KeyboardInterrupt:
+                self.write("\nKeyboardInterrupt\n")
+                self.resetbuffer()
+                more = 0
+
+    def push(self, line):
+        """Push a line to the interpreter.
+
+        The line should not have a trailing newline; it may have
+        internal newlines.  The line is appended to a buffer and the
+        interpreter's runsource() method is called with the
+        concatenated contents of the buffer as source.  If this
+        indicates that the command was executed or invalid, the buffer
+        is reset; otherwise, the command is incomplete, and the buffer
+        is left as it was after the line was appended.  The return
+        value is 1 if more input is required, 0 if the line was dealt
+        with in some way (this is the same as runsource()).
+
+        """
+        self.buffer.append(line)
+        source = "\n".join(self.buffer)
+        more = self.runsource(source, self.filename)
+        if not more:
+            self.resetbuffer()
+        return more
+
+    def raw_input(self, prompt=""):
+        """Write a prompt and read a line.
+
+        The returned line does not include the trailing newline.
+        When the user enters the EOF key sequence, EOFError is raised.
+
+        The base implementation uses the built-in function
+        raw_input(); a subclass may replace this with a different
+        implementation.
+
+        """
+        return raw_input(prompt)

--- a/console.py	Thu Mar 15 14:30:37 2012 +0100
+++ b/console.py	Thu Mar 15 16:24:05 2012 +0100
@@ -96,15 +96,13 @@
         return res
 
     def handlePython(self,command):
-        console_locals = {
+        globals, locals = self.game_state.getGameEnvironment()
+        globals.update({
                         "__name__":"__paprg_console__",
                         "__doc__": None,
-                        }
-        vals, funcs = self.game_state.getGameEnvironment()
-        console_locals.update(vals)
-        console_locals.update(funcs)
+                        })
 
-        console = code.InteractiveConsole(console_locals)
+        console = code.InteractiveConsole(globals, locals)
 
         user_code = command[7:len(command)]
 
@@ -114,17 +112,9 @@
         sys.stdout = codeOut
         sys.stderr = codeOut
 
-        #Workaround it not being possible to enter a blank line in the console
-        if user_code == " ":
-            user_code = ""
-
         #Process the code
         console.push(user_code)
-        if len(console.buffer) == 0:
-            output = codeOut.getvalue()
-        else:
-            output =  "..."
-
+        output = codeOut.getvalue()
 
         #restore stdout and stderr
         sys.stdout = sys.__stdout__

--- a/gamestate.py	Thu Mar 15 14:30:37 2012 +0100
+++ b/gamestate.py	Thu Mar 15 16:24:05 2012 +0100
@@ -35,6 +35,7 @@
             "sqrt":math.sqrt,
             "log":math.log,          
             }
+        self.locals = {}
         
         
     def addObject(self, object_id, map_id, game_object):
@@ -145,12 +146,14 @@
         ret_dict["CurrentMap"] = self.current_map_name
         ret_dict["Quests"] = self.quest_engine.getStateForSaving()
         ret_dict["NPCsMet"] = self.npcs_met
+        ret_dict["locals"] = self.locals
         return ret_dict
 
     def restoreFromState(self, state):
         """Restores the state"""
         self.current_map_name = state["CurrentMap"]
         self.npcs_met = state["NPCsMet"]
+        self.locals = state["locals"]
         self.quest_engine.readQuests()
         self.quest_engine.restoreFromState(state["Quests"])
 
@@ -174,6 +177,8 @@
     def getGameEnvironment(self):
         """Returns a 2 item list containing the entities and functions that 
         can work with it. This can be used in functions like eval or exec"""
-        vals = {}
-        vals.update(self.getObjectDictOfMap(self.current_map_name))
-        return self.funcs, vals
\ No newline at end of file
+        globals = {}
+        globals.update(self.funcs)
+        globals.update(self.getObjectDictOfMap(self.current_map_name))
+        
+        return globals,  self.locals