Changeset 270 for trunk/game


Ignore:
Timestamp:
09/03/09 02:03:40 (10 years ago)
Author:
orlandov
Message:

Fix Issue #78

  • Fully move the inventory display logic from World to Hud.
  • World will pass Hud an inventory model which will be passed to the Hud's Inventory object at creation time.
Location:
trunk/game/scripts
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/scripts/hud.py

    r268 r270  
    2020from scripts.parpgfilebrowser import PARPGFileBrowser 
    2121from scripts.context_menu import ContextMenu 
    22 import weakref 
     22from scripts import inventory 
    2323 
    2424class Hud(object): 
    2525    """Main Hud class""" 
    26     def __init__(self, engine, world, settings): 
     26    def __init__(self, engine, settings, inv_model, callbacks): 
    2727        """Initialise the instance. 
    2828           @type engine: fife.Engine 
     
    3030           @type settings: settings.Setting 
    3131           @param settings: The settings data 
     32           @type inv_model: dict 
     33           @type callbacks: dict 
     34           @param callbacks: a dict of callbacks 
     35               saveGame: called when the user clicks on Save 
     36               loadGame: called when the user clicks on Load 
     37               quitGame: called when the user clicks on Quit 
    3238           @return: None""" 
    3339        pychan.init(engine, debug = True) 
     
    3743        self.engine = engine 
    3844        self.settings = settings 
    39         self.world = weakref.proxy(world) 
     45 
     46        inv_callbacks = { 
     47            'refreshReadyImages': self.refreshReadyImages, 
     48            'toggleInventoryButton': self.toggleInventoryButton, 
     49        } 
     50 
     51        self.inventory = inventory.Inventory(self.engine, inv_model, inv_callbacks) 
     52        self.refreshReadyImages() 
     53 
     54        self.saveGameCallback = callbacks['saveGame'] 
     55        self.loadGameCallback = callbacks['loadGame'] 
     56        self.quitCallback     = callbacks['quitGame'] 
     57 
    4058        self.actionsBox = self.hud.findChild(name="actionsBox") 
    4159        self.actionsText = [] 
     
    121139        self.context_menu = ContextMenu(self.engine, data, pos) 
    122140 
     141    def hideContextMenu(self): 
     142        """Hides the context menu 
     143           @return: None""" 
     144        self.context_menu.hide() 
     145 
    123146    def initializeMainMenu(self): 
    124147        """Initalize the main menu. 
     
    236259            @return: None""" 
    237260        save_browser = PARPGFileBrowser(self.engine, 
    238                                    self.world.saveFunction, 
     261                                   self.saveGameCallback, 
    239262                                   savefile=True, 
    240263                                   guixmlpath="gui/savebrowser.xml", 
     
    251274            @return: None""" 
    252275        load_browser = PARPGFileBrowser(self.engine, 
    253                                    self.world.loadFunction, 
     276                                   self.loadGameCallback, 
    254277                                   savefile=False, 
    255278                                   guixmlpath='gui/loadbrowser.xml', 
     
    276299        window.addChild(hbox) 
    277300 
    278         events_to_map = {"yes_button":self.world.quitFunction, 
    279                          "no_button":window.hide} 
     301        events_to_map = { "yes_button": self.quitCallback, 
     302                          "no_button":  window.hide } 
    280303         
    281304        window.mapEvents(events_to_map) 
     
    286309           @return: None""" 
    287310        button = self.hud.findChild(name="inventoryButton") 
    288         if(button.toggled == 0): 
     311        if button.toggled == 0: 
    289312            button.toggled = 1 
    290313        else: 
    291314            button.toggled = 0 
    292315 
    293     def displayInventory(self, *args, **kwargs): 
     316    def toggleInventory(self, toggleImage=True): 
    294317        """Display's the inventory screen 
    295318           @return: None""" 
    296         self.world.inventory.displayInventory(*args, **kwargs) 
     319 
     320        self.inventory.toggleInventory(toggleImage) 
    297321 
    298322    def refreshReadyImages(self): 
     
    301325           @return: None""" 
    302326        self.setImages(self.hud.findChild(name="hudReady1"), 
    303                        self.world.inventory.inventory.findChild(name="Ready1").up_image) 
     327                       self.inventory.getImage("Ready1").up_image) 
     328 
    304329        self.setImages(self.hud.findChild(name="hudReady2"), 
    305                        self.world.inventory.inventory.findChild(name="Ready2").up_image) 
     330                       self.inventory.getImage("Ready2").up_image) 
     331 
    306332        self.setImages(self.hud.findChild(name="hudReady3"), 
    307                        self.world.inventory.inventory.findChild(name="Ready3").up_image) 
     333                       self.inventory.getImage("Ready3").up_image) 
     334 
    308335        self.setImages(self.hud.findChild(name="hudReady4"), 
    309                        self.world.inventory.inventory.findChild(name="Ready4").up_image) 
     336                       self.inventory.getImage("Ready4").up_image) 
    310337 
    311338    def setImages(self, widget, image): 
     
    324351           @return: None""" 
    325352        events_to_map = {} 
    326         events_to_map["inventoryButton"] = cbwa(self.displayInventory, True) 
     353 
     354        # when we click the toggle button don't change the image 
     355        events_to_map["inventoryButton"] = cbwa(self.toggleInventory, False) 
    327356        events_to_map["saveButton"] = self.saveGame 
    328357        events_to_map["loadButton"] = self.loadGame 
  • trunk/game/scripts/inventory.py

    r267 r270  
    2323class Inventory(object): 
    2424    """Main inventory class""" 
    25     def __init__(self, engine, items, readyCallback, toggleInventoryButtonCallback): 
     25    def __init__(self, engine, items, callbacks): 
    2626        """Initialise the instance. 
    2727           @type engine: fife.Engine 
     
    3030           @param items: A dictionary for every slot that goes '{slot:item, slot:item}' 
    3131                         if a slot is not included in the dict, it is assumed to be empty 
    32            @type readyCallback: function 
    33            @param readyCallback: The function that will make the 
    34                                  ready slots on the HUD reflect those 
    35                                  within the inventory 
    36            @type toggleInventoryButtonCallback: function 
    37            @param toggleInventoryButtonCallback: Function that will toggle the state of the inventory button 
     32           @type callbacks: dict 
     33           @param callbacks: a dict of callbacks 
     34               refreshReadyImages: 
     35                   Function that will make the ready slots on the HUD 
     36                   reflect those within the inventory 
     37               toggleInventoryButton: 
     38                   Function that will toggle the state of the inventory button 
    3839           @return: None""" 
    3940        pychan.init(engine, debug = True) 
    4041        self.engine = engine 
    41         self.readyCallback = readyCallback 
    42         self.toggleInventoryButtonCallback = toggleInventoryButtonCallback 
     42        self.readyCallback = callbacks['refreshReadyImages'] 
     43        self.toggleInventoryButtonCallback = callbacks['toggleInventoryButton'] 
    4344        self.original_cursor_id = self.engine.getCursor().getId() 
    4445        # TODO: remove hard-coded string? 
     
    132133        self.inventoryShown = False 
    133134 
    134     def displayInventory(self, callFromHud): 
     135    def toggleInventory(self, toggleImage=True): 
    135136        """Pause the game and enter the inventory screen, or close the 
    136            inventory screen and resume the game. callFromHud should be true 
    137            (must be True?) if you call this function from the HUD script 
    138            @type callFromHud: boolean 
    139            @param callFromHud: Whether this function is being called  
    140                                from the HUD script 
    141            @return: None""" 
    142         if (self.inventoryShown == False): 
     137           inventory screen and resume the game. 
     138           @type toggleImage: bool 
     139           @param toggleImage: 
     140               Call toggleInventoryCallback if True. Toggling via a 
     141               keypress requires that we toggle the Hud inventory image 
     142               explicitly. Clicking on the Hud inventory button toggles the 
     143               image implicitly, so we don't change it. 
     144           @return: None""" 
     145        if not self.inventoryShown: 
    143146            self.showInventory() 
    144147            self.inventoryShown = True 
     
    146149            self.closeInventory() 
    147150            self.inventoryShown = False 
    148         if (callFromHud == False): 
     151 
     152        if toggleImage: 
    149153            self.toggleInventoryButtonCallback() 
    150154 
     
    296300        return items 
    297301                 
    298  
     302    def getImage(self, name): 
     303        """Return a current image from the inventory 
     304           @type name: string 
     305           @param name: name of image to get 
     306           @return: None""" 
     307        return self.inventory.findChild(name=name) 
     308 
  • trunk/game/scripts/world.py

    r264 r270  
    2424from sounds import SoundEngine 
    2525from settings import Setting 
    26 from scripts import inventory, hud 
     26from scripts import hud 
    2727from scripts.popups import * 
    2828from pychan.tools import callbackWithArguments as cbwa 
     
    5757        self.mouseCallback = None 
    5858        self.obj_hash={} 
     59 
    5960        # self.map is a Map object, set to none here 
    6061        self.activeMap = None 
    6162        self.maps = {} 
    62         self.hud = hud.Hud(self.engine, self, TDS) 
    63  
     63 
     64        # setup the inventory model 
     65        # make slot 'A1' and 'A3' container daggers 
     66        inv_model = {'A1':'dagger01', 'A3':'dagger01'} 
     67 
     68        hud_callbacks = { 
     69            'saveGame': self.saveGame, 
     70            'loadGame': self.loadGame, 
     71            'quitGame': self.quitGame, 
     72        } 
     73        self.hud = hud.Hud(self.engine, TDS, inv_model, hud_callbacks) 
    6474        self.action_number = 1 
    65         # setup the inventory 
    66         # make slot 'A1' and 'A3' container daggers 
    67         inv_data = {'A1':'dagger01', 'A3':'dagger01'} 
    68         self.inventory = inventory.Inventory(self.engine, inv_data, self.hud.refreshReadyImages, self.hud.toggleInventoryButton) 
    69         self.hud.refreshReadyImages() 
    70          
     75 
    7176        self.boxOpen = False 
    7277        self.boxCreated = False 
     
    8085                self.sounds.playMusic("/music/preciouswasteland.ogg") 
    8186                 
    82     def saveFunction(self, *args, **kwargs): 
    83         """Callback for save game 
     87    def quitGame(self): 
     88        """Quits the game 
     89        @return: None""" 
     90        self.quitFunction() 
     91 
     92    def saveGame(self, *args, **kwargs): 
     93        """Saves the game state 
    8494           @return: None""" 
    8595        self.data.save(*args, **kwargs) 
    8696 
    87     def loadFunction(self, *args, **kwargs): 
    88         """Callback for load game 
     97    def loadGame(self, *args, **kwargs): 
     98        """Loads the game state 
    8999           @return: None""" 
    90100        self.data.load(*args, **kwargs) 
     
    152162        if(keyval == key.I): 
    153163            # I opens and closes the inventory 
    154             self.hud.displayInventory(callFromHud=False) 
     164            self.hud.toggleInventory() 
    155165        if(keyval == key.A): 
    156166            # A adds a test action to the action box 
     
    171181           @param evt: The event that fife caught 
    172182           @return: None""" 
    173         self.hud.context_menu.hide() # hide the context menu in case it is displayed 
     183        self.hud.hideContextMenu() # hide the context menu in case it is displayed 
    174184        scr_point = fife.ScreenPoint(evt.getX(), evt.getY()) 
    175185        if(evt.getButton() == fife.MouseEvent.LEFT): 
     
    194204        """Callback sample for the context menu. 
    195205        """ 
    196         self.hud.context_menu.hide() 
     206        self.hud.hideContainer() 
    197207        self.data.gameState.PC.run(click) 
    198208 
Note: See TracChangeset for help on using the changeset viewer.