core/GameState.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            GameState.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           The GameState object is a base class which is implemented
//                  through derived sub-classes.
//
// 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 "GameState.h"


// GameState class
// Static variables.
u32 GameState::mIDCount = 0;

// Constructer of the GameState class.
GameState::GameState()
{
    mID = mIDCount++;

    // Create the base entity.
    std::stringstream ss;
    ss << "GameState#" << mID;
    mBaseEntity = GameManager::Instance()->getEntityManager()->createEntity(ss.str());

    // Store the name of the event group of this state.
    mEventGroup = "ent#" + ss.str();
}

// Deconstructor of the GameState class.
GameState::~GameState()
{
    GameManager::Instance()->getEntityManager()->removeEntity(mBaseEntity);
}

// Initialises the GameState.
// -> Implemented by subclass.
void GameState::init()
{
}

// Clears the GameState.
// -> Implemented by subclass.
void GameState::clear()
{
}

// Updates the GameState.
// -> Implemented by subclass.
void GameState::update(f32 deltaTime)
{
}

// Renders the GameState.
// -> Implemented by subclass.
void GameState::render()
{
}

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

// Angelscript: Increases the reference counter.
void GameState::refAdd()
{
    mRefCount++;
}

// Angelscript: Decreases the reference counter.
void GameState::refRelease()
{
    if(--mRefCount == 0)
      delete this;
}

// Returns the base entity.
const Entity* GameState::getBaseEntity() const
{
    return mBaseEntity;
}

// Event functions
// Sends the "onUpdate" event to all entities subscribed to this state.
void GameState::onUpdate(f32 deltaTime)
{
    GameManager::Instance()->getEventManager()->emitEvent(mEventGroup, "onUpdate", &deltaTime);
}

// Sends the "onUpdate" event to all entities subscribed to this state.
void GameState::onRender()
{
    GameManager::Instance()->getEventManager()->emitEvent(mEventGroup, "onRender");
}

// Sends the "onPause" event to all entities subscribed to this state.
void GameState::onPause()
{
    GameManager::Instance()->getEventManager()->emitEvent(mEventGroup, "onPause");
}

// Sends the "onUnPause" event to all entities subscribed to this state.
void GameState::onUnPause()
{
    GameManager::Instance()->getEventManager()->emitEvent(mEventGroup, "onUnPause");
}


// ScriptedGameState class
// ScriptedGameState constructor
ScriptedGameState::ScriptedGameState(asIScriptObject *object)
: mObject(object)
{
    // No new state was created, so lets fix the IDs.
    mID--;
    mIDCount--;

    // Set up pointers which will be used.
    mObject->AddRef();
    mContext = GameManager::Instance()->getScriptManager()->getEngine()->CreateContext();

    // Get the base entity.
    int id = mObject->GetObjectType()->GetMethodIdByDecl("const Entity@ getBaseEntity()");

    mContext->Prepare(id);
    mContext->SetObject(mObject);
    mContext->Execute();
    mBaseEntity = static_cast<Entity*>(mContext->GetReturnObject());
}

// ScriptedGameState deconstructor
ScriptedGameState::~ScriptedGameState()
{
    mContext->Release();
    mObject->Release();
}

// Initialises the Game State.
void ScriptedGameState::init()
{
    int id = mObject->GetObjectType()->GetMethodIdByDecl("void init()");

    mContext->Prepare(id);
    mContext->SetObject(mObject);
    mContext->Execute();
}

// Clears the Game State.
void ScriptedGameState::clear()
{
    int id = mObject->GetObjectType()->GetMethodIdByDecl("void clear()");

    mContext->Prepare(id);
    mContext->SetObject(mObject);
    mContext->Execute();
}

// Updates the Game State.
void ScriptedGameState::update(f32 deltaTime)
{
    int id = mObject->GetObjectType()->GetMethodIdByDecl("void init()");

    mContext->Prepare(id);
    mContext->SetObject(mObject);
    mContext->SetArgDWord(0, deltaTime);
    mContext->Execute();
}

// Renders the Game State.
void ScriptedGameState::render()
{
    int id = mObject->GetObjectType()->GetMethodIdByDecl("void render()");

    mContext->Prepare(id);
    mContext->SetObject(mObject);
    mContext->Execute();
}


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

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

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

    // Bind GameState class functions.
    r = engine->RegisterObjectMethod("GameState", "void init()",
                                     asMETHOD(GameState, init), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameState", "void clear()",
                                     asMETHOD(DataStack, clear), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("GameState", "void update()",
                                     asMETHOD(GameState, update), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("GameState", "void render()",
                                     asMETHOD(GameState, render), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("GameState", "const Entity@ getBaseEntity()",
                                     asMETHOD(GameState, getBaseEntity), asCALL_THISCALL); assert(r >= 0);

    // Define the interface for inheritance.
    r = engine->RegisterInterface("IGameState"); assert(r >= 0);

    r = engine->RegisterInterfaceMethod("IGameState", "void init()");
    r = engine->RegisterInterfaceMethod("IGameState", "void clear()");
    r = engine->RegisterInterfaceMethod("IGameState", "void update()");
    r = engine->RegisterInterfaceMethod("IGameState", "void render()");
    r = engine->RegisterInterfaceMethod("IGameState", "const Entity@ getBaseEntity()");

    // Define the class for inheritance.
    std::string decl = "CGameState : IGameState\n"
                       "{\n"
                       "    GameState _inner;\n"
                       "    Entity @mBaseEntity\n;"
                       "\n"
                       "    CGameState::CGameState()\n"
                       "    {\n"
                       "       _inner = GameState();\n"
                       "       mBaseEntity = _inner.getBaseEntity();\n"
                       "    }\n"
                       "\n"
                       "    void init() {}\n"
                       "    void clear() {}\n"
                       "    void update() {}\n"
                       "    void render() {}\n"
                       "\n"
                       "    const Entity@ getBaseEntity() { return _inner.getBaseEntity(); }\n"
                       "}\n";

    GameManager::Instance()->getScriptManager()->addScriptSection("CGameState", decl);
}
// End of File

---