Changeset 571


Ignore:
Timestamp:
06/30/10 18:47:25 (9 years ago)
Author:
beliar
Message:

Patch by Beliar.

  • Minor modifications to dialogue files that check for an active quest and the quest variable instead of only for the quest variable
  • Containers now have a "replaceItem" method that can be used to replace an item with another. The new item will be at the same item position the old one was
  • Added "UseAction?" class that can be used when you need to execute commands that need a carryable item
  • Added ReplaceItem? command to UseAction?. This replaces the item, that the command is called on, with a new item of the given object type
  • Changed Box to have a "Use" Action with the display text "Open" that replaces the Box with Boots and sets the "open_box" variable of the fedex quest to 1
  • Added replace_stuff command to dialogues, this replaces an item, in either the pc's or npc's inventory (who), of the given item_id (old_item) with an new object of the given object_type(new_item)
  • When the player has opened the box it is possible to tell Janie who rewraps the Boots (replaces the boots in the pc's inventory with the Box)
  • checkAttributes method in GameModel? now does a deep copy instead of a shallow one.
Location:
trunk/game
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/dialogue/crazy_swede.yaml

    r570 r571  
    5555              - "Enough with the chop talk!  Do you have any yeast?" 
    5656              - end 
    57               - quest['beer'].isGoalValue('beer_instructions') 
     57              - quest.hasActiveQuest('beer') and quest['beer'].isGoalValue('beer_instructions') 
    5858    b1: 
    5959        - say: "Ah, so you chop the chop... but do you Chop the Chop?" 
     
    7878              - "Yeast.  Y-E-A-S-T.  For making booze.  Do you understand me?" 
    7979              - end 
    80               - quest['beer'].isGoalValue('beer_instructions')               
     80              - quest.hasActiveQuest('beer') and quest['beer'].isGoalValue('beer_instructions') 
    8181            - 
    8282              - "Screw this, you cannot argue with a Swede!" 
  • trunk/game/dialogue/fguard.yaml

    r570 r571  
    138138             - "I'm trying to make beer, can you help me find some stuff?" 
    139139             - help_beer 
    140              - quest['beer'].isGoalValue('beer_instructions') and not quest.hasFinishedQuest('beer') and quest['beer'].getValue('beer_quality') < 1 
     140             - quest.hasActiveQuest('beer') and quest['beer'].isGoalValue('beer_instructions') and not quest.hasFinishedQuest('beer') and quest['beer'].getValue('beer_quality') < 1 
    141141           - 
    142142             - "I guess I'll see if I can't find this Pekko character for you." 
     
    373373       - say: "Give me that back! [Janie takes boots from PC and rewraps them].  Now, here.  And don't open it again." 
    374374       # reset the quest: Note we need to make sure we don't generate an infinite supply of combat boots! 
    375        - give_stuff: Boots 
    376375       - restart_quest: fedex 
    377        - get_stuff: Box  
     376       - replace_stuff: 
     377          who: pc 
     378          old_item: Boots 
     379          new_item: Box         
    378380       # I suspect this should be rolled into "start_quest" 
    379381       - responses: 
  • trunk/game/dialogue/leader.yaml

    r570 r571  
    212212              - "Do you think you can tell her to release some supplies for my beer project" 
    213213              - beer_request 
    214               - quest['beer'].isGoalValue('beer_instructions') and quest['beer'].getValue('beer_quality') > 0 
     214              - quest.hasActiveQuest('beer') and quest['beer'].isGoalValue('beer_instructions') and quest['beer'].getValue('beer_quality') > 0 
    215215 
    216216     beer_request: 
  • trunk/game/maps/all_agents.yaml

    r570 r571  
    2323    Rotation: 0 
    2424    Inventory: 
    25         - {ID: "Dagger", object_type: "Dagger", slot: "right_hand"} 
    26         - {ID: "Beer", object_type: "Beer"} 
     25    - {ID: "Dagger", object_type: "Dagger", slot: "right_hand"} 
     26    - {ID: "Beer", object_type: "Beer"} 
     27    - {ID: "Pamphlet", object_type: "Pamphlet"} 
    2728---             
    2829Janie: 
     
    3637    Rotation: 0 
    3738    Inventory: 
    38         - {ID: "Box", object_type: "Box"} 
     39    - {ID: "Box", object_type: "Box"} 
    3940--- 
    4041Bart The Drunkard: 
  • trunk/game/maps/map_agents.yaml

    r568 r571  
    2323    Items: 
    2424    - {ID: "Dagger", object_type: "Dagger"} 
    25     - {ID: "Pamphlet", object_type: "Pamphlet"} 
    2625--- 
    2726ToFarm: 
  • trunk/game/objects/ObjectDatabase.yaml

    r570 r571  
    5050  name: Box 
    5151  image: /gui/inv_images/inv_giftbox.png 
     52  actions: 
     53    Use: 
     54      text: Open 
     55      commands: 
     56        - {Command: ReplaceItem, ObjectType: Boots, ID: Boots} 
     57        - {Command: SetQuestVariable, ID: fedex, Variable: open_box, Value: 1} 
     58--- 
     59Boots: 
     60  name: Boots 
  • trunk/game/scripts/dialogue.py

    r570 r571  
    250250                self.callbacks["give_stuff"](state, command.get("give_stuff")) 
    251251 
     252            elif command.get("replace_stuff"): 
     253                self.callbacks["replace_stuff"](state,  
     254                                                command.get("replace_stuff")\ 
     255                                                    ["who"], 
     256                                                command.get("replace_stuff")\ 
     257                                                    ["old_item"], 
     258                                                command.get("replace_stuff")\ 
     259                                                    ["new_item"]) 
     260 
    252261            elif command.get("dialogue"): 
    253262                command = command.get("dialogue") 
  • trunk/game/scripts/gamemodel.py

    r570 r571  
    6565        self.object_db = {} 
    6666        self.active_map = None 
    67         self.maps = {} 
    6867        self.map_files = {} 
    6968        self.agents = {} 
     
    7170        self.engine = engine 
    7271        self.fife_model = engine.getModel() 
    73         self.maps_file = "maps/maps.yaml" 
     72        self.game_state.maps_file = "maps/maps.yaml" 
    7473        self.all_agents_file = "maps/all_agents.yaml" 
    7574        self.object_db_file = "objects/ObjectDatabase.yaml" 
     
    8584        @param attributes: attributes to check 
    8685        @type attributes: Dictionary 
    87         @return: The modified attributes"""         
     86        @return: The modified attributes"""  
     87        from copy import deepcopy        
    8888        if attributes.has_key("object_type"): 
    8989            class_name = attributes.pop("object_type") 
     
    9191            class_name = attributes["type"] 
    9292        if self.object_db.has_key(class_name): 
    93             db_attributes = self.object_db[class_name].copy() 
     93            db_attributes = deepcopy(self.object_db[class_name]) 
    9494            for key in db_attributes.keys(): 
    9595                if attributes.has_key(key): 
     
    146146        else: 
    147147            container.placeItem(obj, index) 
     148     
     149    def deleteObject(self, object_id): 
     150        """Removes an object from the game 
     151        @param object_id: ID of the object 
     152        @type object_id: str 
     153        """ 
     154        self.game_state.deleteObject(object_id) 
    148155         
    149156    def save(self, path, filename): 
     
    166173            for agent in self.agents[map_name]: 
    167174                agent_obj = self.game_state.getObjectById(agent, map_name) 
    168                 agent_inst = self.maps[map_name].agent_layer.getInstance(agent) 
     175                agent_inst = self.game_state.maps[map_name].agent_layer.getInstance(agent) 
    169176                agent_dict = self.agents[map_name][agent] 
    170177                agent_dict.update(agent_obj.getStateForSaving()) 
     
    182189                agent_obj = self.game_state.getObjectById(agent, map_name) 
    183190            if agent_obj: 
    184                 agent_inst = self.maps[map_name].agent_layer.getInstance(agent) 
     191                agent_inst = self.game_state.maps[map_name].agent_layer.getInstance(agent) 
    185192                agent_dict.update(agent_obj.getStateForSaving()) 
    186193                agent_dict["Rotation"] = agent_inst.getRotation() 
     
    296303    def readMapFiles(self): 
    297304        """Read all a available map-files and store them""" 
    298         maps_data = file(self.maps_file) 
     305        maps_data = file(self.game_state.maps_file) 
    299306        self.map_files = yaml.load(maps_data)["Maps"] 
    300307     
     
    372379           @param map_name: Name of the map to load 
    373380           @return: None""" 
    374         if not map_name in self.maps:   
     381        if not map_name in self.game_state.maps:   
    375382            map_file = self.map_files[map_name] 
    376383            new_map = GameMap(self.engine, self) 
    377             self.maps[map_name] = new_map 
     384            self.game_state.maps[map_name] = new_map 
    378385            new_map.load(map_file) 
    379386     
     
    517524        self.engine.getModel().deleteObjects() 
    518525        self.game_state.clearObjects() 
    519         self.maps = {} 
     526        self.game_state.maps = {} 
    520527         
    521528    def setActiveMap(self, map_name): 
     
    528535        self.active_map.cameras[self.active_map.my_cam_id].setEnabled(False) 
    529536        # Make the new map active. 
    530         self.active_map = self.maps[map_name] 
     537        self.active_map = self.game_state.maps[map_name] 
    531538        self.active_map.makeActive() 
    532539        self.game_state.current_map_name = map_name 
  • trunk/game/scripts/gamescenecontroller.py

    r568 r571  
    211211                                     npc.getLocation().\ 
    212212                                     getLayerCoordinates().y], 
    213                                     TalkAction(self.model, self.view, npc)) 
     213                                    TalkAction(self, npc)) 
    214214 
    215215    def getItemActions(self, obj_id): 
     
    234234                                self.model.game_state.PlayerCharacter.approach,  
    235235                                [obj.X, obj.Y], 
    236                                 ExamineBoxAction(self.model, self.view,  
    237                                                  obj.name, obj.text)]) 
     236                                ExamineBoxAction(self, obj.name, obj.text)]) 
    238237                # is it a Door? 
    239238                if obj.trueAttr("door"): 
     
    241240                       self.model.game_state.PlayerCharacter.approach,  
    242241                       [obj.X, obj.Y], 
    243                        ChangeMapAction(self.model, self.view, 
    244                                        obj.target_map_name, 
     242                       ChangeMapAction(self, obj.target_map_name, 
    245243                                       obj.target_pos)]) 
    246244                # is it a container? 
     
    250248                                        PlayerCharacter.approach, 
    251249                                    [obj.X, obj.Y], 
    252                                     OpenBoxAction(self.model, self.view, obj)]) 
     250                                    OpenBoxAction(self, obj)]) 
    253251                    actions.append(["Unlock", "Unlock",  
    254252                                    self.model.game_state.\ 
    255253                                        PlayerCharacter.approach, 
    256254                                    [obj.X, obj.Y], 
    257                                     UnlockBoxAction(self.model, obj)]) 
     255                                    UnlockBoxAction(self, obj)]) 
    258256                    actions.append(["Lock", "Lock",  
    259257                                    self.model.game_state.\ 
    260258                                        PlayerCharacter.approach, 
    261259                                    [obj.X, obj.Y], 
    262                                     LockBoxAction(self.model, obj)]) 
     260                                    LockBoxAction(self, obj)]) 
    263261                # can you pick it up? 
    264262                if obj.trueAttr("carryable"): 
  • trunk/game/scripts/gamestate.py

    r570 r571  
    2626        self.object_ids = {} 
    2727        self.current_map_name = None 
     28        self.maps = {} 
    2829         
    2930         
     
    4243                self.objects[map_id][object_id] = game_object 
    4344            self.object_ids[object_id] = map_id 
    44          
     45     
     46    def deleteObject(self, object_id): 
     47        """Removes an object from the dictionaries 
     48        @param object_id: ID of the object 
     49        @type object_id: str 
     50        """ 
     51        if self.hasObject(object_id): 
     52            map_id = self.getMapOfObject(object_id) 
     53            if map_id: 
     54                inst = self.maps[map_id].agent_layer.getInstance(object_id) 
     55                self.maps[map_id].agent_layer.deleteInstance(inst) 
     56                del self.objects[map_id][object_id] 
     57            del self.object_ids[object_id] 
     58             
     59             
    4560    def getObjectsFromMap(self, map_id): 
    4661        """Gets all objects that are currently on the given map. 
  • trunk/game/scripts/gui/dialoguegui.py

    r570 r571  
    2323 
    2424class DialogueGUI(object): 
    25     def __init__(self, npc, quest_engine, pc): 
     25    def __init__(self, controller, npc, quest_engine, pc): 
     26        self.controller = controller  
    2627        self.pc = pc 
    2728 
    2829        # define dialogue engine callbacks 
    29         def start_quest(state, quest): 
     30        def startQuest(state, quest): 
    3031            print "You've picked up the '%s' quest!" % quest 
    3132            state['quest'].activateQuest(quest) 
    3233 
    33         def complete_quest(state, quest_id): 
     34        def completeQuest(state, quest_id): 
    3435            print "You've finished the quest %s" % quest_id 
    3536            state['quest'].finishQuest(quest_id) 
    3637 
    37         def fail_quest(state, quest_id): 
     38        def failQuest(state, quest_id): 
    3839            print "You've failed quest %s" % quest_id 
    3940            state['quest'].failQuest(quest_id) 
    4041             
    41         def restart_quest(state, quest_id): 
     42        def restartQuest(state, quest_id): 
    4243            print "You've restarted quest %s" % quest_id 
    4344            state['quest'].restartQuest(quest_id) 
    4445 
    45         def increase_quest_value(state, quest_id, variable, value): 
     46        def increaseQuestValue(state, quest_id, variable, value): 
    4647            print "Increased %s by %i"%(variable,value) 
    4748            state['quest'][quest_id].increaseValue(variable,value) 
    4849 
    49         def decrease_quest_value(state, quest_id, variable, value): 
     50        def decreaseQuestValue(state, quest_id, variable, value): 
    5051            print "Decreased %s by %i"%(variable,value) 
    5152            state['quest'][quest_id].decreaseValue(variable,value) 
    5253 
    53         def set_value(state,quest_id, variable, value): 
     54        def setValue(state,quest_id, variable, value): 
    5455            print "Set %s to %s"%(variable,value) 
    5556            state['quest'][quest_id].setValue(variable,value) 
     
    5960            state['pc'].meet(npc) 
    6061 
    61         def get_stuff(state, thing): 
     62        def getStuff(state, thing): 
    6263            if not state['pc'].inventory.findItem(item_id = thing): 
    6364                try : 
     
    6869                    print "NPC doesn't have the %s" % thing 
    6970 
    70         def give_stuff(state,thing): 
    71             if state['pc'].inventory.has(thing): 
    72                 state['pc'].inventory.takeItem(thing) 
     71        def giveStuff(state, thing): 
     72            item = state['pc'].inventory.findItem(item_id = thing) 
     73            if item: 
     74                state['pc'].inventory.takeItem(item) 
    7375                print "You no longer have the %s" % thing 
    7476 
     77        def replaceStuff(state, who, old_item, new_item): 
     78            old_item = state[who].inventory.findItem(item_id = old_item) 
     79            if old_item: 
     80                inst_dict = {} 
     81                inst_dict["ID"] = new_item 
     82                inst_dict["object_type"] = new_item 
     83                new_item = self.controller.model.\ 
     84                            createContainerObject(inst_dict) 
     85                state[who].inventory.replaceItem(old_item, new_item) 
     86                print "You no longer have the %s" % old_item.name 
     87                print "You've now have the %s" % new_item.name         
     88         
    7589        dialogue_callbacks = { 
    76             'complete_quest': complete_quest, 
    77             'decrease_quest_value': decrease_quest_value, 
    78             'fail_quest'  : fail_quest, 
     90            'complete_quest': completeQuest, 
     91            'decrease_quest_value': decreaseQuestValue, 
     92            'fail_quest'  : failQuest, 
    7993            'end'           : self.handleEnd, 
    80             'get_stuff'     : get_stuff, 
    81             'increase_quest_value': increase_quest_value, 
     94            'get_stuff'     : getStuff, 
     95            'increase_quest_value': increaseQuestValue, 
    8296            'meet'          : meet, 
    8397            'npc_name'      : self.handleNpcName, 
     
    8599            'responses'     : self.handleResponses, 
    86100            'say'           : self.handleSay, 
    87             'set_value'     : set_value, 
    88             'start_quest'   : start_quest, 
    89             "restart_quest" : restart_quest, 
    90             'give_stuff'    : give_stuff 
     101            'set_value'     : setValue, 
     102            'start_quest'   : startQuest, 
     103            "restart_quest" : restartQuest, 
     104            'give_stuff'    : giveStuff, 
     105            "replace_stuff" : replaceStuff 
    91106        } 
    92107 
  • trunk/game/scripts/gui/hud.py

    r568 r571  
    422422           @return: None""" 
    423423        dialogue = DialogueGUI( 
     424                    self.controller, 
    424425                    npc, 
    425426                    self.model.game_state.quest_engine, 
  • trunk/game/scripts/gui/inventorygui.py

    r570 r571  
    117117                       the dictionary 'self.buttons' 
    118118           @return: None""" 
     119        #TODO: Create a class as base for this and ContainerGUI so both use the same function 
    119120        if event.getButton() == event.RIGHT: 
    120121            item = widget.item 
     
    128129                y_pos += event.getY() 
    129130                for action_name in actions: 
     131                    display_name = action_name 
    130132                    if action_name in ACTIONS: 
    131133                        param_dict = {}  
    132                         param_dict["model"] = self.controller.model 
     134                        param_dict["controller"] = self.controller 
    133135                        param_dict["commands"] = {} 
    134136                        if action_name == "Read": 
    135                             param_dict["view"] = self.controller.view 
    136137                            param_dict["text_name"] = item.name 
    137138                            param_dict["text"] = "" 
     139                        if action_name == "Use": 
     140                            param_dict["item"] = item 
     141                            display_name = actions[action_name].pop("text") 
    138142                        param_dict.update(actions[action_name]) 
    139                         menu_actions.append([action_name, action_name,  
     143                        menu_actions.append([action_name, display_name,  
    140144                                            self.executeMenuItem, 
    141145                                            ACTIONS[action_name](**param_dict)]) 
  • trunk/game/scripts/gui/popups.py

    r570 r571  
    121121                       the dictionary 'self.buttons' 
    122122           @return: None""" 
     123        #TODO: Create a class as base for this and InventoryGui so both use the same function 
    123124        if event.getButton() == event.RIGHT: 
    124125            item = widget.item 
     
    132133                y_pos += event.getY() 
    133134                for action_name in actions: 
     135                    display_name = action_name 
    134136                    if action_name in ACTIONS: 
    135137                        param_dict = {}  
    136                         param_dict["model"] = self.controller.model 
     138                        param_dict["controller"] = self.controller 
    137139                        param_dict["commands"] = {} 
    138140                        if action_name == "Read": 
    139                             param_dict["view"] = self.controller.view 
    140141                            param_dict["text_name"] = item.name 
    141142                            param_dict["text"] = "" 
     143                        if action_name == "Use": 
     144                            param_dict["item"] = item 
     145                            display_name = actions[action_name].pop("text") 
    142146                        param_dict.update(actions[action_name]) 
    143                         menu_actions.append([action_name, action_name,  
     147                        menu_actions.append([action_name, display_name,  
    144148                                            self.executeMenuItem, 
    145149                                            ACTIONS[action_name](**param_dict)]) 
  • trunk/game/scripts/inventory.py

    r566 r571  
    2727        """Initialise instance""" 
    2828        CarryableContainer.__init__(self, **kwargs) 
    29         self.items = {"head": Slot(name="head"), "neck": Slot(name="neck"), 
    30                       "shoulders": Slot(name="shoulders"), 
    31                       "chest": Slot(), "abdomen": Slot(), "left_arm": Slot(), 
    32                       "right_arm": Slot(),"groin": Slot(), "hips": Slot(), 
    33                       "left_leg": Slot(), "right_leg": Slot(), 
    34                       "left_hand": Slot(), "right_hand": Slot(), 
    35                       "ready": CarryableContainer(), 
     29        self.items = {"head": Slot(), "neck": Slot(), 
     30                      "shoulders": Slot(), "chest": Slot(), 
     31                      "abdomen": Slot(), "left_arm": Slot(), 
     32                      "right_arm": Slot(),"groin": Slot(), 
     33                      "hips": Slot(), "left_leg": Slot(), 
     34                      "right_leg": Slot(), "left_hand": Slot(), 
     35                      "right_hand": Slot(), "ready": CarryableContainer(), 
    3636                      "backpack": CarryableContainer()} 
    37         for key,item in self.items.iteritems(): 
     37        for key, item in self.items.iteritems(): 
    3838            item.name = key 
     39            kwargs = {} 
     40            kwargs["container"] = item 
     41            item.setScript("onPlaceItem", self.onChildPlaceItem, kwargs = kwargs) 
    3942        self.item_lookup = {} 
     43         
     44    def onChildPlaceItem(self, container): 
     45        for item in container.items.itervalues(): 
     46            self.item_lookup[item.ID] = container.name   
    4047 
    41     def placeItem(self,item, index=None): 
     48    def placeItem(self, item, index=None): 
    4249        self.items["backpack"].placeItem(item, index) 
    43         self.item_lookup[item.ID] = "backpack" 
     50        #self.item_lookup[item.ID] = "backpack" 
    4451         
    45     def takeItem(self,item): 
     52    def takeItem(self, item): 
    4653        if not item.ID in self.item_lookup: 
    4754            raise ValueError ('I do not contain this item: %s' % item) 
    4855        self.items[self.item_lookup[item.ID]].takeItem(item) 
    4956        self.item_lookup[item.ID] = None 
     57 
     58    def replaceItem(self, old_item, new_item): 
     59        """Replaces the old item with the new one 
     60        @param old_item: Old item which is removed 
     61        @type old_item: Carryable 
     62        @param new_item: New item which is added 
     63        @type new_item: Carryable 
     64        """ 
     65        if not old_item.ID in self.item_lookup: 
     66            raise ValueError ('I do not contain this item: %s' % old_item) 
     67        self.items[self.item_lookup[old_item.ID]]\ 
     68            .replaceItem(old_item, new_item) 
    5069 
    5170    def getWeight(self): 
     
    96115        return self.items[slot].count() == 0 
    97116 
    98     def has(self, item): 
    99         return item.ID in self.item_lookup 
     117    def has(self, item_ID): 
     118        return item_ID in self.item_lookup 
    100119 
    101120    def findItemByID(self, ID): 
  • trunk/game/scripts/objects/action.py

    r568 r571  
    11#!/usr/bin/python 
    2 from winioctlcon import UNLOCK_ELEMENT 
    3  
    42#   This file is part of PARPG. 
    53 
     
    2826 
    2927 
    30     def __init__(self, model, commands = None): 
     28    def __init__(self, controller, commands = None): 
    3129        """Basic action constructor 
    32         @param model: A reference to the game model. 
    33         @type model: scripts.GameModel 
    34         @param commands: Special commands that are executed 
    35         @type commands: Dictionary  
    36         """ 
    37         self.commands = commands or {} 
    38         self.model = model 
     30        @param controller: A reference to the GameSceneController. 
     31        @type controller: scripts.GameSceneController 
     32        @param commands: Special commands that are executed 
     33        @type commands: Dictionary  
     34        """ 
     35        self.commands = commands or () 
     36        self.controller = controller 
     37        self.model = controller.model 
    3938     
    4039    def execute(self): 
     
    5554class ChangeMapAction(Action): 
    5655    """A change map scheduled""" 
    57     def __init__(self, model, view, target_map_name, target_pos, commands = None): 
     56    def __init__(self, controller, target_map_name, target_pos, commands = None): 
    5857        """Initiates a change of the position of the character 
    5958        possibly flagging a new map to be loaded. 
    60         @param model: A reference to the game model. 
    61         @type model: scripts.GameModel 
     59        @param controller: A reference to the GameSceneController. 
     60        @type controller: scripts.GameSceneController 
    6261        @param commands: Special commands that are executed 
    6362        @type commands: Dictionary  
     
    6968        @param target_pos: (X, Y) coordinates on the target map. 
    7069        @return: None""" 
    71         Action.__init__(self, model, commands) 
    72         self.model = model 
    73         self.view = view 
     70        super(ChangeMapAction, self).__init__(controller, commands) 
     71        self.view = controller.view 
    7472        self.target_pos = target_pos 
    7573        self.target_map_name = target_map_name 
     
    7977        self.model.changeMap(self.target_map_name, 
    8078                              self.target_pos) 
    81         Action.execute(self) 
     79        super(ChangeMapAction, self).execute() 
    8280        
    8381class OpenBoxAction(Action): 
    8482    """Open a box. Needs to be more generic, but will do for now.""" 
    85     def __init__(self, model, view, container, commands = None): 
    86         """ 
    87         @param model: A reference to the game model. 
    88         @type model: scripts.GameModel 
     83    def __init__(self, controller, container, commands = None): 
     84        """ 
     85        @param controller: A reference to the GameSceneController. 
     86        @type controller: scripts.GameSceneController 
    8987        @param commands: Special commands that are executed 
    9088        @type commands: Dictionary  
     
    9391        @param container: A reference to the container 
    9492        """ 
    95         Action.__init__(self, model, commands) 
    96         self.view = view 
     93        super(OpenBoxAction, self).__init__(controller, commands) 
     94        self.view = controller.view 
    9795        self.container = container 
    9896         
     
    103101            self.view.hud.createBoxGUI(self.container.name, \ 
    104102                                              self.container) 
    105             Action.execute(self) 
     103            super(OpenBoxAction, self).execute() 
    106104 
    107105        except ValueError: 
     
    111109class UnlockBoxAction(Action): 
    112110    """Unlocks a box. Needs to be more generic, but will do for now.""" 
    113     def __init__(self, model, container, commands = None): 
    114         """ 
    115         @param model: A reference to the game model. 
    116         @type model: scripts.GameModel 
     111    def __init__(self, controller, container, commands = None): 
     112        """ 
     113        @param controller: A reference to the GameSceneController. 
     114        @type controller: scripts.GameSceneController 
    117115        @param commands: Special commands that are executed 
    118116        @type commands: Dictionary  
    119117        @param container: A reference to the container 
    120118        """ 
    121         Action.__init__(self, model, commands) 
     119        super(UnlockBoxAction, self).__init__(controller, commands) 
    122120        self.container = container 
    123121     
     
    125123        """Open the box.""" 
    126124        self.container.unlock() 
    127         Action.execute(self) 
     125        super(UnlockBoxAction, self).execute() 
    128126         
    129127class LockBoxAction(Action): 
    130128    """Locks a box. Needs to be more generic, but will do for now.""" 
    131     def __init__(self, model, container, commands = None): 
    132         """ 
    133         @param model: A reference to the game model. 
    134         @type model: scripts.GameModel 
     129    def __init__(self, controller, container, commands = None): 
     130        """ 
     131        @param controller: A reference to the GameSceneController. 
     132        @type controller: scripts.GameSceneController 
    135133        @param commands: Special commands that are executed 
    136134        @type commands: Dictionary  
    137135        @param container: A reference to the container 
    138136        """ 
    139         Action.__init__(self, model, commands) 
     137        super(LockBoxAction, self).__init__(controller, commands) 
    140138        self.container = container 
    141139         
     
    143141        """Lock the box.""" 
    144142        self.container.lock() 
    145         Action.execute(self) 
     143        super(LockBoxAction, self).execute() 
    146144 
    147145 
    148146class ExamineBoxAction(Action): 
    149147    """Examine a box. Needs to be more generic, but will do for now.""" 
    150     def __init__(self, model, view, examine_name, examine_desc, commands = None): 
    151         """ 
    152         @param model: A reference to the game model. 
    153         @type model: scripts.GameModel 
     148    def __init__(self, controller, examine_name, examine_desc, commands = None): 
     149        """ 
     150        @param controller: A reference to the GameSceneController. 
     151        @type controller: scripts.GameSceneController 
    154152        @param commands: Special commands that are executed 
    155153        @type commands: Dictionary  
     
    161159        @param examine_name: Description of the object to be examined. 
    162160        """ 
    163         Action.__init__(self, model, commands) 
    164         self.view = view 
     161        super(ExamineBoxAction, self).__init__(controller, commands) 
     162        self.view = controller.view 
    165163        self.examine_name = examine_name 
    166164        self.examine_desc = examine_desc 
     
    170168        self.view.hud.createExamineBox(self.examine_name, \ 
    171169                                              self.examine_desc) 
    172         Action.execute(self) 
     170        super(ExamineBoxAction, self).execute() 
    173171 
    174172class ReadAction(Action): 
    175173    """Read a text.""" 
    176     def __init__(self, model, view, text_name, text, commands = None): 
    177         """ 
    178         @param model: A reference to the game model. 
    179         @type model: scripts.GameModel 
     174    def __init__(self, controller, text_name, text, commands = None): 
     175        """ 
     176        @param controller: A reference to the GameSceneController. 
     177        @type controller: scripts.GameSceneController 
    180178        @param commands: Special commands that are executed 
    181179        @type commands: Dictionary  
     
    187185        @type text: String 
    188186        """ 
    189         Action.__init__(self, model, commands) 
    190         self.view = view 
     187        super(ReadAction, self).__init__(controller, commands) 
     188        self.view = controller.view 
    191189        self.text_name = text_name 
    192190        self.text = text 
     
    198196        #self.view.hud.createExamineBox(self.text_name, \ 
    199197        #                                      self.text) 
    200         Action.execute(self) 
     198        super(ReadAction, self).execute() 
    201199 
    202200class TalkAction(Action): 
    203201    """An action to represent starting a dialogue""" 
    204     def __init__(self, model, view, npc, commands = None): 
    205         """ 
    206         @param model: A reference to the game model. 
    207         @type model: scripts.GameModel 
     202    def __init__(self, controller, npc, commands = None): 
     203        """ 
     204        @param controller: A reference to the GameSceneController. 
     205        @type controller: scripts.GameSceneController 
    208206        @param commands: Special commands that are executed 
    209207        @type commands: Dictionary  
     
    213211        @param npc: NPC to interact with. 
    214212        """ 
    215         Action.__init__(self, model, commands) 
    216         self.view = view 
     213        super(TalkAction, self).__init__(controller, commands) 
     214        self.view = controller.view 
    217215        self.npc = npc 
    218216         
     
    237235                         self.npc.getLocation(). 
    238236                         getLayerCoordinates().y],  
    239                         TalkAction(self.model, 
    240                                    self.view, 
    241                                    self.npc))         
     237                        TalkAction(self.controller, 
     238                                   self.npc, self.commands))         
    242239        else: 
    243240            player_char.behaviour.agent.act('stand', self.npc.getLocation()) 
     
    251248            self.model.game_state.PlayerCharacter.behaviour.idle() 
    252249            self.model.game_state.PlayerCharacter.nextAction = None 
    253             Action.execute(self) 
     250            super(TalkAction, self).execute() 
     251 
     252class UseAction(Action): 
     253    """Action for carryable items. It executes special commands that can be only 
     254    used on carryable utens""" 
     255 
     256 
     257    def __init__(self, controller, item, commands = None): 
     258        """ 
     259        @param controller: A reference to the GameSceneController. 
     260        @type controller: scripts.GameSceneController 
     261        @param item: Item on which the action is called 
     262        @type item: CarryableItem 
     263        @param commands: Special commands that are executed 
     264        @type commands: Dictionary  
     265        """ 
     266        super(UseAction, self).__init__(controller, commands) 
     267        self.view = controller.view 
     268        self.item = item 
     269     
     270    def execute(self): 
     271        #Check if there are special commands and execute them 
     272        for command_data in self.commands: 
     273            command = command_data["Command"] 
     274            if command == "ReplaceItem": 
     275                object_id = command_data["ID"] 
     276                object_type = command_data["ObjectType"] 
     277                container = self.item.in_container 
     278                inst_dict = {} 
     279                inst_dict["ID"] = object_id 
     280                inst_dict["object_type"] = object_type 
     281                new_item = self.model.createContainerObject(inst_dict) 
     282                container.replaceItem(self.item, new_item) 
     283                self.view.hud.inventory.updateInventoryButtons() 
     284        super(UseAction, self).execute() 
    254285 
    255286ACTIONS = {"ChangeMap":ChangeMapAction,  
     
    259290           "Examine":ExamineBoxAction, 
    260291           "Read":ReadAction, 
    261            "Talk":TalkAction} 
     292           "Talk":TalkAction, 
     293           "Use":UseAction} 
  • trunk/game/scripts/objects/base.py

    r569 r571  
    294294        item.in_container = self 
    295295        if index == None: 
    296             self.placeAtVacant(item) 
     296            self._placeAtVacant(item) 
    297297        else: 
    298298            if index in self.items : 
     
    308308            pass 
    309309 
    310     def placeAtVacant(self, item): 
     310    def _placeAtVacant(self, item): 
    311311        """Places an item at a vacant slot""" 
    312312        vacant = None 
     
    317317            vacant = len(self.items) 
    318318        self.items[vacant] = item 
    319  
    320  
     319     
    321320    def takeItem (self, item): 
    322321        """Takes the listed item out of the inventory.  
    323            Runs an 'ontakeItem' script"""         
     322           Runs an 'onTakeItem' script"""         
    324323        if not item in self.items.values(): 
    325324            raise ValueError ('I do not contain this item: %s' % item) 
     
    332331        except AttributeError : 
    333332            pass 
     333     
     334    def replaceItem(self, old_item, new_item): 
     335        """Replaces the old item with the new one 
     336        @param old_item: Old item which is removed 
     337        @type old_item: Carryable 
     338        @param new_item: New item which is added 
     339        @type new_item: Carryable 
     340        """ 
     341        old_index = self.indexOf(old_item.ID) 
     342        self.removeItem(old_item) 
     343        self.placeItem(new_item, old_index) 
     344         
     345    def removeItem(self, item): 
     346        """Removes an item from the container, basically the same as 'takeItem' 
     347        but does run a different script. This should be used when an item is 
     348        destroyed rather than moved out. 
     349        Runs 'onRemoveItem' script 
     350        """ 
     351        if not item in self.items.values(): 
     352            raise ValueError ('I do not contain this item: %s' % item) 
     353        del self.items[self.items.keys()[self.items.values().index(item)]] 
     354 
     355        # Run any scripts associated with popping an item out of the container 
     356        try: 
     357            if self.trueAttr ('scriptable'): 
     358                self.runScript('onRemoveItem') 
     359        except AttributeError : 
     360            pass 
    334361 
    335362    def count (self): 
     
    340367        """Bulk of the container contents""" 
    341368        return sum((item.bulk for item in self.items.values())) 
     369 
     370    def indexOf(self, ID): 
     371        """Returns the index of the item with the passed ID""" 
     372        for index in self.items : 
     373            if self.items[index].ID == ID: 
     374                return index 
     375        return None 
    342376 
    343377    def findItemByID(self, ID): 
  • trunk/game/scripts/quest_engine.py

    r570 r571  
    113113        if there is a reset value present 
    114114        """ 
    115         for variable in self.quest_variables: 
    116             if variable.has_key["reset_value"]: 
     115        for variable in self.quest_variables.itervalues(): 
     116            if variable.has_key("reset_value"): 
    117117                variable["value"] = variable["reset_value"] 
    118118 
Note: See TracChangeset for help on using the changeset viewer.