Changeset 632


Ignore:
Timestamp:
08/07/10 20:01:34 (9 years ago)
Author:
beliar
Message:

Ticket #139: Patch by Beliar.

  • Initiating a dialogue will now pause the game and no other interaction with the world is possible.
  • Opening the pause menu will now pause the game
  • Opening the save or load window will now pause the game

fixes[s:trac, t:139]

Location:
trunk/game/scripts
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/scripts/common/listeners/event_listener.py

    r631 r632  
    5656        """Removes a listener""" 
    5757        if listener_type in self.listeners.iterkeys(): 
    58             self.listeners[listener_type].remove() 
     58            self.listeners[listener_type].remove(listener) 
    5959        else: 
    6060            print "Listener type \" " + listener_type + "\" not supported" 
  • trunk/game/scripts/controllerbase.py

    r631 r632  
    4444        self.view = view 
    4545        self.model = model 
    46          
    4746        self.application = application 
    4847         
  • trunk/game/scripts/gamemap.py

    r627 r632  
    2626class GameMap(fife.MapChangeListener): 
    2727    """Map class used to flag changes in the map""" 
    28     def __init__(self, engine, data): 
     28    def __init__(self, engine, model): 
    2929        # init mapchange listener 
    3030        fife.MapChangeListener.__init__(self) 
    3131        self.map = None 
    3232        self.engine = engine 
    33         self.model = data 
     33        self.model = model 
    3434 
    3535        # init map attributes 
     
    141141        # Update gamestate.player_character 
    142142        self.model.game_state.player_character.behaviour.onNewMap(self.agent_layer) 
    143         self.cameras[self.my_cam_id].attach(self.model.game_state. 
    144                                             player_character.behaviour.agent) 
     143        self.centerCameraOnPlayer() 
    145144 
    146145    def toggleRenderer(self, r_name): 
     
    150149        renderer.setEnabled(not renderer.isEnabled()) 
    151150 
     151    def isPaused(self): 
     152        """Returns wheter the map is currentply paused or not""" 
     153        # Time multiplier is a float, never do equals on floats 
     154        return not self.map.getTimeMultiplier() >= 1.0 
     155     
     156    def pause(self, paused): 
     157        """ Pause/Unpause the game. 
     158        @return: nothing""" 
     159        if paused: 
     160            self.map.setTimeMultiplier(0.0) 
     161        if not paused and self.isPaused(): 
     162            self.map.setTimeMultiplier(1.0) 
     163         
    152164    def togglePause(self): 
    153         """ Pause/Unpause the game. 
    154             @return: nothing""" 
    155         # Time multiplier is a float, never do equals on floats 
    156         if self.map.getTimeMultiplier() >= 1.0: 
    157             self.map.setTimeMultiplier(0.0) 
    158         else: 
    159             self.map.setTimeMultiplier(1.0) 
     165        """ Toggle paused state. 
     166        @return: nothing""" 
     167        self.pause(not self.isPaused()) 
     168 
     169    def centerCameraOnPlayer(self): 
     170        """Center the camera on the player""" 
     171        camera = self.cameras[self.my_cam_id] 
     172        player_agent = self.model.game_state.player_character.behaviour.agent 
     173        camera.setLocation(player_agent.getLocation()) 
  • trunk/game/scripts/gamemodel.py

    r615 r632  
    332332        return location 
    333333 
     334    def pause(self, paused): 
     335        """ Pause/Unpause the game 
     336        @return: nothing""" 
     337 
     338        self.active_map.pause(paused) 
     339     
    334340    def togglePause(self): 
    335         """ Pause/Unpause the game. 
    336             @return: nothing""" 
     341        """ Toggle paused state. 
     342        @return: nothing""" 
    337343        self.active_map.togglePause() 
     344         
     345    def isPaused(self): 
     346        """Returns wheter the game is paused or not""" 
     347        return self.active_map.isPaused() 
    338348     
    339349    def readMapFiles(self): 
  • trunk/game/scripts/gamescenecontroller.py

    r631 r632  
    7171        #this is temporary untill we can set the native cursor 
    7272        self.resetMouseCursor() 
    73          
     73        self.paused = False 
    7474 
    7575        if model.settings.get("FIFE",  "PlaySounds"): 
     
    140140            # Pause pause/unpause the game  
    141141            self.model.togglePause() 
     142            self.pause(False) 
    142143        if(key_val == key.SPACE): 
    143             #This centers the camera on the player 
    144             camera = self.model.active_map.cameras[self.model.active_map.my_cam_id] 
    145             player_agent = self.model.game_state.player_character.behaviour.agent 
    146             camera.setLocation(player_agent.getLocation()) 
    147  
     144            self.model.active_map.centerCameraOnPlayer()  
     145     
    148146    def setMouseCursor(self, image, dummy_image, mc_type="native"):  
    149147        """Set the mouse cursor to an image. 
     
    232230        @param mouseY: Y-Position of mouse 
    233231        @type mouseY: int""" 
     232        if self.paused: 
     233            return 
    234234         
    235235        self.last_mousecoords = fife.ScreenPoint(mouseX, mouseY)         
     
    383383        """Saves the game state, delegates call to engine.Engine 
    384384           @return: None""" 
     385        self.model.pause(False) 
    385386        self.model.save(*args, **kwargs) 
    386387 
     
    389390           @return: None""" 
    390391        # Remove all currently loaded maps so we can start fresh 
     392        self.model.pause(False) 
    391393        self.model.deleteMaps() 
    392394        self.view.hud.inventory = None 
     
    399401           @return: None""" 
    400402        self.application.listener.quitGame() 
    401  
     403     
     404    def pause(self, paused): 
     405        super(GameSceneController, self).pause(paused) 
     406        self.paused = paused 
     407        if paused: 
     408            self.scroll_timer.stop() 
     409            self.resetMouseCursor() 
     410         
    402411    def pump(self): 
    403412        """Routine called during each frame. Our main loop is in ./run.py""" 
    404413        # uncomment to instrument 
    405414        # t0 = time.time() 
    406          
     415        if self.paused:  
     416            return 
    407417        if self.model.active_map: 
    408418            self.view.highlightFrontObject(self.last_mousecoords) 
    409419            self.view.refreshTopLayerTransparencies() 
    410              
    411420            if self.scroll_direction != [0,0]: 
    412421                self.scroll_timer.start() 
  • trunk/game/scripts/gui/dialoguegui.py

    r609 r632  
    2727        self.controller = controller  
    2828        self.player_character = player_character 
     29        self.active = False 
    2930 
    3031        # define dialogue engine callbacks 
     
    202203    def initiateDialogue(self): 
    203204        """Callback for starting a quest""" 
     205        self.active = True 
    204206        stats_label = self.dialogue_gui.findChild(name='stats_label') 
    205207        stats_label.text = u'Name: John Doe\nAn unnamed one' 
     
    242244        self.npc.behaviour.state = 1 
    243245        self.npc.behaviour.idle() 
     246        self.active = False 
    244247 
    245248    def handleNpcName(self, name): 
  • trunk/game/scripts/gui/hud.py

    r630 r632  
    4343               quitGame: called when the user clicks on Quit 
    4444           @return: None""" 
     45        self.enabled = False 
    4546        pychan.init(controller.engine, debug = True) 
    4647 
     
    114115        actions_scroll_area.max_size = (actions_width, 55) 
    115116        # now it should be OK to display it all 
    116         self.hud.show() 
     117        self.showHUD() 
    117118         
    118119    def mouseMoved(self, event): 
     
    145146           @return: None""" 
    146147        self.hud.show() 
     148        self.enabled = True 
    147149 
    148150    def hideHUD(self): 
     
    150152           @return: None""" 
    151153        self.hud.hide() 
     154        self.enabled = False 
    152155 
    153156    def initializeInventory(self): 
     
    198201        """Displays the main in-game menu. 
    199202           @return: None""" 
     203        if not self.enabled: 
     204            return 
    200205        self.stopActions() 
    201206        if (self.menu_displayed == False): 
    202207            self.main_menu.show() 
    203208            self.menu_displayed = True 
     209            self.model.pause(True) 
    204210        elif (self.menu_displayed == True): 
    205211            self.hideMenu() 
     
    210216        self.main_menu.hide() 
    211217        self.menu_displayed = False 
     218        self.model.pause(False) 
    212219 
    213220 
     
    250257        """ Called when the user wants to save the game. 
    251258            @return: None""" 
     259        if not self.enabled: 
     260            return 
    252261        self.stopActions() 
    253262        save_browser = FileBrowser(self.engine, 
     
    257266                                   extensions = ('.dat')) 
    258267        save_browser.showBrowser() 
     268        self.model.pause(True) 
    259269 
    260270    def stopActions(self): 
     
    265275            data_drag.source_container.placeItem(data_drag.dragged_item) 
    266276            data_drag.dragging = False 
    267             data_drag.dragged_item = None             
     277            data_drag.dragged_item = None 
     278        if self.inventory: 
     279            self.inventory.closeInventory() 
    268280         
    269281    def newGame(self): 
    270282        """Called when user request to start a new game. 
    271283           @return: None""" 
     284        if not self.enabled: 
     285            return 
    272286        self.stopActions() 
    273287        print 'new game' 
     
    276290        """ Called when the user wants to load a game. 
    277291            @return: None""" 
     292        if not self.enabled: 
     293            return 
    278294        self.stopActions() 
    279295        load_browser = FileBrowser(self.engine, 
     
    283299                                   extensions=('.dat')) 
    284300        load_browser.showBrowser() 
     301        self.model.pause(True)         
    285302     
    286303    def initializeQuitDialog(self): 
     
    316333        """Called when user requests to quit game. 
    317334           @return: None""" 
     335        if not self.enabled: 
     336            return 
    318337        self.stopActions() 
    319338        self.quit_window.show() 
     
    331350        """Displays the inventory screen 
    332351           @return: None""" 
     352        if not self.enabled: 
     353            return 
    333354        if self.inventory == None: 
    334355            self.initializeInventory() 
     
    403424    def readyAction(self, ready_button): 
    404425        """ Called when the user selects a ready button from the HUD """ 
     426        if not self.enabled: 
     427            return 
    405428        text = "Used the item from %s" % ready_button         
    406429        self.addAction(text) 
     
    452475           @type npc: actors.NonPlayerCharacter 
    453476           @param npc: the npc that we are having a dialogue with 
    454            @return: None""" 
     477           @return: The dialogue""" 
    455478        self.stopActions() 
    456479        dialogue = DialogueGUI( 
     
    459482                    self.model.game_state.quest_engine, 
    460483                    self.model.game_state.player_character) 
    461         dialogue.initiateDialogue() 
     484        return dialogue 
  • trunk/game/scripts/objects/action.py

    r618 r632  
    283283        """Talk with the NPC when close enough, otherwise move closer. 
    284284           @return: None""" 
    285        
     285        from scripts.dialoguecontroller import DialogueController 
     286         
    286287        player_char = self.model.game_state.player_character 
    287288        npc_coordinates = self.npc.getLocation().getLayerCoordinates() 
     
    306307     
    307308            if self.npc.dialogue is not None: 
    308                 self.npc.talk(player_char) 
    309                 self.view.hud.showDialogue(self.npc) 
     309                dialogue_controller = DialogueController(self.controller.engine, 
     310                                                         self.view, 
     311                                                         self.model, 
     312                                                         self.controller.application) 
     313                self.controller.application.pushController(dialogue_controller) 
     314                dialogue_controller.startTalk(self.npc) 
    310315            else: 
    311316                self.npc.behaviour.agent.say("Leave me alone!", 1000) 
  • trunk/game/scripts/objects/composed.py

    r615 r632  
    6363        if state.has_key("on_map"): 
    6464            del state["on_map"] 
    65         del state["agent"] 
     65        if state.has_key("agent"): 
     66            del state["agent"] 
    6667 
    6768    def getStateForSaving(self): 
  • trunk/game/scripts/parpg.py

    r631 r632  
    128128        self.view = gamesceneview.GameSceneView(self.engine, self.model) 
    129129        self.event_listener = EventListener(self.engine) 
    130         self.controller = gamescenecontroller.GameSceneController(self.engine,  
     130        self.controllers = [] 
     131        controller = gamescenecontroller.GameSceneController(self.engine,  
    131132                                                        self.view,  
    132133                                                        self.model, 
    133134                                                        self) 
    134         self.controller.initHud() 
     135        controller.initHud() 
     136        self.controllers.append(controller) 
    135137        self.listener = ApplicationListener(self.event_listener, 
    136138                                            self.engine,  
     
    146148        # but if we don't put one here, Fife gets all fussy :-) 
    147149        pass 
    148  
     150     
     151    def pushController(self, controller): 
     152        """Adds a controller to the list to be the current active one""" 
     153        self.controllers[-1].pause(True) 
     154        self.controllers.append(controller) 
     155     
     156    def popController(self): 
     157        """Removes and returns the current active controller, unless its the last one""" 
     158        ret_controller = None 
     159        if self.controllers.count > 1: 
     160            ret_controller = self.controllers.pop() 
     161            self.controllers[-1].pause(False) 
     162        return ret_controller 
     163     
     164    def switchController(self, controller): 
     165        """Clears the controller list and adds a controller to be the current active one""" 
     166        self.controllers = [] 
     167        self.controllers.append(controller) 
     168     
    149169    def _pump(self): 
    150170        """Main game loop. 
     
    154174            self.breakRequested = True #pylint: disable-msg=C0103 
    155175        else: 
    156             self.controller.pump() 
     176            for controller in self.controllers: 
     177                controller.pump() 
Note: See TracChangeset for help on using the changeset viewer.