Changeset 625


Ignore:
Timestamp:
08/05/10 16:48:23 (9 years ago)
Author:
vaporice
Message:

Make the console function like a real python interpreter
Use the variables app_listener, model, view and engine to manipulate the game

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/scripts/console.py

    r624 r625  
    1818import sys 
    1919from StringIO import StringIO 
     20import code 
    2021 
    2122class Console: 
     
    5051        self.model = self.app_listener.model 
    5152        self.game_state = self.app_listener.view.model.game_state 
     53        self.console_locals = {"__name__":"__paprg_console__",\ 
     54                               "__doc__": None,\ 
     55                               "app_listener":self.app_listener,\ 
     56                               "model":self.app_listener.model,\ 
     57                               "view":self.app_listener.view,\ 
     58                               "engine":self.app_listener.engine} 
     59       
     60        self.console = code.InteractiveConsole(self.console_locals) 
    5261 
    5362    def handleQuit(self, command): 
     
    97106        return res 
    98107 
    99     def handlePython(self, command): 
    100         """Implements the python console command  
    101            @type command: string 
    102            @param command: The command to run 
    103            @return: The resultstring""" 
    104  
    105         code = command[7:len(command)] 
    106  
    107         #Make parpg print to these variables and not to stdout   
     108    def handlePython(self,command): 
     109        user_code = command[7:len(command)] 
     110 
    108111        codeOut = StringIO() 
    109         codeErr = StringIO() 
    110  
    111         sys.stdout = codeOut 
    112         sys.stderr = codeErr 
    113  
    114         #execute python the code 
    115         exec(code) 
    116  
    117         #restore stdout 
    118         sys.stdout = sys.__stdout__ 
    119         sys.stderr = sys.__stderr__ 
    120  
    121         out = codeOut.getvalue() 
    122         err = codeOut.getvalue() 
    123          
    124         #create output 
    125         temp_output = out 
    126         if not err == out: 
    127                 temp_output += err 
    128  
     112         
     113        #make stdout and stderr write to our file, not the terminal 
     114        sys.stdout = codeOut 
     115        sys.stderr = codeOut 
     116 
     117        #Workaround it not being possible to enter a blank line in the console 
     118        if user_code == " ": 
     119            user_code = "" 
     120 
     121        #Process the code 
     122        self.console.push(user_code) 
     123        if len(self.console.buffer) == 0: 
     124            output = codeOut.getvalue() 
     125        else: 
     126            output =  "..." 
     127         
     128 
     129        #restore stdout and stderr 
     130        sys.stdout = sys.__stdout__ 
     131        sys.stderr = sys.__stderr__ 
     132 
     133        temp_output = output 
     134        output = "" 
    129135        counter = 0 
    130         output = "" 
    131  
     136         
    132137        #Make the output fit in the console screen 
    133138        for char in temp_output: 
    134                 counter += 1 
    135                 if char == "\n": 
    136                      counter = 0 
    137                 elif counter == 110: 
    138                      output += "\n" 
    139                      counter = 0  
    140                 output += char   
     139            counter += 1 
     140            if char == "\n": 
     141                counter = 0 
     142            elif counter == 110: 
     143                output += "\n" 
     144                counter = 0 
     145            output += char 
     146 
    141147        return output 
    142  
    143148 
    144149    def handleLoad(self, command): 
Note: See TracChangeset for help on using the changeset viewer.