core/Entity.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            Entity.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Represents an object in the game world.
//
// 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 "Entity.h"
#include "GameManager.h"


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

// Entity constructor.
Entity::Entity(const std::string &name, Entity *parent)
: mRefCount(1), mName(name), mPosition(0, 0, 0)
{
    mID = mIDCount++;

    // Add to its parent.
    if(parent != NULL)
    {
        if(parent->addChild(this))
          pParent = parent;

        else pParent = NULL;
    }

    else pParent = NULL;

    // Create an event group and event slots.
    EventManager *pEventMgr = GameManager::Instance()->getEventManager();
    std::string groupName;

    groupName = "ent#" + mName;
    pEventMgr->createEventGroup(groupName);
    pEventMgr->createEventSlot(groupName, "onPositionChange");
    pEventMgr->createEventSlot(groupName, "onUpdate");
    pEventMgr->createEventSlot(groupName, "onRender");
    pEventMgr->createEventSlot(groupName, "onPause");
    pEventMgr->createEventSlot(groupName, "onUnPause");

    // Subscribe to parents event slots.
    if(pParent != NULL)
    {
       groupName = "ent#" + pParent->getName();
       pEventMgr->connectEventSignal(groupName, "onUpdate", this, &Entity::onPositionChange);
       pEventMgr->connectEventSignal(groupName, "onUpdate", this, &Entity::onUpdate);
       pEventMgr->connectEventSignal(groupName, "onRender", this, &Entity::onRender);
       pEventMgr->connectEventSignal(groupName, "onPause", this, &Entity::onPause);
       pEventMgr->connectEventSignal(groupName, "onUnPause", this, &Entity::onUnPause);
    }
}

// Entity deconstructor.
Entity::~Entity()
{
    // Remove all children and components.
    removeAllChildren();
    removeAllComponents();

    // Remove events.
    GameManager::Instance()->getEventManager()->removeEventGroup(std::string("ent#") + mName);
}

// AngelScript: Will be used to instanciate objects of this class.
Entity* Entity::refFactory(const std::string &name)
{
    return new Entity(name);
}

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

// Angelscript: Decreases the reference counter.
void Entity::refRelease()
{
    if(--mRefCount == 0)
    {
       if(pParent != NULL)
       {
          if(!pParent->removeChild(this))
          {
             if(!GameManager::Instance()->getEntityManager()->removeEntity(this))
               delete this;
          }
       }

       else if(!GameManager::Instance()->getEntityManager()->removeEntity(this))
         delete this;
    }
}

// Gets the ID of this entity.
u32 Entity::getID() const
{
    return mID;
}

// Gets the name of this entity.
const std::string& Entity::getName() const
{
    return mName;
}

// Adds a child to the entity.
bool Entity::addChild(Entity *entity)
{
    // Did we get a pointer to a entity?
    if(entity == NULL)
      return false;

    // Check if a entity of the given type doesn't already exist.
    if(getChild(entity->getName()))
      return false;

    // Add new component.
    mChildren.push_back(entity);

    return true;
}

// Adds a component to the entity.
bool Entity::addComponent(EntityComponent *component)
{
    // Did we get a pointer to a component?
    if(component == NULL)
      return false;

    // Check if a component of the given type doesn't already exist.
    if(getComponent(component->getName()))
      return false;

    // Add new component.
    mComponents.push_back(component);

    return true;
}

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

    return NULL;
}

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

    return NULL;
}

// Gets the component with the given ID from this entity.
EntityComponent* Entity::getComponent(const u32 id)
{
    for(u32 i = 0; i < mComponents.size(); i++)
    {
       if(mComponents[i]->getID() == id)
         return mComponents[i];
    }

    return NULL;
}

// Gets the component with the given name from this entity.
EntityComponent* Entity::getComponent(const std::string &name)
{
    for(u32 i = 0; i < mComponents.size(); i++)
    {
       if(mComponents[i]->getName() == name)
         return mComponents[i];
    }

    return NULL;
}

// Gets the parent of this entity.
Entity* Entity::getParent() const
{
    return pParent;
}

// Gets the position of the entity.
const vector3df& Entity::getPosition() const
{
    return mPosition;
}

// Removes all children.
void Entity::removeAllChildren()
{
    for(u32 i = 0; i < mChildren.size(); i++)
    {
       if(!GameManager::Instance()->getEntityManager()->removeEntity(mChildren[i]))
         delete mChildren[i];
    }

    mChildren.clear();
}

