source: branches/active/character_customization/game/parpg/gamemodel.py @ 774

Revision 774, 30.8 KB checked in by aspidites, 9 years ago (diff)

Patch by Aspidites

  • removed shebang from all python files except launcher scripts
  • added shebang to pychan_designer
  • Property svn:eol-style set to native
Line 
1#   This file is part of PARPG.
2
3#   PARPG is free software: you can redistribute it and/or modify
4#   it under the terms of the GNU General Public License as published by
5#   the Free Software Foundation, either version 3 of the License, or
6#   (at your option) any later version.
7
8#   PARPG is distributed in the hope that it will be useful,
9#   but WITHOUT ANY WARRANTY; without even the implied warranty of
10#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11#   GNU General Public License for more details.
12
13#   You should have received a copy of the GNU General Public License
14#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>.
15
16# there should be NO references to FIFE here!
17import sys
18import os.path
19import logging
20from copy import deepcopy
21
22from fife import fife
23from fife.extensions.serializers.xmlobject import XMLObjectLoader
24
25from gamestate import GameState
26from objects import createObject
27from objects.composed import CarryableItem, CarryableContainer
28from gamemap import GameMap
29from common.utils import locateFiles
30from common.utils import parseBool
31from inventory import Inventory
32from parpg.dialogueparsers import YamlDialogueParser, DialogueFormatError
33
34try:
35    import xml.etree.cElementTree as ElementTree
36except ImportError:
37    import xml.etree.ElementTree as ElementTree
38
39import yaml
40
41class GameModel(object):
42    """GameModel holds the logic for the game.
43       Since some data (object position and so forth) is held in the
44       fife, and would be pointless to replicate, we hold a instance of
45       the fife view here. This also prevents us from just having a
46       function heavy controller."""
47    ALL_AGENTS_KEY = "All"
48    MAX_ID_NUMBER = 1000
49   
50    def __init__(self, engine, settings):
51        """Initialize the instance.
52        @param engine: A fife.Engine object
53        @type emgome: fife.Engine
54        @param setting: The applications settigns
55        @type setting: parpg.settings.Settings object
56        @return: None"""
57        self.map_change = False
58        self.load_saver = False
59        self.savegame = None
60        self.game_state = GameState(quests_dir=settings.parpg.QuestsDirectory)
61        #self.game_state.quest_engine =
62        #self.game_state.quest_engine.readQuests()
63        self.pc_run = 1
64        self.target_position = None
65        self.target_map_name = None
66        self.object_db = {}
67        self.active_map = None
68        self.map_files = {}
69        self.agents = {}
70        self.agents[self.ALL_AGENTS_KEY] = {}
71        self.engine = engine
72        self.fife_model = engine.getModel()
73
74        # set values from settings
75        self.game_state.maps_file = settings.parpg.MapsFile
76        self.all_agents_file = settings.parpg.AllAgentsFile
77        self.object_db_file = settings.parpg.ObjectDatabaseFile
78        self.agents_directory = settings.parpg.AgentsDirectory
79        self.dialogues_directory = settings.parpg.DialoguesDirectory
80        self.dialogues = {}
81        self.agent_import_files = {}
82        self.settings = settings
83        self.obj_loader = XMLObjectLoader(
84                                          self.engine.getImagePool(), 
85                                          self.engine.getAnimationPool(), 
86                                          self.engine.getModel(),
87                                          self.engine.getVFS() 
88                                          )
89
90    def checkAttributes(self, attributes):
91        """Checks for attributes that where not given in the map file
92        and fills them with values from the object database
93        @param attributes: attributes to check
94        @type attributes: Dictionary
95        @return: The modified attributes""" 
96        if attributes.has_key("object_type"):
97            class_name = attributes.pop("object_type")
98        else:
99            class_name = attributes["type"]
100        if not attributes.has_key("type"):
101            attributes["type"] = class_name
102        if self.object_db.has_key(class_name):
103            db_attributes = deepcopy(self.object_db[class_name])
104            for key in db_attributes.keys():
105                if attributes.has_key(key):
106                    attributes[key] = attributes[key] or db_attributes[key]
107                else:
108                    attributes[key] = db_attributes[key]
109        return attributes
110   
111    def isIDUsed(self, ID):
112        if self.game_state.hasObject(ID):
113            return True
114        for namespace in self.agents:
115            if ID in self.agents[namespace]:
116                return True
117        return False
118   
119    def createUniqueID(self, ID):
120        if self.isIDUsed(ID):
121            id_number = 1
122            while self.isIDUsed(ID + "_" + str(id_number)):
123                id_number += 1
124                if id_number > self.MAX_ID_NUMBER:
125                    raise ValueError(
126                        "Number exceeds MAX_ID_NUMBER:" + str(self.MAX_ID_NUMBER))
127           
128            ID = ID + "_" + str(id_number)
129        return ID
130
131    def createContainerItems(self, container_objs):
132        """Create the items of a container from a dictionary
133        @param container_objs: Dictionary containing the items
134        @type container_objs: dict"""
135        items = []
136        for container_obj in container_objs:
137            items.append(self.createContainerObject(container_obj))
138       
139        return items
140
141    def createContainerObject(self, attributes):
142        """Create an object that can be stored in
143        an container and return it
144        @param attributes: Dictionary of all object attributes
145        @type attributes: Dictionary
146        @return: The created object """
147        # create the extra data
148        extra = {}
149        extra['controller'] = self
150        attributes = self.checkAttributes(attributes)
151       
152        info = {}
153        info.update(attributes)
154        info.update(extra)
155        ID = info.pop("id") if info.has_key("id") else info.pop("ID")
156        if not info.has_key("item_type"):
157            info["item_type"] = info["type"]
158        ID = self.createUniqueID(ID)
159        if info.has_key("attributes"):
160            attributes = info["attributes"]
161            if "Container" in attributes:
162                info["actions"]["Open"] = ""
163                if info.has_key("Items"):
164                    inventory_objs = info["Items"]
165                    info["items"] = self.createContainerItems(inventory_objs)
166               
167                new_item = CarryableContainer(ID = ID, **info) 
168            else:
169                new_item = CarryableItem(ID = ID, **info) 
170        else:
171            new_item = CarryableItem(ID = ID, **info) 
172        self.game_state.addObject(None, new_item)
173        return new_item
174     
175    def createInventoryObject(self, container, attributes):
176        """Create an inventory object and place it into a container
177           @type container: base.Container
178           @param container: Container where the item is on
179           @type attributes: Dictionary
180           @param attributes: Dictionary of all object attributes
181           @return: None"""
182        index = attributes.pop("index") if attributes.has_key("index") else None
183        slot = attributes.pop("slot") if attributes.has_key("slot") else None
184        obj = self.createContainerObject(attributes)       
185        #obj = createObject(attributes, extra)
186        if slot:
187            container.moveItemToSlot(obj, slot)
188        else:
189            container.placeItem(obj, index)
190   
191    def deleteObject(self, object_id):
192        """Removes an object from the game
193        @param object_id: ID of the object
194        @type object_id: str """
195        del self.agents["All"][object_id]
196        self.game_state.deleteObject(object_id)
197       
198    def save(self, path, filename):
199        """Writes the saver to a file.
200           @type filename: string
201           @param filename: the name of the file to write to
202           @return: None"""
203        fname = '/'.join([path, filename])
204        try:
205            save_file = open(fname, 'w')
206        except(IOError):
207            sys.stderr.write("Error: Can't create save game: " + fname + "\n")
208            return
209        save_state = {}
210        save_state["Agents"] = {}
211        for map_name in self.agents:
212            if map_name == self.ALL_AGENTS_KEY:
213                continue
214            agents_dict = {}
215            for agent in self.agents[map_name]:
216                agent_obj = self.game_state.getObjectById(agent, map_name)
217                agent_inst = self.game_state.maps[map_name].\
218                                    agent_layer.getInstance(agent)
219                agent_dict = self.agents[map_name][agent]
220                agent_dict.update(agent_obj.getStateForSaving())
221                agent_dict["Rotation"] = agent_inst.getRotation()
222                agents_dict[agent] = agent_dict
223            save_state["Agents"][map_name] = agents_dict
224        agents_dict = {}
225        for agent in self.agents["All"]:
226            map_name = self.agents["All"][agent]["Map"]
227            agent_dict = self.agents["All"][agent]
228            agent_obj = None
229            if agent == "PlayerCharacter":
230                agent_obj = self.game_state.player_character
231            else:
232                agent_obj = self.game_state.getObjectById(agent, map_name)
233            if agent_obj:
234                agent_inst = self.game_state.maps[map_name].\
235                                    agent_layer.getInstance(agent)
236                agent_dict.update(agent_obj.getStateForSaving())
237                agent_dict["Rotation"] = agent_inst.getRotation()
238                agent_dict["MapName"] = map_name
239            agents_dict[agent] = agent_dict
240        save_state["Agents"]["All"] = agents_dict
241        save_state["GameState"] = self.game_state.getStateForSaving()
242        yaml.dump(save_state, save_file)
243       
244        save_file.close()       
245
246    def load(self, path, filename):
247        """Loads a saver from a file.
248           @type filename: string
249           @param filename: the name of the file (including path) to load from
250           @return: None"""
251        fname = '/'.join([path, filename])
252
253        try:
254            load_file = open(fname, 'r')
255        except(IOError):
256            sys.stderr.write("Error: Can't find save game file\n")
257            return       
258        self.deleteMaps()
259        self.clearAgents()
260       
261        save_state = yaml.load(load_file)
262        self.game_state.restoreFromState(save_state["GameState"])
263        maps = save_state["Agents"]
264        for map_name in maps:
265            for agent_name in maps[map_name]:
266                agent = {agent_name:maps[map_name][agent_name]}
267                self.addAgent(map_name, agent)
268               
269        # Load the current map
270        if self.game_state.current_map_name:
271            self.loadMap(self.game_state.current_map_name)         
272        load_file.close()
273       
274
275        # Recreate all the behaviours. These can't be saved because FIFE
276        # objects cannot be pickled
277       
278        self.placeAgents()
279        self.placePC()
280     
281        # In most maps we'll create the PlayerCharacter Instance internally.
282        # In these cases we need a target position
283         
284    def teleport(self, agent, position):
285        """Called when a an agent is moved instantly to a new position.
286        The setting of position may wan to be created as its own method down the road.
287        @type position: String Tuple
288        @param position: X,Y coordinates passed from engine.changeMap
289        @return: fife.Location"""
290        print position
291        coord = fife.DoublePoint3D(float(position[0]), float(position[1]), 0)
292        location = fife.Location(self.active_map.agent_layer)
293        location.setMapCoordinates(coord)
294        agent.teleport(location)         
295               
296    def getObjectAtCoords(self, coords):
297        """Get the object which is at the given coords
298        @type coords: fife.Screenpoint
299        @param coords: Coordinates where to check for an object
300        @rtype: fife.Object
301        @return: An object or None"""
302        instances = self.active_map.cameras[
303                                            self.active_map.my_cam_id].\
304            getMatchingInstances(coords, self.active_map.agent_layer)
305        # no object returns an empty tuple
306        if(instances != ()):
307            front_y = 0
308           
309
310            for obj in instances:
311                # check to see if this in our list at all
312                if(self.objectActive(obj.getId())):
313                    # check if the object is on the foreground
314                    obj_map_coords = \
315                                      obj.getLocation().getMapCoordinates()
316                    obj_screen_coords = self.active_map.\
317                        cameras[self.active_map.my_cam_id]\
318                        .toScreenCoordinates(obj_map_coords)
319
320                    if obj_screen_coords.y > front_y:
321                        #Object on the foreground
322                        front_y = obj_screen_coords.y
323                        return obj
324                    else:
325                        return None
326        else:
327            return None
328
329    def getCoords(self, click):
330        """Get the map location x, y coordinates from the screen coordinates
331           @type click: fife.ScreenPoint
332           @param click: Screen coordinates
333           @rtype: fife.Location
334           @return: The map coordinates"""
335        coord = self.active_map.cameras[self.active_map.my_cam_id].\
336                    toMapCoordinates(click, False)
337        coord.z = 0
338        location = fife.Location(self.active_map.agent_layer)
339        location.setMapCoordinates(coord)
340        return location
341
342    def pause(self, paused):
343        """ Pause/Unpause the game
344        @return: nothing"""
345        if self.active_map:
346            self.active_map.pause(paused)
347   
348    def togglePause(self):
349        """ Toggle paused state.
350        @return: nothing"""
351        self.active_map.togglePause()
352       
353    def isPaused(self):
354        """Returns wheter the game is paused or not"""
355        return self.active_map.isPaused()
356   
357    def readMapFiles(self):
358        """Read all a available map-files and store them"""
359        maps_data = file(self.game_state.maps_file)
360        self.map_files = yaml.load(maps_data)["Maps"]
361   
362    def addAgent(self, namespace, agent):
363        """Adds an agent to the agents dictionary
364        @param namespace: the namespace where the agent is to be added to
365        @type namespace: str
366        @param agent: The agent to be added
367        @type agent: dict """
368        from fife.extensions.serializers.xml_loader_tools import loadImportFile
369        if not self.agents.has_key(namespace):
370            self.agents[namespace] = {}
371           
372        agent_values = agent.values()[0]
373        unique_agent_id = self.createUniqueID(agent.keys()[0])
374        del agent[agent.keys()[0]]
375        agent[unique_agent_id] = agent_values
376        self.agents[namespace].update(agent)
377        object_model = ""
378        if agent_values.has_key("ObjectModel"): 
379            object_model =  agent_values["ObjectModel"]
380        elif agent_values["ObjectType"] == "MapItem":
381            object_data = self.object_db[agent_values["ItemType"]]
382            object_model = object_data["gfx"] if object_data.has_key("gfx") \
383                        else "generic_item"
384        else:
385            object_model = self.object_db[agent_values["ObjectType"]]["gfx"]
386        import_file = self.agent_import_files[object_model]
387        loadImportFile(self.obj_loader, import_file, self.engine)
388       
389    def readAgentsOfMap(self, map_name):
390        """Read the agents of the map
391        @param map_name: Name of the map
392        @type map_name: str """
393        #Get the agents of the map       
394        map_agents_file = self.map_files[map_name].\
395                            replace(".xml", "_agents.yaml")   
396        agents_data = file(map_agents_file)
397        agents = yaml.load_all(agents_data)
398        for agent in agents:
399            if not agent == None:
400                self.addAgent(map_name, agent) 
401   
402    def readAllAgents(self):
403        """Read the agents of the all_agents_file and store them"""
404        agents_data = file(self.all_agents_file)
405        agents = yaml.load_all(agents_data)
406        for agent in agents:
407            if not agent == None:
408                self.addAgent(self.ALL_AGENTS_KEY, agent) 
409               
410    def getAgentsOfMap(self, map_name):
411        """Returns the agents that are on the given map
412        @param map_name: Name of the map
413        @type map_name: str
414        @return: A dictionary with the agents of the map"""
415        if not self.agents.has_key(map_name):
416            return {}
417        ret_dict = self.agents[map_name].copy()
418        for agent_name, agent_value in self.agents[self.ALL_AGENTS_KEY]\
419                                                .iteritems():
420            if agent_value["Map"] == map_name:
421                ret_dict[agent_name] = agent_value
422        return ret_dict
423               
424    def getAgentsOfActiveMap(self):
425        """Returns the agents that are on active map
426        @return: A dictionary with the agents of the map """
427        return self.getAgentsOfMap(self.active_map.map.getId())
428
429    def clearAgents(self):
430        """Resets the agents dictionary"""
431        self.agents = {}
432        self.agents[self.ALL_AGENTS_KEY] = {}
433   
434    def loadMap(self, map_name):
435        """Load a new map.
436           @type map_name: string
437           @param map_name: Name of the map to load
438           @return: None"""
439        if not map_name in self.game_state.maps: 
440            map_file = self.map_files[map_name]
441            new_map = GameMap(self.engine, self)
442            self.game_state.maps[map_name] = new_map
443            new_map.load(map_file)   
444
445    def createAgent(self, agent, inst_id):
446        object_type = agent["ObjectType"]
447        object_id = agent["ObjectModel"] \
448                                if agent.has_key("ObjectModel") \
449                                else None
450        if object_id == None:
451            if object_type == "MapItem":
452                object_data = self.object_db[agent["ItemType"]]
453                object_id = object_data["gfx"] if object_data.has_key("gfx") \
454                            else "generic_item"
455            else:
456                object_id = self.object_db[object_type]["gfx"]
457        map_obj = self.fife_model.getObject(str(object_id), "PARPG")
458        if not map_obj:
459            print ''.join(['Object with inst_id=', str(object_id), 
460                           ' ns=PARPG', \
461                           ' could not be found. Omitting...'])
462
463        x_pos = agent["Position"][0]
464        y_pos = agent["Position"][1]
465        z_pos = agent["Position"][2] if len(agent["Position"]) == 3 \
466                                        else -0.1 if object_type == "MapItem" \
467                                        else 0.0 
468        stack_pos = agent["Stackposition"] if \
469                        agent.has_key("StackPosition") \
470                        else None
471        inst = self.active_map.agent_layer.\
472                        createInstance(map_obj,
473                                       fife.ExactModelCoordinate(x_pos, 
474                                                                 y_pos, 
475                                                                 z_pos),
476                                       inst_id)
477        inst.setId(inst_id)
478
479        rotation = agent["Rotation"]
480        inst.setRotation(rotation)
481
482        fife.InstanceVisual.create(inst)
483        if (stack_pos):
484            inst.get2dGfxVisual().setStackPosition(int(stack_pos))
485
486        if (map_obj.getAction('default')):
487            target = fife.Location(self.active_map.agent_layer)
488            inst.act('default', target, True)
489           
490        inst_dict = {}
491        inst_dict["id"] = inst_id
492        inst_dict["type"] = object_type
493        inst_dict["xpos"] = x_pos
494        inst_dict["ypos"] = y_pos
495        inst_dict["gfx"] = object_id
496        inst_dict["is_open"] = parseBool(agent["Open"]) \
497                                if agent.has_key("Open") \
498                                else False
499        inst_dict["locked"] = parseBool(agent["Locked"]) \
500                                if agent.has_key("Locked") \
501                                else False
502        inst_dict["name"] = agent["ViewName"]
503        inst_dict["real_name"] = agent["RealName"] \
504                                    if agent.has_key("RealName") \
505                                    else agent["ViewName"]
506        inst_dict["text"] = agent["Text"] \
507                                    if agent.has_key("Text") \
508                                    else None
509        if self.dialogues.has_key(inst_id):
510            inst_dict["dialogue"] = self.dialogues[inst_id]
511        inst_dict["target_map_name"] = agent["TargetMap"] \
512                                        if agent.\
513                                            has_key("TargetMap") \
514                                        else None
515        inst_dict["target_x"] = agent["TargetPosition"][0] \
516                                    if agent.\
517                                        has_key("TargetPosition") \
518                                    else None
519        inst_dict["target_y"] = agent["TargetPosition"][1] \
520                                    if agent.\
521                                        has_key("TargetPosition") \
522                                    else None
523        if agent.has_key("Inventory"):
524            inventory = Inventory()
525            inventory_objs = agent["Inventory"]
526            for inventory_obj in inventory_objs:
527                self.createInventoryObject(inventory,
528                                           inventory_obj
529                                           )
530            inst_dict["inventory"] = inventory
531
532        if agent.has_key("Items"):
533            container_objs = agent["Items"]
534            items = self.createContainerItems(container_objs)
535            inst_dict["items"] = items
536           
537        if agent.has_key("ItemType"):
538            if not agent.has_key("item"):
539                item_data = {}
540                item_data["type"] = agent["ItemType"]
541                item_data["ID"] = inst_id
542                item_data = self.createContainerObject(item_data)
543            else:
544                item_data = agent["item"]
545            inst_dict["item"] = item_data
546            inst_dict["item_type"] = agent["ItemType"]
547
548        self.createMapObject(self.active_map.agent_layer, inst_dict)
549   
550    def placeAgents(self):
551        """Places the current maps agents """
552        if not self.active_map:
553            return
554        agents = self.getAgentsOfMap(self.game_state.current_map_name)
555        for agent in agents:
556            if agent == "PlayerCharacter":
557                continue
558            if self.active_map.agent_layer.getInstances(agent):
559                continue
560            self.createAgent(agents[agent], agent)
561
562    def placePC(self):
563        """Places the PlayerCharacter on the map"""
564        agent = self.agents[self.ALL_AGENTS_KEY]["PlayerCharacter"]
565        inst_id = "PlayerCharacter"
566        self.createAgent(agent, inst_id)
567       
568        # create the PlayerCharacter agent
569        self.active_map.addPC()
570        self.game_state.player_character.start()
571        if agent.has_key("PeopleKnown"):
572            self.game_state.player_character.people_i_know = agent["PeopleKnown"]
573                     
574    def changeMap(self, map_name, target_position = None):
575        """Registers for a map change on the next pump().
576           @type map_name: String
577           @param map_name: Id of the map to teleport to
578           @type map_file: String
579           @param map_file: Filename of the map to teleport to
580           @type target_position: Tuple
581           @param target_position: Position of PlayerCharacter on target map.
582           @return None"""
583        # set the parameters for the map change if moving to a new map
584        if map_name != self.game_state.current_map_name:
585            self.target_map_name = map_name
586            self.target_position = target_position
587            # issue the map change
588            self.map_change = True
589
590    def deleteMaps(self):
591        """Clear all currently loaded maps from FIFE as well as clear our
592            local map cache
593            @return: nothing"""
594        self.engine.getModel().deleteMaps()
595        self.engine.getModel().deleteObjects()
596        self.game_state.clearObjects()
597        self.game_state.maps = {}
598       
599    def setActiveMap(self, map_name):
600        """Sets the active map that is to be rendered.
601           @type map_name: String
602           @param map_name: The name of the map to load
603           @return: None"""
604        # Turn off the camera on the old map before we turn on the camera
605        # on the new map.
606        self.active_map.cameras[self.active_map.my_cam_id].setEnabled(False)
607        # Make the new map active.
608        self.active_map = self.game_state.maps[map_name]
609        self.active_map.makeActive()
610        self.game_state.current_map_name = map_name
611
612    def createMapObject (self, layer, attributes):
613        """Create an object and add it to the current map.
614           @type layer: fife.Layer
615           @param layer: FIFE layer object exists in
616           @type attributes: Dictionary
617           @param attributes: Dictionary of all object attributes
618           @type instance: fife.Instance
619           @param instance: FIFE instance corresponding to the object
620           @return: None"""
621        # create the extra data
622        extra = {}
623        if layer is not None:
624            extra['agent_layer'] = layer
625        attributes = self.checkAttributes(attributes)
626       
627        obj = createObject(attributes, extra)
628       
629        if obj.trueAttr("PC"):
630            self.addPC(layer, obj)
631        else:
632            self.addObject(layer, obj) 
633
634    def addPC(self, layer, player_char):
635        """Add the PlayerCharacter to the map
636           @type layer: fife.Layer
637           @param layer: FIFE layer object exists in
638           @type player_char: PlayerCharacter
639           @param player_char: PlayerCharacter object
640           @type instance: fife.Instance
641           @param instance: FIFE instance of PlayerCharacter
642           @return: None"""
643        # For now we copy the PlayerCharacter,
644        # in the future we will need to copy
645        # PlayerCharacter specifics between the different PlayerCharacter's
646        self.game_state.player_character = player_char
647        self.game_state.player_character.setup()       
648        self.game_state.player_character.behaviour.speed = self.settings.parpg.PCSpeed
649
650
651    def addObject(self, layer, obj):
652        """Adds an object to the map.
653           @type layer: fife.Layer
654           @param layer: FIFE layer object exists in
655           @type obj: GameObject
656           @param obj: corresponding object class
657           @type instance: fife.Instance
658           @param instance: FIFE instance of object
659           @return: None"""
660        ref = self.game_state.getObjectById(obj.ID, \
661                                            self.game_state.current_map_name) 
662        if ref is None:
663            # no, add it to the game state
664            self.game_state.addObject(self.game_state.current_map_name, obj)
665        else:
666            # yes, use the current game state data
667            obj.X = ref.X
668            obj.Y = ref.Y
669            obj.gfx = ref.gfx 
670             
671        if obj.trueAttr("NPC"):
672            # create the agent
673            obj.setup()
674            obj.behaviour.speed = self.settings.parpg.PCSpeed - 1
675            # create the PlayerCharacter agent
676            obj.start()
677        if obj.trueAttr("AnimatedContainer"):
678            # create the agent
679            obj.setup()
680
681    def objectActive(self, ident):
682        """Given the objects ID, pass back the object if it is active,
683           False if it doesn't exist or not displayed
684           @type ident: string
685           @param ident: ID of object
686           @rtype: boolean
687           @return: Status of result (True/False)"""
688        for game_object in \
689           self.game_state.getObjectsFromMap(self.game_state.current_map_name):
690            if (game_object.ID == ident):
691                # we found a match
692                return game_object
693        # no match
694        return False   
695
696    def movePlayer(self, position):
697        """Code called when the player should move to another location
698           @type position: fife.ScreenPoint
699           @param position: Screen position to move to
700           @return: None"""
701        if(self.pc_run == 1):
702            self.game_state.player_character.run(position)
703        else:
704            self.game_state.player_character.walk(position)
705       
706    def teleportAgent(self, agent, position):
707        """Code called when an agent should teleport to another location
708           @type position: fife.ScreenPoint
709           @param position: Screen position to teleport to
710           @return: None"""
711        agent.teleport(position)
712        self.agents[agent.ID]["Position"] = position
713
714    def readObjectDB(self):
715        """Reads the Object Information Database from a file. """
716        database_file = file(self.object_db_file, "r")
717        database = yaml.load_all(database_file)
718        for object_info in database:
719            self.object_db.update(object_info)
720
721    def getAgentImportFiles(self):
722        """Searches the agents directory for import files """
723        files = locateFiles("*.xml", self.agents_directory)
724        for xml_file in files:
725            xml_file = os.path.relpath(xml_file).replace("\\", "/")
726            try:
727                root = ElementTree.parse(xml_file).getroot()
728                if root.tag == "object":
729                    self.agent_import_files[root.attrib["id"]] = xml_file
730            except SyntaxError as error:
731                assert(isinstance(error, SyntaxError))
732                print "Error parsing file " + xml_file + ": " + error.msg
733                #TODO: We may want to make this an fatal error later.
734   
735    def getDialogues(self):
736        """Searches the dialogue directory for dialogues """
737        files = locateFiles("*.yaml", self.dialogues_directory)
738        dialogue_parser = YamlDialogueParser()
739        for dialogue_filepath in files:
740            dialogue_filepath = os.path.relpath(dialogue_filepath) \
741                                .replace("\\", "/")
742            # Note Technomage 2010-11-13: the new DialogueEngine uses its own
743            #     parser now, YamlDialogueParser.
744#            dialogues = yaml.load_all(file(dialogue_file, "r"))
745            with file(dialogue_filepath, 'r') as dialogue_file:
746                try:
747                    dialogue = dialogue_parser.load(dialogue_file)
748                except (DialogueFormatError,) as error:
749                    logging.error('unable to load dialogue file {0}: {1}'
750                                  .format(dialogue_filepath, error))
751                else:
752                    self.dialogues[dialogue.npc_name] = dialogue
753            # Note Technomage 2010-11-13: the below code is used to load
754            #     multiple dialogues from a single file. Is this functionality
755            #     used/necessary?
756#            for dialogue in dialogues:
757#                self.dialogues[dialogue["NPC"]] = dialogue
Note: See TracBrowser for help on using the repository browser.