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> newReasoner);
 
        const Behavior* GetCurrentBehavior() const;
 
        Behavior* GetCurrentBehavior();
 
        std::unique_ptr<Behavior> GetUniqueCurrentBehavior();
 
        std::unique_ptr<Behavior> MoveSuspendedBehavior();
 
        std::unique_ptr<Reasoner>& GetCurrentReasoner();
 
        void StageBehavior(std::unique_ptr<Behavior> behavior);
        
        bool HasStagedBehavior() const;
 
        bool HasActiveBehavior() const;
 
        void AddSharedBlackboard(const std::string& name, std::shared_ptr<Blackboard>& sharedBlackboard);
 
        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 
        //REVIEW: resolve todo
        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> reasoner;
        std::map<std::string, std::shared_ptr<Blackboard>> sharedBlackboards{};
 
    private:
        void SelectBehavior();
        void ExecuteBehavior(float deltaTime);
        void SuspendPreviousBehavior();
        void SetupNextBehavior(std::unique_ptr<Behavior> behavior);
 
        void ChangeStatus(Status newStatus);
        bool ChangeStatusNonBlocking(Status newStatus);
 
        Status GetStatus();
        Status GetStatusNonBlocking();
 
        std::unique_ptr<Behavior> stagedBehavior = nullptr;
        std::unique_ptr<Behavior> currentBehavior = nullptr;
        std::unique_ptr<Behavior> suspendedBehavior = nullptr;
        Blackboard blackboard{};
        std::mutex entityMutex{};
        std::mutex statusMutex{};
        mutable std::mutex behaviorMutex{};
        mutable std::mutex stagingMutex{};
        std::vector<IReasonerChangeObserver*> reasonerChangeObservers{};
 
        Status status = Status::FREE;
        size_t id;
        std::string name;
    };
}
#endif  //GRAIL_AI_ENTITY_H