// Removes all components.
void Entity::removeAllComponents()
{
    for(u32 i = 0; i < mComponents.size(); i++)
       delete mComponents[i];

    mComponents.clear();
}

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

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

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

        if(ent == entity)
        {
           if(!GameManager::Instance()->getEntityManager()->removeEntity(ent))
             delete ent;

           mChildren.erase(it);
           return true;
        }
    }

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

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

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

        if(ent->getID() == id)
        {
           if(!GameManager::Instance()->getEntityManager()->removeEntity(ent))
             delete ent;

           mChildren.erase(it);
           return true;
        }
    }

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

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

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

        if(ent->getName() == name)
        {
           if(!GameManager::Instance()->getEntityManager()->removeEntity(ent))
             delete ent;

           mChildren.erase(it);
           return true;
        }
    }

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

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

    // Try to remove the component.
    vector<EntityComponent*>::iterator it;

    for(it = mComponents.begin(); it < mComponents.end(); it++)
    {
        EntityComponent *comp = *it;

        if(comp == component)
        {
           delete comp;
           mComponents.erase(it);
           return true;
        }
    }

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

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

    for(it = mComponents.begin(); it < mComponents.end(); it++)
    {
        EntityComponent *comp = *it;

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

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

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

    for(it = mComponents.begin(); it < mComponents.end(); it++)
    {
        EntityComponent *comp = *it;

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

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

// Sets the position of the entity.
void Entity::setPosition(const vector3df &position)
{
    // Determine difference.
    vector3df diff = position - mPosition;

    // Set position.
    mPosition = position;

    // Set position for children, components and misc. subscribers.
    GameManager::Instance()->getEventManager()->emitEvent(std::string("ent#") + mName,
                                                          "onPositionChange", &diff);
}

// Updates the position of the entity after its parent has been updated.
void Entity::onPositionChange(void *p)
{
    vector3df diff = static_cast<vector3df*>(p)[0];
    mPosition += diff;
}

// Updates the entity if the parent is updated.
void Entity::onUpdate(void *p)
{
    GameManager::Instance()->getEventManager()->emitEvent(std::string("ent#") + mName,
                                                          "onUpdate", p);
}

// Renders the entity if the parent is rendered.
void Entity::onRender(void *p)
{
    GameManager::Instance()->getEventManager()->emitEvent(std::string("ent#") + mName,
                                                          "onRender", p);
}

// Pauses the entity if the parent is paused.
void Entity::onPause(void *p)
{
    GameManager::Instance()->getEventManager()->emitEvent(std::string("ent#") + mName,
                                                          "onPause", p);
}

// Updates the entity if the parent is unpaused.
void Entity::onUnPause(void *p)
{
    GameManager::Instance()->getEventManager()->emitEvent(std::string("ent#") + mName,
                                                          "onUnPause", p);
}


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

    // Bind Entity class (and dependencies).
    r = engine->RegisterObjectType("Entity", sizeof(Entity), asOBJ_REF);
    r = engine->RegisterObjectType("EntityComponent", sizeof(EntityComponent), asOBJ_REF);

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

    // Bind Entity class functions.
    r = engine->RegisterObjectMethod("Entity", "u32 getID()",
                                     asMETHOD(Entity, getID), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("Entity", "const string& getName()",
                                     asMETHOD(Entity, getName), asCALL_THISCALL); assert(r >= 0);

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

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

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

    r = engine->RegisterObjectMethod("Entity", "void removeAllChildren()",
                                     asMETHOD(Entity, removeAllChildren), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("Entity", "void removeAllComponents()",
                                     asMETHOD(Entity, removeAllComponents), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("Entity", "bool removeChild(Entity @)",
                                     asMETHODPR(Entity, removeChild, (Entity*), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("Entity", "bool removeChild(const u32)",
                                     asMETHODPR(Entity, removeChild, (const u32), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("Entity", "bool removeChild(const string &)",
                                     asMETHODPR(Entity, removeChild, (const std::string&), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("Entity", "bool removeComponent(EntityComponent @)",
                                     asMETHODPR(Entity, removeComponent, (EntityComponent*), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("Entity", "bool removeComponent(const u32)",
                                     asMETHODPR(Entity, removeComponent, (const u32), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("Entity", "bool removeComponent(const string &)",
                                     asMETHODPR(Entity, removeComponent, (const std::string&), bool),
                                     asCALL_THISCALL); assert(r >= 0);
}

// End of File

---