tb_entity.hpp

 
#ifndef TurtleBrains_Entity_hpp
#define TurtleBrains_Entity_hpp
 
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/graphics/tb_graphic_list.hpp>
#include <turtle_brains/math/unstable/tbu_bounding_volume.hpp>
 
#include <vector>
#include <stack>
#include <list>
#include <utility> //std::pair
 
namespace TurtleBrains
{
    namespace Game
    {
 
        typedef String 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);
 
            EntityManager* GetEntityManager(void) const;
 
            void Simulate(void);
 
            //
            // Entity Behavior System
            //
 
            void ClearBehaviors(void);
 
            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 ClearBoundingVolumes(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 OnDebugRender(void) const;
 
            virtual void OnCollide(const Entity& other);
 
            virtual void OnAdd(void);
 
            virtual void OnRemove(void);
 
        private:
            void ReallyPopBehavior(void);
            void DeleteDelayedBehaviors(void);
 
            typedef std::stack<EntityBehaviorInterface*> BehaviorStack;
            typedef std::list<EntityBehaviorInterface*> BehaviorList;
            typedef std::pair<tbMath::Unstable::BoundingVolume, tbMath::Vector2> BoundingVolumeInformation;
            typedef std::vector<BoundingVolumeInformation> BoundingVolumeContainer;
 
            BehaviorStack mBehaviorStack;
            BehaviorList mBehaviorsToDelete;
            BoundingVolumeContainer mBoundingVolumes;
            EntityTypeContainer mEntityTypes;
 
            EntityManager* mEntityManager;
            bool mIsCollidable;
 
            friend class EntityManager;
 
            //This is only a friend until BoundingVolume API is stabilized and Entity has accessors to grab the volumes of
            //the entity in a better way to perform MoveEntity in the TileSystem.
            friend class TileSystem;
        };
 
    }; /* namespace Game */
}; /* namespace TurtleBrains */
 
namespace tbGame = TurtleBrains::Game;
 
#endif /* TurtleBrains_Entity_hpp */