UtilityReasoner.hh

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