core/GameManager.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            GameManager.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           The Game Manager is the central access point to the game.
//                  It is able to perform generic game initialisation and
//                  deinitialisation. It's main purpose, though, is to control
//                  the flow of the game.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "GameManager.h"


// GameManager class
// Constructor of the GameManager class.
GameManager::GameManager()
: pDevice(0), mLastTime(0)
{
}

// Deconstructor of the GameManager class.
GameManager::~GameManager()
{
    clear();
}

// GameManager singleton.
GameManager* GameManager::pInstance = 0;

GameManager* GameManager::Instance()
{
    if(pInstance == 0)
      pInstance = new GameManager();

    return pInstance;
}

GameManager& GameManager::Reference()
{
    if(pInstance == 0)
      pInstance = new GameManager();

    return *pInstance;
}

// Initialises the GameManager.
void GameManager::init()
{
    // Initialise the subsystems of the framework. (stage 1)
    pDataStore = new DataStore();
    pEventManager = new EventManager();

    // Initialise the Irrlicht engine.
    pDevice = createDevice(EDT_OPENGL, dimension2d<u32>(1024, 768), 32, false, false, false, pEventManager);

    // Get points to subsystems of the Irrlicht engine.
    pDriver = pDevice->getVideoDriver();
    pSceneManager = pDevice->getSceneManager();
        pGUIEnvironment = pDevice->getGUIEnvironment();

        // Initialise subsystems of the framework (stage 2);
        pEntityManager = new EntityManager();
        pSoundManager = new SoundManager();

        pScriptManager = new ScriptManager();
        pScriptManager->init();
}

// Updates the GameManager.
void GameManager::update()
{
    // Updating
    u32 time = pDevice->getTimer()->getTime();
    f32 deltaTime = ( (float)time - (float)mLastTime ) *0.01f;
    mLastTime = time;

    if(!mGameStates.empty() && deltaTime > 0.0f)
    {
        mGameStates.back()->onUpdate(deltaTime);
        mGameStates.back()->update(deltaTime);
    }

    // Rendering
    if(pDevice->isWindowActive())
    {
       if(!mGameStates.empty())
       {
          pDriver->beginScene();

          pSceneManager->drawAll();
          pGUIEnvironment->drawAll();

          mGameStates.back()->onRender();
          mGameStates.back()->render();

          pDriver->endScene();
       }
    }
}

// Clears the GameManager.
void GameManager::clear()
{
    // Clean up the state stack.
    while(!mGameStates.empty())
    {
       mGameStates.back()->clear();
       mGameStates.pop_back();
    }

    // Clean up subsystems of the framework.
    pScriptManager->clear();
    delete pScriptManager;

    delete pSoundManager;
    delete pEventManager;
    delete pEntityManager;
    delete pDataStore;

    // Clean up Irrlicht.
    pDevice->drop();
}

// AngelScript: Will be used to instanciate objects of this class.
GameManager* GameManager::refFactory()
{
    return GameManager::Instance();
}

// Angelscript: Increases the reference counter.
void GameManager::refAdd()
{
    // Dummy function.
}

// Angelscript: Decreases the reference counter.
void GameManager::refRelease()
{
    // Dummy function.
}

// Close the current state and change to the given state.
void GameManager::changeState(GameState *state)
{
    // Clear the current state.
    popState();

    // Initialise the state.
    if(state != NULL)
    {
        mGameStates.push_back(state);
        state->init();
    }
}

// Close the current state and change to the given state.
void GameManager::changeState(asIScriptObject *object)
{
    // Clear the current state.
    popState();

    // Initialise the state.
    if(object != NULL)
    {
        ScriptedGameState *state = new ScriptedGameState(object);
        mGameStates.push_back(state);
        state->init();
    }
}

// Pause the current state and change to the given state.
void GameManager::pushState(GameState *state)
{
    // Pause the current state.
    if(!mGameStates.empty())
      mGameStates.back()->onPause();

    // Initialise the state.
    if(state != NULL)
    {
       mGameStates.push_back(state);
       state->init();
    }
}

// Pause the current state and change to the given state.
void GameManager::pushState(asIScriptObject *object)
{
    // Pause the current state.
    if(!mGameStates.empty())
      mGameStates.back()->onPause();

    // Initialise the state.
    if(object != NULL)
    {
       ScriptedGameState *state = new ScriptedGameState(object);
       mGameStates.push_back(state);
       state->init();
    }
}

