AIManager.hh

#ifndef GRAIL_AI_MANAGER_H
#define GRAIL_AI_MANAGER_H
 
#include "AIEntity.hh"
#include "SynchronizedEntityContainer.h"
#include "EntityGroup.h"
 
#include <set>
#include <queue>
#include <map>
#include <thread>
#include <condition_variable>
 
 
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 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