Changeset 66


Ignore:
Timestamp:
05/13/09 02:20:25 (11 years ago)
Author:
maximinus_parpg
Message:

OK, you win Bretzel...
Lots of small annoying PEP 8 standards correction.

Location:
trunk/PARPG
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/PARPG/run.py

    r62 r66  
    3636 
    3737class ApplicationListener(eventlistenerbase.EventListenerBase): 
    38     def __init__(self,engine,world): 
     38    def __init__(self, engine, world): 
    3939        super(ApplicationListener, self).__init__(engine, 
    4040                                                  regKeys=True,regCmd=True, 
     
    4242                                                  regConsole=True, 
    4343                                                  regWidget=True) 
    44         self.engine=engine 
    45         self.world=world 
     44        self.engine = engine 
     45        self.world = world 
    4646        engine.getEventManager().setNonConsumableKeys([fife.Key.ESCAPE,]) 
    47         self.quit=False 
    48         self.aboutWindow=None 
     47        self.quit = False 
     48        self.aboutWindow = None 
    4949 
    5050    def quitGame(self): 
    5151        """Forces a quit game on next cycle""" 
    52         self.quit=True 
     52        self.quit = True 
    5353 
    54     def onCommand(self,command): 
     54    def onCommand(self, command): 
    5555        """Enables the game to be closed via the 'X' button on the window frame""" 
    56         if(command.getCommandType()==fife.CMD_QUIT_GAME): 
    57             self.quit=True 
     56        if(command.getCommandType() == fife.CMD_QUIT_GAME): 
     57            self.quit = True 
    5858            command.consume() 
    5959 
     
    6565    def __init__(self): 
    6666        super(PARPG,self).__init__() 
    67         self.world=world.World(self.engine) 
    68         self.model=engine.Engine(self.world) 
    69         self.listener=ApplicationListener(self.engine,self.world) 
    70         self.world.quitFunction=self.listener.quitGame 
     67        self.world = world.World(self.engine) 
     68        self.model = engine.Engine(self.world) 
     69        self.listener = ApplicationListener(self.engine,self.world) 
     70        self.world.quitFunction = self.listener.quitGame 
    7171        self.model.loadMap(str(TDS.readSetting("MapFile")))    
    7272 
     
    7575           Called in the ApplicationBase constructor.""" 
    7676        import settings 
    77         self.settings=settings 
     77        self.settings = settings 
    7878        eSet=self.engine.getSettings() 
    79         eSet.setDefaultFontGlyphs(str(TDS.readSetting("FontGlyphs",strip=False))) 
     79        eSet.setDefaultFontGlyphs(str(TDS.readSetting("FontGlyphs", 
     80                                                      strip=False))) 
    8081        eSet.setDefaultFontPath(str(TDS.readSetting("Font"))) 
    8182        eSet.setBitsPerPixel(int(TDS.readSetting("BitsPerPixel"))) 
     
    9899    def initLogging(self): 
    99100        """Initialize the LogManager""" 
    100         LogModules=TDS.readSetting("LogModules",type='list') 
    101         self.log=fifelog.LogManager(self.engine, 
     101        LogModules = TDS.readSetting("LogModules",type='list') 
     102        self.log = fifelog.LogManager(self.engine, 
    102103                                      int(TDS.readSetting("LogToPrompt")), 
    103104                                      int(TDS.readSetting("LogToFile"))) 
     
    107108    def createListener(self): 
    108109        # already created in constructor 
     110        # but if we don't put here, Fife gets bitchy :-) 
    109111        pass 
    110112 
     
    119121def main(): 
    120122    """Application code starts from here""" 
    121     app=PARPG() 
     123    app = PARPG() 
    122124    app.run() 
    123125 
  • trunk/PARPG/scripts/engine.py

    r62 r66  
    3737       local objects data""" 
    3838    def __init__(self): 
    39         self.search="objects" 
    40         self.pc=None 
    41         self.objects=[] 
    42         self.npcs=[] 
     39        self.search = "objects" 
     40        self.pc = None 
     41        self.objects = [] 
     42        self.npcs = [] 
    4343     
    44     def startElement(self,name,attrs): 
     44    def startElement(self, name, attrs): 
    4545        """Called every time we meet a new element in the XML file""" 
    4646        # we are only looking for the 'layer' elements, the rest we ignore 
    47         if(name=="PC"): 
     47        if(name == "PC"): 
    4848            # already have a PC? 
    49             if(self.pc!=None): 
     49            if(self.pc != None): 
    5050                sys.stderr.write("Error: 2 PC characters defined") 
    5151                sys.exit(False) 
    5252            # grab the data and store that as well 
    5353            try: 
    54                 xpos=attrs.getValue("xpos") 
    55                 ypos=attrs.getValue("ypos") 
     54                xpos = attrs.getValue("xpos") 
     55                ypos = attrs.getValue("ypos") 
    5656            except(KeyError): 
    5757                sys.stderr.write("Error: Data missing in PC definition") 
     
    5959            # store for later 
    6060            self.pc=[xpos,ypos] 
    61         elif(name=="NPC"): 
     61        elif(name == "NPC"): 
    6262            # let's parse and add the data 
    6363            try: 
    6464                xpos=attrs.getValue("xpos") 
    65                 ypos=attrs.getValue("ypos") 
    66                 gfx=attrs.getValue("gfx") 
     65                ypos = attrs.getValue("ypos") 
     66                gfx = attrs.getValue("gfx") 
    6767            except(KeyError): 
    6868                sys.stderr.write("Error: Data missing in NPC definition\n") 
     
    7070            # now we have the data, save it for later 
    7171            self.npcs.append([xpos,ypos,gfx]) 
    72         elif(name=="object"): 
     72        elif(name == "object"): 
    7373            # same old same old 
    7474            try: 
    75                 xpos=attrs.getValue("xpos") 
    76                 ypos=attrs.getValue("ypos") 
    77                 gfx=attrs.getValue("gfx") 
     75                xpos = attrs.getValue("xpos") 
     76                ypos = attrs.getValue("ypos") 
     77                gfx = attrs.getValue("gfx") 
    7878            except(KeyError): 
    7979                sys.stderr.write("Error: Data missing in object definition\n") 
    8080                sys.exit(False) 
    8181            # now we have the data, save it for later 
    82             self.objects.append([xpos,ypos,gfx]) 
     82            self.objects.append([xpos, ypos, gfx]) 
    8383 
    8484class Engine: 
     
    8888       the fife view here. This also prevents us from just having a 
    8989       function heavy controller""" 
    90     def __init__(self,view): 
    91         self.view=view 
    92         self.PC=None 
    93         self.npcs=[] 
    94         self.objects=[] 
     90    def __init__(self, view): 
     91        self.view = view 
     92        self.PC = None 
     93        self.npcs = [] 
     94        self.objects = [] 
    9595 
    96     def loadObjects(self,filename): 
     96    def loadObjects(self, filename): 
    9797        """Load objects from the XML file 
    9898           Returns True if it worked, False otherwise""" 
    9999        try: 
    100             objects_file=open(filename,'rt') 
     100            objects_file = open(filename, 'rt') 
    101101        except(IOError): 
    102102            sys.stderr.write("Error: Can't find objects file\n") 
    103103            return False 
    104104        # now open and read the XML file 
    105         parser=make_parser() 
    106         cur_handler=LocalXMLParser() 
     105        parser = make_parser() 
     106        cur_handler = LocalXMLParser() 
    107107        parser.setContentHandler(cur_handler) 
    108108        parser.parse(objects_file) 
    109109        objects_file.close() 
    110110        # must have at least 1 PC 
    111         if(cur_handler.pc==None): 
     111        if(cur_handler.pc == None): 
    112112            sys.stderr.write("Error: No PC defined\n") 
    113113            sys.exit(False) 
     
    120120    def addPC(self,pc): 
    121121        """Add the PC to the world""" 
    122         self.view.addObject(float(pc[0]),float(pc[1]),"PC") 
    123         self.PC=Hero("PC",self.view.agent_layer) 
     122        self.view.addObject(float(pc[0]), float(pc[1]),"PC") 
     123        self.PC = Hero("PC", self.view.agent_layer) 
    124124        # ensure the PC starts on a default action 
    125125        self.PC.start() 
     
    131131           An NPC is just an object to FIFE""" 
    132132        for i in objects: 
    133             self.view.addObject(float(i[0]),float(i[1]),i[2]) 
     133            self.view.addObject(float(i[0]), float(i[1]), i[2]) 
    134134 
    135135    def addNPCs(self,npcs): 
     
    137137           and into this class""" 
    138138        for i in npcs: 
    139             self.view.addObject(float(i[0]),float(i[1]),i[2]) 
     139            self.view.addObject(float(i[0]), float(i[1]),i[2]) 
    140140 
    141141    def loadMap(self,map_file): 
  • trunk/PARPG/scripts/inventory.py

    r65 r66  
    1111    """Main inventory class""" 
    1212    def __init__(self, engine): 
    13         pychan.init(engine,debug=True) 
     13        pychan.init(engine, debug = True) 
    1414        self.engine = engine 
    1515        self.dragging = False 
     
    3737                        'RightHeld':'held', 'Body':'body'} 
    3838        # all possible categories 
    39         self.locations = ['ready','head','foot','hand','belt','held','body'] 
     39        self.locations = ['ready', 'head', 'foot', 'hand', 
     40                          'belt', 'held', 'body'] 
    4041        for button in self.buttons: 
    4142            # make every button's callback be self.dragDrop 
    4243            events_to_map[button] = cbwa(self.dragDrop, button) 
    43             ch=self.inventory.findChild(name=button) 
     44            ch=self.inventory.findChild(name = button) 
    4445            # make every slot's item be empty 
    45             ch.item="" 
    46             self.empty_images[button]=ch._getUpImage() 
     46            ch.item = "" 
     47            self.empty_images[button] = ch._getUpImage() 
    4748        self.inventory.mapEvents(events_to_map)    
    4849        self.resetMouseCursor() 
     
    6263           TODO: should be taken out on release (WHY?)""" 
    6364        for image in self.empty_images: 
    64             child=self.inventory.findChild(name=image) 
    65             original_image=self.empty_images[image] 
     65            child = self.inventory.findChild(name = image) 
     66            original_image = self.empty_images[image] 
    6667            child._setUpImage(original_image) 
    6768            child._setDownImage(original_image) 
    6869            child._setHoverImage(original_image) 
    6970 
    70     def setMouseCursor(self,image,dummy_image,type="native"):  
     71    def setMouseCursor(self, image, dummy_image, type = "native"):  
    7172        """Set the mouse cursor to an image""" 
    72         cursor=self.engine.getCursor() 
    73         cursor_type=fife.CURSOR_IMAGE 
    74         img_pool=self.engine.getImagePool() 
    75         if(type=="target"): 
    76             target_cursor_id=img_pool.addResourceFromFile(image)   
    77             dummy_cursor_id=img_pool.addResourceFromFile(dummy_image) 
     73        cursor = self.engine.getCursor() 
     74        cursor_type = fife.CURSOR_IMAGE 
     75        img_pool = self.engine.getImagePool() 
     76        if(type == "target"): 
     77            target_cursor_id = img_pool.addResourceFromFile(image)   
     78            dummy_cursor_id = img_pool.addResourceFromFile(dummy_image) 
    7879            cursor.set(cursor_type,target_dummy_cursor_id) 
    7980            cursor.setDrag(cursor_type,target_cursor_id,-16,-16) 
    8081        else: 
    81             cursor_type=fife.CURSOR_IMAGE 
    82             zero_cursor_id=img_pool.addResourceFromFile(image) 
     82            cursor_type = fife.CURSOR_IMAGE 
     83            zero_cursor_id = img_pool.addResourceFromFile(image) 
    8384            cursor.set(cursor_type,zero_cursor_id) 
    8485            cursor.setDrag(cursor_type,zero_cursor_id) 
     
    8687    def resetMouseCursor(self): 
    8788        """Reset cursor to default image""" 
    88         c=self.engine.getCursor() 
    89         img_pool=self.engine.getImagePool() 
    90         cursor_type=fife.CURSOR_IMAGE 
     89        c = self.engine.getCursor() 
     90        img_pool = self.engine.getImagePool() 
     91        cursor_type = fife.CURSOR_IMAGE 
    9192        # this is the path to the default image 
    92         cursor_id=img_pool.addResourceFromFile("gui/inv_images/cursor.png") 
     93        cursor_id = img_pool.addResourceFromFile("gui/inv_images/cursor.png") 
    9394        c.setDrag(cursor_type,cursor_id) 
    9495        c.set(cursor_type,cursor_id) 
    9596         
    9697    # decide whether to drag or drop the image 
    97     def dragDrop(self,obj): 
    98         if(self.dragging==True): 
     98    def dragDrop(self, obj): 
     99        if(self.dragging == True): 
    99100            self.dropObject(obj) 
    100         elif(self.dragging==False): 
     101        elif(self.dragging == False): 
    101102            self.dragObject(obj) 
    102103                 
    103104    # drag the selected object 
    104     def dragObject(self,obj): 
    105         drag_widget=self.inventory.findChild(name=obj) 
    106         self.dragged_type=self.buttons[obj] 
    107         self.dragged_item=drag_widget.item 
    108         up_image=drag_widget._getUpImage() 
    109         down_image=drag_widget._getDownImage() 
     105    def dragObject(self, obj): 
     106        drag_widget = self.inventory.findChild(name = obj) 
     107        self.dragged_type = self.buttons[obj] 
     108        self.dragged_item = drag_widget.item 
     109        up_image = drag_widget._getUpImage() 
     110        down_image = drag_widget._getDownImage() 
    110111        self.setMouseCursor(up_image,down_image) 
    111         self.dragged_image=up_image 
    112         self.dragging=True 
     112        self.dragged_image = up_image 
     113        self.dragging = True 
    113114         
    114     def dropObject(self,obj): 
     115    def dropObject(self, obj): 
    115116        """Drops the object being dropped""" 
    116         self.dropped_type = self.buttons[obj] 
    117         if((self.dragged_type=='main_inv') or 
    118            (self.dropped_type=='main_inv')): 
    119             drag_widget = self.inventory.findChild(name=obj) 
     117        self.dropped_type  = self.buttons[obj] 
     118        if((self.dragged_type == 'main_inv') or 
     119           (self.dropped_type == 'main_inv')): 
     120            drag_widget = self.inventory.findChild(name = obj) 
    120121            drag_widget._setUpImage(self.dragged_image) 
    121122            drag_widget._setHoverImage(self.dragged_image) 
     
    124125            self.dragging = False 
    125126            self.resetMouseCursor() 
    126         elif((self.dragged_type==self.dropped_type) and 
     127        elif((self.dragged_type == self.dropped_type) and 
    127128             (self.dragged_type in self.locations)): 
    128             drag_widget = self.inventory.findChild(name=obj) 
     129            drag_widget = self.inventory.findChild(name = obj) 
    129130            drag_widget._setUpImage(self.dragged_image) 
    130131            drag_widget._setHoverImage(self.dragged_image) 
    131132            drag_widget._setDownImage(self.dragged_image) 
    132133            drag_widget.item = self.dragged_item 
    133             self.dragging=False 
     134            self.dragging = False 
    134135            self.resetMouseCursor() 
    135136        else: 
    136137            self.resetMouseCursor() 
    137             self.dragging=False 
     138            self.dragging = False 
  • trunk/PARPG/scripts/world.py

    r65 r66  
    5151 
    5252class Map: 
    53     def __init__(self,fife_map): 
    54         self.listener=MapListener 
    55         self.map=fife_map 
     53    def __init__(self, fife_map): 
     54        self.listener = MapListener 
     55        self.map = fife_map 
    5656 
    5757class World(EventListenerBase): 
     
    5959       The engine keeps a copy of this class""" 
    6060    def __init__(self, engine): 
    61         super(World, self).__init__(engine, regMouse=True, regKeys=True) 
    62         self.engine=engine 
    63         self.eventmanager=engine.getEventManager() 
    64         self.model=engine.getModel() 
    65         self.view=self.engine.getView() 
    66         self.quitFunction=None 
     61        super(World, self).__init__(engine, regMouse = True, regKeys = True) 
     62        self.engine = engine 
     63        self.eventmanager = engine.getEventManager() 
     64        self.model = engine.getModel() 
     65        self.view = self.engine.getView() 
     66        self.quitFunction = None 
    6767        self.inventoryShown = False 
    6868        self.firstInventory = True 
    69         self.mouseCallback=None 
     69        self.mouseCallback = None 
    7070 
    7171    def reset(self): 
    7272        """Rest the map to default settings""" 
    73         self.transitions=[] 
    74         self.PC=None 
    75         self.npcs=[] 
    76         self.map,self.agent_layer=None,None 
    77         self.cameras={} 
    78         self.PC=None 
    79         self.npcs=[] 
    80         self.cur_cam2_x,self.initial_cam2_x,self.cam2_scrolling_right=0,0,True 
    81         self.target_rotation=0 
     73        self.transitions = [] 
     74        self.PC = None 
     75        self.npcs = [] 
     76        self.map,self.agent_layer = None,None 
     77        self.cameras = {} 
     78        self.PC = None 
     79        self.npcs = [] 
     80        self.cur_cam2_x,self.initial_cam2_x,self.cam2_scrolling_right = 0,0,True 
     81        self.target_rotation = 0 
    8282 
    83     def load(self,filename): 
     83    def load(self, filename): 
    8484        """Load a map given the filename 
    8585           TODO: a map should only contain static items and floor tiles 
     
    8787           is subject to change""" 
    8888        self.reset() 
    89         self.map=loadMapFile(filename,self.engine) 
    90         self.maplistener=MapListener(self.map) 
     89        self.map = loadMapFile(filename, self.engine) 
     90        self.maplistener = MapListener(self.map) 
    9191 
    9292        # there must be a PC object on the objects layer! 
    93         self.agent_layer=self.map.getLayer('ObjectLayer') 
     93        self.agent_layer = self.map.getLayer('ObjectLayer') 
    9494        # it's possible there's no transition layer 
    95         size=len('TransitionLayer') 
     95        size = len('TransitionLayer') 
    9696        for layer in self.map.getLayers(): 
    9797            # could be many layers, but hopefully no more than 3 
    98             if(layer.getId()[:size]=='TransitionLayer'): 
     98            if(layer.getId()[:size] == 'TransitionLayer'): 
    9999                self.transitions.append(self.map.getLayer(layer.getId())) 
    100100 
     
    104104        self.view.resetRenderers() 
    105105        self.target_rotation = self.cameras['main'].getRotation() 
    106         self.cord_render=self.cameras['main'].getRenderer('CoordinateRenderer') 
     106        self.cord_render = self.cameras['main'].getRenderer('CoordinateRenderer') 
    107107 
    108     def addPC(self,agent): 
     108    def addPC(self, agent): 
    109109        """Add the player character to the map""" 
    110110        # actually this is real easy, we just have to 
     
    112112        self.cameras['main'].attach(agent) 
    113113     
    114     def addObject(self,xpos,ypos,name): 
     114    def addObject(self, xpos, ypos, name): 
    115115        """Add an object or an NPC to the map 
    116116           It makes no difference to fife which is which""" 
    117         obj=self.agent_layer.createInstance( 
    118                 self.model.getObject(str(name),"PARPG"), 
    119                 fife.ExactModelCoordinate(xpos,ypos,0.0),str(name)) 
     117        obj = self.agent_layer.createInstance( 
     118                self.model.getObject(str(name), "PARPG"), 
     119                fife.ExactModelCoordinate(xpos,ypos,0.0), str(name)) 
    120120        obj.setRotation(0) 
    121121        fife.InstanceVisual.create(obj) 
     
    124124    def keyPressed(self, evt): 
    125125        """When a key is depressed, fife calls this routine.""" 
    126         key=evt.getKey() 
     126        key = evt.getKey() 
    127127        keyval = key.getValue() 
    128128 
    129         if(keyval==key.Q): 
     129        if(keyval == key.Q): 
    130130            # we need to quit the game 
    131131            self.quitGame() 
    132         if(keyval==key.T): 
     132        if(keyval == key.T): 
    133133            self.toggle_renderer('GridRenderer') 
    134         if(keyval==key.F1): 
     134        if(keyval == key.F1): 
    135135            # display the help screen and pause the game 
    136136            self.displayHelp() 
    137         if(keyval==key.F5): 
     137        if(keyval == key.F5): 
    138138            # logic would say we use similar code to above and toggle 
    139139            # logic here does not work, my friend :-( 
    140140            self.cord_render.setEnabled(not self.cord_render.isEnabled()) 
    141         if(keyval==key.F7): 
     141        if(keyval == key.F7): 
    142142            # F7 saves a screenshot to fife/clients/parpg/screenshots 
    143143            # TODO: add a time stamp as well as a date stamp 
    144             t="screenshots/screen-%s.png" % date.today().strftime('%Y-%m-%d') 
     144            t = "screenshots/screen-%s.png" % date.today().strftime('%Y-%m-%d') 
    145145            self.engine.getRenderBackend().captureScreen(t) 
    146         if(keyval==key.I): 
     146        if(keyval == key.I): 
    147147            # show the inventory 
    148             if(self.firstInventory==True): 
    149                 self.inventory=inventory.Inventory(self.engine) 
    150                 self.firstInventory=False 
    151                 self.inventoryShown=True 
     148            if(self.firstInventory == True): 
     149                self.inventory = inventory.Inventory(self.engine) 
     150                self.firstInventory = False 
     151                self.inventoryShown = True 
    152152            # logically firstInventory is false here 
    153             elif(self.inventoryShown==True): 
     153            elif(self.inventoryShown == True): 
    154154                self.inventory.closeInventory() 
    155                 self.inventoryShown=False 
     155                self.inventoryShown = False 
    156156            # and here inventoryShown must be false 
    157157            else: 
    158158                self.inventory.showInventory() 
    159                 self.inventoryShown=True 
     159                self.inventoryShown = True 
    160160 
    161161    def mousePressed(self, evt): 
     
    164164           the map""" 
    165165        clickpoint = fife.ScreenPoint(evt.getX(), evt.getY()) 
    166         if (evt.getButton()==fife.MouseEvent.LEFT): 
    167             target_mapcoord=self.cameras['main'].toMapCoordinates(clickpoint, 
    168                                                                   False) 
     166        if (evt.getButton() == fife.MouseEvent.LEFT): 
     167            target_mapcoord = self.cameras['main'].toMapCoordinates(clickpoint, 
     168                                                                    False) 
    169169            target_mapcoord.z = 0 
    170             l=fife.Location(self.agent_layer) 
     170            l = fife.Location(self.agent_layer) 
    171171            l.setMapCoordinates(target_mapcoord) 
    172172            self.mouseCallback(l) 
    173173             
    174     def toggle_renderer (self,r_name): 
     174    def toggle_renderer (self, r_name): 
    175175        """Enable or disable the renderer named `r_name`""" 
    176176        renderer = self.cameras['main'].getRenderer('GridRenderer') 
     
    184184        """Called when user requests to quit game 
    185185           Just calls the ApplicationListener to do the quit""" 
    186         if(self.quitFunction!=None): 
     186        if(self.quitFunction != None): 
    187187            self.quitFunction() 
    188188 
Note: See TracChangeset for help on using the changeset viewer.