Ticket #72: map_file_merge.patch

File map_file_merge.patch, 22.6 KB (added by Kaydeth_parpg, 10 years ago)
  • local_loaders/loaders.py

     
     1# coding: utf-8 
     2# Loader interface for FIFE's native xml format. 
     3 
     4import fife 
     5 
     6from xmlmap import XMLMapLoader 
     7from serializers import WrongFileType, NameClash 
     8 
     9from serializers.xmlobject import XMLObjectLoader 
     10 
     11fileExtensions = ('xml',) 
     12 
     13def loadMapFile(path, engine, data, callback=None): 
     14        """     load map file and get (an optional) callback if major stuff is done: 
     15        - map creation 
     16        - parsed impor0ts 
     17        - parsed layers  
     18        - parsed cameras 
     19        the callback will send both a string and a float (which shows 
     20        the overall process), callback(string, float) 
     21         
     22        Inputs: 
     23                path = filename for map 
     24                engine = FIFE engine 
     25                data = Engine object for PARPG data 
     26                 
     27        @return map     : map object 
     28        """ 
     29        map_loader = XMLMapLoader(engine, data, callback) 
     30        map = map_loader.loadResource(fife.ResourceLocation(path)) 
     31        print "--- Loading map took: ", map_loader.time_to_load, " seconds." 
     32        return map 
     33 
     34def loadImportFile(path, engine): 
     35        object_loader = XMLObjectLoader(engine.getImagePool(), engine.getAnimationPool(), engine.getModel(), engine.getVFS()) 
     36        res = None 
     37        try: 
     38                res = object_loader.loadResource(fife.ResourceLocation(path)) 
     39                print 'imported object file ' + path 
     40        except WrongFileType: 
     41                pass 
     42#               print 'ignored non-object file ' + path 
     43        except NameClash: 
     44                pass 
     45#               print 'ignored already loaded file ' + path 
     46        return res 
     47 
     48def loadImportDir(path, engine): 
     49        for file in filter(lambda f: f.split('.')[-1] == 'xml', engine.getVFS().listFiles(path)): 
     50                loadImportFile('/'.join([path, file]), engine) 
     51 
     52def loadImportDirRec(path, engine): 
     53        loadImportDir(path, engine) 
     54 
     55        for dir in filter(lambda d: not d.startswith('.'), engine.getVFS().listDirectories(path)): 
     56                loadImportDirRec('/'.join([path, dir]), engine) 
  • local_loaders/xmlmap.py

     
     1import fife 
     2try: 
     3        import xml.etree.cElementTree as ET 
     4except: 
     5        import xml.etree.ElementTree as ET 
     6 
     7import loaders 
     8from serializers import * 
     9import time 
     10 
     11FORMAT = '1.0' 
     12 
     13class XMLMapLoader(fife.ResourceLoader): 
     14        def __init__(self, engine, data, callback): 
     15                """ The XMLMapLoader parses the xml map using several section.  
     16                Each section fires a callback (if given) which can e. g. be 
     17                used to show a progress bar. 
     18                 
     19                The callback sends two values, a string and a float (which shows 
     20                the overall process): callback(string, float) 
     21                 
     22                Inputs: 
     23                        engine = FIFE engine 
     24                        data = Engine object for PARPG data 
     25                        callback = function callback 
     26                         
     27                @param  engine  :       a pointer to fife.engine 
     28                @param  callback:       a callback with two arguments, optional 
     29                """ 
     30                fife.ResourceLoader.__init__(self) 
     31                self.thisown = 0 
     32                 
     33                self.callback = callback 
     34 
     35                self.engine = engine 
     36                self.data = data 
     37                self.vfs = self.engine.getVFS() 
     38                self.model = self.engine.getModel() 
     39                self.pool = self.engine.getImagePool() 
     40                self.anim_pool = self.engine.getAnimationPool() 
     41                self.map = None 
     42                self.source = None 
     43                self.time_to_load = 0 
     44 
     45                self.nspace = None 
     46 
     47        def _err(self, msg): 
     48                raise SyntaxError(''.join(['File: ', self.source, ' . ', msg])) 
     49 
     50        def loadResource(self, location): 
     51                start_time = time.time() 
     52                self.source = location.getFilename() 
     53                f = self.vfs.open(self.source) 
     54                f.thisown = 1 
     55                tree = ET.parse(f) 
     56                root = tree.getroot() 
     57                         
     58                map = self.parse_map(root) 
     59                self.time_to_load = time.time() - start_time 
     60                return map 
     61 
     62        def parse_map(self, mapelt): 
     63                if not mapelt: 
     64                        self._err('No <map> element found at top level of map file definition.') 
     65                id,format = mapelt.get('id'),mapelt.get('format') 
     66 
     67                if not format == FORMAT: self._err(''.join(['This file has format ', format, ' but this loader has format ', FORMAT])) 
     68                if not id: self._err('Map declared without an identifier.') 
     69 
     70                map = None 
     71                try: 
     72                        self.map = self.model.createMap(str(id)) 
     73                        self.map.setResourceFile(self.source) 
     74                except fife.Exception, e: # NameClash appears as general fife.Exception; any ideas? 
     75                        print e.getMessage() 
     76                        print ''.join(['File: ', self.source, '. The map ', str(id), ' already exists! Ignoring map definition.']) 
     77                        return None 
     78 
     79                # xml-specific directory imports. This is used by xml savers. 
     80                self.map.importDirs = [] 
     81 
     82                if self.callback is not None: 
     83                        self.callback('created map', float(0.25) ) 
     84 
     85                self.parse_imports(mapelt, self.map) 
     86                 
     87                self.parse_layers(mapelt, self.map)      
     88                 
     89                self.parse_cameras(mapelt, self.map) 
     90 
     91                return self.map 
     92 
     93        def parse_imports(self, mapelt, map): 
     94                parsedImports = {} 
     95 
     96                if self.callback:                
     97                        tmplist = mapelt.findall('import') 
     98                        i = float(0) 
     99                 
     100                for item in mapelt.findall('import'): 
     101                        file = item.get('file') 
     102                        if file: 
     103                                file = reverse_root_subfile(self.source, file) 
     104                        dir = item.get('dir') 
     105                        if dir: 
     106                                dir = reverse_root_subfile(self.source, dir) 
     107 
     108                        # Don't parse duplicate imports 
     109                        if (dir,file) in parsedImports: 
     110                                print "Duplicate import:" ,(dir,file) 
     111                                continue 
     112                        parsedImports[(dir,file)] = 1 
     113 
     114                        if file and dir: 
     115                                loaders.loadImportFile('/'.join(dir, file), self.engine) 
     116                        elif file: 
     117                                loaders.loadImportFile(file, self.engine) 
     118                        elif dir: 
     119                                loaders.loadImportDirRec(dir, self.engine) 
     120                                map.importDirs.append(dir) 
     121                        else: 
     122                                print 'Empty import statement?' 
     123                                 
     124                        if self.callback: 
     125                                i += 1                           
     126                                self.callback('loaded imports', float( i / float(len(tmplist)) * 0.25 + 0.25 ) ) 
     127 
     128 
     129        def parse_layers(self, mapelt, map): 
     130                if self.callback is not None:            
     131                        tmplist = mapelt.findall('layer') 
     132                        i = float(0) 
     133 
     134                for layer in mapelt.findall('layer'): 
     135                        id = layer.get('id') 
     136                        grid_type = layer.get('grid_type') 
     137                        x_scale = layer.get('x_scale') 
     138                        y_scale = layer.get('y_scale') 
     139                        rotation = layer.get('rotation') 
     140                        x_offset = layer.get('x_offset') 
     141                        y_offset = layer.get('y_offset') 
     142                        pathing = layer.get('pathing') 
     143 
     144                        if not x_scale: x_scale = 1.0 
     145                        if not y_scale: y_scale = 1.0 
     146                        if not rotation: rotation = 0.0 
     147                        if not x_offset: x_offset = 0.0 
     148                        if not y_offset: y_offset = 0.0 
     149                        if not pathing: pathing = "cell_edges_only" 
     150 
     151                        if not id: self._err('<layer> declared with no id attribute.') 
     152                        if not grid_type: self._err(''.join(['Layer ', str(id), ' has no grid_type attribute.'])) 
     153 
     154                        allow_diagonals = pathing == "cell_edges_and_diagonals" 
     155                        cellgrid = self.model.getCellGrid(grid_type) 
     156                        if not cellgrid: self._err('<layer> declared with invalid cellgrid type. (%s)' % grid_type) 
     157 
     158                        cellgrid.setRotation(float(rotation)) 
     159                        cellgrid.setXScale(float(x_scale)) 
     160                        cellgrid.setYScale(float(y_scale)) 
     161                        cellgrid.setXShift(float(x_offset)) 
     162                        cellgrid.setYShift(float(y_offset)) 
     163 
     164                        layer_obj = None 
     165                        try: 
     166                                layer_obj = map.createLayer(str(id), cellgrid) 
     167                        except fife.Exception, e: 
     168                                print e.getMessage() 
     169                                print 'The layer ' + str(id) + ' already exists! Ignoring this layer.' 
     170                                continue 
     171 
     172                        strgy = fife.CELL_EDGES_ONLY 
     173                        if pathing == "cell_edges_and_diagonals": 
     174                                strgy = fife.CELL_EDGES_AND_DIAGONALS 
     175                        if pathing == "freeform": 
     176                                strgy = fife.FREEFORM 
     177                        layer_obj.setPathingStrategy(strgy) 
     178 
     179                        self.parse_instances(layer, layer_obj) 
     180 
     181                        if self.callback is not None: 
     182                                i += 1 
     183                                self.callback('loaded layer :' + str(id), float( i / float(len(tmplist)) * 0.25 + 0.5 ) ) 
     184 
     185                # cleanup 
     186                if self.callback is not None: 
     187                        del tmplist 
     188                        del i 
     189 
     190        def parse_instances(self, layerelt, layer): 
     191                instelt = layerelt.find('instances') 
     192 
     193                instances = instelt.findall('i') 
     194                instances.extend(instelt.findall('inst')) 
     195                instances.extend(instelt.findall('instance')) 
     196                for instance in instances: 
     197 
     198                        objectID = instance.get('object') 
     199                        if not objectID: 
     200                                objectID = instance.get('obj') 
     201                        if not objectID: 
     202                                objectID = instance.get('o') 
     203 
     204                        if not objectID: self._err('<instance> does not specify an object attribute.') 
     205 
     206                        nspace = instance.get('namespace') 
     207                        if not nspace: 
     208                                nspace = instance.get('ns') 
     209                        if not nspace: 
     210                                nspace = self.nspace 
     211 
     212                        if not nspace: self._err('<instance> %s does not specify an object namespace, and no default is available.' % str(objectID)) 
     213 
     214                        self.nspace = nspace 
     215 
     216                        object = self.model.getObject(str(objectID), str(nspace)) 
     217                        if not object: 
     218                                print ''.join(['Object with id=', str(objectID), ' ns=', str(nspace), ' could not be found. Omitting...']) 
     219                                continue 
     220 
     221                        x = instance.get('x') 
     222                        y = instance.get('y') 
     223                        z = instance.get('z') 
     224                        stackpos = instance.get('stackpos') 
     225                        id = instance.get('id') 
     226 
     227                        if x: 
     228                                x = float(x) 
     229                                self.x = x 
     230                        else: 
     231                                self.x = self.x + 1 
     232                                x = self.x 
     233 
     234                        if y: 
     235                                y = float(y) 
     236                                self.y = y 
     237                        else: 
     238                                y = self.y 
     239 
     240                        if z: 
     241                                z = float(z) 
     242                        else: 
     243                                z = 0.0 
     244 
     245                        if not id: 
     246                                id = '' 
     247                        else: 
     248                                id = str(id) 
     249 
     250                        inst = layer.createInstance(object, fife.ExactModelCoordinate(x,y,z), str(id)) 
     251 
     252                        rotation = instance.get('r') 
     253                        if not rotation: 
     254                                rotation = instance.get('rotation') 
     255                        if not rotation: 
     256                                angles = object.get2dGfxVisual().getStaticImageAngles() 
     257                                if angles: 
     258                                        rotation = angles[0] 
     259                                else: 
     260                                        rotation = 0 
     261                        else: 
     262                                rotation = int(rotation) 
     263                        inst.setRotation(rotation) 
     264 
     265                        fife.InstanceVisual.create(inst) 
     266                        if (stackpos): 
     267                                inst.get2dGfxVisual().setStackPosition(int(stackpos)) 
     268 
     269                        if (object.getAction('default')): 
     270                                target = fife.Location(layer) 
     271                                inst.act('default', target, True) 
     272                                 
     273                        #Check for PARPG specific object attributes 
     274                        object_type = instance.get('object_type') 
     275                        if ( object_type ): 
     276                                inst_dict = {} 
     277                                inst_dict["type"] = object_type 
     278                                inst_dict["id"] = id 
     279                                inst_dict["xpos"] = x 
     280                                inst_dict["ypos"] = y 
     281                                inst_dict["gfx"] = objectID 
     282                                inst_dict["is_open"] = instance.get('is_open') 
     283                                inst_dict["locked"] = instance.get('locked') 
     284                                inst_dict["text"] = instance.get('text') 
     285                                inst_dict["desc"] = instance.get('desc') 
     286                                self.data.createObject( layer, inst_dict, inst ) 
     287                                 
     288        def parse_cameras(self, mapelt, map): 
     289                if self.callback:                
     290                        tmplist = mapelt.findall('camera') 
     291                        i = float(0) 
     292 
     293                for camera in mapelt.findall('camera'): 
     294                        id = camera.get('id') 
     295                        zoom = camera.get('zoom') 
     296                        tilt = camera.get('tilt') 
     297                        rotation = camera.get('rotation') 
     298                        ref_layer_id = camera.get('ref_layer_id') 
     299                        ref_cell_width = camera.get('ref_cell_width') 
     300                        ref_cell_height = camera.get('ref_cell_height') 
     301                        viewport = camera.get('viewport') 
     302 
     303                        if not zoom: zoom = 1 
     304                        if not tilt: tilt = 0 
     305                        if not rotation: rotation = 0 
     306 
     307                        if not id: self._err('Camera declared without an id.') 
     308                        if not ref_layer_id: self._err(''.join(['Camera ', str(id), ' declared with no reference layer.'])) 
     309                        if not (ref_cell_width and ref_cell_height): self._err(''.join(['Camera ', str(id), ' declared without reference cell dimensions.'])) 
     310 
     311                        try: 
     312                                if viewport: 
     313                                        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)) 
     314                                else: 
     315                                        screen = self.engine.getRenderBackend() 
     316                                        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)) 
     317 
     318                                cam.setCellImageDimensions(int(ref_cell_width), int(ref_cell_height)) 
     319                                cam.setRotation(float(rotation)) 
     320                                cam.setTilt(float(tilt)) 
     321                                cam.setZoom(float(zoom)) 
     322                        except fife.Exception, e: 
     323                                print e.getMessage() 
     324                                 
     325                        if self.callback: 
     326                                i += 1 
     327                                self.callback('loaded camera: ' +  str(id), float( i / len(tmplist) * 0.25 + 0.75 ) )    
     328                         
  • maps/map.xml

     
    11171117            <i x="7" o="block" z="0.0" y="-3" r="0"></i> 
    11181118            <i x="8" o="block" z="0.0" y="-4" r="0"></i> 
    11191119            <i x="8" o="block" z="0.0" y="-3" r="0"></i> 
     1120             
     1121            <!-- There must be one and one only PC character --> 
     1122                        <i x="0.0" o="PC" z="0.0" y="0.0" r="0" id="PC" object_type="PlayerCharacter"></i> 
     1123             
     1124            <!-- There can be any number of NPC characters --> 
     1125                        <i x="-4.0" o="npc-woman" z="0.0" y="-7.0" r="0" id="woman01" object_type="NonPlayerCharacter" 
     1126                                text="A friendly woman"></i> 
     1127             
     1128             
     1129                        <i x="-3.0" o="crate" z="0.0" y="-4.0" r="0" id="crate01" object_type="WoodenCrate" is_open="False" locked="False" text="asdf" 
     1130                desc="A crate that is covered in grime and dirt. There doesn't seem to be anything remarkable about it"></i> 
     1131  
     1132                        <!-- There can be any number of objects --> 
     1133                        <!-- Object blocking is set in the objects own xml file --> 
     1134                        <i x="-4.0" o="crate" z="0.0" y="-6.0" r="0" id="crate02" object_type="WoodenCrate" 
     1135                is_open="False" locked="False" text="A dirty old crate" 
     1136                        desc="A crate that is covered in grime and dirt. There doesn't seem to be anything remarkable about it"></i> 
     1137             
    11201138                </instances> 
    11211139        </layer> 
    11221140 
  • scripts/engine.py

     
    101101        if self.gameState.currentMap: 
    102102            self.loadMap(self.gameState.currentMap)  
    103103 
    104     def loadObjects(self, filename): 
    105         """Load objects from the XML file 
    106            Returns True if it worked, False otherwise. 
    107            @type filename: string 
    108            @param filename: The XML file to read. 
    109            @rtype: boolean 
    110            @return: Status of result (True/False)""" 
    111         try: 
    112             objects_file = open(filename, 'rt') 
    113         except(IOError): 
    114             sys.stderr.write("Error: Can't find objects file\n") 
    115             return False 
    116         # now open and read the XML file 
    117         other_handler = ObjectXMLParser() 
    118         other_handler.getObjects(objects_file) 
    119         objects_file.close() 
    120              
    121         # now add to the map and the engine 
    122         self.createGameObjects(other_handler.local_info) 
    123         return True 
    124  
    125     def createGameObjects(self, objList): 
    126         """Add all found game objects to the world 
    127            @type objList: list 
    128            @param objList: a list of the objects found in the xml file 
    129            @return: None""" 
    130          
     104    def createObject (self, layer, attributes, instance): 
     105        """Create an object and add it to the current map. 
     106            Inputs: 
     107                layer = FIFE layer object exists in 
     108                attributes = dictionary of all object attributes 
     109                instance = FIFE instance corresponding to the object 
     110            Return: 
     111                Nothing 
     112        """ 
    131113        # create the extra data 
    132114        extra = {} 
    133         extra['agent_layer'] = self.view.activeMap.agent_layer 
     115        extra['agent_layer'] = layer 
    134116        extra['engine'] = self 
    135117         
    136         # create the objects 
    137         for info in objList: 
    138             obj = createObject(info, extra) 
    139             if obj.trueAttr("PC"): 
    140                 self.addPC(obj) 
    141             else: 
    142                 self.addObject(obj) 
     118        obj = createObject(attributes, extra) 
     119         
     120        print attributes 
    143121 
    144     def addPC(self,pc): 
    145         """Add the PC to the world 
    146            @type pc: list 
    147            @param pc: List of data for PC attributes 
    148            @return: None""" 
    149         # add to view data     
    150         self.view.activeMap.addObject(pc.X, pc.X, pc.gfx, pc.ID) 
     122        if obj.trueAttr("PC"): 
     123            self.addPC( layer, obj, instance) 
     124        else: 
     125            self.addObject( layer, obj, instance) 
     126 
    151127         
     128 
     129    def addPC(self, layer, pc, instance): 
     130        """Add the PC to the map 
     131            Inputs: 
     132                layer = FIFE layer object exists in 
     133                pc = PlayerCharacter object 
     134                instance = FIFE instance of PC 
     135            Returns: 
     136                Nothing 
     137        """ 
     138        # add to view data  
     139        self.view.activeMap.addObject(pc.ID, instance)           
     140         
    152141        # sync with game data 
    153142        if not self.gameState.PC: 
    154143            self.gameState.PC = pc 
    155144             
    156145        self.gameState.PC.setup() 
    157         self.view.activeMap.addPC(self.gameState.PC.behaviour.agent) 
    158              
    159         # create the PC agent 
    160         self.gameState.PC.start() 
    161146 
    162     def addObject(self,obj): 
    163         """Adds an object to the game state. 
    164            @type npcs: list 
    165            @param npcs: List of NPC's to add 
    166            @return: None""" 
     147 
     148    def addObject(self, layer, obj, instance): 
     149        """Adds an object to the map. 
     150            Inputs: 
     151                layer = FIFE layer object exists in 
     152                obj = corresponding object class 
     153                instance = FIFE instance of object 
     154            Returns: 
     155                Nothing 
     156        """ 
    167157         
    168158        ref = self.gameState.getObjectById(obj.ID)  
    169159        if ref is None: 
     
    177167            obj.gfx = ref.gfx   
    178168             
    179169        # add it to the view 
    180         self.view.activeMap.addObject(obj.X, obj.Y, obj.gfx, obj.ID)           
    181          
     170        self.view.activeMap.addObject(obj.ID, instance)           
     171        
    182172        if obj.trueAttr("NPC"): 
    183173            # create the agent 
    184174            obj.setup() 
     
    260250           @param map_file: Name of map file to load 
    261251           @return: None""" 
    262252        # then we let FIFE load the rest of the map 
     253        self.gameState.currentMap = map_file 
    263254        self.view.loadMap(map_name, str(map_file)) 
    264255        self.view.setActiveMap(map_name) 
     256 
    265257        # then we update FIFE with the PC, NPC and object details 
    266         self.reset() 
    267         self.gameState.currentMap = map_file 
    268         self.loadObjects(map_file[:-4] + "_objects.xml") 
     258        self.reset()         
    269259 
     260        self.view.activeMap.addPC(self.gameState.PC.behaviour.agent) 
     261         
     262        # create the PC agent 
     263        self.gameState.PC.start() 
     264        #self.loadObjects(map_file[:-4] + "_objects.xml") 
     265 
    270266    def handleMouseClick(self,position): 
    271267        """Code called when user left clicks the screen. 
    272268           @type position: fife.ScreenPoint 
  • scripts/map.py

     
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    1818import fife, time 
    19 from loaders import loadMapFile 
     19from local_loaders.loaders import loadMapFile 
    2020from scripts.common.eventlistenerbase import EventListenerBase 
    2121 
    2222from settings import Setting 
     
    2424 
    2525class Map(fife.MapChangeListener): 
    2626    """Map class used to flag changes in the map""" 
    27     def __init__(self, engine): 
     27    def __init__(self, engine, data): 
    2828        # init mapchange listener 
    2929        fife.MapChangeListener.__init__(self) 
    3030        self.map = None 
    3131        self.engine = engine 
     32        self.data = data 
    3233         
    3334        # init map attributes 
    3435        self.cameras = {} 
     
    7172           @param filename: Name of map to load 
    7273           @return: None""" 
    7374        self.reset() 
    74         self.map = loadMapFile(filename, self.engine) 
    75          
     75        self.map = loadMapFile(filename, self.engine, self.data) 
     76          
    7677        # there must be a PC object on the objects layer! 
    7778        self.agent_layer = self.map.getLayer('ObjectLayer') 
    7879         
     
    106107        # attach the main camera to the PC 
    107108        self.cameras['main'].attach(agent) 
    108109 
    109     def addObject(self, xpos, ypos, gfx, name): 
    110         """Add an object or an NPC to the map. 
    111            It makes no difference to fife which is which. 
    112            @type xpos: integer 
    113            @param xpos: x position of object 
    114            @type ypos: integer 
    115            @param ypos: y position of object 
    116            @type gfx: string 
    117            @param gfx: name of gfx image 
    118            @type name: string 
    119            @param name: name of object 
    120            @return: None""" 
    121         obj = self.agent_layer.createInstance( 
    122                 self.model.getObject(str(gfx), "PARPG"), 
    123                 fife.ExactModelCoordinate(float(xpos), float(ypos), 0.0), str(name)) 
    124         obj.setRotation(0) 
    125         fife.InstanceVisual.create(obj) 
     110    def addObject(self, name, obj): 
     111        """Add an object to this map0 
     112            Inputs: 
     113                name - ID of object 
     114                obj - FIFE instance of object 
     115            Return: 
     116                Nothing 
     117        """ 
    126118        # save it for later use 
    127119        self.obj_hash[name]=obj 
    128120         
  • scripts/world.py

     
    2121from scripts.parpgfilebrowser import PARPGFileBrowser 
    2222from datetime import date 
    2323from scripts.common.eventlistenerbase import EventListenerBase 
     24from local_loaders.loaders import loadMapFile 
     25from sounds import SoundEngine 
    2426from settings import Setting 
    2527from scripts import inventory, hud 
    2628from scripts.popups import * 
     
    98100    def loadMap(self, mapname, filename): 
    99101        """Loads a map an stores it under the given name in the maps list. 
    100102        """ 
    101         map = Map(self.engine) 
     103        map = Map(self.engine, self.data) 
     104         
     105        """Need to set active map before we load it because the map  
     106        loader uses call backs that expect to find an active map.  
     107        This needs to be reworked. 
     108        """ 
     109        self.maps[mapname] = map 
     110        self.setActiveMap(mapname) 
     111 
    102112        map.load(filename) 
    103         self.maps[mapname] = map 
     113 
    104114     
    105115    def setActiveMap(self, mapname): 
    106116        """Sets the active map that is to be rendered. 
     
    254264            for obj in i: 
    255265                # check to see if this in our list at all 
    256266                if(self.data.objectActive(obj.getId())): 
    257                     # yes, so outline     
     267                    # yes, so outline  
    258268                    self.activeMap.outline_render.addOutlined(obj, 0, 137, 255, 2) 
    259269                    # get the text 
    260270                    item = self.data.objectActive(obj.getId())