Consideration.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_CONSIDERATION_H
#define GRAIL_CONSIDERATION_H
 
#include "Evaluator.hh"
#include "../GrailCore/AIEntity.hh"
#include "../GrailCore/Blackboard.hh"
#include "../GrailCore/EntityBlackboardPair.hh"
 
namespace grail
{
namespace evaluator
{
    template <typename ContextType>
    class Consideration : public Evaluator<ContextType>
    {
        template <typename FunctionContextType>
        friend void CacheConsiderationEvaluations(std::shared_ptr<Evaluator<FunctionContextType>> evaluator, FunctionContextType context);
    public:
        Consideration() = default;
 
        Consideration(const Consideration<ContextType>&) = default;
        Consideration(Consideration<ContextType>&&) = default;
 
        virtual ~Consideration() = default;
 
        Consideration& operator =(const Consideration<ContextType>&) = default;
        Consideration& operator =(Consideration<ContextType>&&) = default;
 
        virtual data::EvaluatorType GetEvaluatorType() const override final { return data::EvaluatorType::CONSIDERATION; }
 
        virtual std::string GetDisplayName() const { return "unnamed_consideration"; }
        
        virtual void GetDependentConsiderations(std::vector<Consideration<ContextType>*>& considerations) override
        {
            if(std::find(considerations.begin(), considerations.end(), this) == considerations.end())
            {
                considerations.push_back(this);
            }
        }
 
    protected:
        virtual float Evaluate(const ContextType& context) const = 0;
 
        virtual void DebugDump(const std::map<const void*, unsigned int>&,
                               data::EvaluationDebugData& debugData) const override final
        {
            debugData.SetMetadata(GetDisplayName());
        }
 
        virtual float
        Evaluate(const ContextType& context, data::UtilityEvaluatorSnapshot* const snapshot) const override final
        {
            return value;
        }
        
    private:
        void CacheEvaluation(const ContextType& context)
        {
            value = Evaluate(context);
        }
        
        float value{};
    };
 
    using DefaultConsideration = Consideration<const AIEntity*>;
    using UtilityConsideration = Consideration<EntityBlackboardPair>;
    
    template <typename ContextType>
    void CacheConsiderationEvaluations(std::shared_ptr<Evaluator<ContextType>> evaluator, ContextType context)
    {
        std::vector<Consideration<ContextType>*> considerations{};
        evaluator->GetDependentConsiderations(considerations);
        for(auto& consideration : considerations)
        {
            consideration->CacheEvaluation(context);
        }
    }
}
}
#endif  //GRAIL_CONSIDERATION_H