Changeset 631


Ignore:
Timestamp:
08/07/10 15:19:55 (9 years ago)
Author:
beliar
Message:

Patch by Beliar.

Location:
trunk/game/scripts
Files:
8 added
1 deleted
3 edited

Legend:

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

    r584 r631  
    1515#   You should have received a copy of the GNU General Public License 
    1616#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>. 
    17 from scripts.common.eventlistenerbase import EventListenerBase 
     17from scripts.common.listeners.key_listener import KeyListener 
     18from scripts.common.listeners.mouse_listener import MouseListener 
    1819 
    19 class ControllerBase(EventListenerBase): 
     20class ControllerBase(KeyListener, MouseListener): 
    2021    """Base of Controllers""" 
    2122    def __init__(self,  
     
    2324                 view,  
    2425                 model,  
    25                  application,  
    26                  reg_mouse = True,  
    27                  reg_keys = True): 
     26                 application): 
    2827        ''' 
    2928        Constructor 
     
    3938        @type settings: fife.extensions.fife_settings.Setting 
    4039        ''' 
    41         super(ControllerBase, self).__init__(engine,  
    42                                              reg_mouse=reg_mouse,  
    43                                              reg_keys=reg_keys) 
     40        KeyListener.__init__(self, application.event_listener)         
     41        MouseListener.__init__(self, application.event_listener)         
    4442        self.engine = engine 
    4543        self.event_manager = engine.getEventManager() 
     
    4846         
    4947        self.application = application 
     48         
     49    def pause(self, paused): 
     50        """Stops receiving events""" 
     51        if paused: 
     52            KeyListener.detach(self) 
     53            MouseListener.detach(self) 
     54        else: 
     55            KeyListener.attach(self, self.application.event_listener) 
     56            MouseListener.attach(self, self.application.event_listener) 
     57 
  • trunk/game/scripts/gamescenecontroller.py

    r629 r631  
    5656                                                  view, 
    5757                                                  model, 
    58                                                   application, 
    59                                                   reg_mouse=True,  
    60                                                   reg_keys=True) 
     58                                                  application) 
    6159        # Last saved mouse coords         
    6260        self.last_mousecoords = None 
  • trunk/game/scripts/parpg.py

    r627 r631  
    1313#   You should have received a copy of the GNU General Public License 
    1414#   along with this program.  If not, see <http://www.gnu.org/licenses/>. 
     15"""This module contains the main Application class  
     16and the basic Listener for PARPG """ 
     17 
    1518 
    1619from fife import fife 
     
    2225from scripts import console 
    2326from scripts import gamescenecontroller 
    24 from scripts.common import eventlistenerbase 
     27from scripts.common.listeners.event_listener import EventListener 
     28from scripts.common.listeners.key_listener import KeyListener 
     29from scripts.common.listeners.mouse_listener import MouseListener 
     30from scripts.common.listeners.command_listener import CommandListener 
     31from scripts.common.listeners.console_executor import ConsoleExecuter 
     32from scripts.common.listeners.widget_listener import WidgetListener 
    2533 
    2634class KeyFilter(fife.IKeyFilter): 
     
    3543 
    3644    def isFiltered(self, event): 
     45        """Checks if an key is filtered""" 
    3746        return event.getKey().getValue() in self._keys 
    3847 
    39 class ApplicationListener(eventlistenerbase.EventListenerBase): 
    40     def __init__(self, engine, world, model): 
    41         """Initialise the instance. 
     48class 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. 
    4257           @type engine: fife.GameModel 
    4358           @param engine: ??? 
    44            @type gamesceneview: gamesceneview.GameSceneView 
    45            @param gamesceneview: ??? 
     59           @type view: viewbase.ViewBase 
     60           @param view: View that draws the current state 
    4661           @type model: script.GameModel 
    4762           @param model: The game model""" 
    48         super(ApplicationListener, self).__init__(engine, 
    49                                                   reg_keys=True,reg_cmd=True, 
    50                                                   reg_mouse=False,  
    51                                                   reg_console=True, 
    52                                                   reg_widget=True) 
     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)         
    5368        self.engine = engine 
    54         self.view = world 
     69        self.view = view 
    5570        self.model = model 
    5671        keyfilter = KeyFilter([fife.Key.ESCAPE]) 
     
    5974        engine.getEventManager().setKeyFilter(keyfilter) 
    6075        self.quit = False 
    61         self.aboutWindow = None 
    62         self.console=console.Console(self) 
     76        self.about_window = None 
     77        self.console = console.Console(self) 
    6378 
    6479    def quitGame(self): 
     
    91106       self.gamesceneview is our view,self.model is our model 
    92107       self.controller is the controller""" 
     108        
    93109    def __init__(self, setting): 
    94110        """Initialise the instance. 
     
    111127        self.model.getDialogues() 
    112128        self.view = gamesceneview.GameSceneView(self.engine, self.model) 
     129        self.event_listener = EventListener(self.engine) 
    113130        self.controller = gamescenecontroller.GameSceneController(self.engine,  
    114131                                                        self.view,  
    115                                                         self.model,  
     132                                                        self.model, 
    116133                                                        self) 
    117134        self.controller.initHud() 
    118         self.listener = ApplicationListener(self.engine,  
     135        self.listener = ApplicationListener(self.event_listener, 
     136                                            self.engine,  
    119137                                            self.view,  
    120138                                            self.model) 
    121139        start_map = self._setting.get("PARPG", "Map") 
    122         #self.model.loadMap(start_map) 
    123         #self.model.readAgentsOfMap(start_map) 
    124140        self.model.changeMap(start_map) 
    125         #self.model.placeAgents() 
    126         #self.model.placePC() 
    127141        pychan.init(self.engine, debug = True) 
    128142 
     
    138152           @return: None""" 
    139153        if self.listener.quit: 
    140             self.breakRequested = True 
     154            self.breakRequested = True #pylint: disable-msg=C0103 
    141155        else: 
    142156            self.controller.pump() 
Note: See TracChangeset for help on using the changeset viewer.