core/EntityManager.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            EntityManager.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           The Entity Manager is the central interface point to all
//                  entity related functions of this program.
//
// 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 "EntityManager.h"
#include "GameManager.h"


// EntityManager class
// EntityManager constructor.
EntityManager::EntityManager()
{
    init();
}

// EntityManager deconstructor.
EntityManager::~EntityManager()
{
    clear();
}

// Initialises the Entity Manager.
void EntityManager::init()
{
}

// Clears the Entity Manager.
void EntityManager::clear()
{
    // Clear entities.
    removeAllEntities();
}

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

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

// Adds an entity to the Entity Manager.
bool EntityManager::addEntity(Entity *entity)
{
    // Did we get a valid pointer?
    if(entity == NULL)
      return false;

    // Look if a entity with given name doesn't already exist.
    if(getEntity(entity->getName()))
      return false;

    // Add the entity.
    mEntities.push_back(entity);

    return true;
}

// Creates (and adds) an entity with the given name and adds it to the Entity Manager.
Entity* EntityManager::createEntity(const std::string &name, Entity *parent)
{
    // Look if a entity with given name doesn't already exist.
    if(getEntity(name))
      return NULL;

    // Add the entity.
    Entity *entity = new Entity(name, parent);
    entity->refAdd();
    mEntities.push_back(entity);
    return entity;
}

// Gets the entity with the given ID.
Entity* EntityManager::getEntity(const u32 id)
{
    for(u32 i = 0; i < mEntities.size(); i++)
    {
       if(mEntities[i]->getID() == id)
         return mEntities[i];
    }

    return NULL;
}

// Gets the entity with the given name.
Entity* EntityManager::getEntity(const std::string &name)
{
    for(u32 i = 0; i < mEntities.size(); i++)
    {
       if(mEntities[i]->getName() == name)
         return mEntities[i];
    }

    return NULL;
}

// Removes all entities.
void EntityManager::removeAllEntities()
{
    for(u32 i = 0; i < mEntities.size(); i++)
      delete mEntities[i];

    mEntities.clear();
}

// Removes the given entity.
bool EntityManager::removeEntity(Entity *entity)
{
    // Did we get a valid pointer?
    if(entity == NULL)
      return false;

    // Try to remove the entity.
    vector<Entity*>::iterator it;

    for(it = mEntities.begin(); it < mEntities.end(); it++)
    {
        Entity *ent = *it;

        if(ent == entity)
        {
           delete ent;
           mEntities.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}

// Removes the entity with the given ID.
bool EntityManager::removeEntity(const u32 id)
{
    // Try to remove the entity.
    vector<Entity*>::iterator it;

    for(it = mEntities.begin(); it < mEntities.end(); it++)
    {
        Entity *ent = *it;

        if(ent->getID() == id)
        {
           delete ent;
           mEntities.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}

// Removes the entity with the given name.
bool EntityManager::removeEntity(const std::string &name)
{
    // Try to remove the entity.
    vector<Entity*>::iterator it;

    for(it = mEntities.begin(); it < mEntities.end(); it++)
    {
        Entity *ent = *it;

        if(ent->getName() == name)
        {
           delete ent;
           mEntities.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}


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

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

    // Set EntityManager behaviour.
    r = engine->RegisterObjectBehaviour("EntityManager", asBEHAVE_ADDREF, "void f()",
                                        asMETHOD(EntityManager, refAdd), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectBehaviour("EntityManager", asBEHAVE_RELEASE, "void f()",
                                        asMETHOD(EntityManager, refRelease), asCALL_THISCALL); assert(r >= 0);

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

    r = engine->RegisterObjectMethod("EntityManager", "bool addEntity(Entity @)",
                                     asMETHOD(EntityManager, addEntity), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("EntityManager", "Entity@ createEntity(const string &)",
                                     asMETHOD(EntityManager, createEntity), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("EntityManager", "Entity@ createEntity(const string &, Entity @)",
                                     asMETHOD(EntityManager, createEntity), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("EntityManager", "Entity@ getEntity(const u32)",
                                     asMETHODPR(EntityManager, getEntity, (const u32), Entity*),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("EntityManager", "Entity@ getEntity(const string &)",
                                     asMETHODPR(EntityManager, getEntity, (const std::string &), Entity*),
                                     asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("EntityManager", "void removeAllEntities()",
                                     asMETHOD(EntityManager, removeAllEntities), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("EntityManager", "bool removeEntity(Entity @)",
                                     asMETHODPR(EntityManager, removeEntity, (Entity*), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("EntityManager", "bool removeEntity(const u32)",
                                     asMETHODPR(EntityManager, removeEntity, (const u32), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("EntityManager", "bool removeEntity(const string &)",
                                     asMETHODPR(EntityManager, removeEntity, (const std::string &), bool),
                                     asCALL_THISCALL); assert(r >= 0);
}
// End of File

---