source: branches/active/character_customization/game/parpg/application.py @ 748

#!/usr/bin/env python

#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License, or
#   (at your option) any later version.

#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.

#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""This module contains the main Application class 
and the basic Listener for PARPG """

import os

from fife import fife
from fife.extensions import pychan
from fife.extensions.serializers.xmlanimation import XMLAnimationLoader
from fife.extensions.basicapplication import ApplicationBase

from parpg.gamemodel import GameModel
from parpg.mainmenuview import MainMenuView
from parpg import console
from parpg.mainmenucontroller import MainMenuController
from parpg.common.listeners.event_listener import EventListener
from parpg.common.listeners.key_listener import KeyListener
from parpg.common.listeners.mouse_listener import MouseListener
from parpg.common.listeners.command_listener import CommandListener
from parpg.common.listeners.console_executor import ConsoleExecuter
from parpg.common.listeners.widget_listener import WidgetListener

class KeyFilter(fife.IKeyFilter):
    """
    This is the implementation of the fife.IKeyFilter class.
    
    Prevents any filtered keys from being consumed by guichan.
    """
    def __init__(self, keys):
        fife.IKeyFilter.__init__(self)
        self._keys = keys

    def isFiltered(self, event):
        """Checks if an key is filtered"""
        return event.getKey().getValue() in self._keys

class ApplicationListener(KeyListener,
                        MouseListener,
                        ConsoleExecuter,
                        CommandListener,
                        WidgetListener):    
    """Basic listener for PARPG"""
        
    def __init__(self, event_listener, engine, view, model):
        """Initialize the instance.
           @type engine: fife.engine
           @param engine: ???
           @type view: viewbase.ViewBase
           @param view: View that draws the current state
           @type model: GameModel
           @param model: The game model"""
        KeyListener.__init__(self, event_listener)
        MouseListener.__init__(self, event_listener)
        ConsoleExecuter.__init__(self, event_listener)
        CommandListener.__init__(self, event_listener)
        WidgetListener.__init__(self, event_listener)        
        self.engine = engine
        self.view = view
        self.model = model
        keyfilter = KeyFilter([fife.Key.ESCAPE])
        keyfilter.__disown__()        
        
        engine.getEventManager().setKeyFilter(keyfilter)
        self.quit = False
        self.about_window = None
        self.console = console.Console(self)

    def quitGame(self):
        """Forces a quit game on next cycle.
           @return: None"""
        self.quit = True

    def onConsoleCommand(self, command):
        """
        Called on every console comand, delegates calls  to the a console
        object, implementing the callbacks
        @type command: string
        @param command: the command to run
        @return: result
        """
        return self.console.handleConsoleCommand(command)

    def onCommand(self, command):
        """Enables the game to be closed via the 'X' button on the window frame
           @type command: fife.Command
           @param command: The command to read.
           @return: None"""
        if(command.getCommandType() == fife.CMD_QUIT_GAME):
            self.quit = True
            command.consume()

class PARPGApplication(ApplicationBase):
    """Main Application class
       We use an MVC model model
       self.gamesceneview is our view,self.model is our model
       self.controller is the controller"""
       
    def __init__(self, setting):
        """Initialise the instance.
           @return: None"""
        self._setting = setting 
        self.engine = fife.Engine()
        self.loadSettings()
        self.engine.init()
        self._animationloader = XMLAnimationLoader(self.engine.getImagePool(),
                                                   self.engine.getVFS())
        self.engine.getAnimationPool().addResourceLoader(self._animationloader)

        pychan.init(self.engine, debug = True)
        #self.engine.getModel(self)
        self.model = GameModel(self.engine, setting)
        self.model.maps_file = self._setting.get("PARPG", "MapsFile")
        self.model.readMapFiles()
        self.model.object_db_file = self._setting.get("PARPG", 
                                                      "ObjectDatabaseFile") 
        self.model.readObjectDB()
        self.model.agents_directory = self._setting.get("PARPG",
                                                        "AgentsDirectory") 
        self.model.getAgentImportFiles()
        self.model.all_agents_file = self._setting.get("PARPG", "AllAgentsFile")
        self.model.readAllAgents()
        self.model.dialogues_directory = self._setting.get("PARPG", 
                                                           "DialoguesDirectory")
        self.model.getDialogues()
        self.view = MainMenuView(self.engine, self.model)
        self.fonts_directory = self._setting.get("FIFE", "FontsDirectory")
        self.loadFonts(self.fonts_directory)
        self.event_listener = EventListener(self.engine)
        self.controllers = []
        controller = MainMenuController(self.engine, 
                                                        self.view, 
                                                        self.model,
                                                        self)
        #controller.initHud()
        self.controllers.append(controller)
        self.listener = ApplicationListener(self.event_listener,
                                            self.engine, 
                                            self.view, 
                                            self.model)
        #start_map = self._setting.get("PARPG", "Map")
        #self.model.changeMap(start_map)

    def loadFonts(self, fonts_directory):
        file_names = os.listdir(fonts_directory)
        for file_name in file_names:
            base_name, extension = os.path.splitext(file_name)
            if extension == '.fontdef':
                pychan.loadFonts(file_name)

    def loadSettings(self):
        """
        Load the settings from a python file and load them into the engine.
        Called in the ApplicationBase constructor.
        """

        engineSetting = self.engine.getSettings()
        engineSetting.setDefaultFontGlyphs(self._setting.fife.FontGlyphs)
        engineSetting.setDefaultFontPath(self._setting.fife.Font)
        engineSetting.setDefaultFontSize(self._setting.fife.DefaultFontSize)
        engineSetting.setBitsPerPixel(self._setting.fife.BitsPerPixel)
        engineSetting.setInitialVolume(self._setting.fife.InitialVolume)
        engineSetting.setSDLRemoveFakeAlpha(self._setting.fife.SDLRemoveFakeAlpha)
        engineSetting.setScreenWidth(self._setting.fife.ScreenWidth)
        engineSetting.setScreenHeight(self._setting.fife.ScreenHeight)
        engineSetting.setRenderBackend(self._setting.fife.RenderBackend)
        engineSetting.setFullScreen(self._setting.fife.FullScreen)
        engineSetting.setVideoDriver(self._setting.fife.VideoDriver)
        engineSetting.setLightingModel(self._setting.fife.Lighting)
        engineSetting.setColorKeyEnabled(self._setting.fife.ColorKeyEnabled)

        key = [int(digit) for digit in self._setting.fife.ColorKey]
        engineSetting.setColorKey(*key)

        engineSetting.setWindowTitle(self._setting.fife.WindowTitle)
        engineSetting.setWindowIcon(self._setting.fife.WindowIcon)

        try:
            engineSetting.setImageChunkSize(self._setting.fife.ImageChunkSize)
        except:
            pass

    def createListener(self):
        """ __init__ takes care of the event listener, basicapplication's 
           createListener is only harmful. Without overriding it, the program
           quit's on esc press, rather than invoking the main menu.
        """
        pass

    def pushController(self, controller):
        """Adds a controller to the list to be the current active one."""
        self.controllers[-1].pause(True)
        self.controllers.append(controller)
    
    def popController(self):
        """Removes and returns the current active controller, unless its the last one"""
        ret_controller = None
        if self.controllers.count > 1:
            ret_controller = self.controllers.pop()
            self.controllers[-1].pause(False)
        ret_controller.onStop()
        return ret_controller
    
    def switchController(self, controller):
        """Clears the controller list and adds a controller to be the current active one"""
        for old_controller in self.controllers:
            old_controller.onStop()
        self.controllers = []
        self.controllers.append(controller)
    
    def _pump(self):
        """Main game loop.
           There are in fact 2 main loops, this one and the one in GameSceneView.
           @return: None"""
        if self.listener.quit:
            self.breakRequested = True #pylint: disable-msg=C0103
        else:
            for controller in self.controllers:
                controller.pump()