Changeset 67


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

All code now PEP-8 standard, with spaces

Location:
trunk/PARPG
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/PARPG/scripts/agents/agent.py

    r62 r67  
    2020class Agent(fife.InstanceActionListener): 
    2121    """Base class for all NPC's and the main character""" 
    22     # self.model,'PC',self.agent_layer 
    23     def __init__(self,agentName,layer): 
     22    def __init__(self, agentName, layer): 
    2423        # add this class for callbacks from fife itself 
    2524        fife.InstanceActionListener.__init__(self) 
    26         self.agentName=agentName 
    27         self.agent=layer.getInstance(agentName) 
     25        self.agentName = agentName 
     26        self.agent = layer.getInstance(agentName) 
    2827        self.agent.addActionListener(self) 
    2928 
  • trunk/PARPG/scripts/agents/hero.py

    r62 r67  
    77class Hero(Agent): 
    88    """This is the class we use for the PC character""" 
    9     def __init__(self,agentName,layer): 
    10         super(Hero, self).__init__(agentName,layer) 
    11         self.state=_STATE_NONE 
    12         self.idlecounter=1 
    13         self.speed=float(TDS.readSetting("PCSpeed")) 
     9    def __init__(self, agentName, layer): 
     10        super(Hero, self).__init__(agentName, layer) 
     11        self.state = _STATE_NONE 
     12        self.idlecounter = 1 
     13        self.speed = float(TDS.readSetting("PCSpeed")) 
    1414 
    1515    def onInstanceActionFinished(self, instance, action): 
    1616        self.idle() 
    17         if action.getId() != 'stand': 
     17        if(action.getId() != 'stand'): 
    1818            self.idlecounter = 1 
    1919        else: 
     
    2929    def run(self, location): 
    3030        self.state = _STATE_RUN 
    31         self.agent.move('run',location,self.speed) 
     31        self.agent.move('run', location, self.speed) 
    3232 
  • trunk/PARPG/utilities/gfxsplit.py

    r52 r67  
    2525 
    2626class TileImage: 
    27     def __init__(self,picture,name): 
    28         self.image=picture 
    29         self.filename=name 
     27    def __init__(self, picture, name): 
     28        self.image = picture 
     29        self.filename = name 
    3030 
    3131def writeXML(name): 
     
    3535    # TODO: this code will not work on windows 
    3636    # strip off the png part and replace with the XML 
    37     filename=name.split('/')[-1] 
    38     x_file=open(name[:-4]+".xml","wt") 
     37    filename = name.split('/')[-1] 
     38    x_file = open(name[:-4]+".xml","wt") 
    3939    x_file.write('''<?fife type="object"?>\n''') 
    4040    x_file.write('''<object id="''') 
     
    5252       Returns True if it worked""" 
    5353    # files is a list of TileImages 
    54     complete=[] 
     54    complete = [] 
    5555    for i in files: 
    5656        try: 
    57             pygame.image.save(i.image,i.filename) 
     57            pygame.image.save(i.image, i.filename) 
    5858            # output the XML file as well 
    5959            writeXML(i.filename) 
     
    6161            print "Error: Failed to save",filename 
    6262            # if we saved some anyway, then tell the user 
    63             if(complete!=[]): 
     63            if(complete != []): 
    6464                print "  Managed to save", 
    6565                for name in complete: 
     
    7171    return True 
    7272             
    73 def splitImage(image,filename): 
     73def splitImage(image, filename): 
    7474    """Quite complex this, as there are many differing layouts on the 
    7575       hexes that we could be dealing with. However, for now we assume 
    7676       that we blit from left to right, with the image x position increasing 
    7777       by one and the y value staying the same (on the grid map)""" 
    78     xpos=0 
    79     file_counter=0 
    80     tiles=[] 
    81     height=image.get_height() 
     78    xpos = 0 
     79    file_counter = 0 
     80    tiles = [] 
     81    height = image.get_height() 
    8282    while(xpos<image.get_width()): 
    8383        # create a new surface the same height as the original but 
    8484        # with a width of TILE_WIDTH, and with per-pixel alpha 
    85         new_surface=pygame.Surface((TILE_WIDTH,height),pygame.SRCALPHA,32) 
     85        new_surface = pygame.Surface((TILE_WIDTH, height),pygame.SRCALPHA,32) 
    8686        # now blit a strip of the image across 
    87         if(xpos==0): 
    88             new_surface.blit(image,(0,0),pygame.Rect(0,0,TILE_WIDTH,height)) 
     87        if(xpos == 0): 
     88            new_surface.blit(image,(0,0), 
     89                             pygame.Rect(0,0, TILE_WIDTH, height)) 
    8990            # on the first time around, move ahead by the width of a tile 
    90             xpos+=TILE_WIDTH 
     91            xpos += TILE_WIDTH 
    9192        else: 
    9293            # we need to offset into halfway through the tile on other blits 
    93             new_surface.blit(image,((TILE_WIDTH/2)-1,0), 
    94                 pygame.Rect(xpos,0,TILE_WIDTH/2,height)) 
    95             xpos+=(TILE_WIDTH/2) 
     94            new_surface.blit(image, ((TILE_WIDTH/2)-1, 0), 
     95                pygame.Rect(xpos, 0, TILE_WIDTH/2, height)) 
     96            xpos += (TILE_WIDTH/2) 
    9697        # store the image for later 
    9798        tiles.append(TileImage(new_surface, 
    98             filename+chr(ord('a')+file_counter)+".png")) 
    99         file_counter+=1 
     99            filename + chr(ord('a')+file_counter) + ".png")) 
     100        file_counter += 1 
    100101    return tiles 
    101102             
     
    114115    images=splitImage(image,filename[:-4]) 
    115116    # save it and we are done 
    116     if(images==[]): 
     117    if(images == []): 
    117118        # something funny happened 
    118119        print "Error: Couldn't splice given image file" 
     
    122123if __name__=="__main__": 
    123124    # check we have some options 
    124     if(len(sys.argv)<2): 
     125    if(len(sys.argv) < 2): 
    125126        sys.stderr.write("Error: No image given!\n") 
    126127        sys.exit(False) 
  • trunk/PARPG/utilities/transition.py

    r39 r67  
    6666 
    6767class XMLTileData: 
    68     def __init__(self,x,y,z,o,i=None): 
    69         self.x=x 
    70         self.y=y 
    71         self.z=z 
    72         self.object=o 
    73         self.ident=i 
     68    def __init__(self, x, y, z, o, i=None): 
     69        self.x = x 
     70        self.y = y 
     71        self.z = z 
     72        self.object = o 
     73        self.ident = i 
    7474 
    7575class XMLLayerData: 
    7676    """Class to store one complete layer""" 
    77     def __init__(self,x,y,name): 
    78         self.x_scale=x 
    79         self.y_scale=y 
    80         self.name=name 
    81         self.tiles=[] 
     77    def __init__(self, x, y, name): 
     78        self.x_scale = x 
     79        self.y_scale = y 
     80        self.name = name 
     81        self.tiles = [] 
    8282 
    8383class LocalXMLParser(ContentHandler): 
     
    8585       local map data""" 
    8686    def __init__(self): 
    87         self.search="map" 
    88         self.layers=[] 
    89         self.current_layer=False 
    90         self.final=[] 
     87        self.search = "map" 
     88        self.layers = [] 
     89        self.current_layer = False 
     90        self.final = [] 
    9191     
    92     def startElement(self,name,attrs): 
     92    def startElement(self, name, attrs): 
    9393        """Called every time we meet a new element""" 
    9494        # we are only looking for the 'layer' elements, the rest we ignore 
    95         if(name=="layer"): 
     95        if(name == "layer"): 
    9696            # grab the data and store that as well 
    9797            try: 
    98                 x=attrs.getValue('x_scale') 
    99                 y=attrs.getValue('y_scale') 
    100                 name=attrs.getValue('id') 
     98                x = attrs.getValue('x_scale') 
     99                y = attrs.getValue('y_scale') 
     100                name = attrs.getValue('id') 
    101101            except(KeyError): 
    102102                sys.stderr.write("Error: Layer information invalid") 
     
    105105            self.layers.append(XMLLayerData(x,y,name)) 
    106106            self.current_layer = True 
    107         elif name == "i": 
     107        elif(name == "i"): 
    108108            # have a current layer? 
    109109            if self.current_layer == False: 
     
    128128            z = float(z) 
    129129            # now we have the tile data, save it for later 
    130             self.layers[-1].tiles.append(XMLTileData(x,y,z,o,i)) 
     130            self.layers[-1].tiles.append(XMLTileData(x, y, z, o, i)) 
    131131 
    132132    def endElement(self,name): 
    133         if(name=="layer"): 
     133        if(name == "layer"): 
    134134            # end of current layer 
    135135            self.current_layer=False 
     
    145145        self.max_y = 0 
    146146 
    147     def OutputTransLayer(self,l_file,l_count): 
    148         if(len(self.render_tiles)==0): 
     147    def OutputTransLayer(self, l_file, l_count): 
     148        if(len(self.render_tiles) == 0): 
    149149            return True 
    150150        try: 
     
    175175        # check all of the tiles around the current tile 
    176176        value=0 
    177         if(self.PMatchSearch(x,y+1,search)==True): 
    178             value+=RIGHT 
    179         if(self.PMatchSearch(x-1,y+1,search)==True): 
    180             value+=BOTTOM_RIGHT 
    181         if(self.PMatchSearch(x-1,y,search)==True): 
    182             value+=BOTTOM 
    183         if(self.PMatchSearch(x-1,y-1,search)==True): 
    184             value+=BOTTOM_LEFT 
    185         if(self.PMatchSearch(x,y-1,search)==True): 
    186             value+=LEFT 
    187         if(self.PMatchSearch(x+1,y-1,search)==True): 
    188             value+=TOP_LEFT 
    189         if(self.PMatchSearch(x+1,y,search)==True): 
    190             value+=TOP 
    191         if(self.PMatchSearch(x+1,y+1,search)==True): 
    192             value+=TOP_RIGHT 
     177        if(self.PMatchSearch(x,y+1,search) == True): 
     178            value += RIGHT 
     179        if(self.PMatchSearch(x-1,y+1,search) == True): 
     180            value += BOTTOM_RIGHT 
     181        if(self.PMatchSearch(x-1,y,search) == True): 
     182            value += BOTTOM 
     183        if(self.PMatchSearch(x-1,y-1,search) == True): 
     184            value += BOTTOM_LEFT 
     185        if(self.PMatchSearch(x,y-1,search) == True): 
     186            value += LEFT 
     187        if(self.PMatchSearch(x+1,y-1,search) == True): 
     188            value += TOP_LEFT 
     189        if(self.PMatchSearch(x+1,y,search) == True): 
     190            value += TOP 
     191        if(self.PMatchSearch(x+1,y+1,search) == True): 
     192            value += TOP_RIGHT 
    193193        return value 
    194194 
    195     def GetTransitionTiles(self,search): 
     195    def GetTransitionTiles(self, search): 
    196196        """Build up and return a list of the tiles that might 
    197197           need a transition tiles layed over them""" 
    198         size=len(search) 
    199         tiles=[] 
     198        size = len(search) 
     199        tiles = [] 
    200200        for t in self.layers[0].tiles: 
    201201            # we are only interested in tiles that DON'T have what we are 
    202202            # are looking for (because they might need a transition gfx) 
    203             if t.object!=None and t.object[:size]!=search: 
     203            if(t.object != None and t.object[:size] != search): 
    204204                # whereas now we we need to check all the tiles around 
    205205                # this tile 
    206                 trans_value=self.GetSurroundings(t.x,t.y,search) 
    207                 if(trans_value!=0): 
     206                trans_value = self.GetSurroundings(t.x,t.y,search) 
     207                if(trans_value != 0): 
    208208                    # we found an actual real transition 
    209                     tiles.append([t.x,t.y,trans_value]) 
     209                    tiles.append([t.x, t.y, trans_value]) 
    210210        return tiles 
    211211 
    212     def GetTransitionName(self,base,value,corner=False): 
    213         if(corner==False): 
    214             name=base+"-ts" 
     212    def GetTransitionName(self, base, value, corner=False): 
     213        if(corner == False): 
     214            name = base+"-ts" 
    215215        else: 
    216             name=base+"-tc" 
    217         if(value<10): 
    218             name+="0" 
     216            name = base+"-tc" 
     217        if(value < 10): 
     218            name += "0" 
    219219        name+=str(value) 
    220220        return name 
    221221 
    222     def BuildTransLayer(self,search): 
     222    def BuildTransLayer(self, search): 
    223223        """Build up the data for a transition layer 
    224224           search is the string that matches the start of the name of 
    225225           each tile that we are looking for""" 
    226         transition_tiles=self.GetTransitionTiles(search)        
     226        transition_tiles = self.GetTransitionTiles(search)        
    227227        # now we have all the possible tiles, lets see what they 
    228228        # actually need to have rendered 
    229229        for t in transition_tiles: 
    230230            # first we calculate the side tiles: 
    231             sides=(t[2]&15) 
    232             if(sides!=0): 
     231            sides = (t[2]&15) 
     232            if(sides != 0): 
    233233                # there are some side tiles to be drawn. Now we just 
    234234                # need to see if there are any corners to be done 
    235                 corners=(t[2]&240)&(CORNER_LOOKUP[sides-1])                     
    236                 if(corners!=0): 
     235                corners = (t[2]&240)&(CORNER_LOOKUP[sides-1])                     
     236                if(corners != 0): 
    237237                    # we must add a corner piece as well 
    238                     corners=corners/16 
    239                     name=self.GetTransitionName(search,corners,True) 
    240                     self.ttiles.append(XMLTileData(t[0],t[1],0,name)) 
     238                    corners = corners/16 
     239                    name = self.GetTransitionName(search, corners, True) 
     240                    self.ttiles.append(XMLTileData(t[0], t[1], 0, name)) 
    241241                # add the side tile pieces 
    242                 name=self.GetTransitionName(search,sides,False) 
    243                 self.ttiles.append(XMLTileData(t[0],t[1],0,name)) 
     242                name = self.GetTransitionName(search, sides, False) 
     243                self.ttiles.append(XMLTileData(t[0], t[1], 0, name)) 
    244244            else: 
    245245                # there are no side tiles, so let's just look at 
    246246                # the corners (quite easy): 
    247                 corners=(t[2]&240)/16 
    248                 if(corners!=0): 
     247                corners = (t[2]&240)/16 
     248                if(corners != 0): 
    249249                    # there is a corner piece needed 
    250                     name=self.GetTransitionName(search,corners,True) 
    251                     self.ttiles.append(XMLTileData(t[0],t[1],0,name)) 
    252  
    253     def LoadFromXML(self,filename): 
     250                    name = self.GetTransitionName(search, corners, True) 
     251                    self.ttiles.append(XMLTileData(t[0], t[1], 0, name)) 
     252 
     253    def LoadFromXML(self, filename): 
    254254        """Load a map from the XML file used in Fife 
    255255           Returns True if it worked, False otherwise""" 
    256256        try: 
    257             map_file=open(filename,'rt') 
     257            map_file = open(filename,'rt') 
    258258        except(IOError): 
    259259            sys.stderr.write("Error: No map given!\n") 
    260260            return(False) 
    261261        # now open and read the XML file 
    262         parser=make_parser() 
    263         curHandler=LocalXMLParser() 
     262        parser = make_parser() 
     263        curHandler = LocalXMLParser() 
    264264        parser.setContentHandler(curHandler) 
    265265        parser.parse(map_file) 
    266266        map_file.close() 
    267267        # make a copy of the layer data 
    268         self.layers=curHandler.layers 
     268        self.layers = curHandler.layers 
    269269        return True 
    270270     
     
    281281                self.min_y = t.y 
    282282     
    283     def CheckRange(self,x,y): 
     283    def CheckRange(self, x, y): 
    284284        """Grid co-ords in range?""" 
    285         if((x<self.min_x)or(x>self.max_x)or 
    286            (y<self.min_y)or(y>self.max_y)): 
     285        if((x < self.min_x)or(x > self.max_x)or 
     286           (y < self.min_y)or(y > self.max_y)): 
    287287           return False 
    288288        return True 
    289289 
    290     def PMatchSearch(self,x,y,search): 
     290    def PMatchSearch(self, x, y, search): 
    291291        """Brute force method used for matching grid""" 
    292292        # is the tile even in range? 
    293         if(self.CheckRange(x,y)==False): 
     293        if(self.CheckRange(x,y) == False): 
    294294            return False 
    295         size=len(search) 
     295        size = len(search) 
    296296        for t in self.layers[0].tiles: 
    297             if((t.x==x)and(t.y==y)and(t.object[:size]==search)): 
     297            if((t.x == x)and(t.y == y)and(t.object[:size] == search)): 
    298298                return(True) 
    299299        # no match 
    300300        return False 
    301301 
    302     def CoordsMatch(self,x,y,tiles): 
     302    def CoordsMatch(self, x, y, tiles): 
    303303        """Helper routine to check wether the list of tiles 
    304304           in tiles has any contain the coords x,y""" 
    305305        for t in tiles: 
    306             if((t.x==x)and(t.y==y)): 
     306            if((t.x == x)and(t.y == y)): 
    307307                return True 
    308308        # obviously no match 
    309309        return False 
    310310 
    311     def SaveMap(self,filename): 
     311    def SaveMap(self, filename): 
    312312        """Save the new map""" 
    313313        # open the new files for writing 
    314314        try: 
    315             map_file=open(filename,'wt') 
     315            map_file = open(filename, 'wt') 
    316316        except(IOError): 
    317317            sys.stderr.write("Error: Couldn't save map\n") 
     
    320320        # this is a brute force solution but it does work, and speed 
    321321        # is not required in this utility 
    322         layer_count=0 
    323         while(self.ttiles!=[]): 
    324             recycled_tiles=[] 
    325             self.render_tiles=[] 
     322        layer_count = 0 
     323        while(self.ttiles != []): 
     324            recycled_tiles = [] 
     325            self.render_tiles = [] 
    326326            for t in self.ttiles: 
    327                 if(self.CoordsMatch(t.x,t.y,self.render_tiles)==False): 
     327                if(self.CoordsMatch(t.x, t.y, self.render_tiles) == False): 
    328328                    # no matching tile in the grid so far, so add it 
    329329                    self.render_tiles.append(t) 
     
    332332                    recycled_tiles.append(t) 
    333333            # render this layer 
    334             if(self.OutputTransLayer(map_file,layer_count)==False): 
     334            if(self.OutputTransLayer(map_file,layer_count) == False): 
    335335                return False 
    336             layer_count+=1 
     336            layer_count += 1 
    337337            self.ttiles=recycled_tiles 
    338338        # phew, that was it 
     
    349349        for l in self.layers: 
    350350            print l.name, 
    351         print "\nMap Dimensions: X=",(self.max_x-self.min_x)+1, 
    352         print " Y=",(self.max_y-self.min_y)+1 
     351        print "\nMap Dimensions: X=",(self.max_x-self.min_x) + 1, 
     352        print " Y=",(self.max_y-self.min_y) + 1 
    353353 
    354354if __name__=="__main__": 
    355355    # pass a map name as the first argument 
    356     if(len(sys.argv)<2): 
     356    if(len(sys.argv) < 2): 
    357357        sys.stderr.write("Error: No map given!\n") 
    358358        sys.exit(False) 
    359359    new_map=LocalMap() 
    360     if(new_map.LoadFromXML(sys.argv[1])==True): 
     360    if(new_map.LoadFromXML(sys.argv[1]) == True): 
    361361        new_map.GetSize() 
    362362        new_map.BuildTransLayer("grass") 
Note: See TracChangeset for help on using the changeset viewer.