Changeset 312 for trunk/game/scripts


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/scripts
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • 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.