Changeset 264


Ignore:
Timestamp:
08/28/09 15:05:39 (10 years ago)
Author:
Kaydeth_parpg
Message:

Ticket #72: Patch by Kaydeth. The separate objects file was merged back into the main map file that FIFE parses to load each Map. The Map, Engine, and World classes were all updated to allow game object creation to happen as the map file is loaded. loaders.py and xmlmap.py were copied from the FIFE code base and made local so that we can now customize how we pass the parsed map and object information to FIFE.

Location:
trunk/game
Files:
4 added
1 deleted
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/maps/map.xml

    r204 r264  
    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> 
  • trunk/game/scripts/engine.py

    r253 r264  
    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) 
    143  
    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) 
     118        obj = createObject(attributes, extra) 
     119         
     120        if obj.trueAttr("PC"): 
     121            self.addPC( layer, obj, instance) 
     122        else: 
     123            self.addObject( layer, obj, instance) 
     124 
     125         
     126 
     127    def addPC(self, layer, pc, instance): 
     128        """Add the PC to the map 
     129            Inputs: 
     130                layer = FIFE layer object exists in 
     131                pc = PlayerCharacter object 
     132                instance = FIFE instance of PC 
     133            Returns: 
     134                Nothing 
     135        """ 
     136        # add to view data  
     137        self.view.activeMap.addObject(pc.ID, instance)           
    151138         
    152139        # sync with game data 
     
    155142             
    156143        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() 
    161  
    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""" 
     144 
     145 
     146    def addObject(self, layer, obj, instance): 
     147        """Adds an object to the map. 
     148            Inputs: 
     149                layer = FIFE layer object exists in 
     150                obj = corresponding object class 
     151                instance = FIFE instance of object 
     152            Returns: 
     153                Nothing 
     154        """ 
    167155         
    168156        ref = self.gameState.getObjectById(obj.ID)  
     
    178166             
    179167        # add it to the view 
    180         self.view.activeMap.addObject(obj.X, obj.Y, obj.gfx, obj.ID)           
    181          
     168        self.view.activeMap.addObject(obj.ID, instance)           
     169        
    182170        if obj.trueAttr("NPC"): 
    183171            # create the agent 
     
    260248           @param map_file: Name of map file to load 
    261249           @return: None""" 
    262         # then we let FIFE load the rest of the map 
     250        self.gameState.currentMap = map_file 
    263251        self.view.loadMap(map_name, str(map_file)) 
    264252        self.view.setActiveMap(map_name) 
    265         # 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") 
     253 
     254        self.reset()         
     255         
     256        # create the PC agent 
     257        self.view.activeMap.addPC(self.gameState.PC.behaviour.agent) 
     258        self.gameState.PC.start() 
    269259 
    270260    def handleMouseClick(self,position): 
  • trunk/game/scripts/map.py

    r262 r264  
    1717 
    1818import fife, time 
    19 from loaders import loadMapFile 
     19from local_loaders.loaders import loadMapFile 
    2020from scripts.common.eventlistenerbase import EventListenerBase 
    2121 
     
    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 
     
    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') 
     
    100101    def addPC(self, agent): 
    101102        """Add the player character to the map 
    102            @type agent: Fife.instance 
    103            @param : The object to use as the PC sprite 
     103           @type agent: Fife.instance of PC 
    104104           @return: None""" 
    105105        # actually this is real easy, we just have to 
     
    107107        self.cameras['main'].attach(agent) 
    108108 
    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) 
     109    def addObject(self, name, obj): 
     110        """Add an object to this map0 
     111            Inputs: 
     112                name - ID of object 
     113                obj - FIFE instance of object 
     114            Return: 
     115                Nothing 
     116        """ 
    126117        # save it for later use 
    127118        self.obj_hash[name]=obj 
  • trunk/game/scripts/world.py

    r261 r264  
    2121from datetime import date 
    2222from scripts.common.eventlistenerbase import EventListenerBase 
     23from local_loaders.loaders import loadMapFile 
     24from sounds import SoundEngine 
    2325from settings import Setting 
    2426from scripts import inventory, hud 
     
    9193        """Loads a map an stores it under the given name in the maps list. 
    9294        """ 
    93         map = Map(self.engine) 
     95        map = Map(self.engine, self.data) 
     96         
     97        """Need to set active map before we load it because the map  
     98        loader uses call backs that expect to find an active map.  
     99        This needs to be reworked. 
     100        """ 
     101        self.maps[mapname] = map 
     102        self.setActiveMap(mapname) 
     103 
    94104        map.load(filename) 
    95         self.maps[mapname] = map 
     105 
    96106     
    97107    def setActiveMap(self, mapname): 
     
    199209                # check to see if this in our list at all 
    200210                if(self.data.objectActive(obj.getId())): 
    201                     # yes, so outline     
     211                    # yes, so outline  
    202212                    self.activeMap.outline_render.addOutlined(obj, 0, 137, 255, 2) 
    203213                    # get the text 
Note: See TracChangeset for help on using the changeset viewer.