AIEntity.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_AI_ENTITY_H
#define GRAIL_AI_ENTITY_H
 
#include "Behavior.hh"
#include "Blackboard.hh"
#include "EntityToken.hh"
 
#include <atomic>
#include <map>
#include <memory>
#include <mutex>
#include <random>
#include <string>
#include <vector>
#include <thread>
 
namespace grail
{
    enum class ProcessingStatus
    {
        FREE = 0,
        RUNNING,
        DONE,
    };
 
    enum class RegistrationStatus
    {
        NOT_REGISTERED,
        PENDING_REMOVAL,
        REGISTERED,
    };
 
    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 GrailStateSnapshotGenerator;
        friend class EntityToken;
 
    public:
        AIEntity(const std::string& name = "");
        AIEntity(const AIEntity&) = delete;
        AIEntity(AIEntity&&) = delete;
 
        virtual ~AIEntity();
 
        AIEntity& operator =(const AIEntity&) = delete;
        AIEntity& operator =(AIEntity&&) = delete;
 
        static void ResetNextID(const size_t nextId = 0);
        
        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> TakeOwnershipOfReasoner();
        
        Reasoner* GetReasoner();
 
        void StageBehavior(std::unique_ptr<Behavior> behavior);
 
        bool HasStagedBehavior() const;
 
        bool HasActiveBehavior() const;
 
        void AddSharedBlackboard(const std::string& name, std::shared_ptr<Blackboard>& sharedBlackboard);
 
        void RemoveSharedBlackboard(const std::string& name);
 
        std::shared_ptr<Blackboard> GetSharedBlackboard(const std::string& name) const;
 
        Blackboard& GetBlackboard();
 
        const Blackboard& GetBlackboard() const;
 
        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);
 
        bool ChangeProcessingStatus(ProcessingStatus newStatus);
        ProcessingStatus GetProcessingStatus() const;
 
        bool ChangeRegistrationStatus(RegistrationStatus newStatus);
        RegistrationStatus GetRegistrationStatus() const;
 
        [[nodiscard]] EntityToken Acquire();
        bool Release();
 
        inline static size_t nextEntityId = 0;
        std::unique_ptr<Behavior> stagedBehavior = nullptr;
        std::unique_ptr<Behavior> currentBehavior = nullptr;
        std::unique_ptr<Behavior> suspendedBehavior = nullptr;
        Blackboard blackboard{};
        mutable std::thread::id threadId{};
        mutable bool isAcquired{false};
        mutable std::mutex entityUpdateMutex{};
        mutable std::mutex entityAcquireMutex{};
        mutable std::mutex behaviorMutex{};
        mutable std::mutex stagingMutex{};
        mutable std::mutex reasonerMutex{};
        float entityDeltaTime{0.f}; //Used only in AIManager. Helps with bookkeeping without additional memory and synchronization overhead.
        std::vector<IReasonerChangeObserver*> reasonerChangeObservers{};
 
        ProcessingStatus processingStatus = ProcessingStatus::FREE;
        RegistrationStatus registrationStatus = RegistrationStatus::NOT_REGISTERED;
        size_t id;
        std::string name;
    };
}
#endif  //GRAIL_AI_ENTITY_H