C:/Users/Marc/Desktop/Phystank/trunk/src/engine/Engine.h

//This file is part of PhysTank.
//
//PhysTank 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.
//
//PhysTank 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 PhysTank.  If not, see <http://www.gnu.org/licenses/>.
//
// © Marc Johnson, 2009

#ifndef _ENGINE_
#define _ENGINE_

#include <map>
#include <stack>

#include "input/InputListener.h"

#include "resource/ResourceCache.h"

#include "ui/ModalDialog.h"

#define IMAGE_RESOURCE_FILE "images.zip"
#define SOUND_RESOURCE_FILE "sounds.zip"
#define MUSIC_RESOURCE_FILE "music.zip"
#define MODEL_RESOURCE_FILE "models.zip"
#define MAP_RESOURCE_FILE "maps.zip"
#define MISC_RESOURCE_FILE "misc.zip"

class AbstractAudioSystem;
class AbstractPlatform;
class AbstractRenderer;
class BaseScreen;
class Game;
class ModalDialog;

class Engine
{
private:
        typedef std::map<std::string, BaseScreen*> BaseScreenMap;
        typedef std::list<AbstractMouseListener*> MouseListenerList;
        typedef std::list<AbstractKeyListener*> KeyListenerList;
        typedef MouseListenerList::const_iterator MouseListenerListIterator;
        typedef KeyListenerList::const_iterator KeyListenerListIterator;
        typedef std::list<MouseListenerListIterator> MouseListenerIteratorList;
        typedef std::list<KeyListenerListIterator> KeyListenerIteratorList;

        AbstractPlatform* m_pPlatform; 
        AbstractRenderer* m_pRenderer; 
        AbstractAudioSystem* m_pAudio; 
        
        BaseScreen* m_pActiveScreen; 

        BaseScreenMap m_screens; 

        MouseListenerList m_mouseListeners; 
        KeyListenerList m_keyListeners;

        MouseListenerIteratorList m_mouseListenerBin; 
        KeyListenerIteratorList m_keyListenerBin; 

        ResourceCache* m_pResourceCache; 
        Game* m_pGame; 

        ModalDialogPtr m_pDialog; 
        std::stack<ModalDialogPtr> m_dialogStack; 

        unsigned long m_nNextUpdateTime; 

        int m_nDelta; 
        int m_nUpdateRate; 
        int m_nFrameRate; 
        int m_nMouseX; 
        int m_nMouseY; 

        bool m_bShowFPS; 
        bool m_bShowMouseCoordinates; 

        void CalculateFrameRate(); 

        void EraseKeyAndMouseListeners();
public:

        // Constructor & Deconstructor

        Engine(AbstractPlatform* pPlatform, AbstractRenderer* pRenderer, AbstractAudioSystem* pAudio)
        :m_pPlatform(pPlatform), m_pRenderer(pRenderer), m_pAudio(pAudio), m_pResourceCache(0), m_pGame(0), m_nNextUpdateTime(0), m_nUpdateRate(0), m_nFrameRate(0)
        ,m_pActiveScreen(0), m_nDelta(0), m_bShowFPS(true), m_bShowMouseCoordinates(false), m_nMouseX(0), m_nMouseY(0)
        { }

        ~Engine();

        // Accessor methods.

        AbstractPlatform* GetPlatform() const { return m_pPlatform; }

        AbstractRenderer* GetRenderer() const { return m_pRenderer; }

        AbstractAudioSystem* GetAudio() const { return m_pAudio; }

        ResourceCache* GetResourceCache() const { return m_pResourceCache; }

        Game* GetGame() const { return m_pGame; }

        int GetUpdateRate() const { return m_nUpdateRate; }

        // Core methods.

        bool Initialize();

        void Step();

        void SetModalDialog(ModalDialogPtr pDialog) {

                m_dialogStack.push(m_pDialog); 

                m_pDialog = pDialog;

        }

        void PrintFPS();

        void PrintMouseCoordinates();

        void ActivateScreen(const std::string& screenName);

        void RegisterScreen(const std::string& screenName, BaseScreen* pScreen);

        // Input methods.

        void RegisterMouseListener(AbstractMouseListener* pListener);

        void UnregisterMouseListener(AbstractMouseListener* pListener);

        void RegisterKeyListener(AbstractKeyListener* pListener);

        void UnregisterKeyListener(AbstractKeyListener* pListener);

        void OnMouseMove(const MouseEvent& e);

        void OnMouseButtonPressed(const MouseEvent& e);

        void OnMouseButtonReleased(const MouseEvent& e);

        void OnKeyPressed(const KeyEvent& e);

        void OnKeyReleased(const KeyEvent& e);
};

#endif

---