AIManager.hh

#ifndef GRAIL_AI_MANAGER_H
#define GRAIL_AI_MANAGER_H
 
#include "AIEntity.hh"
#include "EntityGroup.h"
#include "SynchronizedEntityContainer.h"
 
#include <condition_variable>
#include <map>
#include <queue>
#include <set>
#include <thread>
 
namespace grail
{
    class IEntityChangeObserver
    {
    public:
        IEntityChangeObserver() = default;
        IEntityChangeObserver(const IEntityChangeObserver&) = delete;
        IEntityChangeObserver(IEntityChangeObserver&&) = delete;
        IEntityChangeObserver& operator=(const IEntityChangeObserver&) = delete;
        IEntityChangeObserver& operator=(IEntityChangeObserver&&) = delete;
        virtual ~IEntityChangeObserver() = default;
 
        virtual void OnEntityAdded(const AIManager& manager, AIEntity& entity) = 0;
        virtual void OnEntityRemoved(const AIManager& manager, size_t entityId) = 0;
    };
 
    class AIManager final
    {
    public:
        AIManager(std::size_t threadsNumber = 0);
        ~AIManager();
 
        void UpdateReasoners();
 
        void UpdateEntities(float deltaTime);
 
        void RegisterAIEntity(const std::shared_ptr<AIEntity>& entity, int priority);
 
        void RegisterAIEntity(const std::shared_ptr<AIEntity>& entity,
                              const std::shared_ptr<AIEntity>& parent,
                              int priorityOffset = 1);
 
        void RemoveAIEntity(const AIEntity* entity);
 
        void RegisterEntityGroup(const std::shared_ptr<EntityGroup>& entityGroup, int priority);
        void RemoveEntityGroup(const std::shared_ptr<EntityGroup>& entityGroup);
 
        bool ContainsEntity(const AIEntity& entity) const;
 
        Blackboard& CreateBlackboard(const std::string& name);
 
        void SubscribeToBlackboard(const std::string& blackboardName, AIEntity& entity);
 
        void UnsubscribeFromBlackboard(const std::string& blackboardName, AIEntity& entity);
 
        void RegisterEntityChangeObserver(IEntityChangeObserver* observer);
        void RemoveEntityChangeObserver(IEntityChangeObserver* observer);
 
        const std::vector<std::pair<std::shared_ptr<AIEntity>, int>>& GetEntities() const;
        const std::vector<std::shared_ptr<EntityGroup>>& GetEntityGroups() const;
        const std::map<std::string, std::shared_ptr<Blackboard>>& GetSharedBlackboards() const;
 
    private:
        void RequestProcessingEntities();
        void ThreadUpdate(std::size_t id);
        void SortEntities();
        void RemoveEntities();
        void RegisterEntity(const std::shared_ptr<AIEntity>& entity, int priority);
        std::shared_ptr<EntityGroup>& RegisterEntityGroup(const std::string& groupName,
                                                          int groupPriority,
                                                          const std::vector<std::pair<std::shared_ptr<AIEntity>, int>>&
                                                          entityPriorityPairs,
                                                          const std::map<std::string, std::shared_ptr<Blackboard>>&
                                                          nameBlackboardPairs);
 
        std::vector<std::pair<std::shared_ptr<AIEntity>, int>> entities{};
        std::set<const AIEntity*> entitiesToRemove{};
        std::map<std::string, std::shared_ptr<Blackboard>> sharedBlackboards{};
 
        SynchronizedEntityContainer processedEntities{};
        std::atomic<bool> shouldTerminateWorkers = {0};
 
        std::vector<std::thread> threads{};
        std::mutex blackboardMutex{};
        std::mutex entityRemovalMutex{};
 
        size_t nextEntityId = 0;
        size_t nextEntityGroupId = 0;
        std::vector<std::shared_ptr<EntityGroup>> entityGroups{};
        std::vector<IEntityChangeObserver*> entityChangeObservers{};
        std::shared_ptr<EntityGroup> ungroupedEntities;
    };
}
#endif  //GRAIL_AI_MANAGER_H