Changeset 328 for trunk


Ignore:
Timestamp:
10/17/09 02:05:35 (10 years ago)
Author:
Kaydeth_parpg
Message:

Ticket #2: Patch by Kaydeth. Updated the classes in local_loaders and utilities directories to correct some obvious discrepancies with our coding standard. comment[s:trac, t:2] fixes[s:trac, t:2]

Location:
trunk/game
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/local_loaders/loaders.py

    r317 r328  
    2727 
    2828def loadMapFile(path, engine, data, callback=None): 
    29     """     load map file and get (an optional) callback if major stuff is done: 
     29    """     load map file and get (an optional) callback if major stuff  
     30            is done: 
    3031    - map creation 
    3132    - parsed impor0ts 
     
    4849 
    4950def loadImportFile(path, engine): 
    50     object_loader = XMLObjectLoader(engine.getImagePool(), engine.getAnimationPool(), engine.getModel(), engine.getVFS()) 
     51    object_loader = XMLObjectLoader(engine.getImagePool(), \ 
     52                                    engine.getAnimationPool(), \ 
     53                                    engine.getModel(), engine.getVFS()) 
    5154    res = None 
    5255    try: 
  • trunk/game/local_loaders/xmlmap.py

    r325 r328  
    5959        self.time_to_load = 0 
    6060 
    61         self.nspace = None 
     61        self.n_space = None 
    6262 
    6363    def _err(self, msg): 
     
    7878    def parseMap(self, map_elt): 
    7979        if not map_elt: 
    80             self._err('No <map> element found at top level of map file definition.') 
     80            self._err(\ 
     81                'No <map> element found at top level of map file definition.') 
    8182        id,format = map_elt.get('id'),map_elt.get('format') 
    8283 
    83         if not format == FORMAT: self._err(''.join(['This file has format ', format, ' but this loader has format ', FORMAT])) 
     84        if not format == FORMAT: self._err(''.join(['This file has format ', \ 
     85                                            format, \ 
     86                                            ' but this loader has format ', \ 
     87                                            FORMAT])) 
    8488        if not id: self._err('Map declared without an identifier.') 
    8589 
     
    8892            self.map = self.model.createMap(str(id)) 
    8993            self.map.setResourceFile(self.source) 
    90         except fife.Exception, e: # NameClash appears as general fife.Exception; any ideas? 
     94        # NameClash appears as general fife.Exception; any ideas? 
     95        except fife.Exception, e:  
    9196            print e.getMessage() 
    92             print ''.join(['File: ', self.source, '. The map ', str(id), ' already exists! Ignoring map definition.']) 
     97            print ''.join(['File: ', self.source, '. The map ', str(id), \ 
     98                           ' already exists! Ignoring map definition.']) 
    9399            return None 
    94100 
     
    111117 
    112118        if self.callback:         
    113             tmplist = map_elt.findall('import') 
     119            tmp_list = map_elt.findall('import') 
    114120            i = float(0) 
    115121         
     
    140146            if self.callback: 
    141147                i += 1                 
    142                 self.callback('loaded imports', float( i / float(len(tmplist)) * 0.25 + 0.25 ) ) 
     148                self.callback('loaded imports', \ 
     149                              float( i / float(len(tmp_list)) * 0.25 + 0.25 )) 
    143150 
    144151 
    145152    def parseLayers(self, map_elt, map): 
    146153        if self.callback is not None:         
    147             tmplist = map_elt.findall('layer') 
     154            tmp_list = map_elt.findall('layer') 
    148155            i = float(0) 
    149156 
     
    157164            y_offset = layer.get('y_offset') 
    158165            pathing = layer.get('pathing') 
    159             transparency = layer.get('transparency') 
     166            transparency = layer.get('transparency') 
    160167 
    161168            if not x_scale: x_scale = 1.0 
     
    172179 
    173180            if not id: self._err('<layer> declared with no id attribute.') 
    174             if not grid_type: self._err(''.join(['Layer ', str(id), ' has no grid_type attribute.'])) 
     181            if not grid_type: self._err(''.join(['Layer ', str(id), \ 
     182                                            ' has no grid_type attribute.'])) 
    175183 
    176184            allow_diagonals = pathing == "cell_edges_and_diagonals" 
    177             cellgrid = self.model.getCellGrid(grid_type) 
    178             if not cellgrid: self._err('<layer> declared with invalid cellgrid type. (%s)' % grid_type) 
    179  
    180             cellgrid.setRotation(float(rotation)) 
    181             cellgrid.setXScale(float(x_scale)) 
    182             cellgrid.setYScale(float(y_scale)) 
    183             cellgrid.setXShift(float(x_offset)) 
    184             cellgrid.setYShift(float(y_offset)) 
     185            cell_grid = self.model.getCellGrid(grid_type) 
     186            if not cell_grid: self._err('<layer> declared with invalid '\ 
     187                                       'cell grid type. (%s)' % grid_type) 
     188 
     189            cell_grid.setRotation(float(rotation)) 
     190            cell_grid.setXScale(float(x_scale)) 
     191            cell_grid.setYScale(float(y_scale)) 
     192            cell_grid.setXShift(float(x_offset)) 
     193            cell_grid.setYShift(float(y_offset)) 
    185194 
    186195            layer_obj = None 
    187196            try: 
    188                 layer_obj = map.createLayer(str(id), cellgrid) 
     197                layer_obj = map.createLayer(str(id), cell_grid) 
    189198            except fife.Exception, e: 
    190199                print e.getMessage() 
    191                 print 'The layer ' + str(id) + ' already exists! Ignoring this layer.' 
     200                print 'The layer ' + str(id) + \ 
     201                        ' already exists! Ignoring this layer.' 
    192202                continue 
    193203 
     
    205215            if self.callback is not None: 
    206216                i += 1 
    207                 self.callback('loaded layer :' + str(id), float( i / float(len(tmplist)) * 0.25 + 0.5 ) ) 
     217                self.callback('loaded layer :' + \ 
     218                              str(id), float( i / float(len(tmp_list)) * \ 
     219                                              0.25 + 0.5 ) ) 
    208220 
    209221        # cleanup 
    210222        if self.callback is not None: 
    211             del tmplist 
     223            del tmp_list 
    212224            del i 
    213225 
    214     def parseInstances(self, layerelt, layer): 
    215         instelt = layerelt.find('instances') 
    216  
    217         instances = instelt.findall('i') 
    218         instances.extend(instelt.findall('inst')) 
    219         instances.extend(instelt.findall('instance')) 
     226    def parseInstances(self, layer_elt, layer): 
     227        inst_elt = layer_elt.find('instances') 
     228 
     229        instances = inst_elt.findall('i') 
     230        instances.extend(inst_elt.findall('inst')) 
     231        instances.extend(inst_elt.findall('instance')) 
    220232        for instance in instances: 
    221233 
    222             objectID = instance.get('object') 
    223             if not objectID: 
    224                 objectID = instance.get('obj') 
    225             if not objectID: 
    226                 objectID = instance.get('o') 
    227  
    228             if not objectID: self._err('<instance> does not specify an object attribute.') 
    229  
    230             nspace = instance.get('namespace') 
    231             if not nspace: 
    232                 nspace = instance.get('ns') 
    233             if not nspace: 
    234                 nspace = self.nspace 
    235  
    236             if not nspace: self._err('<instance> %s does not specify an object namespace, and no default is available.' % str(objectID)) 
    237  
    238             self.nspace = nspace 
    239  
    240             object = self.model.getObject(str(objectID), str(nspace)) 
     234            object_id = instance.get('object') 
     235            if not object_id: 
     236                object_id = instance.get('obj') 
     237            if not object_id: 
     238                object_id = instance.get('o') 
     239 
     240            if not object_id: self._err('<instance> does not specify an '\ 
     241                                        'object attribute.') 
     242 
     243            n_space = instance.get('namespace') 
     244            if not n_space: 
     245                n_space = instance.get('ns') 
     246            if not n_space: 
     247                n_space = self.n_space 
     248 
     249            if not n_space: self._err('<instance> %s does not specify an '\ 
     250                                      'object namespace, and no default is '\ 
     251                                      'available.' % str(object_id)) 
     252 
     253            self.n_space = n_space 
     254 
     255            object = self.model.getObject(str(object_id), str(n_space)) 
    241256            if not object: 
    242                 print ''.join(['Object with id=', str(objectID), ' ns=', str(nspace), ' could not be found. Omitting...']) 
     257                print ''.join(['Object with id=', str(object_id), ' ns=', \ 
     258                               str(n_space), \ 
     259                               ' could not be found. Omitting...']) 
    243260                continue 
    244261 
     
    246263            y = instance.get('y') 
    247264            z = instance.get('z') 
    248             stackpos = instance.get('stackpos') 
     265            stack_pos = instance.get('stackpos') 
    249266            id = instance.get('id') 
    250267 
     
    272289                id = str(id) 
    273290 
    274             inst = layer.createInstance(object, fife.ExactModelCoordinate(x,y,z), str(id)) 
     291            inst = layer.createInstance(object, \ 
     292                                        fife.ExactModelCoordinate(x,y,z), \ 
     293                                        str(id)) 
    275294 
    276295            rotation = instance.get('r') 
     
    288307 
    289308            fife.InstanceVisual.create(inst) 
    290             if (stackpos): 
    291                 inst.get2dGfxVisual().setStackPosition(int(stackpos)) 
     309            if (stack_pos): 
     310                inst.get2dGfxVisual().setStackPosition(int(stack_pos)) 
    292311 
    293312            if (object.getAction('default')): 
     
    303322                inst_dict["xpos"] = x 
    304323                inst_dict["ypos"] = y 
    305                 inst_dict["gfx"] = objectID 
     324                inst_dict["gfx"] = object_id 
    306325                inst_dict["is_open"] = instance.get('is_open') 
    307326                inst_dict["locked"] = instance.get('locked') 
     
    312331                inst_dict["target_map_name"] = instance.get('target_map_name') 
    313332                inst_dict["target_map"] = instance.get('target_map') 
    314                 inst_dict["target_pos"] = (instance.get('target_x'), instance.get('target_y')) 
     333                inst_dict["target_pos"] = (instance.get('target_x'), \ 
     334                                           instance.get('target_y')) 
    315335                self.data.createObject(layer, inst_dict, inst) 
    316336                 
    317337    def parseCameras(self, map_elt, map): 
    318338        if self.callback:         
    319             tmplist = map_elt.findall('camera') 
     339            tmp_list = map_elt.findall('camera') 
    320340            i = float(0) 
    321341 
     
    328348            ref_cell_width = camera.get('ref_cell_width') 
    329349            ref_cell_height = camera.get('ref_cell_height') 
    330             viewport = camera.get('viewport') 
     350            view_port = camera.get('viewport') 
    331351 
    332352            if not zoom: zoom = 1 
     
    335355 
    336356            if not id: self._err('Camera declared without an id.') 
    337             if not ref_layer_id: self._err(''.join(['Camera ', str(id), ' declared with no reference layer.'])) 
    338             if not (ref_cell_width and ref_cell_height): self._err(''.join(['Camera ', str(id), ' declared without reference cell dimensions.'])) 
     357            if not ref_layer_id: self._err(''.join(['Camera ', str(id), \ 
     358                                                    ' declared with no '\ 
     359                                                    'reference layer.'])) 
     360            if not (ref_cell_width and ref_cell_height): 
     361                self._err(''.join(['Camera ', str(id), \ 
     362                                   ' declared without reference cell '\ 
     363                                   'dimensions.'])) 
    339364 
    340365            try: 
    341                 if viewport: 
    342                     cam = self.engine.getView().addCamera(str(id), map.getLayer(str(ref_layer_id)),fife.Rect(*[int(c) for c in viewport.split(',')]),fife.ExactModelCoordinate(0,0,0)) 
     366                if view_port: 
     367                    cam = self.engine.getView().addCamera(str(id), \ 
     368                                    map.getLayer(str(ref_layer_id)), \ 
     369                                    fife.Rect(\ 
     370                                    *[int(c) for c in view_port.split(',')]),\ 
     371                                    fife.ExactModelCoordinate(0,0,0)) 
    343372                else: 
    344373                    screen = self.engine.getRenderBackend() 
    345                     cam = self.engine.getView().addCamera(str(id), map.getLayer(str(ref_layer_id)),fife.Rect(0,0,screen.getScreenWidth(),screen.getScreenHeight()),fife.ExactModelCoordinate(0,0,0)) 
    346  
    347                 cam.setCellImageDimensions(int(ref_cell_width), int(ref_cell_height)) 
     374                    cam = self.engine.getView().addCamera(str(id), \ 
     375                                    map.getLayer(str(ref_layer_id)), \ 
     376                                    fife.Rect(0, 0, screen.getScreenWidth(), \ 
     377                                              screen.getScreenHeight()), \ 
     378                                              fife.ExactModelCoordinate(0, 0,\ 
     379                                                                        0)) 
     380 
     381                cam.setCellImageDimensions(int(ref_cell_width), \ 
     382                                           int(ref_cell_height)) 
    348383                cam.setRotation(float(rotation)) 
    349384                cam.setTilt(float(tilt)) 
     
    354389            if self.callback: 
    355390                i += 1 
    356                 self.callback('loaded camera: ' +  str(id), float( i / len(tmplist) * 0.25 + 0.75 ) )     
     391                self.callback('loaded camera: ' +  str(id), \ 
     392                              float( i / len(tmp_list) * 0.25 + 0.75 ) )     
  • trunk/game/utilities/agentXmlGen.py

    r317 r328  
    1414#   along with this program.  If not, see <http://www.gnu.org/licenses/>. 
    1515 
    16 import os, sys, getopt, logging, re 
     16import os 
     17import sys 
     18import getopt 
     19import logging 
     20import re 
    1721 
    1822log = logging.getLogger("agentxml") 
    1923log.setLevel(logging.DEBUG) 
    2024 
    21 def generateAgent(path, delay, xoff, yoff): 
     25def generateAgent(path, delay, x_off, y_off): 
    2226    """ Generates the agent XML file and creates animation 
    2327    XML files for found children.  
     
    2832    @type xoff: string 
    2933    @param xoff: X offset (used in animation.xml) 
    30     @type yoff: string 
    31     @param yoff: Y offset (used in animation.xml) 
     34    @type y_off: string 
     35    @param y_off: Y offset (used in animation.xml) 
    3236    @return True on success, False on failure 
    3337    """ 
     
    3943    log.debug("Opened " + os.path.join(path,name + ".xml")) 
    4044    f.write('<?fife type="object"?>\n') 
    41     f.write('<object id="%s" namespace="PARPG" blocking="1" static="0">\n' % (name,)) 
     45    f.write('<object id="%s" namespace="PARPG" blocking="1" static="0">\n' % \ 
     46            (name,)) 
    4247 
    4348    # Iterate the animations  
     
    4550    anims.sort() 
    4651    for anim in anims: 
    47         animpath=os.path.join(path,anim) 
    48         if os.path.isdir(animpath) and anim.find("svn")==-1: 
     52        anim_path=os.path.join(path,anim) 
     53        if os.path.isdir(anim_path) and anim.find("svn")==-1: 
    4954            log.debug("Found animation: %s", anim) 
    5055            f.write('\t<action id="' + anim +'">\n') 
    51             angles = os.listdir(animpath) 
     56            angles = os.listdir(anim_path) 
    5257            angles.sort() 
    5358            for angle in angles: 
    54                 anglepath=os.path.join(animpath,angle) 
    55                 if os.path.isdir(anglepath) and angle.find("svn")==-1: 
     59                angle_path=os.path.join(anim_path,angle) 
     60                if os.path.isdir(angle_path) and angle.find("svn")==-1: 
    5661                    log.debug("Found angle: %s", angle) 
    5762                    f.write('\t\t<animation source="' + anim + '/' + angle  
    5863                            + '/animation.xml" direction="'  
    5964                            + str(int(angle)) + '" />\n') 
    60                     if not generateAnimation(anglepath,delay,xoff,yoff): 
    61                         log.error("Failed to create animation for " + anum + " (angle: " + angle + ")") 
     65                    if not generateAnimation(angle_path,delay,xoff,y_off): 
     66                        log.error("Failed to create animation for " + anum\ 
     67                                   + " (angle: " + angle + ")") 
    6268            f.write('\t</action>\n') 
    6369    f.write('</object>\n') 
     
    7682    regex="[^0-9]*([0-9]*).*" 
    7783    try: 
    78         intX=int(re.sub(regex,"\\1",x)) 
     84        int_x = int(re.sub(regex,"\\1",x)) 
    7985    except: 
    80         intX=-1 
     86        int_x = -1 
    8187 
    8288    try: 
    83         intY=int(re.sub(regex,"\\1",y)) 
     89        int_y = int(re.sub(regex,"\\1",y)) 
    8490    except: 
    85         intY=-1 
     91        int_y = -1 
    8692     
    87     if intX>intY: 
     93    if int_x > int_y: 
    8894        return 1 
    89     elif intX<intY: 
     95    elif int_x < int_y: 
    9096        return -1; 
    9197     
    9298    return 0 
    9399 
    94 def generateAnimation(path, delay, xoff, yoff): 
     100def generateAnimation(path, delay, xoff, y_off): 
    95101    """ Generate animation.xml for a given path. 
    96102    @type path: string  
     
    98104    @type delay: string 
    99105    @param delay: Animation delay  
    100     @type xoff: string 
    101     @param xoff: X offset  
    102     @type yoff: string 
    103     @param yoff: Y offset  
     106    @type x_off: string 
     107    @param x_off: X offset  
     108    @type y_off: string 
     109    @param y_off: Y offset  
    104110    @return True on success, False on failure """ 
    105111 
    106     (tmp,angle)=os.path.split(os.path.abspath(path)) 
    107     (tmp,anim)=os.path.split(tmp) 
    108     (tmp,agent)=os.path.split(tmp) 
    109     id="%s:%s:%s"%(agent,anim,angle) 
     112    (tmp, angle) = os.path.split(os.path.abspath(path)) 
     113    (tmp, anim) = os.path.split(tmp) 
     114    (tmp, agent) = os.path.split(tmp) 
     115    id = "%s:%s:%s"%(agent, anim, angle) 
    110116    log.debug("Doing animation with id: %s" % (id)) 
    111117 
    112     images=os.listdir(path) 
     118    images = os.listdir(path) 
    113119    # Get those with the correct extension 
    114     imagesfiltered=[] 
     120    images_filtered = [] 
    115121    for image in images: 
    116122        if image.endswith(".png"): 
    117             imagesfiltered.append(image) 
     123            images_filtered.append(image) 
    118124 
    119125 
     
    121127    log.debug("Opened: " + os.path.join("animation.xml")) 
    122128    f.write('<animation delay="' + delay + '" namespace="PAPRG" id="' + id  
    123             + '" x_offset="' + xoff  
    124             + '" y_offset="' + yoff + '">\n') 
     129            + '" x_offset="' + x_off  
     130            + '" y_offset="' + y_off + '">\n') 
    125131 
    126132    # Sort them 
    127     imagesfiltered.sort(cmp=imageCompare) 
    128     for image in imagesfiltered: 
     133    images_filtered.sort(cmp=imageCompare) 
     134    for image in images_filtered: 
    129135        log.debug("Found image: %s" % image) 
    130136        f.write('\t<frame source="' + image + '" />\n') 
     
    157163        sys.exit(2) 
    158164 
    159     agentpath="." 
    160     delay="100" 
    161     x_offset="0" 
    162     y_offset="0" 
    163     verbose=False 
     165    agent_path = "." 
     166    delay = "100" 
     167    x_offset = "0" 
     168    y_offset = "0" 
     169    verbose = False 
    164170 
    165171    ch = logging.StreamHandler() 
     
    168174    for opt, arg in opts:         
    169175        if opt in ("-p","--path"): 
    170             agentpath=path 
     176            agent_path = path 
    171177        elif opt in ("-d","--delay"): 
    172             delay=arg 
     178            delay = arg 
    173179        elif opt in ("-x","--x_offset"): 
    174             x_offset=arg 
     180            x_offset = arg 
    175181        elif opt in ("-y","--y_offset"): 
    176             y_offset=arg 
     182            y_offset = arg 
    177183        elif opt in ("-v","--verbose"): 
    178184            ch.setLevel(logging.DEBUG) 
     
    185191    log.addHandler(ch) 
    186192 
    187     log.debug("Going to generate animation for %s" %(agentpath)) 
    188     generateAgent(agentpath, delay, x_offset, y_offset) 
     193    log.debug("Going to generate animation for %s" % (agent_path)) 
     194    generateAgent(agent_path, delay, x_offset, y_offset) 
    189195    log.info("Done"); 
    190196 
  • trunk/game/utilities/gfxsplit.py

    r147 r328  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/> 
    1717 
    18 import sys, pygame 
     18import sys 
     19import pygame 
    1920 
    2021# place defines here 
     
    2829 
    2930class TileImage: 
    30     def __init__(self, picture, name, yoff): 
     31    def __init__(self, picture, name, y_off): 
    3132        self.image = picture 
    3233        self.filename = name 
    33         self.y_offset = yoff 
     34        self.y_offset = y_off 
    3435 
    35 def writeXML(name, yoff): 
     36def writeXML(name, y_off): 
    3637    """Write the XML file as well 
    3738       Always the same small file so we do it automatically""" 
     
    5152    x_file.write('''" direction="0"''') 
    5253    x_file.write(''' y_offset="''') 
    53     x_file.write(yoff) 
     54    x_file.write(y_off) 
    5455    x_file.write('''" />\n''') 
    5556    # the \n\n is ESSENTIAL otherwise the XML parser in FIFE craps out! 
     
    5960def stitchImages(files, width, height): 
    6061    """Put the images together and output them to stitched.png""" 
    61     new_image=pygame.Surface((width, height), pygame.SRCALPHA, 32) 
    62     xpos = 0 
     62    new_image = pygame.Surface((width, height), pygame.SRCALPHA, 32) 
     63    x_pos = 0 
    6364    for i in files: 
    64         new_image.blit(i.image, (xpos, 0)) 
    65         xpos += i.image.get_width() 
    66     pygame.image.save(new_image,"stitched.png") 
     65        new_image.blit(i.image, (x_pos, 0)) 
     66        x_pos += i.image.get_width() 
     67    pygame.image.save(new_image, "stitched.png") 
    6768     
    6869def saveFiles(files): 
     
    103104    # the starting point for the grab is always the middle of the image 
    104105    height = (image.get_height() / 2) + (TILE_HEIGHT / 2) 
    105     xpos = 0 
     106    x_pos = 0 
    106107    file_counter = 0 
    107108    tiles = [] 
    108109    height_adjust = 0 
    109     yoff_next = -((height - TILE_HEIGHT) / 2) 
     110    y_off_next = -((height - TILE_HEIGHT) / 2) 
    110111    for t in data: 
    111         yoff = yoff_next 
     112        y_off = y_off_next 
    112113        if(t == 'm'): 
    113114            # switchback, so this tile must fill the whole width 
    114115            width += TILE_WIDTH / 2 
    115116            height_adjust = TILE_HEIGHT / 2 
    116             yoff_next += (TILE_HEIGHT / 4) + (TILE_HEIGHT / 2) 
     117            y_off_next += (TILE_HEIGHT / 4) + (TILE_HEIGHT / 2) 
    117118            xoff = 0 
    118119        elif(t == 'r'): 
     
    120121            width = TILE_WIDTH / 2 
    121122            height_adjust = - (TILE_HEIGHT / 2) 
    122             yoff_next += TILE_HEIGHT / 4 
     123            y_off_next += TILE_HEIGHT / 4 
    123124            xoff = TILE_WIDTH / 2 
    124125        elif(t == 'l'): 
     
    126127            width = TILE_WIDTH / 2 
    127128            height_adjust = TILE_HEIGHT / 2 
    128             yoff_next -= TILE_HEIGHT / 4 
     129            y_off_next -= TILE_HEIGHT / 4 
    129130            xoff = 0 
    130131        else: 
     
    137138            height += 1 
    138139        # build the new surface 
    139         new_surface = pygame.Surface((TILE_WIDTH, height), pygame.SRCALPHA, 32) 
     140        new_surface = pygame.Surface((TILE_WIDTH, height), \ 
     141                                     pygame.SRCALPHA, 32) 
    140142        # now blit a strip of the image across 
    141         new_surface.blit(image, (0+xoff, 0), pygame.Rect(xpos, 0, width, height)) 
     143        new_surface.blit(image, (0+xoff, 0), pygame.Rect(x_pos, 0, \ 
     144                                                         width, height)) 
    142145        # store the image for later 
    143         tiles.append(TileImage(new_surface, 
    144             filename + chr(ord('a')+file_counter) + ".png",yoff)) 
     146        tiles.append(TileImage(new_surface, \ 
     147            filename + chr(ord('a')+file_counter) + ".png",y_off)) 
    145148        file_counter += 1 
    146149        # amend variables 
    147         xpos += width 
     150        x_pos += width 
    148151        height += height_adjust 
    149152    return tiles 
     
    164167    # validate each data statement 
    165168    for i in data: 
    166         if((i != 'l')and(i != 'r')and(i != 'm')and(i.isdigit()==False)): 
     169        if((i != 'l')and(i != 'r')and(i != 'm')and(i.isdigit() == False)): 
    167170            # some issue 
    168171            print "Error: Can't decode tile string structure" 
     
    172175        image = pygame.image.load(filename) 
    173176    except(pygame.error): 
    174         print "Error: Couldn't load",filename 
     177        print "Error: Couldn't load", filename 
    175178        return False         
    176179    # split into seperate files 
  • trunk/game/utilities/transition.py

    r147 r328  
    103103                sys.exit(False) 
    104104            # start a new layer 
    105             self.layers.append(XMLLayerData(x,y,name)) 
     105            self.layers.append(XMLLayerData(x, y, name)) 
    106106            self.current_layer = True 
    107107        elif(name == "i"): 
     
    130130            self.layers[-1].tiles.append(XMLTileData(x, y, z, o, i)) 
    131131 
    132     def endElement(self,name): 
     132    def endElement(self, name): 
    133133        if(name == "layer"): 
    134134            # end of current layer 
     
    145145        self.max_y = 0 
    146146 
    147     def OutputTransLayer(self, l_file, l_count): 
     147    def outputTransLayer(self, l_file, l_count): 
    148148        if(len(self.render_tiles) == 0): 
    149149            return True 
    150150        try: 
    151             layer_name="TransitionLayer"+str(l_count) 
     151            layer_name = "TransitionLayer" + str(l_count) 
    152152            l_file.write('''    <layer x_offset="0.0" pathing="''') 
    153153            l_file.write('''cell_edges_and_diagonals" y_offset="0.0"''') 
    154154            l_file.write(''' grid_type="square" id="''') 
    155             l_file.write(layer_name+'''"''') 
     155            l_file.write(layer_name + '''"''') 
    156156            l_file.write(''' x_scale="1" y_scale="1" rotation="0.0">\n''') 
    157157            l_file.write('        <instances>\n') 
     
    170170        return True 
    171171 
    172     def GetSurroundings(self,x,y,search): 
    173         """Function called by BuildTransLayer to see if a tile needs to 
     172    def GetSurroundings(self, x, y, search): 
     173        """Function called by buildTransLayer to see if a tile needs to 
    174174           display transition graphics over it (drawn on another layer)""" 
    175175        # check all of the tiles around the current tile 
    176176        value=0 
    177         if(self.PMatchSearch(x,y+1,search) == True): 
     177        if(self.pMatchSearch(x,y+1,search) == True): 
    178178            value += RIGHT 
    179         if(self.PMatchSearch(x-1,y+1,search) == True): 
     179        if(self.pMatchSearch(x-1,y+1,search) == True): 
    180180            value += BOTTOM_RIGHT 
    181         if(self.PMatchSearch(x-1,y,search) == True): 
     181        if(self.pMatchSearch(x-1,y,search) == True): 
    182182            value += BOTTOM 
    183         if(self.PMatchSearch(x-1,y-1,search) == True): 
     183        if(self.pMatchSearch(x-1,y-1,search) == True): 
    184184            value += BOTTOM_LEFT 
    185         if(self.PMatchSearch(x,y-1,search) == True): 
     185        if(self.pMatchSearch(x,y-1,search) == True): 
    186186            value += LEFT 
    187         if(self.PMatchSearch(x+1,y-1,search) == True): 
     187        if(self.pMatchSearch(x+1,y-1,search) == True): 
    188188            value += TOP_LEFT 
    189         if(self.PMatchSearch(x+1,y,search) == True): 
     189        if(self.pMatchSearch(x+1,y,search) == True): 
    190190            value += TOP 
    191         if(self.PMatchSearch(x+1,y+1,search) == True): 
     191        if(self.pMatchSearch(x+1,y+1,search) == True): 
    192192            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""" 
     
    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) 
     206                trans_value = self.GetSurroundings(t.x, t.y, search) 
    207207                if(trans_value != 0): 
    208208                    # we found an actual real transition 
     
    210210        return tiles 
    211211 
    212     def GetTransitionName(self, base, value, corner=False): 
     212    def getTransitionName(self, base, value, corner=False): 
    213213        if(corner == False): 
    214             name = base+"-ts" 
     214            name = base + "-ts" 
    215215        else: 
    216             name = base+"-tc" 
     216            name = base + "-tc" 
    217217        if(value < 10): 
    218218            name += "0" 
    219         name+=str(value) 
     219        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 
     
    237237                    # we must add a corner piece as well 
    238238                    corners = corners/16 
    239                     name = self.GetTransitionName(search, corners, True) 
     239                    name = self.getTransitionName(search, corners, True) 
    240240                    self.ttiles.append(XMLTileData(t[0], t[1], 0, name)) 
    241241                # add the side tile pieces 
    242                 name = self.GetTransitionName(search, sides, False) 
     242                name = self.getTransitionName(search, sides, False) 
    243243                self.ttiles.append(XMLTileData(t[0], t[1], 0, name)) 
    244244            else: 
     
    248248                if(corners != 0): 
    249249                    # there is a corner piece needed 
    250                     name = self.GetTransitionName(search, corners, True) 
     250                    name = self.getTransitionName(search, corners, True) 
    251251                    self.ttiles.append(XMLTileData(t[0], t[1], 0, name)) 
    252252 
    253     def LoadFromXML(self, filename): 
     253    def loadFromXML(self, filename): 
    254254        """Load a map from the XML file used in Fife 
    255255           Returns True if it worked, False otherwise""" 
     
    261261        # now open and read the XML file 
    262262        parser = make_parser() 
    263         curHandler = LocalXMLParser() 
    264         parser.setContentHandler(curHandler) 
     263        cur_handler = LocalXMLParser() 
     264        parser.setContentHandler(cur_handler) 
    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 = cur_handler.layers 
    269269        return True 
    270270     
    271     def GetSize(self): 
    272         """GetSize stores the size of the grid""" 
     271    def getSize(self): 
     272        """getSize stores the size of the grid""" 
    273273        for t in self.layers[0].tiles: 
    274274            if t.x > self.max_x: 
     
    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 
    295295        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 
     
    325325            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 
    336336            layer_count += 1 
    337             self.ttiles=recycled_tiles 
     337            self.ttiles = recycled_tiles 
    338338        # phew, that was it 
    339339        map_file.close() 
    340340        print "Output new file as new.xml" 
    341         print "Had to render",layer_count,"layers" 
     341        print "Had to render", layer_count, "layers" 
    342342        return True 
    343343     
    344     def PrintDetails(self): 
     344    def printDetails(self): 
    345345        """Debugging routine to output some details about the map 
    346346           Used to check the map loaded ok""" 
     
    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__": 
     
    357357        sys.stderr.write("Error: No map given!\n") 
    358358        sys.exit(False) 
    359     new_map=LocalMap() 
    360     if(new_map.LoadFromXML(sys.argv[1]) == True): 
    361         new_map.GetSize() 
    362         new_map.BuildTransLayer("grass") 
    363         new_map.SaveMap("new.xml") 
    364         new_map.PrintDetails() 
    365  
     359         
     360    new_map = LocalMap() 
     361    if(new_map.loadFromXML(sys.argv[1]) == True): 
     362        new_map.getSize() 
     363        new_map.buildTransLayer("grass") 
     364        new_map.saveMap("new.xml") 
     365        new_map.printDetails() 
     366 
Note: See TracChangeset for help on using the changeset viewer.