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>& 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);
 
 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;
 
 //TODO: nodiscard in C++17
 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{};
 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