tb_entity_manager.h

#ifndef _TurtleBrains_EntityManager_h_
#define _TurtleBrains_EntityManager_h_

#include "tb_entity.h" //For EntityType definition.
#include "../core/tb_noncopyable.h"

#include <map>
#include <set>
#include <list>

namespace TurtleBrains
{
    namespace Game
    {

        class Entity;

        class EntityFactoryInterface : public tbCore::Noncopyable
        {
        public:
            EntityFactoryInterface(void);

            virtual ~EntityFactoryInterface(void);

            Entity* CreateEntityByType(const EntityType& entityType);

            bool DestroyEntity(Entity* entityToDestroy);
        };

//
// UPDATE (before) March 22, 2016:
//
// The following is now working with GraphicList and EntityManager by using two similar, but DIFFERENT, AddItem()
//   functions:  AddItem(ItemInterface* managedItem) will get deleted automatically, add and forget, while the alternative
//   AddItem(ItemInterface& ownedItem) will not be deleted or cleaned up, and is expected to remain in scope/valid until
//   after it gets manually removed.
//
//class ItemInterface
//{
//public:
//  virtual ~ItemInterface(void) = 0;
//};
//
//class Manager
//{
//public:
//  void AddItem(ItemInterface* item);
//  void RemoveItem(ItemInterface* item);
//
//  //Contain and do things with Items...
//};
//
//class Scene
//{
//public:
//  void OnEnter()
//  {
//      //The following line is desired, but currently can't be done because Scene needs to own (cleanup) the item.
//      //But I want to support dynamically allocated items for bullets and other effects/entities etc... that then
//      //clean themselves up automatically when theManager.RemoveItem() is called on it, without needing Scene() to
//      //do so.
//      theManager.AddItem(new AwesomeItem());
//
//      //The following is okay and works flawlessly without dynamic memory!
//      theManager.AddItem(&mCoin);
//  }
//
//  void OnExit()
//  {
//
//      theManager.RemoveItem(&mCoin);
//      theManager.ClearItems();
//  }
//
//private:
//  CoinItem mCoin;
//};







        class EntityManager : public tbGraphics::GraphicList
        {
        public:
            typedef std::list<Entity*> EntityList;

            EntityManager(void);

            virtual ~EntityManager(void) = 0;

//          Entity& AddEntity(const EntityType& entityType);

            void AddEntity(Entity* entity);

            void AddEntity(Entity& entity);

            void RemoveEntity(Entity* entity);

            void RemoveEntities(const EntityType& byType = Entity::kInvalidType);

            void EntityTypeChanged(Entity& entity, const EntityTypeContainer& oldTypes);

            EntityList GetAllEntities(void);

            EntityList GetEntitiesByType(const EntityType& byType);

            EntityList GetEntitiesAt(const tbMath::Vector2& point, const EntityType& byType = Entity::kInvalidType, bool onlyCollidableEntities = false);

            EntityList GetEntitiesWithin(const tbMath::Vector2& center, const float radius, const EntityType& byType = Entity::kInvalidType, bool onlyCollidableEntities = false);

            EntityList GetEntitiesWithin(const tbMath::Vector2& center, const float width, const float height, const EntityType& byType = Entity::kInvalidType, bool onlyCollidableEntities = false);

            void Simulate(void);

        protected:
            virtual void OnUpdate(const float deltaTime) override;

        private:
            void ReallyAddEntity(Entity* entity, bool managed);
            void SafeToRemoveEntities(void);

            typedef std::set<Entity*> EntitySet;
            typedef std::map<EntityType, EntityList> EntityByTypeMap;

            EntityList mEntities;
            EntityList mManagedEntities;
            EntitySet mEntitiesToRemove;
            EntityByTypeMap mEntitiesByType;
        };

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

namespace tbGame = TurtleBrains::Game;

#endif /* _TurtleBrains_EntityManager_h_ */