Changeset 562


Ignore:
Timestamp:
06/25/10 17:39:59 (9 years ago)
Author:
beliar
Message:

Ticket #200: Patch by Beliar.

  • Saving and loading works again - even when not saving on the main map
  • Small code changes
Location:
branches/map_loading_change/game
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • branches/map_loading_change/game/local_loaders/xmlmap.py

    r560 r562  
    404404                if inventory_el is not None: 
    405405                    inventory = Inventory() 
    406                     inv_objects = inventory_el.findall("map_obj") 
     406                    inv_objects = inventory_el.findall("object") 
    407407                    for inv_object in inv_objects: 
    408408                        attributes = inv_object.attrib.copy() 
    409409                        self.model.createInventoryObject(inventory, attributes) 
    410410                    inst_dict["inventory"] = inventory 
     411                 
     412                inventory_el = instance.find("items")    
     413                if inventory_el is not None: 
     414                    items = [] 
     415                    inv_objects = inventory_el.findall("object") 
     416                    for inv_object in inv_objects: 
     417                        attributes = inv_object.attrib.copy() 
     418                        items.append(self.model.createContainerObject(attributes)) 
     419                    inst_dict["items"] = items 
     420 
    411421                self.model.createMapObject(layer, inst_dict, inst) 
    412422                 
  • branches/map_loading_change/game/maps/all_agents.yaml

    r561 r562  
    1313#   You should have received a copy of the GNU General Public License 
    1414#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    15 --- 
     15---             
    1616PlayerCharacter: 
    1717    ViewName: "Player Character" 
     
    2323    Rotation: 0 
    2424    Inventory: 
    25         - {ID: "456", object_type: "Dagger123", slot: "right_hand"} 
     25        - {ID: "456", object_type: "Dagger", slot: "right_hand"} 
    2626        - {ID: "555", object_type: "Beer"} 
    2727        - {ID: "616", object_type: "Pamphlet"} 
    28 --- 
     28---             
    2929Janie: 
    3030    ViewName: "Janie" 
     
    166166    Position: [-3.0, -3.0, 0.0] 
    167167    Rotation: 0 
    168 --- 
     168---             
    169169Sami: 
    170170    ViewName: "Sami" 
     
    176176    Position: [3.0, 4.0, 0.0] 
    177177    Rotation: 0 
    178 --- 
     178---             
    179179Rasmus: 
    180180    ViewName: "Rasmus" 
  • branches/map_loading_change/game/maps/map2_agents.yaml

    r560 r562  
    2121    Rotation: 0 
    2222    TargetMap: "Mall" 
    23     TargetPosition: [5.0, 5.0] 
     23    TargetPosition: [-6.5, -12.0] 
  • branches/map_loading_change/game/maps/map_agents.yaml

    r560 r562  
    2121    Position: [-2.0, -11.0, 0.0] 
    2222    Rotation: 0 
     23    Items: 
     24    - {ID: "456", object_type: "Dagger"} 
    2325--- 
    2426ShantyDoor: 
     
    2931    Rotation: 0 
    3032    TargetMap: "Farm" 
    31     TargetPosition: [10.0, 10.0] 
     33    TargetPosition: [-2.0, 5.0] 
    3234--- 
    3335Footlocker: 
     
    3739    Position: [-9.0, 0.0, 0.0] 
    3840    Rotation: 255 
     41    Items: 
     42    - {ID: "456", object_type: "Dagger"} 
  • branches/map_loading_change/game/objects/ObjectDatabase.yaml

    r555 r562  
    1515--- 
    1616Footlocker: 
    17   name: Footlockers 
     17  name: Footlocker 
    1818  text: Just a normal footlocker used to store items. 
    1919  gfx: lock_box_metal01 
     
    2525--- 
    2626ShantyDoor: 
    27   name: "Shanty Door" 
    28   text: "Looks like the entrance to the building." 
    29   gfx: "shanty-door" 
     27  name: Shanty Door 
     28  text: Looks like the entrance to the building. 
     29  gfx: shanty-door 
    3030--- 
    31 Dagger123: 
    32   name: "Dagger123" 
     31Dagger: 
     32  name: Dagger 
    3333--- 
    3434Beer: 
    35   name: "Beer" 
     35  name: Beer 
    3636--- 
    3737Pamphlet: 
    38   name: "Pamphlet" 
    39   image: "/gui/inv_images/inv_pamphlet.png" 
     38  name: Pamphlet 
     39  image: /gui/inv_images/inv_pamphlet.png 
    4040   
  • branches/map_loading_change/game/scripts/gamemodel.py

    r560 r562  
    4141       the fife view here. This also prevents us from just having a 
    4242       function heavy controller.""" 
     43    ALL_AGENTS_KEY = "All" 
    4344        
    4445    def __init__(self, engine, settings): 
     
    6162        self.map_files = {} 
    6263        self.agents = {} 
    63         self.agents["all"] = {} 
     64        self.agents[self.ALL_AGENTS_KEY] = {} 
    6465        self.engine = engine 
    6566        self.fife_model = engine.getModel() 
     
    9293        return attributes 
    9394     
     95    def createContainerObject(self, attributes): 
     96        """Create an object that can be stored in  
     97        an container and return it 
     98        @param attributes: Dictionary of all object attributes 
     99        @type attributes: Dictionary 
     100        @return: The created object 
     101        """ 
     102        # create the extra data 
     103        extra = {} 
     104        extra['controller'] = self 
     105        attributes = self.checkAttributes(attributes) 
     106         
     107        """TODO: Change when we use other and or more classes  
     108        for inventory objects""" 
     109        info = {} 
     110        info.update(attributes) 
     111        info.update(extra) 
     112        ID = info.pop("id") if info.has_key("id") else info.pop("ID") 
     113                 
     114        return CarryableItem(ID = ID, **info)   
     115       
    94116    def createInventoryObject(self, container, attributes): 
    95117        """Create an inventory object and place it into a container 
     
    99121           @param attributes: Dictionary of all object attributes 
    100122           @return: None""" 
    101         # create the extra data 
    102         extra = {} 
    103         extra['controller'] = self 
    104         attributes = self.checkAttributes(attributes) 
    105          
    106         """TODO: Change when we use other and or more classes  
    107         for inventory objects""" 
    108         info = {} 
    109         info.update(attributes) 
    110         info.update(extra) 
    111         ID = info.pop("id") if info.has_key("id") else info.pop("ID") 
    112         index = info.pop("index") if info.has_key("index") else None 
    113         slot = info.pop("slot") if info.has_key("slot") else None 
    114          
    115         obj = CarryableItem(ID = ID, **info) 
     123        index = attributes.pop("index") if attributes.has_key("index") else None 
     124        slot = attributes.pop("slot") if attributes.has_key("slot") else None 
     125        obj = self.createContainerObject(attributes)         
    116126        #obj = createObject(attributes, extra) 
    117127        if slot: 
     
    127137        fname = '/'.join([path, filename]) 
    128138        try: 
    129             save_file = open(fname, 'wb') 
     139            save_file = open(fname, 'w') 
    130140        except(IOError): 
    131             sys.stderr.write("Error: Can't find save game: " + fname + "\n") 
     141            sys.stderr.write("Error: Can't create save game: " + fname + "\n") 
    132142            return 
    133          
    134         # save the PC coordinates 
    135         coords = self.game_state.PlayerCharacter.behaviour.agent.getLocation().\ 
    136                     getMapCoordinates() 
    137         self.game_state.saved_pc_coordinates = (coords.x, coords.y) 
    138          
    139         # Pickle it  
    140         pickle.dump(self.game_state, save_file) 
     143        save_state = {} 
     144        save_state["Agents"] = {} 
     145        for map_name in self.agents: 
     146            if map_name == self.ALL_AGENTS_KEY: 
     147                continue 
     148            agents_dict = {} 
     149            for agent in self.agents[map_name]: 
     150                agent_obj = self.game_state.getObjectById(agent, map_name) 
     151                agent_inst = self.maps[map_name].agent_layer.getInstance(agent) 
     152                agent_dict = self.agents[map_name][agent] 
     153                agent_dict.update(agent_obj.getStateForSaving()) 
     154                agent_dict["Rotation"] = agent_inst.getRotation() 
     155                agents_dict[agent] = agent_dict 
     156            save_state["Agents"][map_name] = agents_dict 
     157        agents_dict = {} 
     158        for agent in self.agents["All"]: 
     159            map_name = self.agents["All"][agent]["Map"] 
     160            agent_dict = self.agents["All"][agent] 
     161            agent_obj = None 
     162            if agent == "PlayerCharacter": 
     163                agent_obj = self.game_state.PlayerCharacter 
     164            else: 
     165                agent_obj = self.game_state.getObjectById(agent, map_name) 
     166            if agent_obj: 
     167                agent_inst = self.maps[map_name].agent_layer.getInstance(agent) 
     168                agent_dict.update(agent_obj.getStateForSaving()) 
     169                agent_dict["Rotation"] = agent_inst.getRotation() 
     170                agent_dict["MapName"] = map_name 
     171            agents_dict[agent] = agent_dict 
     172        save_state["Agents"]["All"] = agents_dict 
     173        save_state["GameState"] = self.game_state.getStateForSaving() 
     174        yaml.dump(save_state, save_file) 
     175         
    141176        save_file.close()        
    142177 
     
    149184 
    150185        try: 
    151             load_file = open(fname, 'rb') 
     186            load_file = open(fname, 'r') 
    152187        except(IOError): 
    153188            sys.stderr.write("Error: Can't find save game file\n") 
    154189            return         
    155          
    156         self.game_state = pickle.load(load_file) 
     190        self.deleteMaps() 
     191        self.clearAgents() 
     192         
     193        save_state = yaml.load(load_file) 
     194        self.game_state.restoreFromState(save_state["GameState"]) 
     195        maps = save_state["Agents"] 
     196        for map_name in maps: 
     197            for agent_name in maps[map_name]: 
     198                agent = {agent_name:maps[map_name][agent_name]} 
     199                self.addAgent(map_name, agent) 
     200                 
    157201        load_file.close() 
    158  
    159         self.target_position = self.game_state.saved_pc_coordinates 
    160  
     202         
    161203        # Load the current map 
    162         if self.game_state.current_map_file: 
    163             self.loadMap(self.game_state.current_map_name, \ 
    164                          self.game_state.current_map_file)          
     204        if self.game_state.current_map_name: 
     205            self.loadMap(self.game_state.current_map_name)          
    165206 
    166207        # Recreate all the behaviours. These can't be saved because FIFE 
    167208        # objects cannot be pickled 
    168209         
    169         for map_id in self.game_state.objects: 
    170             for obj in self.game_state.objects[map_id].itervalues(): 
    171                 if obj.trueAttr("NPC") or obj.trueAttr("AnimatedContainer"): 
    172                     obj.createBehaviour(self.active_map.agent_layer) 
    173                     obj.setup() 
     210        self.placeAgents() 
     211        self.placePC() 
    174212       
    175213        # In most maps we'll create the PlayerCharacter Instance internally.  
     
    271309        for agent in agents: 
    272310            if not agent == None: 
    273                 self.addAgent("all", agent)   
     311                self.addAgent(self.ALL_AGENTS_KEY, agent)   
    274312                 
    275313    def getAgentsOfMap(self, map_name): 
     
    281319        if not self.agents.has_key(map_name): 
    282320            return {} 
    283         ret_dict = self.agents[map_name] 
    284         for agent_name, agent_value in self.agents["all"].iteritems(): 
     321        ret_dict = self.agents[map_name].copy() 
     322        for agent_name, agent_value in self.agents[self.ALL_AGENTS_KEY].iteritems(): 
    285323            if agent_value["Map"] == map_name: 
    286324                ret_dict[agent_name] = agent_value 
     
    296334        """Resets the agents dictionary""" 
    297335        self.agents = {} 
    298         self.agents["all"] = {} 
     336        self.agents[self.ALL_AGENTS_KEY] = {} 
    299337     
    300338    def loadMap(self, map_name): 
     
    302340           @type map_name: string 
    303341           @param map_name: Name of the map to load 
    304            @type map_file: string 
    305            @param map_file: Filename of map file to load 
    306342           @return: None""" 
    307343        self.game_state.current_map_name = map_name 
    308         self.game_state.current_map_file = self.map_files[map_name] 
    309344 
    310345        if not map_name in self.maps:   
     
    323358            self.setActiveMap(map_name) 
    324359 
    325     def placeAgents(self): 
    326         """Places the current maps agents 
    327         """ 
    328         if not self.active_map: 
    329             return 
    330         agents = self.getAgentsOfMap(self.game_state.current_map_name) 
    331         for agent in agents: 
    332             if agent == "PlayerCharacter": 
    333                 continue 
    334             if self.active_map.agent_layer.getInstances(agent): 
    335                 continue 
    336              
    337             object_type = agents[agent]["ObjectType"] 
    338             object_id = agents[agent]["ObjectModel"] \ 
    339                                     if agents[agent].has_key("ObjectModel") \ 
    340                                     else None 
    341             if object_id == None: 
    342                 object_id = self.object_db[object_type]["gfx"] 
    343             map_obj = self.fife_model.getObject(str(object_id), "PARPG") 
    344             if not map_obj: 
    345                 print ''.join(['Object with inst_id=', str(object_id),  
    346                                ' ns=PARPG', \ 
    347                                ' could not be found. Omitting...']) 
    348                 continue 
    349  
    350             x_pos = agents[agent]["Position"][0] 
    351             y_pos = agents[agent]["Position"][1] 
    352             z_pos = agents[agent]["Position"][2] \ 
    353                         if len(agents[agent]["Position"]) == 3 else 0.0 
    354             stack_pos = agents[agent]["Stackposition"] if \ 
    355                             agents[agent].has_key("StackPosition") \ 
    356                             else None 
    357             inst = self.active_map.agent_layer.\ 
    358                             createInstance(map_obj, 
    359                                            fife.ExactModelCoordinate(x_pos,  
    360                                                                      y_pos,  
    361                                                                      z_pos), 
    362                                            agent) 
    363  
    364             inst.setId(agent) 
    365             rotation = agents[agent]["Rotation"] 
    366             inst.setRotation(rotation) 
    367  
    368             fife.InstanceVisual.create(inst) 
    369             if (stack_pos): 
    370                 inst.get2dGfxVisual().setStackPosition(int(stack_pos)) 
    371  
    372             if (map_obj.getAction('default')): 
    373                 target = fife.Location(self.active_map.agent_layer) 
    374                 inst.act('default', target, True) 
    375                  
    376             inst_dict = {} 
    377             inst_dict["type"] = object_type 
    378             inst_dict["id"] = agent 
    379             inst_dict["xpos"] = x_pos 
    380             inst_dict["ypos"] = y_pos 
    381             inst_dict["gfx"] = object_id 
    382             inst_dict["is_open"] = parseBool(agents[agent]["Open"]) \ 
    383                                     if agents[agent].has_key("Open") \ 
    384                                     else False 
    385             inst_dict["locked"] = parseBool(agents[agent]["Locked"]) \ 
    386                                     if agents[agent].has_key("Locked") \ 
    387                                     else False 
    388             inst_dict["name"] = agents[agent]["ViewName"] 
    389             inst_dict["real_name"] = agents[agent]["RealName"] \ 
    390                                         if agents[agent].has_key("RealName") \ 
    391                                         else agents[agent]["ViewName"] 
    392             inst_dict["text"] = agents[agent]["Text"] \ 
    393                                         if agents[agent].has_key("Text") \ 
    394                                         else None 
    395             if self.dialogues.has_key(agent): 
    396                 inst_dict["dialogue"] = self.dialogues[agent] 
    397             inst_dict["target_map_name"] = agents[agent]["TargetMap"] \ 
    398                                             if agents[agent].\ 
    399                                                 has_key("TargetMap") \ 
    400                                             else None 
    401             inst_dict["target_x"] = agents[agent]["TargetPosition"][0] \ 
    402                                         if agents[agent].\ 
    403                                             has_key("TargetPosition") \ 
    404                                         else None 
    405             inst_dict["target_y"] = agents[agent]["TargetPosition"][1] \ 
    406                                         if agents[agent].\ 
    407                                             has_key("TargetPosition") \ 
    408                                         else None 
    409             if agents[agent].has_key("Inventory"): 
    410                 inventory = Inventory() 
    411                 inventory_objs = agents[agent]["Inventory"] 
    412                 for inventory_obj in inventory_objs: 
    413                     self.createInventoryObject(inventory, 
    414                                                inventory_obj  
    415                                                ) 
    416                 inst_dict["inventory"] = inventory 
    417  
    418  
    419                              
    420             self.createMapObject(self.active_map.agent_layer, inst_dict, inst) 
    421  
    422     def placePC(self): 
    423         """Places the PlayerCharacter on the map""" 
    424         agent = self.agents["all"]["PlayerCharacter"] 
    425         inst_id = "PlayerCharacter" 
     360    def createAgent(self, agent, inst_id): 
    426361        object_type = agent["ObjectType"] 
    427362        object_id = agent["ObjectModel"] \ 
     
    503438            inst_dict["inventory"] = inventory 
    504439 
     440        if agent.has_key("Items"): 
     441            items = [] 
     442            inventory_objs = agent["Items"] 
     443            for inventory_obj in inventory_objs: 
     444                items.append(self.createContainerObject(inventory_obj)) 
     445            inst_dict["items"] = items 
    505446 
    506447                     
    507448        self.createMapObject(self.active_map.agent_layer, inst_dict, inst) 
     449     
     450    def placeAgents(self): 
     451        """Places the current maps agents 
     452        """ 
     453        if not self.active_map: 
     454            return 
     455        agents = self.getAgentsOfMap(self.game_state.current_map_name) 
     456        for agent in agents: 
     457            if agent == "PlayerCharacter": 
     458                continue 
     459            if self.active_map.agent_layer.getInstances(agent): 
     460                continue 
     461            self.createAgent(agents[agent], agent) 
     462 
     463    def placePC(self): 
     464        """Places the PlayerCharacter on the map""" 
     465        agent = self.agents[self.ALL_AGENTS_KEY]["PlayerCharacter"] 
     466        inst_id = "PlayerCharacter" 
     467        self.createAgent(agent, inst_id) 
    508468         
    509469        # create the PlayerCharacter agent 
     
    536496        self.engine.getModel().deleteMaps() 
    537497        self.engine.getModel().deleteObjects() 
     498        self.game_state.clearObjects() 
    538499        self.maps = {} 
    539500         
  • branches/map_loading_change/game/scripts/gamescenecontroller.py

    r560 r562  
    179179            player_char = self.model.game_state.PlayerCharacter 
    180180            self.model.game_state.PlayerCharacter = None 
    181             pc_agent = self.model.agents["all"]["PlayerCharacter"]  
    182             pc_agent["GameMap"] = self.model.target_map_name  
     181            pc_agent = self.model.agents[self.model.ALL_AGENTS_KEY]["PlayerCharacter"]  
     182            pc_agent["Map"] = self.model.target_map_name  
    183183            pc_agent["Position"] = self.model.target_position 
    184             backpack = player_char.inventory.items["backpack"] 
    185             inventory = [] 
    186             for index, item in backpack.items.iteritems(): 
    187                 item_dict = item.__dict__ 
    188                 item.prepareStateForSaving(item_dict) 
    189                 item_dict["index"] = index 
    190                 item_dict["type"] = type(item).__name__  
    191                 inventory.append(item_dict) 
    192             for key, slot in player_char.inventory.items.iteritems(): 
    193                 if key == "ready" or key == "backpack": 
    194                     continue 
    195                 elif len(slot.items) > 0: 
    196                     item = slot.items[0] 
    197                     item_dict = item.__dict__ 
    198                     item.prepareStateForSaving(item_dict) 
    199                     item_dict["slot"] = key                                 
    200                     item_dict["type"] = type(item).__name__  
    201                     inventory.append(item_dict) 
    202                      
    203             pc_agent["Inventory"] = inventory 
     184            pc_agent["Inventory"] = player_char.inventory.serializeInventory() 
    204185            self.model.placeAgents() 
    205186            self.model.placePC() 
  • branches/map_loading_change/game/scripts/gamestate.py

    r553 r562  
    2424        self.quest_engine = quest_engine.QuestEngine() 
    2525        self.objects = {} 
    26         self.current_map_file = None 
    2726        self.current_map_name = None 
    28         # these coordinates are only used for saving and loading the game. 
    29         # They do not represent the pc's active location 
    30         self.saved_pc_coordinates = (0,0) 
    3127         
    3228    def getObjectsFromMap(self, map_id): 
     
    3632           @returns: The list of objects on this map. Or an empty list""" 
    3733        if map_id in self.objects: 
    38             return [i for i in self.objects[map_id].values() if map_id in self.objects] 
     34            return [i for i in self.objects[map_id].values() \ 
     35                                        if map_id in self.objects] 
    3936         
    4037        return {} 
     
    5148        if obj_id in self.objects[map_id]: 
    5249            return self.objects[map_id][obj_id] 
     50     
     51    def clearObjects(self): 
     52        """Delete all objects from the state 
     53        """ 
     54        self.objects = {} 
     55         
     56    def getStateForSaving(self): 
     57        """Prepares state for saving 
     58        @type state: dictionary 
     59        @param state: State of the object   
     60        """ 
     61        ret_dict = {} 
     62        ret_dict["CurrentMap"] = self.current_map_name 
     63        return ret_dict 
     64 
     65    def restoreFromState(self, state): 
     66        """Restores the state""" 
     67        self.current_map_name = state["CurrentMap"] 
     68         
  • branches/map_loading_change/game/scripts/gui/inventorygui.py

    r553 r562  
    2121 
    2222from scripts.gui import drag_drop_data as data_drag 
     23from scripts.objects.base import Container 
    2324 
    2425class InventoryGUI(object): 
     
    227228                    data_drag.dragged_container.takeItem(data_drag.dragged_item) 
    228229                self.inventory_storage.moveItemToSlot(data_drag.dragged_item, 
    229                                                   drop_widget.slot, drop_widget.index) 
     230                                                      drop_widget.slot, 
     231                                                      drop_widget.index) 
    230232            if drop_widget.slot == 'ready': 
    231233                self.readyCallback() 
    232234            self.resetMouseCursor() 
    233235            data_drag.dragging = False 
    234         except "Container.TooBig" : 
     236        except Container.TooBig : 
    235237            print("%s too big to fit into %s" % (data_drag.dragged_item, 
    236238                                                 drop_widget.slot)) 
  • branches/map_loading_change/game/scripts/inventory.py

    r553 r562  
    121121 
    122122    def __repr__(self): 
    123         return "[Inventory contents: " +reduce((lambda a,b: str(a) +', '+str(b)), self.items.values())+" ]" 
     123        return "[Inventory contents: " + \ 
     124                            reduce((lambda a,b: str(a)  
     125                                    + ', ' + str(b)),  
     126                                    self.items.values()) + " ]" 
     127 
     128    def serializeInventory(self): 
     129        """Returns the inventory items as a list""" 
     130        inventory = [] 
     131        inventory.extend(self.items["backpack"].serializeItems()) 
     132        for key, slot in self.items.iteritems(): 
     133            if key == "ready" or key == "backpack": 
     134                continue 
     135            elif len(slot.items) > 0: 
     136                item = slot.items[0] 
     137                item_dict = item.item_dict = item.getStateForSaving() 
     138                item_dict["slot"] = key                                 
     139                item_dict["type"] = type(item).__name__  
     140                inventory.append(item_dict) 
     141        return inventory 
     142             
     143    def getStateForSaving(self): 
     144        """Returns state for saving 
     145        """ 
     146        state = {} 
     147        state["Inventory"] = self.serializeInventory() 
     148        return state 
  • branches/map_loading_change/game/scripts/objects/actors.py

    r560 r562  
    114114class PlayerCharacter (GameObject, Living, CharStats): 
    115115    """PC class""" 
    116     def __init__ (self, ID, agent_layer = None, inventory = None, **kwargs): 
    117         GameObject.__init__( self, ID, **kwargs ) 
     116    def __init__ (self, ID, agent_layer = None, inventory = None, text = "Its you. Who would've thought that?", **kwargs): 
     117        GameObject.__init__( self, ID, text = text, **kwargs ) 
    118118        Living.__init__( self, **kwargs ) 
    119119        CharStats.__init__( self, **kwargs ) 
     
    138138        self.createBehaviour(agent_layer) 
    139139     
    140     def prepareStateForSaving(self, state): 
    141         """Prepares state for saving 
    142         @type state: dictionary 
    143         @param state: State of the object   
     140    def getLocation(self): 
     141        """Get the NPC's position as a fife.Location object. Basically a 
     142           wrapper. 
     143           @rtype: fife.Location 
     144           @return: the location of the NPC""" 
     145        return self.behaviour.agent.getLocation() 
     146 
     147    def getStateForSaving(self): 
     148        """Returns state for saving 
    144149        """ 
    145         GameObject.prepareStateForSaving(self, state) 
    146         del state["behaviour"] 
    147  
     150        ret_dict = super(PlayerCharacter, self).getStateForSaving() 
     151        ret_dict["Inventory"] = self.inventory.serializeInventory() 
     152        ret_dict["PeopleKnown"] = self.peopleIknow 
     153        return ret_dict 
     154     
    148155    def meet(self, npc): 
    149156        """Record that the PC has met a certain NPC 
     
    216223        l.setLayerCoordinates(fife.ModelCoordinate(*boxLocation)) 
    217224        self.behaviour.agent.move('run', l, self.behaviour.speed+1) 
     225     
     226    def _getCoords(self): 
     227        """Get-er property function""" 
     228        return (self.getLocation().getMapCoordinates().x,  
     229                self.getLocation().getMapCoordinates().y) 
     230     
     231    def _setCoords(self, coords): 
     232        """Set-er property function""" 
     233        map_coords = self.getLocation().getMapCoordinates() 
     234        map_coords.X, map_coords.Y = float(coords[0]), float (coords[1]) 
     235        self.teleport(map_coords) 
     236     
     237    coords = property (_getCoords, _setCoords,  
     238        doc = "Property allowing you to get and set the object's \ 
     239                coordinates via tuples") 
    218240 
    219241 
     
    226248        self.pc = None 
    227249        self.target_loc = None 
     250        self.nextAction = None 
    228251         
    229252        # hard code this for now 
     
    289312                 real_name = 'NPC', dialogue = None, **kwargs): 
    290313        # init game object 
    291         GameObject.__init__(self, ID, name=name, real_name=real_name, **kwargs) 
     314        GameObject.__init__(self, ID, name=name, real_name=real_name, text = text, **kwargs) 
    292315        Living.__init__(self, **kwargs) 
    293316        Scriptable.__init__(self, **kwargs) 
     
    296319        self.is_NPC = True 
    297320        self.behaviour = None 
     321        self.state = None 
    298322         
    299323        if inventory == None: 
     
    308332        self.createBehaviour(agent_layer)         
    309333        self.dialogue = dialogue 
    310          
     334 
    311335    def prepareStateForSaving(self, state): 
    312336        """Prepares state for saving 
     
    316340        GameObject.prepareStateForSaving(self, state) 
    317341        del state["behaviour"] 
     342 
     343    def getStateForSaving(self): 
     344        """Returns state for saving 
     345        """ 
     346        ret_dict = super(NonPlayerCharacter, self).getStateForSaving() 
     347        ret_dict["Lives"] = self.is_living 
     348        ret_dict["State"] = self.behaviour.state 
     349        return ret_dict 
    318350 
    319351    def createBehaviour(self, layer): 
     
    375407        """@return: None""" 
    376408        self.behaviour.idle() 
     409 
     410    def _getCoords(self): 
     411        """Get-er property function""" 
     412        return (self.getLocation().getMapCoordinates().x,  
     413                self.getLocation().getMapCoordinates().y) 
     414     
     415    def _setCoords(self, coords): 
     416        """Set-er property function""" 
     417        map_coords = self.getLocation().getMapCoordinates() 
     418        map_coords.X, map_coords.Y = float(coords[0]), float (coords[1]) 
     419        self.teleport(map_coords) 
     420 
     421    coords = property (_getCoords, _setCoords,  
     422        doc = "Property allowing you to get and set the object's \ 
     423                coordinates via tuples") 
  • branches/map_loading_change/game/scripts/objects/base.py

    r560 r562  
    5656class DynamicObject (object): 
    5757    """A base class that only supports dynamic attributes functionality""" 
    58     def __init__ (self, name="Dynamic object", real_name="Dynamic object", image=None, **kwargs): 
     58    def __init__ (self, name="Dynamic object", real_name=None, image=None, **kwargs): 
    5959        """Initialise minimalistic set of data 
    6060           @type name: String 
     
    6363           @param name: Filename of image to use in inventory""" 
    6464        self.name = name 
    65         self.real_name = real_name 
     65        self.real_name = real_name or name 
    6666        self.image = image 
    6767 
     
    9292           is_%attr and if that attribute evaluates to True""" 
    9393        return hasattr(self,'is_%s' % attr) and getattr(self, 'is_%s' % attr) 
    94  
     94     
     95    def getStateForSaving(self): 
     96        """Returns state for saving 
     97        """ 
     98        state = {} 
     99        state["Name"] = self.name 
     100        state["RealName"] = self.real_name 
     101        state["Image"] = self.image 
     102        return state 
    95103 
    96104class GameObject (DynamicObject): 
     
    137145         
    138146    coords = property (_getCoords, _setCoords,  
    139         doc = "Property allowing you to get and set the obejct's \ 
     147        doc = "Property allowing you to get and set the object's \ 
    140148                coordinates via tuples") 
    141149     
     
    143151        """A debugging string representation of the object""" 
    144152        return "<%s:%s>" % (self.name, self.ID) 
     153 
     154    def getStateForSaving(self): 
     155        """Returns state for saving 
     156        """ 
     157        state = super(GameObject, self).getStateForSaving() 
     158        state["ObjectModel"] = self.gfx 
     159        state["Text"] = self.text 
     160        state["Desc"] = self.desc 
     161        state["Position"] = list(self.coords) 
     162        return state 
     163 
    145164 
    146165class Scriptable (object): 
     
    256275        pass 
    257276 
    258     def __init__ (self, capacity = 0, **kwargs): 
     277    def __init__ (self, capacity = 0, items = None, **kwargs): 
    259278        DynamicObject.__init__(self, **kwargs) 
    260279        Scriptable.__init__(self, **kwargs) 
     
    262281        self.items = {} 
    263282        self.capacity = capacity 
     283        if items: 
     284            for item in items: 
     285                self.placeItem(item) 
    264286         
    265287    def placeItem (self, item, index=None): 
     
    340362            return self.items[i] 
    341363        return None 
     364     
     365    def serializeItems(self): 
     366        """Returns the items as a list""" 
     367        items = [] 
     368        for index, item in self.items.iteritems(): 
     369            item_dict = item.getStateForSaving() 
     370            item_dict["index"] = index 
     371            item_dict["type"] = type(item).__name__  
     372            items.append(item_dict) 
     373        return items 
     374     
     375    def getStateForSaving(self): 
     376        """Returns state for saving 
     377        """ 
     378        ret_state = {} 
     379        ret_state["Items"] = self.serializeItems() 
     380        return ret_state 
    342381         
    343382class Living (object): 
  • branches/map_loading_change/game/scripts/objects/composed.py

    r560 r562  
    4343    def getWeight(self): 
    4444        """Resulting weight of a container""" 
    45         return sum((item.weight for item in self.items.values()), self.own_weight) 
     45        return sum((item.weight for item in self.items.values()),  
     46                   self.own_weight) 
    4647 
    4748    def setWeight(self, weight): 
    48         """Set container's own weight. For compatibility with inherited methods""" 
     49        """Set container's own weight.  
     50        For compatibility with inherited methods""" 
    4951        self.own_weight = weight 
    5052 
     
    6264 
    6365    def __repr__(self): 
    64         return "[%s"%self.name +str(reduce((lambda a,b: a +', '+ \ 
    65                                     str(self.items[b])), self.items,""))+" ]" 
    66  
     66        return "[%s" % self.name + str(reduce((lambda a, b: a + ', ' + \ 
     67                                    str(self.items[b])), self.items, "")) + " ]" 
     68     
    6769class SingleItemContainer (CarryableContainer) : 
    6870    """Container that can only store a single item. 
     
    7981    """Composite class that will be used for all carryable items""" 
    8082    def __init__(self, **kwargs): 
    81         GameObject.__init__(self,**kwargs) 
    82         Carryable.__init__(self,**kwargs) 
     83        GameObject.__init__(self, **kwargs) 
     84        Carryable.__init__(self, **kwargs) 
    8385 
    8486    def prepareStateForSaving(self, state): 
     
    8890        """ 
    8991        del state["in_container"] 
     92 
     93    def getStateForSaving(self): 
     94        """Returns state for saving 
     95        @type state: dictionary 
     96        @param state: State of the object   
     97        """ 
     98        ret_dict = self.__dict__.copy() 
     99        self.prepareStateForSaving(ret_dict) 
     100        return ret_dict 
    90101         
    91102class Door(GameObject, Lockable, Scriptable, Trappable): 
     
    101112        self.target_pos = (target_x, target_y) 
    102113        self.blocking = True 
     114 
     115    def getStateForSaving(self): 
     116        """Returns state for saving 
     117        """ 
     118        ret_dict = super(Door, self).getStateForSaving() 
     119        return ret_dict 
  • branches/map_loading_change/game/scripts/objects/containers.py

    r542 r562  
    2525 
    2626from composed import ImmovableContainer 
    27 from composed import CarryableItem 
    2827from fife import fife 
    2928 
     
    3332        ImmovableContainer.__init__(self, ID = object_id, name = name,  
    3433                                    gfx = gfx, text = text, **kwargs) 
    35         self.placeItem(CarryableItem(ID=987, name="Dagger456")) 
    3634         
    3735class ContainerBehaviour(fife.InstanceActionListener): 
     
    8785                                    gfx = gfx, text = text, **kwargs) 
    8886        self.behaviour = None 
    89         self.placeItem(CarryableItem(ID=987, name="Dagger456")) 
    9087 
    9188        self.is_AnimatedContainer = True 
Note: See TracChangeset for help on using the changeset viewer.