AIManager.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_AI_MANAGER_H
#define GRAIL_AI_MANAGER_H
 
#include "AIEntity.hh"
#include "EntityGroup.h"
#include "SynchronizedEntityContainer.h"
#include <map>
#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 RemoveAIEntity(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 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:
        EntityToken WaitForAcquiringEntity(AIEntity& entity) const;
        void RequestProcessingEntities();
        void ThreadUpdate(std::size_t id);
        void SortEntities();
        void RemoveEntities();
        void RegisterEntity(const std::shared_ptr<AIEntity>& entity, int priority);
 
        std::vector<std::pair<std::shared_ptr<AIEntity>, int>> entities{};
        std::map<std::string, std::shared_ptr<Blackboard>> sharedBlackboards{};
 
        SynchronizedEntityContainer processedEntities{};
        std::atomic<bool> shouldTerminateWorkers = {0};
 
        std::vector<std::thread> threads{};
        std::mutex blackboardMutex{};
        mutable std::mutex entitiesMutex{};
        
        std::vector<std::shared_ptr<EntityGroup>> entityGroups{};
        std::vector<IEntityChangeObserver*> entityChangeObservers{};
 
        std::thread::id mainThreadId{};
    };
}
#endif  //GRAIL_AI_MANAGER_H