AIEntity.hh

#ifndef GRAIL_AI_ENTITY_H
#define GRAIL_AI_ENTITY_H
 
#include "Behavior.hh"
#include "Blackboard.hh"
 
#include <vector>
#include <string>
#include <random>
#include <memory>
#include <atomic>
#include <mutex>
#include <map>
 
namespace grail
{
 enum class Status
 {
 FREE = 0,
 RUNNING,
 DONE,
 };
 
 class AIEntity;
 class Reasoner;
 class IReasonerChangeObserver
 {
 public:
 virtual ~IReasonerChangeObserver() = default;
 virtual void OnReasonerSet(AIEntity& entity, Reasoner* newReasoner) = 0;
 };
 
 class AIManager;
 
 class AIEntity
 {
 friend class AIManager;
 friend class SynchronizedEntityContainer;
 
 public:
 AIEntity(const std::string& name = "");
 AIEntity(const AIEntity&) = delete;
 AIEntity(AIEntity&&) = delete;
 
 virtual ~AIEntity();
 
 AIEntity& operator = (const AIEntity&) = delete;
 AIEntity& operator = (AIEntity&&) = delete;
 
 void SetReasoner(std::unique_ptr<Reasoner> reasoner);
 
 const Behavior* GetCurrentBehavior() const;
 
 Behavior* GetCurrentBehavior();
 
 std::unique_ptr<Behavior> GetUniqueCurrentBehavior();
 
 Behavior* GetPreviousBehavior();
 
 std::unique_ptr<Reasoner>& GetCurrentReasoner();
 
 void SetNewBehavior(std::unique_ptr<Behavior> behavior);
 
 bool HasActiveBehavior() const;
 
 void AddSharedBlackboard(const std::string& name, std::shared_ptr<Blackboard>& sharedBlackboard);
 
 const std::shared_ptr<Blackboard> GetSharedBlackboard(const std::string& name) const;
 
 Blackboard& GetBlackboard();
 
 const Blackboard& GetBlackboard() const;
 
 //TODO: after UE4 plugin is ready, verify if these methods' arguments can be changed to shared_ptr 
 void AddReasonerChangeObserver(IReasonerChangeObserver* observer);
 void RemoveReasonerChangeObserver(IReasonerChangeObserver* observer);
 void SetId(size_t id);
 size_t GetId() const;
 const std::string& GetName() const;
 std::string GetCurrentBehaviorName() const;
 
 protected:
 virtual void Update(float deltaTime);
 
 std::unique_ptr<Reasoner> playingModel;
 std::map<std::string, std::shared_ptr<Blackboard>> sharedBlackboards{};
 
 private:
 void SelectBehavior();
 void ExecuteBehavior(float deltaTime);
 void FinishPreviousBehavior();
 void SetupNextBehavior(std::unique_ptr<Behavior> behavior);
 
 void ChangeStatus(Status newStatus);
 bool ChangeStatusNonBlocking(Status newStatus);
 
 Status GetStatus();
 Status GetStatusNonBlocking();
 
 std::unique_ptr<Behavior> currentBehavior = nullptr;
 Behavior* previousBehavior = nullptr;
 std::atomic<bool> wasPreviousBehaviorCaptured{false};
 Blackboard blackboard{};
 std::mutex entityMutex{};
 std::mutex statusMutex{};
 mutable std::mutex behaviorMutex{};
 std::vector<IReasonerChangeObserver*> reasonerChangeObservers{};
 
 Status status = Status::FREE;
 size_t id;
 std::string name;
 };
}
#endif //GRAIL_AI_ENTITY_H