Changeset 312 for trunk/game


Ignore:
Timestamp:
10/10/09 17:26:08 (10 years ago)
Author:
Kaydeth_parpg
Message:

Ticket #2: Patch by Kaydeth. Updated the classes in console.py through engine.py (went through files alphabetically) to correct some obvious discrepancies with our coding standard. comment[s:trac, t:2]

Location:
trunk/game
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/run.py

    r310 r312  
    3737"""This folder holds the main meta-data for PARPG. This file should be 
    3838   minimal, since folding code into the controller with MVC is usually bad 
    39    All game and logic and data is held held and referenced in /scripts/engine.py 
    40    All fife stuff goes in /scripts/world.py""" 
     39   All game and logic and data is held held and referenced in  
     40   /scripts/engine.py. All fife stuff goes in /scripts/world.py""" 
    4141 
    4242class ApplicationListener(eventlistenerbase.EventListenerBase): 
  • trunk/game/scripts/console.py

    r295 r312  
    1717 
    1818class Console: 
    19     def __init__(self, appListener): 
     19    def __init__(self, app_listener): 
    2020        """  
    2121        Constructor 
     
    2323        @param appListener: ApplicationListener object providing a link with 
    2424        the engine, the world and the model""" 
     25        exit_help = "Terminate application" 
     26        grid_help = "Toggle grid display" 
     27        run_help = "Toggle player run/walk" 
     28        help_help = "Show this help string" 
     29        load_help = "load directory file" 
     30        python_help = "Run some python code" 
     31        quit_help = "Terminate application" 
     32        save_help = "save directory file" 
    2533 
    2634        self.commands = [ 
    27             {"cmd":"exit"  ,"callback":self.handleQuit  ,"help":"Terminate application "}, 
    28             {"cmd":"grid"  ,"callback":self.handleGrid  ,"help":"Toggle grid display   "}, 
    29             {"cmd":"run"   ,"callback":self.handleRun   ,"help":"Toggle player run/walk"}, 
    30             {"cmd":"help"  ,"callback":self.handleHelp  ,"help":"Show this help string "}, 
    31             {"cmd":"load"  ,"callback":self.handleLoad  ,"help":"load directory file   "}, 
    32             {"cmd":"python","callback":self.handlePython,"help":"Run some python code  "}, 
    33             {"cmd":"quit"  ,"callback":self.handleQuit  ,"help":"Terminate application "}, 
    34             {"cmd":"save"  ,"callback":self.handleSave  ,"help":"save directory file   "}, 
     35            {"cmd":"exit"  ,"callback":self.handleQuit  ,"help": exit_help}, 
     36            {"cmd":"grid"  ,"callback":self.handleGrid  ,"help": grid_help}, 
     37            {"cmd":"run"   ,"callback":self.handleRun   ,"help": run_help}, 
     38            {"cmd":"help"  ,"callback":self.handleHelp  ,"help": help_help}, 
     39            {"cmd":"load"  ,"callback":self.handleLoad  ,"help": load_help}, 
     40            {"cmd":"python","callback":self.handlePython,"help": python_help}, 
     41            {"cmd":"quit"  ,"callback":self.handleQuit  ,"help": quit_help}, 
     42            {"cmd":"save"  ,"callback":self.handleSave  ,"help": save_help}, 
    3543        ] 
    36         self.appListener=appListener 
     44        self.app_listener=app_listener 
    3745 
    3846    def handleQuit(self, command): 
     
    4351        @return: The resultstring""" 
    4452         
    45         self.appListener.quitGame() 
     53        self.app_listener.quitGame() 
    4654        return "Terminating ..." 
    4755 
     
    5361        @return: The resultstring""" 
    5462 
    55         self.appListener.world.activeMap.toggle_renderer('GridRenderer') 
     63        self.app_listener.world.activeMap.toggle_renderer('GridRenderer') 
    5664        return "Grid toggled" 
    5765 
     
    6371        @return: The response""" 
    6472         
    65         if self.appListener.model.pc_run==1: 
    66             self.appListener.model.pc_run=0 
     73        if self.app_listener.model.pc_run == 1: 
     74            self.app_listener.model.pc_run = 0 
    6775            return "PC is now walking" 
    6876        else: 
    69             self.appListener.model.pc_run=1 
     77            self.app_listener.model.pc_run = 1 
    7078            return "PC is now running" 
    7179             
     
    8088        res="" 
    8189        for cmd in self.commands: 
    82             res+= "%10s: %s\n" % (cmd["cmd"], cmd["help"]) 
     90            res += "%10s: %s\n" % (cmd["cmd"], cmd["help"]) 
    8391 
    8492        return res 
     
    9199        @return: The resultstring""" 
    92100 
    93         result=None 
     101        result = None 
    94102        python_regex = re.compile('^python') 
    95103        python_matches = python_regex.match(command.lower()) 
    96         if (python_matches != None): 
    97             end_python = command[python_matches.end()+1:] 
     104        if (python_matches is not None): 
     105            end_python = command[python_matches.end() + 1:] 
    98106            try: 
    99107                result = str(eval(end_python)) 
     
    110118        @return: The resultstring""" 
    111119 
    112         result=None 
     120        result = None 
    113121        load_regex = re.compile('^load') 
    114122        l_matches = load_regex.match(command.lower()) 
    115         if (l_matches != None): 
     123        if (l_matches is not None): 
    116124            end_load = l_matches.end() 
    117125            try: 
    118                 l_args = command.lower()[end_load+1:].strip() 
     126                l_args = command.lower()[end_load + 1:].strip() 
    119127                l_path, l_filename = l_args.split(' ') 
    120                 self.appListener.model.load(l_path, l_filename) 
     128                self.app_listener.model.load(l_path, l_filename) 
    121129                result = "Loaded file: " + l_path + l_filename 
    122130 
    123131            except Exception, l_error: 
    124                 self.appListener.engine.getGuiManager().getConsole().println('Error: ' + str(l_error)) 
     132                self.app_listener.engine.getGuiManager().getConsole().println('Error: ' + str(l_error)) 
    125133                result="Failed to load file" 
    126134 
     
    141149                s_args = command.lower()[end_save+1:].strip() 
    142150                s_path, s_filename = s_args.split(' ') 
    143                 self.appListener.model.save(s_path, s_filename) 
     151                self.app_listener.model.save(s_path, s_filename) 
    144152                result = "Saved to file: " + s_path + s_filename 
    145153 
    146154            except Exception, s_error: 
    147                 self.appListener.engine.getGuiManager().getConsole().println('Error: ' + str(s_error)) 
     155                self.app_listener.engine.getGuiManager().getConsole(). \ 
     156                    println('Error: ' + str(s_error)) 
    148157                result = "Failed to save file" 
    149158 
     
    164173                result=cmd["callback"](command) 
    165174 
    166         if result==None: 
     175        if result is None: 
    167176            result = "Invalid command, enter help for more information" 
    168177 
  • trunk/game/scripts/context_menu.py

    r158 r312  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 import fife, pychan 
     18import fife 
     19import pychan 
    1920 
    2021class ContextMenu(object): 
     
    3536            p = pychan.widgets.Button(name=item[0], text=unicode(item[1])) 
    3637            self.vbox.addChild(p) 
    37             events_to_map [item[0]] = self.action_decorator(*item[2:]) 
     38            events_to_map [item[0]] = self.actionDecorator(*item[2:]) 
    3839        self.vbox.mapEvents(events_to_map) 
    3940        self.show() 
     
    4647        self.vbox.hide() 
    4748         
    48     def action_decorator (self,func, *args, **kwargs): 
     49    def actionDecorator (self,func, *args, **kwargs): 
    4950        """This function is supposed to add some generic that should be 
    5051        executed before and/or after an action is fired through the 
     
    5859        """ 
    5960         
    60         def decorated_func (): 
     61        def decoratedFunc (): 
    6162            """ This is the actual wrapped version of func, that is returned. 
    6263            It takes no external arguments, so it can safely be passed around 
     
    7071            # return the value, as if the original function was called 
    7172            return ret_val 
    72         return decorated_func 
     73        return decoratedFunc 
    7374         
  • trunk/game/scripts/dialogue.py

    r300 r312  
    2222class EndException(Exception): 
    2323    """EndException is used to bail out from a deeply nested 
    24        run_section/continue_with_response call stack and end the 
     24       runSection/continueWithResponse call stack and end the 
    2525       conversation""" 
    2626    pass 
     
    2828class ResponseException(Exception): 
    2929    """ResponseException is used to bail out from a deeply nested 
    30        run_section/continue_with_response call stack and allow the user to 
     30       runSection/continueWithResponse call stack and allow the user to 
    3131       specify a response""" 
    3232    pass 
     
    3434class BackException(Exception): 
    3535    """BackException is used to bail out from a deeply nested 
    36        run_section/continue_with_response call stack and rewind the section 
     36       runSection/continueWithResponse call stack and rewind the section 
    3737       stack""" 
    3838    pass 
     
    6767 
    6868        try: 
    69             self.run_section(start_section) 
     69            self.runSection(start_section) 
    7070        except EndException: 
    7171            # we stopped talking to the NPC 
    7272            logging.debug("Reached the end") 
    7373            end_cb = self.callbacks.get('end') 
    74             if end_cb: end_cb() 
     74            if end_cb: 
     75                end_cb() 
    7576            return 
    7677        except ResponseException, e: 
     
    7980            self.section_stack.pop(-1) 
    8081            try: 
    81                 self.run_section(self.section_stack[-1]) 
     82                self.runSection(self.section_stack[-1]) 
    8283                return e 
    8384            except ResponseException, e: 
    8485                return e.args[0] 
    8586 
    86     def get_section(self, section_name): 
     87    def getSection(self, section_name): 
    8788        """Return a section object. 
    8889        @type section_name: string 
     
    101102            try: 
    102103                if response is not None: 
    103                     self.continue_with_response(self.section_stack[-1], response) 
     104                    self.continueWithResponse(self.section_stack[-1], \ 
     105                                                response) 
    104106                else: 
    105                     self.run_section(self.section_stack[-1]) 
     107                    self.runSection(self.section_stack[-1]) 
    106108            except ResponseException, e: 
    107109                logging.debug("Got response exception %s" % (e.args, )) 
     
    124126            except EndException: 
    125127                end_cb = self.callbacks.get('end') 
    126                 if end_cb: end_cb() 
     128                if end_cb: 
     129                    end_cb() 
    127130                logging.debug("Reached the end") 
    128131                return 
    129132 
    130     def continue_with_response(self, section_name, response): 
    131         """Reply to a response in a section and continue executing dialogue script 
     133    def continueWithResponse(self, section_name, response): 
     134        """Reply to a response in a section and continue executing dialogue 
     135           script 
    132136           @type section_name: str 
    133137           @param section_name: the section to continue 
     
    142146                self.section_stack.pop(-1) 
    143147 
    144         for command in itertools.cycle(self.get_section(section_name)): 
    145             if not command.get('responses'): continue 
     148        for command in itertools.cycle(self.getSection(section_name)): 
     149            if not command.get('responses'): 
     150                continue 
    146151 
    147152            responses = [] 
     
    161166                raise EndException() 
    162167 
    163             self.run_section(section) 
    164  
    165     def run_section(self, section_name): 
     168            self.runSection(section) 
     169 
     170    def runSection(self, section_name): 
    166171        """Run a section 
    167172           @type section_name: string 
     
    179184                self.section_stack.pop(-1) 
    180185 
    181         logging.debug("In run_section %s %s" % (section_name, self.section_stack,)) 
    182         for command in itertools.cycle(self.get_section(section_name)): 
     186        logging.debug("In runSection %s %s" % (section_name, \ 
     187                                               self.section_stack,)) 
     188        for command in itertools.cycle(self.getSection(section_name)): 
    183189            if command.get("say"): 
    184190                if self.callbacks.get('say'): 
     
    197203 
    198204            elif command.get("start_quest"): 
    199                 self.callbacks["start_quest"](state, command.get("start_quest")) 
     205                self.callbacks["start_quest"](state, \ 
     206                                              command.get("start_quest")) 
    200207 
    201208            elif command.get("complete_quest"): 
    202                 self.callbacks["complete_quest"](state, command.get("complete_quest")) 
     209                self.callbacks["complete_quest"](state, \ 
     210                                                 command.get("complete_quest")) 
    203211 
    204212            elif command.get("dialogue"): 
  • trunk/game/scripts/dialoguegui.py

    r290 r312  
    150150                position_technique='center:center' 
    151151            ) 
    152             button.margins=(5,5) 
    153             button.background_color=fife.Color(0,0,0) 
    154             button.color=fife.Color(0,255,0) 
     152            button.margins = (5,5) 
     153            button.background_color = fife.Color(0,0,0) 
     154            button.color = fife.Color(0,255,0) 
    155155            button.border_size = 0 
    156156            button.wrap_text = 1 
    157             button.capture(lambda button=button: self.handleEntered(button), event_name='mouseEntered') 
    158             button.capture(lambda button=button: self.handleExited(button), event_name='mouseExited') 
    159             button.capture(lambda button=button: self.handleClicked(button), event_name='mouseClicked') 
     157            button.capture(lambda button=button: self.handleEntered(button), \ 
     158                           event_name='mouseEntered') 
     159            button.capture(lambda button=button: self.handleExited(button), \ 
     160                           event_name='mouseExited') 
     161            button.capture(lambda button=button: self.handleClicked(button), \ 
     162                           event_name='mouseClicked') 
    160163            choices_list.addChild(button) 
    161164            self.dialogue_gui.adaptLayout(True) 
  • trunk/game/scripts/engine.py

    r310 r312  
    1717 
    1818# there should be NO references to FIFE here! 
    19 import pickle, sys 
     19import pickle 
     20import sys 
    2021from gamestate import GameState 
    2122from objects import * 
     
    3839        # a World object (the fife stuff, essentially) 
    3940        self.view = view 
    40         self.mapchange = False 
    41         self.gameState = GameState() 
     41        self.map_change = False 
     42        self.game_state = GameState() 
    4243        self.pc_run = 1 
    43         self.targetPosition = None 
     44        self.target_position = None 
    4445    def reset(self): 
    4546        """Clears the data on a map reload so we don't have objects/npcs from 
     
    6162        # can't pickle SwigPyObjects 
    6263        behaviours = {} 
    63         behaviours[self.gameState.PC.ID] = self.gameState.PC.behaviour; 
    64         self.gameState.PC.behaviour = None; 
    65          
    66         npcs = [npc for npc in self.gameState.objects.values() if npc.trueAttr("NPC")] 
     64        behaviours[self.game_state.PC.ID] = self.game_state.PC.behaviour; 
     65        self.game_state.PC.behaviour = None; 
     66         
     67        npcs = [npc for npc in self.game_state.objects.values() \ 
     68                if npc.trueAttr("NPC")] 
    6769        for npc in npcs: 
    6870            behaviours[npc.ID] = npc.behaviour; 
    6971            npc.behaviour = None; 
    7072         
    71         pickle.dump(self.gameState, f) 
     73        pickle.dump(self.game_state, f) 
    7274        f.close() 
    7375         
     
    7577        for npc in npcs: 
    7678            npc.behaviour = behaviours[npc.ID]; 
    77         self.gameState.PC.behaviour = behaviours[self.gameState.PC.ID] 
     79        self.game_state.PC.behaviour = behaviours[self.game_state.PC.ID] 
    7880 
    7981    def load(self, path, filename): 
     
    9092            sys.stderr.write("Error: Can't find save game file\n") 
    9193            return 
    92         self.gameState = pickle.load(f) 
     94        self.game_state = pickle.load(f) 
    9395        f.close() 
    94         if self.gameState.currentMap: 
    95             self.loadMap(self.gameState.currentMapName, self.gameState.currentMap)  
     96        if self.game_state.currentMap: 
     97            self.loadMap(self.game_state.currentMapName, \ 
     98                         self.game_state.currentMap)  
    9699 
    97100    def createObject (self, layer, attributes, instance): 
     
    113116         
    114117        if obj.trueAttr("PC"): 
    115             self.addPC( layer, obj, instance) 
     118            self.addPC(layer, obj, instance) 
    116119        else: 
    117             self.addObject( layer, obj, instance) 
     120            self.addObject(layer, obj, instance) 
    118121 
    119122         
     
    133136         
    134137        # sync with game data 
    135         if not self.gameState.PC: 
    136             self.gameState.PC = pc 
     138        if self.game_state.PC is None: 
     139            self.game_state.PC = pc 
    137140             
    138         self.gameState.PC.setup() 
     141        self.game_state.PC.setup() 
    139142 
    140143 
     
    150153        """ 
    151154         
    152         ref = self.gameState.getObjectById(obj.ID)  
     155        ref = self.game_state.getObjectById(obj.ID)  
    153156        if ref is None: 
    154157            # no, add it to the game state 
    155             obj.map_id = self.gameState.currentMap 
    156             self.gameState.objects[obj.ID] = obj 
     158            obj.map_id = self.game_state.currentMap 
     159            self.game_state.objects[obj.ID] = obj 
    157160        else: 
    158161            # yes, use the current game state data 
     
    178181           @rtype: boolean 
    179182           @return: Status of result (True/False)""" 
    180         for i in self.gameState.getObjectsFromMap(self.gameState.currentMap): 
     183        for i in self.game_state.getObjectsFromMap(self.game_state.currentMap): 
    181184            if (i.ID == ident): 
    182185                # we found a match 
     
    193196        actions=[] 
    194197        # note: ALWAYS check NPC's first! 
    195         obj = self.gameState.getObjectById(obj_id) 
    196          
    197         if obj: 
     198        obj = self.game_state.getObjectById(obj_id) 
     199         
     200        if obj is not None: 
    198201            if obj.trueAttr("NPC"): 
    199202                # keep it simple for now, None to be replaced by callbacks 
     
    201204                actions.append(["Attack", "Attack", self.nullFunc, obj]) 
    202205            else: 
    203                 actions.append(["Examine", "Examine", self.gameState.PC.approach, \ 
    204                                 [obj.X, obj.Y], ExamineBoxAction(self, obj.name, obj.text)]) 
     206                actions.append(["Examine", "Examine", \ 
     207                                self.game_state.PC.approach, [obj.X, obj.Y], \ 
     208                                ExamineBoxAction(self, obj.name, obj.text)]) 
    205209                # is it a Door? 
    206210                if obj.trueAttr("door"): 
    207211                    actions.append(["Change Map", "Change Map", \ 
    208                        self.gameState.PC.approach, [obj.X, obj.Y], \ 
     212                       self.game_state.PC.approach, [obj.X, obj.Y], \ 
    209213                            ChangeMapAction(self, obj.target_map_name, \ 
    210214                                obj.target_map, obj.target_pos)]) 
    211215                # is it a container? 
    212216                if obj.trueAttr("container"): 
    213                     actions.append(["Open", "Open", self.gameState.PC.approach, [obj.X, obj.Y], OpenBoxAction(self, "Box")]) 
     217                    actions.append(["Open", "Open",  
     218                                    self.game_state.PC.approach, \ 
     219                                    [obj.X, obj.Y], \ 
     220                                    OpenBoxAction(self, "Box")]) 
    214221                # can you pick it up? 
    215222                if obj.trueAttr("carryable"): 
     
    226233        # TODO: work more on this when we get NPCData and HeroData straightened 
    227234        # out 
    228         npc = self.gameState.getObjectById(npcInfo.ID) 
    229         self.gameState.PC.approach([npc.getLocation().getLayerCoordinates().x, npc.getLocation().getLayerCoordinates().y], TalkAction(self, npc)) 
     235        npc = self.game_state.getObjectById(npcInfo.ID) 
     236        self.game_state.PC.approach([npc.getLocation().\ 
     237                                     getLayerCoordinates().x, \ 
     238                                     npc.getLocation().\ 
     239                                     getLayerCoordinates().y], \ 
     240                                     TalkAction(self, npc)) 
    230241 
    231242    def loadMap(self, map_name, map_file): 
     
    237248           @param map_file: Filename of map file to load 
    238249           @return: None""" 
    239         self.gameState.currentMap = map_file 
    240         self.gameState.currentMapName= map_name 
     250        self.game_state.currentMap = map_file 
     251        self.game_state.currentMapName= map_name 
    241252        self.view.loadMap(map_name, str(map_file)) 
    242253        self.view.setActiveMap(map_name) 
     
    245256 
    246257        # create the PC agent 
    247         self.view.activeMap.addPC(self.gameState.PC.behaviour.agent) 
    248         self.gameState.PC.start() 
     258        self.view.activeMap.addPC(self.game_state.PC.behaviour.agent) 
     259        self.game_state.PC.start() 
    249260 
    250261 
     
    254265           @param position: Screen position of click 
    255266           @return: None""" 
    256         if(self.pc_run==1): 
    257             self.gameState.PC.run(position) 
     267        if(self.pc_run == 1): 
     268            self.game_state.PC.run(position) 
    258269        else: 
    259             self.gameState.PC.walk(position) 
    260  
    261     def changeMap(self, mapName, mapFile, targetPosition): 
    262         """Registers for a mapchange on the next pump(). 
     270            self.game_state.PC.walk(position) 
     271 
     272    def changeMap(self, mapName, mapFile, target_position): 
     273        """Registers for a map change on the next pump(). 
    263274           @type nameName: String 
    264275           @param mapName: Id of the map to teleport to 
    265276           @type mapFile: String 
    266277           @param mapFile: Filename of the map to teleport to 
    267            @type targetPosition: Tuple 
    268            @param targetPosition: Position of PC on target map. 
     278           @type target_position: Tuple 
     279           @param target_position: Position of PC on target map. 
    269280           @return None""" 
    270         # set the parameters for the mapchange if moving to a new map 
    271         print self.gameState.currentMapName 
    272         if mapName != self.gameState.currentMapName: 
    273             self.gameState.currentMapName = mapName 
    274             self.gameState.currentMap = mapFile 
    275             self.targetPosition = targetPosition 
    276             # issue the mapchange 
    277             self.mapchange = True 
     281        # set the parameters for the map change if moving to a new map 
     282        print self.game_state.currentMapName 
     283        if mapName != self.game_state.currentMapName: 
     284            self.game_state.currentMapName = mapName 
     285            self.game_state.currentMap = mapFile 
     286            self.target_position = target_position 
     287            # issue the map change 
     288            self.map_change = True 
    278289        else: 
    279290            #set the player position on the current map 
    280             self.view.teleport(targetPosition) 
     291            self.view.teleport(target_position) 
    281292 
    282293    def handleCommands(self): 
    283         if self.mapchange: 
    284             self.loadMap(self.gameState.currentMapName, self.gameState.currentMap) 
    285             self.view.teleport(self.targetPosition) 
    286             self.mapchange = False 
     294        if self.map_change: 
     295            self.loadMap(self.game_state.currentMapName, \ 
     296                         self.game_state.currentMap) 
     297            self.view.teleport(self.target_position) 
     298            self.map_change = False 
    287299 
    288300    def pump(self): 
  • trunk/game/scripts/objects/action.py

    r310 r312  
    4242 
    4343    def execute(self): 
    44         """Executes the mapchange.""" 
     44        """Executes the map change.""" 
    4545        self.engine.changeMap(self.targetmapname, self.targetmapfile, self.targetpos) 
    4646        
     
    9393    def execute(self): 
    9494        """Examine the box.""" 
    95         pc = self.engine.gameState.PC 
     95        pc = self.engine.game_state.PC 
    9696        pc.behaviour.agent.act('stand', self.npc.getLocation()) 
    9797        self.npc.talk(pc) 
  • trunk/game/scripts/world.py

    r310 r312  
    209209        """Callback sample for the context menu.""" 
    210210        self.hud.hideContainer() 
    211         self.data.gameState.PC.run(click) 
     211        self.data.game_state.PC.run(click) 
    212212 
    213213    def teleport(self, position): 
     
    223223        location = fife.Location(self.activeMap.agent_layer) 
    224224        location.setMapCoordinates(coord) 
    225         self.data.gameState.PC.teleport(location) 
     225        self.data.game_state.PC.teleport(location) 
    226226 
    227227    def mouseMoved(self, evt): 
Note: See TracChangeset for help on using the changeset viewer.