UtilityReasoner.hh

#ifndef GRAIL_UTILITY_REASONER_H
#define GRAIL_UTILITY_REASONER_H
 
#include "../../GrailCore/Reasoner.hh"
#include "../../GrailEvaluators/Evaluator.hh"
#include "../Selector.hh"
#include "../../GrailData/DebugInfo/UtilityReasonerSnapshot.h"
#include "../../GrailData/UtilityModel/UtilitySelectorModel.h"
 
#include <functional>
#include <stack>
#include <tuple>
#include <map>
#include <mutex>
 
 
namespace grail
{
    struct BlueprintOption
    {
        std::shared_ptr<utility::Evaluator<utility::EntityBlackboardPair>> evaluator;
        utility::Blueprint<Behavior> behaviorBlueprint;
        int rank;
 
        BlueprintOption(const std::shared_ptr<utility::Evaluator<utility::EntityBlackboardPair>>& evaluator,
            utility::Blueprint<Behavior>&& behaviorBlueprint, int rank);
        BlueprintOption(const std::shared_ptr<utility::Evaluator<utility::EntityBlackboardPair>>& evaluator,
            const utility::Blueprint<Behavior>& behaviorBlueprint, int rank);
    };
 
    class UtilityReasoner : public Reasoner
    {
    public:
        UtilityReasoner(std::vector<BlueprintOption>&& blueprintOptions,
                        SelectionMethod selectionMethod = SelectionMethod::MAX,
                        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;
 
        void SelectBehavior(AIEntity& entity) override;
 
        std::unique_ptr<ISnapshotGenerator> CreateSnapshotGenerator(size_t entityId) override;
        UtilityReasonerSnapshot GetUtilityReasonerSnapshot() const;
        void SetSnapshotProduction(bool isEnabled);
 
    private:
        void AssignBehaviorInstance(AIEntity& entity, std::unique_ptr<Behavior> instance, utility::Option<utility::EntityBlackboardPair>&& option);
        std::vector<std::unique_ptr<Behavior>> GenerateContextsAndInstances(const AIEntity& entity);
        void ValidateOperationStack(const AIEntity& entity);
        void SelectBehaviorFromStack(AIEntity& entity);
 
        std::vector<BlueprintOption> blueprintOptions = {};
        std::stack<std::pair<std::unique_ptr<Behavior>, utility::Option<utility::EntityBlackboardPair>>> operationStack{};
        std::vector<utility::Option<utility::EntityBlackboardPair>> generatedOptions{};
        utility::Option<utility::EntityBlackboardPair> currentBehaviorOption{{}, nullptr, "", "", 0};
 
        SelectionMethod selectionMethod = SelectionMethod::MAX;
 
        float persistence = 0.0f;
 
        bool produceSnapshot = false;
        UtilityReasonerSnapshot cachedSnapshot{};
        mutable std::mutex snapshotMutex;
    };
}
#endif  //GRAIL_UTILITY_REASONER_H