C:/Users/Marc/Desktop/Phystank/trunk/src/game/GameEntity.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

class AbstractComponent;
class Game;

#include <iostream>
#include <hash_map>
#include <string>

#include "game/AbstractComponent.h"
#include "game/ComponentFactory.h"

#include "util/AbstractStreamedObject.h"
#include "util/Attribute.h"
#include "util/Macros.h"
#include "util/Matrix.h"
#include "util/StringHasher.h"
#include "util/Vector2.h"

#define INVALIDID 0xFFFFFFFF

class Game;

class GameEntity : public AbstractStreamedObject
{
private:
        typedef stdext::hash_map<ComponentId, AbstractComponent*, StringHasher> ComponentMap;
        typedef std::list<AbstractComponent*> ComponentList;
        typedef ComponentMap::const_iterator ComponentMapIterator;
        typedef ComponentList::const_iterator ComponentListIterator;

        Vector2 m_position;
        float m_fRotation;

        bool m_bActive;

        UNIQUEID m_id;

        Game* m_pGame;

        ComponentMap m_componentMap;
        ComponentList m_updateList;
public:
        GameEntity();

        ~GameEntity();

        const Vector2& GetPosition() const { return m_position; }

        void SetPosition(const Vector2 & position) { m_position = position; }

        float GetRotation() const { return m_fRotation; }

        void SetRotation(const float & fRotation) { m_fRotation = fRotation; }

        Matrix GetXForm() const;

        const UNIQUEID & GetId() const { return m_id; }

        void SetId(const UNIQUEID & id) { m_id = id; }

        bool GetActive() const { return m_bActive; }

        void SetActive(bool bActive) { m_bActive = bActive; }

        Game* GetGame() const { return m_pGame; }

        void SetGame(Game* pGame) { m_pGame = pGame; }

        template<class T>
        T* GetComponent(const ComponentId& familyId) const;
        
        template<class T>
        T* CreateComponentCast(const ComponentId& id);

        AbstractComponent* CreateComponent(const ComponentId& id);

        void RemoveComponent(const ComponentId& id);

        void Update(const int nDelta);

        bool FromAttribute(const Attribute * pAttributes);

        virtual void ToStream(std::ostream& stream) const;

        virtual void FromStream(std::istream& stream);
};

template<class T>
inline T* GameEntity::GetComponent(const ComponentId& familyId) const
{
        ComponentMapIterator i = m_componentMap.find(familyId);

        if(i != m_componentMap.end())
                return reinterpret_cast<T*>(i->second);

        return 0;
}

template<class T>
inline T* GameEntity::CreateComponentCast(const ComponentId& id)
{
        return reinterpret_cast<T*>(CreateComponent(id));
}

inline Matrix GameEntity::GetXForm() const
{
        Matrix xform;
        
        xform.Rotation(MATH_2PI - m_fRotation);
        xform.Translation(m_position._x, m_position._y);

        return xform;
}

---