// Close the current state and resume the previous state.
void GameManager::popState()
{
    // Clear the current state.
    if(!mGameStates.empty())
    {
       mGameStates.back()->clear();
       delete mGameStates.back();
       mGameStates.pop_back();
    }

    // Unpause the newly selected state.
    if(!mGameStates.empty())
      mGameStates.back()->onUnPause();
}

// Returns a pointer to the Irrlicht Device.
IrrlichtDevice* GameManager::getDevice()
{
        return pDevice;
}

// Returns a pointer to the Irrlicht driver.
IVideoDriver* GameManager::getDriver()
{
        return pDriver;
}

// Returns a pointer to the Irrlicht SceneManager.
ISceneManager* GameManager::getSceneManager()
{
        return pSceneManager;
}

// Returns a pointer to the Irrlicht GUI Manager.
IGUIEnvironment* GameManager::getGUIEnvironment()
{
        return pGUIEnvironment;
}

// Returns a pointer to the DataStore.
DataStore* GameManager::getDataStore()
{
    return pDataStore;
}

// Returns a pointer to the EntityManager.
EntityManager* GameManager::getEntityManager()
{
    return pEntityManager;
}

// Returns a pointer to the EventManager.
EventManager* GameManager::getEventManager()
{
    return pEventManager;
}

// Returns a pointer to the ScriptManager.
ScriptManager* GameManager::getScriptManager()
{
    return pScriptManager;
}

// Returns a pointer to the Sound Manager.
SoundManager* GameManager::getSoundManager()
{
    return pSoundManager;
}

// Returns whether the Irrlicht device is running.
bool GameManager::getIsRunning() const
{
    return pDevice->run();
}

// Sets the running state of the Irrlicht device.
// --> Wrapper function for pDevice->closeDevice()
void GameManager::setIsRunning(bool value)
{
    if(value == false)
      pDevice->closeDevice();
}


// GameManager Angelscript binding.
void bindGameManager(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

    // Bind GameManager class.
    r = engine->RegisterObjectType("GameManager", sizeof(GameManager), asOBJ_REF); assert(r >= 0);

    // Set GameManager behaviour.
    r = engine->RegisterObjectBehaviour("GameManager", asBEHAVE_FACTORY, "GameManager@ f()",
                                        asFUNCTION(GameManager::refFactory), asCALL_CDECL); assert(r >= 0);
    r = engine->RegisterObjectBehaviour("GameManager", asBEHAVE_ADDREF, "void f()",
                                        asMETHOD(GameManager, refAdd), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectBehaviour("GameManager", asBEHAVE_RELEASE, "void f()",
                                        asMETHOD(GameManager, refRelease), asCALL_THISCALL); assert(r >= 0);

    // Bind GameManager class functions.
    r = engine->RegisterGlobalFunction("GameManager& getGameManager()", asFUNCTION(GameManager::Instance),
                                       asCALL_CDECL); assert( r >= 0 );

    r = engine->RegisterObjectMethod("GameManager", "void changeState(GameState @)",
                                     asMETHODPR(GameManager, changeState, (GameState*), void),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameManager", "void changeState(IGameState @)",
                                     asMETHODPR(GameManager, changeState, (asIScriptObject*), void),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameManager", "void pushState(GameState @)",
                                     asMETHODPR(GameManager, pushState, (GameState*), void),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameManager", "void pushState(IGameState @)",
                                     asMETHODPR(GameManager, pushState, (asIScriptObject*), void),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameManager", "void popState()",
                                     asMETHOD(GameManager, popState), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("GameManager", "DataStore@ getDataStore()",
                                     asMETHOD(GameManager, getDataStore), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameManager", "EntityManager@ getEntityManager()",
                                     asMETHOD(GameManager, getEntityManager), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameManager", "EventManager@ getEventManager()",
                                     asMETHOD(GameManager, getEventManager), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameManager", "ScriptManager@ getScriptManager()",
                                     asMETHOD(GameManager, getScriptManager), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameManager", "SoundManager@ getSoundManager()",
                                     asMETHOD(GameManager, getSoundManager), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("GameManager", "bool getIsRunning()",
                                     asMETHOD(GameManager, getIsRunning), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("GameManager", "void setIsRunning(bool)",
                                     asMETHOD(GameManager, setIsRunning), asCALL_THISCALL); assert(r >= 0);
}

// End of File

---