Changeset 261


Ignore:
Timestamp:
08/25/09 08:56:37 (10 years ago)
Author:
b0rland_parpg
Message:

Ticket #78, #80: Patch by superfluid. Moving the hud events and context menu code (and inventory code) from world.py to hud.py

Location:
trunk/game/scripts
Files:
3 edited

Legend:

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

    r182 r261  
    1818import shutil, fife, pychan 
    1919from pychan.tools import callbackWithArguments as cbwa 
    20  
    21  
    22 class Hud(): 
     20from scripts.parpgfilebrowser import PARPGFileBrowser 
     21from scripts.context_menu import ContextMenu 
     22import weakref 
     23 
     24class Hud(object): 
    2325    """Main Hud class""" 
    24     def __init__(self, engine, settings): 
     26    def __init__(self, engine, world, settings): 
    2527        """Initialise the instance. 
    2628           @type engine: fife.Engine 
     
    3032           @return: None""" 
    3133        pychan.init(engine, debug = True) 
     34 
    3235        # TODO: perhaps this should not be hard-coded here 
    3336        self.hud = pychan.loadXML("gui/hud.xml") 
     37        self.engine = engine 
    3438        self.settings = settings 
     39        self.world = weakref.proxy(world) 
    3540        self.actionsBox = self.hud.findChild(name="actionsBox") 
    3641        self.actionsText = [] 
     
    3843        self.initializeHud() 
    3944        self.initializeMainMenu() 
     45        self.initializeContextMenu() 
    4046        self.initializeOptionsMenu() 
    4147        self.initializeHelpMenu() 
     48        self.initializeEvents() 
    4249 
    4350    def initializeHud(self): 
     
    122129           @return: None""" 
    123130        self.hud.hide() 
    124          
     131 
     132    def initializeContextMenu(self): 
     133        """Initialize the Context Menu 
     134           @return: None""" 
     135        self.context_menu = ContextMenu (self.engine, [], (0,0)) 
     136        self.context_menu.hide() 
     137 
     138    def showContextMenu(self, data, pos): 
     139        """Display the Context Menu with data at pos 
     140           @type data: list 
     141           @param data: data to pass to context menu 
     142           @type pos: tuple 
     143           @param pos: tuple of x and y coordinates 
     144           @return: None""" 
     145        self.context_menu = ContextMenu(self.engine, data, pos) 
     146 
    125147    def initializeMainMenu(self): 
    126148        """Initalize the main menu. 
     
    153175        help_events = {"closeButton":self.help_dialog.hide} 
    154176        self.help_dialog.mapEvents(help_events) 
    155         main_help_text = "Welcome to Post-Apocalyptic RPG or PARPG![br][br]"\ 
     177        main_help_text = u"Welcome to Post-Apocalyptic RPG or PARPG![br][br]"\ 
    156178        "This game is still in development, so please expect for there to be bugs"\ 
    157179        " and[br]feel free to tell us about them at http://www.forums.parpg.net.[br]"\ 
     
    162184        " depending on[br]what you have clicked on, hence it's name \"context menu\".[br][br]" 
    163185         
    164         k_text =" Keybindings"  
     186        k_text = u" Keybindings"  
    165187        k_text+="[br] A : Add a test action to the actions display" 
    166188        k_text+="[br] I : Toggle the inventory screen" 
     
    230252        self.options_menu.mapEvents(self.options_events) 
    231253 
     254    def saveGame(self): 
     255        """ Called when the user wants to save the game. 
     256            @return: None""" 
     257        save_browser = PARPGFileBrowser(self.engine, 
     258                                   self.world.saveFunction, 
     259                                   savefile=True, 
     260                                   guixmlpath="gui/savebrowser.xml", 
     261                                   extensions = ('.dat')) 
     262        save_browser.showBrowser() 
     263             
     264    def newGame(self): 
     265        """Called when user request to start a new game. 
     266           @return: None""" 
     267        print 'new game' 
     268 
     269    def loadGame(self): 
     270        """ Called when the user wants to load a game. 
     271            @return: None""" 
     272        load_browser = PARPGFileBrowser(self.engine, 
     273                                   self.world.loadFunction, 
     274                                   savefile=False, 
     275                                   guixmlpath='gui/loadbrowser.xml', 
     276                                   extensions=('.dat')) 
     277        load_browser.showBrowser() 
     278 
     279    def quitGame(self): 
     280        """Called when user requests to quit game. 
     281           @return: None""" 
     282 
     283        window = pychan.widgets.Window(title=unicode("Quit?")) 
     284 
     285        hbox = pychan.widgets.HBox() 
     286        are_you_sure = "Are you sure you want to quit?" 
     287        label = pychan.widgets.Label(text=unicode(are_you_sure)) 
     288        yes_button = pychan.widgets.Button(name="yes_button",  
     289                                           text=unicode("Yes")) 
     290        no_button = pychan.widgets.Button(name="no_button", 
     291                                          text=unicode("No")) 
     292 
     293        window.addChild(label) 
     294        hbox.addChild(yes_button) 
     295        hbox.addChild(no_button) 
     296        window.addChild(hbox) 
     297 
     298        events_to_map = {"yes_button":self.world.quitFunction, 
     299                         "no_button":window.hide} 
     300         
     301        window.mapEvents(events_to_map) 
     302        window.show() 
     303 
     304    def toggleInventoryButton(self): 
     305        """Manually toggles the inventory button. 
     306           @return: None""" 
     307        button = self.hud.findChild(name="inventoryButton") 
     308        if(button.toggled == 0): 
     309            button.toggled = 1 
     310        else: 
     311            button.toggled = 0 
     312 
     313    def displayInventory(self, *args, **kwargs): 
     314        """Display's the inventory screen 
     315           @return: None""" 
     316        self.world.inventory.displayInventory(*args, **kwargs) 
     317 
     318    def refreshReadyImages(self): 
     319        """Make the Ready slot images on the HUD be the same as those  
     320           on the inventory 
     321           @return: None""" 
     322        self.setImages(self.hud.findChild(name="hudReady1"), 
     323                       self.world.inventory.inventory.findChild(name="Ready1").up_image) 
     324        self.setImages(self.hud.findChild(name="hudReady2"), 
     325                       self.world.inventory.inventory.findChild(name="Ready2").up_image) 
     326        self.setImages(self.hud.findChild(name="hudReady3"), 
     327                       self.world.inventory.inventory.findChild(name="Ready3").up_image) 
     328        self.setImages(self.hud.findChild(name="hudReady4"), 
     329                       self.world.inventory.inventory.findChild(name="Ready4").up_image) 
     330 
     331    def setImages(self, widget, image): 
     332        """Set the up, down, and hover images of an Imagebutton. 
     333           @type widget: pychan.widget 
     334           @param widget: widget to set 
     335           @type image: string 
     336           @param image: image to use 
     337           @return: None""" 
     338        widget.up_image = image 
     339        widget.down_image = image 
     340        widget.hover_image = image 
     341 
     342    def initializeEvents(self): 
     343        """Intialize Hud events 
     344           @return: None""" 
     345        events_to_map = {} 
     346        events_to_map["inventoryButton"] = cbwa(self.displayInventory, True) 
     347        events_to_map["saveButton"] = self.saveGame 
     348        events_to_map["loadButton"] = self.loadGame 
     349 
     350        hud_ready_buttons = ["hudReady1", "hudReady2", "hudReady3", "hudReady4"] 
     351 
     352        for item in hud_ready_buttons: 
     353            events_to_map[item] = cbwa(self.readyAction, item) 
     354 
     355        self.hud.mapEvents(events_to_map) 
     356 
     357        menu_events = {} 
     358        menu_events["newButton"] = self.newGame 
     359        menu_events["quitButton"] = self.quitGame 
     360        menu_events["saveButton"] = self.saveGame 
     361        menu_events["loadButton"] = self.loadGame 
     362        self.main_menu.mapEvents(menu_events) 
     363 
    232364    def updateVolumeText(self): 
    233365        """ 
     
    345477        self.options_menu.show() 
    346478     
    347     def toggleInventory(self): 
    348         """Manually toggles the inventory button. 
    349            @return: None""" 
    350         button = self.hud.findChild(name="inventoryButton") 
    351         if(button.toggled == 0): 
    352             button.toggled = 1 
    353         else: 
    354             button.toggled = 0 
    355  
    356479    def readyAction(self, ready_button): 
    357480        """ Called when the user selects a ready button from the HUD """ 
  • trunk/game/scripts/inventory.py

    r208 r261  
    2121from scripts.items import item_image_dict 
    2222 
    23 class Inventory(): 
     23class Inventory(object): 
    2424    """Main inventory class""" 
    25     def __init__(self, engine, items, readyCallback): 
     25    def __init__(self, engine, items, readyCallback, toggleInventoryButtonCallback): 
    2626        """Initialise the instance. 
    2727           @type engine: fife.Engine 
     
    3434                                 ready slots on the HUD reflect those 
    3535                                 within the inventory 
     36           @type toggleInventoryButtonCallback: function 
     37           @param toggleInventoryButtonCallback: Function that will toggle the state of the inventory button 
    3638           @return: None""" 
    3739        pychan.init(engine, debug = True) 
    3840        self.engine = engine 
    3941        self.readyCallback = readyCallback 
     42        self.toggleInventoryButtonCallback = toggleInventoryButtonCallback 
    4043        self.original_cursor_id = self.engine.getCursor().getId() 
    4144        # TODO: remove hard-coded string? 
    4245        self.inventory = pychan.loadXML("gui/inventory.xml") 
     46        self.inventoryShown = False  
    4347        self.events_to_map = {} 
    4448        # the images that should be used for the buttons when they are "empty" 
     
    112116                ch.item = "" 
    113117 
     118        self.events_to_map['close_button'] = self.closeInventoryAndToggle 
    114119        self.inventory.mapEvents(self.events_to_map)    
    115120        self.resetMouseCursor() 
     
    119124           @return: None""" 
    120125        self.inventory.hide() 
     126 
     127    def closeInventoryAndToggle(self): 
     128        """Close the inventory screen. 
     129           @return: None""" 
     130        self.closeInventory() 
     131        self.toggleInventoryButtonCallback() 
     132        self.inventoryShown = False 
     133 
     134    def displayInventory(self, callFromHud): 
     135        """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): 
     143            self.showInventory() 
     144            self.inventoryShown = True 
     145        else: 
     146            self.closeInventory() 
     147            self.inventoryShown = False 
     148        if (callFromHud == False): 
     149            self.toggleInventoryButtonCallback() 
    121150 
    122151    def showInventory(self): 
  • trunk/game/scripts/world.py

    r253 r261  
    1919import pychan 
    2020from sounds import SoundEngine 
    21 from scripts.parpgfilebrowser import PARPGFileBrowser 
    2221from datetime import date 
    2322from scripts.common.eventlistenerbase import EventListenerBase 
     
    2524from scripts import inventory, hud 
    2625from scripts.popups import * 
    27 from scripts.context_menu import ContextMenu 
    2826from pychan.tools import callbackWithArguments as cbwa 
    2927from map import Map 
     
    5250        self.eventmanager = engine.getEventManager() 
    5351        self.quitFunction = None 
    54         self.inventoryShown = False  
    5552         
    5653        # self.data is an engine.Engine object, but is set in run.py 
     
    6158        self.activeMap = None 
    6259        self.maps = {} 
    63         self.hud = hud.Hud(self.engine, TDS) 
    64         self.hud.events_to_map["inventoryButton"] = cbwa(self.displayInventory, True) 
    65         self.hud.events_to_map["saveButton"] = self.saveGame 
    66         self.hud.events_to_map["loadButton"] = self.loadGame 
    67         hud_ready_buttons = ["hudReady1", "hudReady2", "hudReady3", "hudReady4"] 
    68         for item in hud_ready_buttons: 
    69             self.hud.events_to_map[item] = cbwa(self.hud.readyAction, item) 
    70         self.hud.hud.mapEvents(self.hud.events_to_map) 
    71         self.hud.menu_events["newButton"] = self.newGame 
    72         self.hud.menu_events["quitButton"] = self.quitGame 
    73         self.hud.menu_events["saveButton"] = self.saveGame 
    74         self.hud.menu_events["loadButton"] = self.loadGame 
    75         self.hud.main_menu.mapEvents(self.hud.menu_events) 
     60        self.hud = hud.Hud(self.engine, self, TDS) 
     61 
    7662        self.action_number = 1 
    7763        # setup the inventory 
    7864        # make slot 'A1' and 'A3' container daggers 
    7965        inv_data = {'A1':'dagger01', 'A3':'dagger01'} 
    80         self.inventory = inventory.Inventory(self.engine, inv_data, self.refreshReadyImages) 
    81         self.inventory.events_to_map['close_button'] = self.closeInventoryAndToggle 
    82         self.inventory.inventory.mapEvents(self.inventory.events_to_map) 
    83         self.refreshReadyImages() 
    84          
    85         self.context_menu = ContextMenu (self.engine, [], (0,0)) 
    86         self.context_menu.hide() 
     66        self.inventory = inventory.Inventory(self.engine, inv_data, self.hud.refreshReadyImages, self.hud.toggleInventoryButton) 
     67        self.hud.refreshReadyImages() 
     68         
    8769        self.boxOpen = False 
    8870        self.boxCreated = False 
     
    9678                self.sounds.playMusic("/music/preciouswasteland.ogg") 
    9779                 
     80    def saveFunction(self, *args, **kwargs): 
     81        """Callback for save game 
     82           @return: None""" 
     83        self.data.save(*args, **kwargs) 
     84 
     85    def loadFunction(self, *args, **kwargs): 
     86        """Callback for load game 
     87           @return: None""" 
     88        self.data.load(*args, **kwargs) 
     89 
    9890    def loadMap(self, mapname, filename): 
    9991        """Loads a map an stores it under the given name in the maps list. 
     
    118110        obj.say(str(text), 1000) 
    119111 
    120     def refreshReadyImages(self): 
    121         """Make the Ready slot images on the HUD be the same as those  
    122            on the inventory 
    123            @return: None""" 
    124         self.setImages(self.hud.hud.findChild(name="hudReady1"), 
    125                        self.inventory.inventory.findChild(name="Ready1").up_image) 
    126         self.setImages(self.hud.hud.findChild(name="hudReady2"), 
    127                        self.inventory.inventory.findChild(name="Ready2").up_image) 
    128         self.setImages(self.hud.hud.findChild(name="hudReady3"), 
    129                        self.inventory.inventory.findChild(name="Ready3").up_image) 
    130         self.setImages(self.hud.hud.findChild(name="hudReady4"), 
    131                        self.inventory.inventory.findChild(name="Ready4").up_image) 
    132  
    133     def setImages(self, widget, image): 
    134         """Set the up, down, and hover images of an Imagebutton. 
    135            @type widget: pychan.widget 
    136            @param widget: widget to set 
    137            @type image: string 
    138            @param image: image to use 
    139            @return: None""" 
    140         widget.up_image = image 
    141         widget.down_image = image 
    142         widget.hover_image = image 
    143  
    144     def closeInventoryAndToggle(self): 
    145         """Close the inventory screen. 
    146            @return: None""" 
    147         self.inventory.closeInventory() 
    148         self.hud.toggleInventory() 
    149         self.inventoryShown = False 
    150  
    151     def displayInventory(self, callFromHud): 
    152         """Pause the game and enter the inventory screen, or close the 
    153            inventory screen and resume the game. callFromHud should be true 
    154            (must be True?) if you call this function from the HUD script 
    155            @type callFromHud: boolean 
    156            @param callFromHud: Whether this function is being called  
    157                                from the HUD script 
    158            @return: None""" 
    159         if (self.inventoryShown == False): 
    160             self.inventory.showInventory() 
    161             self.inventoryShown = True 
    162         else: 
    163             self.inventory.closeInventory() 
    164             self.inventoryShown = False 
    165         if (callFromHud == False): 
    166             self.hud.toggleInventory() 
    167  
    168112    # all key / mouse event handling routines go here 
    169113    def keyPressed(self, evt): 
     
    177121        if(keyval == key.Q): 
    178122            # we need to quit the game 
    179             self.quitGame() 
     123            self.hud.quitGame() 
    180124        if(keyval == key.T): 
    181             self.toggle_renderer('GridRenderer') 
     125            self.activeMap.toggle_renderer('GridRenderer') 
    182126        if(keyval == key.F1): 
    183127            # display the help screen and pause the game 
    184             self.displayHelp() 
     128            self.hud.displayHelp() 
    185129        if(keyval == key.F5): 
    186130            # logic would say we use similar code to above and toggle 
     
    198142        if(keyval == key.I): 
    199143            # I opens and closes the inventory 
    200             self.displayInventory(callFromHud=False) 
     144            self.hud.displayInventory(callFromHud=False) 
    201145        if(keyval == key.A): 
    202146            # A adds a test action to the action box 
     
    217161           @param evt: The event that fife caught 
    218162           @return: None""" 
    219         self.context_menu.hide() # hide the context menu in case it is displayed 
     163        self.hud.context_menu.hide() # hide the context menu in case it is displayed 
    220164        scr_point = fife.ScreenPoint(evt.getX(), evt.getY()) 
    221165        if(evt.getButton() == fife.MouseEvent.LEFT): 
     
    235179            data = info or [["Walk", "Walk here", self.onWalk, self.getCoords(scr_point)]] 
    236180            # show the menu 
    237             self.context_menu = ContextMenu(self.engine, data, (scr_point.x,scr_point.y)) 
     181            self.hud.showContextMenu(data, (scr_point.x, scr_point.y)) 
    238182 
    239183    def onWalk(self, click): 
    240184        """Callback sample for the context menu. 
    241185        """ 
    242         self.context_menu.hide() 
     186        self.hud.context_menu.hide() 
    243187        self.data.gameState.PC.run(click) 
    244188 
     
    276220        location.setMapCoordinates(coord) 
    277221        return location 
    278  
    279     def clearMenu(self): 
    280         """ Hides the context menu. Just nice to have it as a function. 
    281             @return: None""" 
    282         if hasattr(self, "context_menu"): 
    283             self.context_menu.vbox.hide() 
    284             delattr(self, "context_menu") 
    285  
    286     def newGame(self): 
    287         """Called when user request to start a new game. 
    288            @return: None""" 
    289         print 'new game' 
    290  
    291     def quitGame(self): 
    292         """Called when user requests to quit game. 
    293            @return: None""" 
    294         if(self.quitFunction != None): 
    295             window = pychan.widgets.Window(title=unicode("Quit?")) 
    296  
    297             hbox = pychan.widgets.HBox() 
    298             are_you_sure = "Are you sure you want to quit?" 
    299             label = pychan.widgets.Label(text=unicode(are_you_sure)) 
    300             yes_button = pychan.widgets.Button(name="yes_button",  
    301                                                text=unicode("Yes")) 
    302             no_button = pychan.widgets.Button(name="no_button", 
    303                                               text=unicode("No")) 
    304  
    305             window.addChild(label) 
    306             hbox.addChild(yes_button) 
    307             hbox.addChild(no_button) 
    308             window.addChild(hbox) 
    309  
    310             events_to_map = {"yes_button":self.quitFunction, 
    311                              "no_button":window.hide} 
    312              
    313             window.mapEvents(events_to_map) 
    314             window.show() 
    315  
    316     def saveGame(self): 
    317         """ Called when the user wants to save the game. 
    318             @return: None""" 
    319         self.save_browser = PARPGFileBrowser(self.engine, 
    320                                         self.data.save, 
    321                                         savefile=True, 
    322                                         guixmlpath="gui/savebrowser.xml", 
    323                                         extensions = ('.dat')) 
    324         self.save_browser.showBrowser() 
    325              
    326  
    327     def loadGame(self): 
    328         """ Called when the user wants to load a game. 
    329             @return: None""" 
    330         self.load_browser = PARPGFileBrowser(self.engine, 
    331                                         self.data.load, 
    332                                         savefile=False, 
    333                                         guixmlpath='gui/loadbrowser.xml', 
    334                                         extensions=('.dat')) 
    335         self.load_browser.showBrowser() 
    336  
    337222 
    338223    def createBoxGUI(self, title): 
Note: See TracChangeset for help on using the changeset viewer.