UtilityReasoner.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_UTILITY_REASONER_H
#define GRAIL_UTILITY_REASONER_H
 
#include "../Selectors/SelectionOption.hh"
#include "../Selectors/SelectionResult.hh"
#include "../../GrailCore/Reasoner.hh"
#include "../../GrailCore/EntityBlackboardPair.hh"
#include "../../GrailData/DebugInfo/UtilityReasonerSnapshot.h"
#include "../Selectors/BlueprintOption.hh"
 
#include <functional>
#include <mutex>
#include <stack>
 
namespace grail
{
namespace utility
{
    class UtilityReasoner : public Reasoner
    {
    public:
        UtilityReasoner(std::vector<BlueprintOption<Behavior, EntityBlackboardPair, grail::AIEntity>> blueprintOptions,
            float persistence = 0.1f);
        UtilityReasoner(const UtilityReasoner& other) = delete;
        UtilityReasoner(UtilityReasoner&& other) = delete;
 
        virtual ~UtilityReasoner() override = default;
 
        UtilityReasoner& operator =(const UtilityReasoner& other) = delete;
        UtilityReasoner& operator =(UtilityReasoner&& other) = delete;
 
        virtual void StageBehavior(AIEntity& entity) override;
 
        virtual std::unique_ptr<ISnapshotGenerator> CreateSnapshotGenerator(size_t entityId) override;
 
        data::UtilityReasonerSnapshot GetUtilityReasonerSnapshot() const;
 
        void SetSnapshotProduction(bool isEnabled);
        
    protected:
        virtual void GetBestOption(const std::vector<SelectionOption<EntityBlackboardPair>>& options,
                           SelectionResult& result,
                           std::function<bool(const std::size_t&)> validator) = 0;
        
        virtual void ClearCache() override;
        
    private:
        void AssignBehaviorInstance(AIEntity& entity,
                                    std::unique_ptr<Behavior> instance,
                                    utility::SelectionOption<EntityBlackboardPair>&& option);
        std::vector<std::unique_ptr<Behavior>> GenerateContextsAndInstances(const AIEntity& entity);
        void ValidateOperationStack(const AIEntity& entity);
        void SelectBehaviorFromStack(AIEntity& entity);
 
        std::vector<BlueprintOption<Behavior, EntityBlackboardPair, grail::AIEntity>> blueprintOptions = {};
        std::stack<std::pair<std::unique_ptr<Behavior>, utility::SelectionOption<EntityBlackboardPair>>> operationStack
            {};
        std::vector<utility::SelectionOption<EntityBlackboardPair>> generatedOptions{};
        utility::SelectionOption<EntityBlackboardPair> currentBehaviorOption{{}, nullptr, "", "", 0};
        utility::SelectionOption<EntityBlackboardPair> previousBehaviorOption{{}, nullptr, "", "", 0};
 
        float persistence = 0.0f;
 
        bool produceSnapshot = false;
        data::UtilityReasonerSnapshot cachedSnapshot{};
        mutable std::mutex snapshotMutex;
    };
}
}
 
#endif  //GRAIL_UTILITY_REASONER_H