Source Code for Script scripts.parpg

  1  #!/usr/bin/env python 
  2   
  3  #   This program is free software: you can redistribute it and/or modify 
  4  #   it under the terms of the GNU General Public License as published by 
  5  #   the Free Software Foundation, either version 3 of the License, or 
  6  #   (at your option) any later version. 
  7   
  8  #   This program is distributed in the hope that it will be useful, 
  9  #   but WITHOUT ANY WARRANTY; without even the implied warranty of 
 10  #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 11  #   GNU General Public License for more details. 
 12   
 13  #   You should have received a copy of the GNU General Public License 
 14  #   along with this program.  If not, see <http://www.gnu.org/licenses/>. 
 15  """This module contains the main Application class  
 16  and the basic Listener for PARPG """ 
 17   
 18   
 19  from fife import fife 
 20  from fife.extensions import pychan 
 21  from fife.extensions.basicapplication import ApplicationBase 
 22   
 23  from scripts.gamemodel import GameModel 
 24  from scripts.mainmenuview import MainMenuView 
 25  from scripts import console 
 26  from scripts.mainmenucontroller import MainMenuController 
 27  from scripts.common.listeners.event_listener import EventListener 
 28  from scripts.common.listeners.key_listener import KeyListener 
 29  from scripts.common.listeners.mouse_listener import MouseListener 
 30  from scripts.common.listeners.command_listener import CommandListener 
 31  from scripts.common.listeners.console_executor import ConsoleExecuter 
 32  from scripts.common.listeners.widget_listener import WidgetListener 
 33   
 34 -class KeyFilter(fife.IKeyFilter): 
 35      """ 
 36      This is the implementation of the fife.IKeyFilter class. 
 37       
 38      Prevents any filtered keys from being consumed by guichan. 
 39      """ 
 40 -    def __init__(self, keys): 
 41          fife.IKeyFilter.__init__(self) 
 42          self._keys = keys 
 43   
 44 -    def isFiltered(self, event): 
 45          """Checks if an key is filtered""" 
 46          return event.getKey().getValue() in self._keys 
 47   
 48 -class ApplicationListener(KeyListener, 
 49                          MouseListener, 
 50                          ConsoleExecuter, 
 51                          CommandListener, 
 52                          WidgetListener):     
 53      """Basic listener for PARPG""" 
 54           
 55 -    def __init__(self, event_listener, engine, view, model): 
 56          """Initialize the instance. 
 57             @type engine: fife.engine 
 58             @param engine: ??? 
 59             @type view: viewbase.ViewBase 
 60             @param view: View that draws the current state 
 61             @type model: GameModel 
 62             @param model: The game model""" 
 63          KeyListener.__init__(self, event_listener) 
 64          MouseListener.__init__(self, event_listener) 
 65          ConsoleExecuter.__init__(self, event_listener) 
 66          CommandListener.__init__(self, event_listener) 
 67          WidgetListener.__init__(self, event_listener)         
 68          self.engine = engine 
 69          self.view = view 
 70          self.model = model 
 71          keyfilter = KeyFilter([fife.Key.ESCAPE]) 
 72          keyfilter.__disown__()         
 73           
 74          engine.getEventManager().setKeyFilter(keyfilter) 
 75          self.quit = False 
 76          self.about_window = None 
 77          self.console = console.Console(self) 
 78   
 79 -    def quitGame(self): 
 80          """Forces a quit game on next cycle. 
 81             @return: None""" 
 82          self.quit = True 
 83   
 84 -    def onConsoleCommand(self, command): 
 85          """ 
 86          Called on every console comand, delegates calls  to the a console 
 87          object, implementing the callbacks 
 88          @type command: string 
 89          @param command: the command to run 
 90          @return: result 
 91          """ 
 92          return self.console.handleConsoleCommand(command) 
 93   
 94 -    def onCommand(self, command): 
 95          """Enables the game to be closed via the 'X' button on the window frame 
 96             @type command: fife.Command 
 97             @param command: The command to read. 
 98             @return: None""" 
 99          if(command.getCommandType() == fife.CMD_QUIT_GAME): 
100              self.quit = True 
101              command.consume() 
102   
103 -class PARPGApplication(ApplicationBase): 
104      """Main Application class 
105         We use an MVC model model 
106         self.gamesceneview is our view,self.model is our model 
107         self.controller is the controller""" 
108          
109 -    def __init__(self, setting): 
110          """Initialise the instance. 
111             @return: None""" 
112          super(PARPGApplication, self).__init__(setting) 
113          pychan.init(self.engine, debug = True) 
114          #self.engine.getModel(self) 
115          self.model = GameModel(self.engine, setting) 
116          self.model.maps_file = self._setting.get("PARPG", "MapsFile") 
117          self.model.readMapFiles() 
118          self.model.object_db_file = self._setting.get("PARPG",  
119                                                        "ObjectDatabaseFile")  
120          self.model.readObjectDB() 
121          self.model.agents_directory = self._setting.get("PARPG", 
122                                                          "AgentsDirectory")  
123          self.model.getAgentImportFiles() 
124          self.model.all_agents_file = self._setting.get("PARPG", "AllAgentsFile") 
125          self.model.readAllAgents() 
126          self.model.dialogues_directory = self._setting.get("PARPG",  
127                                                             "DialoguesDirectory") 
128          self.model.getDialogues() 
129          self.view = MainMenuView(self.engine, self.model) 
130          self.event_listener = EventListener(self.engine) 
131          self.controllers = [] 
132          controller = MainMenuController(self.engine,  
133                                                          self.view,  
134                                                          self.model, 
135                                                          self) 
136          #controller.initHud() 
137          self.controllers.append(controller) 
138          self.listener = ApplicationListener(self.event_listener, 
139                                              self.engine,  
140                                              self.view,  
141                                              self.model) 
142          #start_map = self._setting.get("PARPG", "Map") 
143          #self.model.changeMap(start_map) 
144   
145 -    def createListener(self): 
146          """@return: None""" 
147          # already created in constructor 
148          # but if we don't put one here, Fife gets all fussy :-) 
149          pass 
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          ret_controller.onStop() 
163          return ret_controller 
164       
165 -    def switchController(self, controller): 
166          """Clears the controller list and adds a controller to be the current active one""" 
167          for old_controller in self.controllers: 
168              old_controller.onStop() 
169          self.controllers = [] 
170          self.controllers.append(controller) 
171       
172 -    def _pump(self): 
173          """Main game loop. 
174             There are in fact 2 main loops, this one and the one in GameSceneView. 
175             @return: None""" 
176          if self.listener.quit: 
177              self.breakRequested = True #pylint: disable-msg=C0103 
178          else: 
179              for controller in self.controllers: 
180                  controller.pump() 
181