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

All code now PEP-8 standard, with spaces

File:
1 edited

Legend:

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