tb_entity.h

#ifndef _TurtleBrains_Entity_h_
#define _TurtleBrains_Entity_h_

#include "../core/tb_string.h"
#include "../graphics/tb_graphic_list.h"
#include "../math/unstable/tbu_bounding_volume.h"

#include <vector>
#include <stack>
#include <list>
#include <utility> //std::pair

namespace TurtleBrains
{
    namespace Game
    {

        typedef tbCore::tbString EntityType;

        typedef std::list<EntityType> EntityTypeContainer;

        class EntityManager;
        class EntityBehaviorInterface;

        class Entity : public tbGraphics::GraphicList
        {
        public:
            static const EntityType kInvalidType;

            explicit Entity(const EntityType& entityType);

            virtual ~Entity(void) = 0;

            EntityManager* GetEntityManager(void) const;

            void Simulate(void);

            //
            // Entity Behavior System
            //

            void PushBehavior(EntityBehaviorInterface* entityBehavior);

            void PopBehavior(void);

            void PopBehaviorIf(EntityBehaviorInterface* entityBehavior);

            void PopAllBehaviors(void);

            const EntityBehaviorInterface* GetActiveBehavior(void) const;

            EntityBehaviorInterface* GetActiveBehavior(void);

            //
            // Collision and Bounding Volume
            //

            bool IsCollidable(void) const;

            void SetCollidable(const bool isCollidable);

            bool HasBoundingVolume(void) const;

            void RemoveBoundingVolumes(void);

            void AddBoundingCircle(const float circleRadius, const tbMath::Vector2& centerOffset = tbMath::Vector2::Zero());

            void AddBoundingBox(const float boxWidth, const float boxHeight, const tbMath::Vector2& centerOffset = tbMath::Vector2::Zero());

            bool CheckCollisionWith(const tbMath::Vector2& point) const;

            bool CheckCollisionWith(const tbMath::Vector2& center, const float radius) const;

            bool CheckCollisionWith(const tbMath::Vector2& center, const float width, const float height) const;

            bool CheckCollisionWith(const Entity& otherEntity) const;

            //
            // EntityType and other Properties
            //

            const EntityType& GetEntityType(void) const;

            const EntityTypeContainer& GetEntityTypes(void) const;

            void AddEntityType(const EntityType& entityType);

            void RemoveEntityType(const EntityType& entityType);

            bool IsEntityOfType(const EntityType& entityType) const;

        protected:
            virtual void OnSimulate(void);

            virtual void OnUpdate(const float deltaTime);

            virtual void OnRender(void) const;

            virtual void OnCollideWith(Entity& other);

            virtual void OnAdded(void);

            virtual void OnRemoved(void);

        private:
            void ReallyPopBehavior(void);

            typedef std::stack<EntityBehaviorInterface*> BehaviorContainer;
            typedef std::pair<tbMath::Unstable::BoundingVolume, tbMath::Vector2> BoundingVolumeInformation;
            typedef std::vector<BoundingVolumeInformation> BoundingVolumeContainer;

            BehaviorContainer mBehaviorStack;
            BoundingVolumeContainer mBoundingVolumes;
            EntityTypeContainer mEntityTypes;

            EntityManager* mEntityManager;
            bool mIsCollidable;

            friend class EntityManager;
        };

    }; /* namespace Game */
}; /* namespace TurtleBrains */

namespace tbGame = TurtleBrains::Game;

#endif /* _TurtleBrains_Entity_h_ */