Changeset 568


Ignore:
Timestamp:
06/27/10 13:52:27 (9 years ago)
Author:
beliar
Message:

Patch by Beliar.

  • The Basic Action now has a commands property. The execute method of the class now loops through this dictionary, parses the values and executes special commands based on these values.
  • Implemented "SetQuestVariable?" command in the Action class. This sets a variable of a quest.
  • Added action property to Usable
  • Added ReadAction? class. For now this prints a name and a text to the console.
  • When right clicking on an item in a container or the pc's inventory the item will be checked for available actions and create a menu from these.
  • Implemented "Read" action to container/inventory items
  • Moved Pamphlet from pc inventory to "DirtyOldCrate?"
  • Added "Grain" object to ObjectDatabase?
  • Gave "Grain" object with ID "bushel_of_grain" to "Farmer Manslow" NPC
  • With these changes it is now possible to advance a bit into the Beer-Quest without using the console. It is still not finishable though.
Location:
trunk/game
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/maps/all_agents.yaml

    r565 r568  
    2525        - {ID: "Dagger", object_type: "Dagger", slot: "right_hand"} 
    2626        - {ID: "Beer", object_type: "Beer"} 
    27         - {ID: "Pamphlet", object_type: "Pamphlet"} 
    2827---             
    2928Janie: 
     
    166165    Position: [-3.0, -3.0, 0.0] 
    167166    Rotation: 0 
     167    Inventory: 
     168        - {ID: bushel_of_grain, object_type: Grain} 
    168169---             
    169170Sami: 
  • trunk/game/maps/map_agents.yaml

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

    r563 r568  
    3838  name: Pamphlet 
    3939  image: /gui/inv_images/inv_pamphlet.png 
    40    
     40  actions: 
     41    Read: 
     42      text: This pamphlet describes how to brew beer. You think with this information you are able to brew your own beer. 
     43      commands: 
     44        - {Command: SetQuestVariable, ID: beer, Variable: beer_instructions, Value: Read} 
     45Grain: 
     46    name: Grain 
  • trunk/game/scripts/gamescenecontroller.py

    r566 r568  
    7575            'quitGame': self.quitGame, 
    7676        } 
    77         self.view.hud = Hud(self.engine,  
     77        self.view.hud = Hud(self,  
    7878                            self.model.settings,  
    79                             self.model,  
    8079                            hud_callbacks) 
    8180 
     
    256255                                        PlayerCharacter.approach, 
    257256                                    [obj.X, obj.Y], 
    258                                     UnlockBoxAction(obj)]) 
     257                                    UnlockBoxAction(self.model, obj)]) 
    259258                    actions.append(["Lock", "Lock",  
    260259                                    self.model.game_state.\ 
    261260                                        PlayerCharacter.approach, 
    262261                                    [obj.X, obj.Y], 
    263                                     LockBoxAction(obj)]) 
     262                                    LockBoxAction(self.model, obj)]) 
    264263                # can you pick it up? 
    265264                if obj.trueAttr("carryable"): 
  • trunk/game/scripts/gui/context_menu.py

    r479 r568  
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1717 
    18 from fife import fife 
    1918from fife.extensions import pychan 
    2019 
  • trunk/game/scripts/gui/dialoguegui.py

    r553 r568  
    5858            if not state['pc'].inventory.findItem(name = thing): 
    5959                try : 
    60                     self.npc.give(self.npc.inventory.findItem(name = thing), state['pc']) 
     60                    self.npc.give(self.npc.inventory.findItem(ID = thing), state['pc']) 
    6161                    print "You've now have the %s" % thing 
    6262                except ValueError : 
  • trunk/game/scripts/gui/hud.py

    r566 r568  
    2727class Hud(object): 
    2828    """Main Hud class""" 
    29     def __init__(self, engine, settings, model, callbacks): 
     29    def __init__(self, controller, settings, callbacks): 
    3030        """Initialise the instance. 
    31            @type engine: fife.Engine 
    32            @param engine: An instance of the fife engine 
     31           @type controller: Class derived from ControllerBase 
     32           @param controller: The current controller 
    3333           @type settings: settings.Setting 
    3434           @param settings: The settings 
     
    4040               quitGame: called when the user clicks on Quit 
    4141           @return: None""" 
    42         pychan.init(engine, debug = True) 
     42        pychan.init(controller.engine, debug = True) 
    4343 
    4444        # TODO: perhaps this should not be hard-coded here 
    4545        self.hud = pychan.loadXML("gui/hud.xml") 
    46         self.engine = engine 
     46        self.controller = controller 
     47        self.engine = controller.engine 
     48        self.model = controller.model 
    4749        self.settings = settings 
    48         self.model = model 
    4950        self.inventory = None 
    5051 
     
    140141        self.inventory_storage = self.model.game_state.PlayerCharacter.inventory 
    141142        if self.inventory == None: 
    142             self.inventory = inventorygui.InventoryGUI(self.engine, 
     143            self.inventory = inventorygui.InventoryGUI(self.controller, 
    143144                                                       self.inventory_storage, 
    144145                                                       inv_callbacks) 
     
    385386        self.hideContainer() 
    386387 
    387         self.box_container = ContainerGUI(self.engine, \ 
     388        self.box_container = ContainerGUI(self.controller, 
    388389                                              unicode(title), container) 
    389390        self.box_container.container_gui.mapEvents(events) 
  • trunk/game/scripts/gui/inventorygui.py

    r563 r568  
    2222from scripts.gui import drag_drop_data as data_drag 
    2323from scripts.objects.base import Container 
     24from scripts.objects.action import ACTIONS 
     25from context_menu import ContextMenu 
    2426 
    2527class InventoryGUI(object): 
    2628    """Inventory GUI class""" 
    27     def __init__(self, engine, inventory, callbacks): 
     29    def __init__(self, controller, inventory, callbacks): 
    2830        """Initialise the instance. 
    29            @type engine: fife.Engine 
    30            @param engine: An instance of the fife engine 
     31           @param controller: Current Controller 
     32           @type controller: Class derived from ControllerBase 
    3133           @type inventory: Inventory 
    3234           @param inventory: An inventory object to be displayed and manipulated 
     
    3941                   Function that will toggle the state of the inventory button 
    4042           @return: None""" 
    41         self.engine = engine 
     43        self.controller = controller 
     44        self.engine = controller.engine 
    4245        self.readyCallback = callbacks['refreshReadyImages'] 
    4346        self.toggleInventoryButtonCallback = callbacks['toggleInventoryButton'] 
     
    8285            for _, button in enumerate(self.slot_buttons[slot]): 
    8386                events_to_map[button] = cbwa(self.dragDrop, button) 
     87                events_to_map[button + "/mouseReleased"] = \ 
     88                                                self.showContextMenu 
    8489        events_to_map['close_button'] = self.closeInventoryAndToggle 
    8590        self.inventory.mapEvents(events_to_map) 
     
    105110        button.down_image = image 
    106111        button.hover_image = image 
     112 
     113    def showContextMenu(self, event, widget): 
     114        """Decide whether to drag or drop the image. 
     115           @type obj: string 
     116           @param obj: The name of the object within  
     117                       the dictionary 'self.buttons' 
     118           @return: None""" 
     119        if event.getButton() == event.RIGHT: 
     120            item = widget.item 
     121            if item and item.trueAttr("usable"): 
     122                actions = item.actions 
     123                menu_actions = [] 
     124                x_pos, y_pos = widget.getAbsolutePos() 
     125                x_pos += event.getX() 
     126                y_pos += event.getY() 
     127                for action_name in actions: 
     128                    if action_name in ACTIONS: 
     129                        param_dict = {}  
     130                        param_dict["model"] = self.controller.model 
     131                        param_dict["commands"] = {} 
     132                        if action_name == "Read": 
     133                            param_dict["view"] = self.controller.view 
     134                            param_dict["text_name"] = item.name 
     135                            param_dict["text"] = "" 
     136                        param_dict.update(actions[action_name]) 
     137                        menu_actions.append([action_name, action_name,  
     138                                            self.executeMenuItem, 
     139                                            ACTIONS[action_name](**param_dict)]) 
     140                context_menu = ContextMenu(self.controller.engine, 
     141                                                menu_actions, 
     142                                                 (x_pos,  
     143                                                  y_pos) 
     144                                                  ) 
     145                context_menu.show() 
     146     
     147    def executeMenuItem(self, action): 
     148        #self.hideContainer() 
     149        action.execute() 
    107150 
    108151    def closeInventory(self): 
  • trunk/game/scripts/gui/popups.py

    r483 r568  
    2121 
    2222from scripts.gui import drag_drop_data as data_drag 
     23from scripts.objects.action import ACTIONS 
     24from context_menu import ContextMenu 
    2325 
    2426class ContainerGUI(): 
    25     def __init__(self, engine, title, container): 
     27    def __init__(self, controller, title, container): 
    2628        """A class to create a window showing the contents of a container. 
    27            @type engine: fife.Engine 
    28            @param engine: an instance of the fife engine 
     29           @param controller: The current Controller 
     30           @type controller: Class derived from ControllerBase 
     31           @param title: The title of the window 
    2932           @type title: string 
    30            @param title: The title of the window 
     33           @param container: A container to represent 
    3134           @type container: Container 
    32            @param container: A container to represent 
    33            @return: None""" 
    34         self.engine = engine 
     35           @return: None""" 
     36        self.controller = controller 
    3537        self.container_gui = pychan.loadXML("gui/container_base.xml") 
    3638        self.container_gui.findChild(name="topWindow").title = title 
    3739     
    3840        data_drag.dragging = False 
    39         self.original_cursor_id = self.engine.getCursor().getId() 
     41        self.original_cursor_id = self.controller.engine.getCursor().getId() 
    4042        self.container = container 
    41          
     43        self.empty_images = dict() 
     44        self.events_to_map = {}         
    4245        self.resetMouseCursor() 
    4346             
     
    5861        empty_image = "gui/inv_images/inv_backpack.png" 
    5962        slot_count = 9 
    60         self.empty_images = dict() 
    61         self.events_to_map = {} 
    6263        for counter in range(1, slot_count+1): 
    6364            slot_name = "Slot%i" % counter 
     
    6869            self.updateImage(widget) 
    6970            self.events_to_map[slot_name] = cbwa(self.dragDrop, slot_name) 
     71            self.events_to_map[slot_name + "/mouseReleased"] = \ 
     72                                            self.showContextMenu 
    7073 
    7174        self.container_gui.mapEvents(self.events_to_map) 
     
    8790           @param type: ??? 
    8891           @return: None""" 
    89         cursor = self.engine.getCursor() 
     92        cursor = self.controller.engine.getCursor() 
    9093        cursor_type = fife.CURSOR_IMAGE 
    91         img_pool = self.engine.getImagePool() 
     94        img_pool = self.controller.engine.getImagePool() 
    9295        if(mc_type == "target"): 
    9396            target_cursor_id = img_pool.addResourceFromFile(image)   
    9497            dummy_cursor_id = img_pool.addResourceFromFile(dummy_image) 
    9598            cursor.set(cursor_type, dummy_cursor_id) 
    96             cursor.setDrag(cursor_type, target_cursor_id,-16,-16) 
     99            cursor.setDrag(cursor_type, target_cursor_id, -16, -16) 
    97100        else: 
    98101            cursor_type = fife.CURSOR_IMAGE 
     
    104107        """Reset cursor to default image. 
    105108           @return: None""" 
    106         c = self.engine.getCursor() 
    107         img_pool = self.engine.getImagePool() 
     109        c = self.controller.engine.getCursor() 
     110        img_pool = self.controller.engine.getImagePool() 
    108111        cursor_type = fife.CURSOR_NATIVE 
    109112        # this is the path to the default image 
     
    112115        c.set(cursor_type, cursor_id) 
    113116         
     117    def showContextMenu(self, event, widget): 
     118        """Decide whether to drag or drop the image. 
     119           @type obj: string 
     120           @param obj: The name of the object within  
     121                       the dictionary 'self.buttons' 
     122           @return: None""" 
     123        if event.getButton() == event.RIGHT: 
     124            item = widget.item 
     125            if item and item.trueAttr("usable"): 
     126                actions = item.actions 
     127                menu_actions = [] 
     128                x_pos, y_pos = widget.getAbsolutePos() 
     129                x_pos += event.getX() 
     130                y_pos += event.getY() 
     131                for action_name in actions: 
     132                    if action_name in ACTIONS: 
     133                        param_dict = {}  
     134                        param_dict["model"] = self.controller.model 
     135                        param_dict["commands"] = {} 
     136                        if action_name == "Read": 
     137                            param_dict["view"] = self.controller.view 
     138                            param_dict["text_name"] = item.name 
     139                            param_dict["text"] = "" 
     140                        param_dict.update(actions[action_name]) 
     141                        menu_actions.append([action_name, action_name,  
     142                                            self.executeMenuItem, 
     143                                            ACTIONS[action_name](**param_dict)]) 
     144                context_menu = ContextMenu(self.controller.engine, 
     145                                                menu_actions, 
     146                                                 (x_pos,  
     147                                                  y_pos) 
     148                                                  ) 
     149                context_menu.show() 
     150 
     151     
     152    def executeMenuItem(self, action): 
     153        #self.hideContainer() 
     154        action.execute() 
     155     
    114156    def dragDrop(self, obj): 
    115157        """Decide whether to drag or drop the image. 
  • trunk/game/scripts/objects/action.py

    r563 r568  
    11#!/usr/bin/python 
     2from winioctlcon import UNLOCK_ELEMENT 
    23 
    34#   This file is part of PARPG. 
     
    1617#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    1718 
     19#exceptions 
     20class NoSuchQuestException(Exception): 
     21    """NoQuestException is used when there is no active quest with the id""" 
     22    pass 
     23 
     24#classes 
     25 
    1826class Action(object): 
    1927    """Base Action class, to define the structure""" 
    20     def execute(self): 
    21         """To be overwritten""" 
    22         pass 
    23  
     28 
     29 
     30    def __init__(self, model, commands = None): 
     31        """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 
     39     
     40    def execute(self): 
     41        """To be overwritten"""         
     42        #Check if there are special commands and execute them 
     43        for command_data in self.commands: 
     44            command = command_data["Command"] 
     45            if command == "SetQuestVariable": 
     46                quest_id = command_data["ID"] 
     47                variable = command_data["Variable"] 
     48                value = command_data["Value"] 
     49                quest_engine = self.model.game_state.quest_engine  
     50                if quest_engine.hasQuest(quest_id): 
     51                    quest_engine[quest_id].setValue(variable, value) 
     52                else: 
     53                    raise NoSuchQuestException 
     54                 
    2455class ChangeMapAction(Action): 
    2556    """A change map scheduled""" 
    26     def __init__(self, model, view, target_map_name, target_pos): 
     57    def __init__(self, model, view, target_map_name, target_pos, commands = None): 
    2758        """Initiates a change of the position of the character 
    28            possibly flagging a new map to be loaded. 
    29            @type model: scripts.GameModel 
    30            @param model: A reference to the game model. 
    31            @type view: class derived from scripts.ViewBase 
    32            @param view: The view 
    33            @type target_map_name: String 
    34            @param target_map_name: Target map id  
    35            @type target_pos: Tuple 
    36            @param target_pos: (X, Y) coordinates on the target map. 
    37            @return: None""" 
    38         Action.__init__(self) 
     59        possibly flagging a new map to be loaded. 
     60        @param model: A reference to the game model. 
     61        @type model: scripts.GameModel 
     62        @param commands: Special commands that are executed 
     63        @type commands: Dictionary  
     64        @type view: class derived from scripts.ViewBase 
     65        @param view: The view 
     66        @type target_map_name: String 
     67        @param target_map_name: Target map id  
     68        @type target_pos: Tuple 
     69        @param target_pos: (X, Y) coordinates on the target map. 
     70        @return: None""" 
     71        Action.__init__(self, model, commands) 
    3972        self.model = model 
    4073        self.view = view 
     
    4679        self.model.changeMap(self.target_map_name, 
    4780                              self.target_pos) 
     81        Action.execute(self) 
    4882        
    4983class OpenBoxAction(Action): 
    5084    """Open a box. Needs to be more generic, but will do for now.""" 
    51     def __init__(self, model, view, container): 
    52         """@type model: Engine reference 
    53            @param model: A reference to the model. 
    54            @type view: class derived from scripts.ViewBase 
    55            @param view: The view 
    56            @param container: A reference to the container""" 
    57         Action.__init__(self) 
    58         self.model = model 
     85    def __init__(self, model, view, container, commands = None): 
     86        """ 
     87        @param model: A reference to the game model. 
     88        @type model: scripts.GameModel 
     89        @param commands: Special commands that are executed 
     90        @type commands: Dictionary  
     91        @type view: class derived from scripts.ViewBase 
     92        @param view: The view 
     93        @param container: A reference to the container 
     94        """ 
     95        Action.__init__(self, model, commands) 
    5996        self.view = view 
    6097        self.container = container 
     
    66103            self.view.hud.createBoxGUI(self.container.name, \ 
    67104                                              self.container) 
     105            Action.execute(self) 
    68106 
    69107        except ValueError: 
     
    73111class UnlockBoxAction(Action): 
    74112    """Unlocks a box. Needs to be more generic, but will do for now.""" 
    75     def __init__(self,  container): 
    76         """@param container: A reference to the container""" 
    77         Action.__init__(self) 
     113    def __init__(self, model, container, commands = None): 
     114        """ 
     115        @param model: A reference to the game model. 
     116        @type model: scripts.GameModel 
     117        @param commands: Special commands that are executed 
     118        @type commands: Dictionary  
     119        @param container: A reference to the container 
     120        """ 
     121        Action.__init__(self, model, commands) 
    78122        self.container = container 
    79123     
     
    81125        """Open the box.""" 
    82126        self.container.unlock() 
     127        Action.execute(self) 
    83128         
    84129class LockBoxAction(Action): 
    85130    """Locks a box. Needs to be more generic, but will do for now.""" 
    86     def __init__(self, container): 
    87         """@param container: A reference to the container""" 
    88         Action.__init__(self) 
     131    def __init__(self, model, container, commands = None): 
     132        """ 
     133        @param model: A reference to the game model. 
     134        @type model: scripts.GameModel 
     135        @param commands: Special commands that are executed 
     136        @type commands: Dictionary  
     137        @param container: A reference to the container 
     138        """ 
     139        Action.__init__(self, model, commands) 
    89140        self.container = container 
    90141         
     
    92143        """Lock the box.""" 
    93144        self.container.lock() 
     145        Action.execute(self) 
    94146 
    95147 
    96148class ExamineBoxAction(Action): 
    97149    """Examine a box. Needs to be more generic, but will do for now.""" 
    98     def __init__(self, model, view, examine_name, examine_desc): 
    99         """@type model: Engine reference 
    100            @param model: A reference to the model. 
    101            @type view: class derived from scripts.ViewBase 
    102            @param view: The view 
    103            @type examine_name: String 
    104            @param examine_name: Name of the object to be examined. 
    105            @type examine_name: String 
    106            @param examine_name: Description of the object to be examined.""" 
    107         Action.__init__(self) 
    108         self.model = model 
     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 
     154        @param commands: Special commands that are executed 
     155        @type commands: Dictionary  
     156        @type view: class derived from scripts.ViewBase 
     157        @param view: The view 
     158        @type examine_name: String 
     159        @param examine_name: Name of the object to be examined. 
     160        @type examine_name: String 
     161        @param examine_name: Description of the object to be examined. 
     162        """ 
     163        Action.__init__(self, model, commands) 
    109164        self.view = view 
    110165        self.examine_name = examine_name 
     
    115170        self.view.hud.createExamineBox(self.examine_name, \ 
    116171                                              self.examine_desc) 
     172        Action.execute(self) 
     173 
     174class ReadAction(Action): 
     175    """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 
     180        @param commands: Special commands that are executed 
     181        @type commands: Dictionary  
     182        @param view: The view 
     183        @type view: class derived from scripts.ViewBase 
     184        @param text_name: Name of the object containing the text 
     185        @type text_name: String 
     186        @param text: Text to be displayied 
     187        @type text: String 
     188        """ 
     189        Action.__init__(self, model, commands) 
     190        self.view = view 
     191        self.text_name = text_name 
     192        self.text = text 
     193         
     194    def execute(self): 
     195        """Examine the box.""" 
     196        print "You read " + self.text_name 
     197        print self.text 
     198        #self.view.hud.createExamineBox(self.text_name, \ 
     199        #                                      self.text) 
     200        Action.execute(self) 
    117201 
    118202class TalkAction(Action): 
    119203    """An action to represent starting a dialogue""" 
    120     def __init__(self, model, view, npc): 
    121         """@type model: Engine reference 
    122            @param model: A reference to the model. 
    123            @type view: class derived from scripts.ViewBase 
    124            @param view: The view 
    125            @type npc: NonPlayerCharacter 
    126            @param npc: NPC to interact with.""" 
    127         Action.__init__(self) 
    128         self.model = model 
     204    def __init__(self, model, view, npc, commands = None): 
     205        """ 
     206        @param model: A reference to the game model. 
     207        @type model: scripts.GameModel 
     208        @param commands: Special commands that are executed 
     209        @type commands: Dictionary  
     210        @type view: class derived from scripts.ViewBase 
     211        @param view: The view 
     212        @type npc: NonPlayerCharacter 
     213        @param npc: NPC to interact with. 
     214        """ 
     215        Action.__init__(self, model, commands) 
    129216        self.view = view 
    130217        self.npc = npc 
     
    134221           @return: None""" 
    135222       
    136         pc = self.model.game_state.PlayerCharacter 
     223        player_char = self.model.game_state.PlayerCharacter 
    137224        npc_coordinates = self.npc.getLocation().getLayerCoordinates() 
    138         pc_coordinates = pc.behaviour.agent.getLocation().getLayerCoordinates() 
     225        pc_coordinates = player_char.behaviour.agent.\ 
     226                            getLocation().getLayerCoordinates() 
    139227         
    140228        distance_squared = (npc_coordinates.x - pc_coordinates.x) *\ 
     
    145233        # If we are too far away, we approach the NPC again 
    146234        if distance_squared > 2: 
    147             pc.approach([self.npc.getLocation(). 
     235            player_char.approach([self.npc.getLocation(). 
    148236                         getLayerCoordinates().x, 
    149237                         self.npc.getLocation(). 
     
    153241                                   self.npc))         
    154242        else: 
    155             pc.behaviour.agent.act('stand', self.npc.getLocation()) 
     243            player_char.behaviour.agent.act('stand', self.npc.getLocation()) 
    156244     
    157245            if self.npc.dialogue is not None: 
    158                 self.npc.talk(pc) 
     246                self.npc.talk(player_char) 
    159247                self.view.hud.showDialogue(self.npc) 
    160248            else: 
     
    163251            self.model.game_state.PlayerCharacter.behaviour.idle() 
    164252            self.model.game_state.PlayerCharacter.nextAction = None 
     253            Action.execute(self) 
     254 
     255ACTIONS = {"ChangeMap":ChangeMapAction,  
     256           "OpenBox":OpenBoxAction,  
     257           "Unlock":UnlockBoxAction, 
     258           "Lock":LockBoxAction, 
     259           "Examine":ExamineBoxAction, 
     260           "Read":ReadAction, 
     261           "Talk":TalkAction} 
  • trunk/game/scripts/objects/actors.py

    r563 r568  
    323323        if inventory == None: 
    324324            self.inventory = Inventory() 
    325             self.inventory.placeItem(CarryableItem(ID = 632, 
    326                                                    name = "box", 
    327                                                    image = "/gui/inv_images/inv_giftbox.png")) 
    328  
    329325        else: 
    330326            self.inventory = inventory 
     
    346342        ret_dict = super(NonPlayerCharacter, self).getStateForSaving() 
    347343        ret_dict["Lives"] = self.is_living 
     344        ret_dict["Inventory"] = self.inventory.serializeInventory() 
    348345        ret_dict["State"] = self.behaviour.state 
    349346        return ret_dict 
  • trunk/game/scripts/objects/base.py

    r563 r568  
    358358            if "name" in kwargs and self.items[i].name != kwargs["name"]: 
    359359                continue 
     360            if "ID" in kwargs and self.items[i].ID != kwargs["ID"]: 
     361                continue 
    360362            if "kind" in kwargs and not self.items[i].trueAttr(kwargs["kind"]): 
    361363                continue 
     
    407409    """Allows the object to be used in some way (e.g. a Zippo lighter  
    408410       to make a fire)""" 
    409     def __init__ (self, **kwargs): 
     411    def __init__ (self, actions = None, **kwargs): 
    410412        self.is_usable = True 
     413        self.actions = actions or {}    
    411414         
    412415class Weapon (object): 
  • trunk/game/scripts/objects/composed.py

    r563 r568  
    1919 
    2020from base import GameObject, Container, Lockable, \ 
    21                 Scriptable, Trappable, Destructable, Carryable 
     21                Scriptable, Trappable, Destructable, Carryable, \ 
     22                Usable 
    2223 
    2324class ImmovableContainer(GameObject, Container, Lockable, Scriptable,  
     
    7879        CarryableContainer.placeItem(self, item) 
    7980 
    80 class CarryableItem (GameObject, Carryable): 
     81class CarryableItem (GameObject, Carryable, Usable): 
    8182    """Composite class that will be used for all carryable items""" 
    8283    def __init__(self, **kwargs): 
    8384        GameObject.__init__(self, **kwargs) 
    8485        Carryable.__init__(self, **kwargs) 
     86        Usable.__init__(self, **kwargs) 
    8587 
    8688    def prepareStateForSaving(self, state): 
Note: See TracChangeset for help on using the changeset viewer.