PlannerReasoner.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_PLANNER_REASONER_H
#define GRAIL_PLANNER_REASONER_H
 
#include "../GoalSelector.hh"
#include "../../GrailCore/Behavior.hh"
#include "../../GrailCore/Plan.hh"
#include "../../GrailCore/Reasoner.hh"
#include "../../GrailData/DebugInfo/PlannerSnapshots.h"
 
namespace grail
{
namespace planner
{
    using PlannerCallback = std::function<void(const Plan&, const planner::Goal&)>;
    class DomainTranslator;
 
    class PlannerReasoner final : public grail::Reasoner, public planner::IGoalAcceptor
    {
    public:
        struct Config
        {
            Config() noexcept
            {
            }
 
            std::size_t maxIterations = 1000;
 
            int maxPlanLength = -1;
 
            std::size_t iterationsPerFrame = 10;
 
            double maxPlanCost = -1;
 
            bool usePartialPlans = true;
        };
 
        PlannerReasoner(std::unique_ptr<MemoryPool> memory);
 
 
        PlannerReasoner(std::unique_ptr<MemoryPool> memory,
                        std::shared_ptr<planner::GoalSelector> goalSelector,
                        std::unique_ptr<planner::DomainTranslator> domainTranslator,
                        const Config& config);
        virtual void StageBehavior(AIEntity& entity) override;
        virtual void SetNewGoal(std::unique_ptr<planner::Goal> newGoal, AIEntity& entity) override;
 
        void SetupNewPlanner(std::unique_ptr<planner::DomainTranslator> domainTranslator, const Config& config);
 
        void SetFallbackBehavior(std::unique_ptr<Behavior> behavior);
 
        virtual const planner::Goal* GetCurrentGoal() const override;
        
        void BindPlanningSucceededCallback(PlannerCallback callback);
 
        void BindPartialPlanFoundCallback(PlannerCallback callback);
 
        void BindPlanningFailedCallback(std::function<void(const planner::Goal&)> callback);
 
        void BindPlanExecutedCallback(std::function<void()> callback);
 
        void SetSnapshotProduction(bool shouldProduce);
 
        bool IsComputing() const;
 
        data::PlannerReasonerSnapshot ProduceDebugSnapshot();
        virtual std::unique_ptr<ISnapshotGenerator> CreateSnapshotGenerator(std::size_t) override;
 
        void ClearCurrentDebugSnapshot();
 
        void SetDebugSnapshotFirstIteration(std::size_t iterationNumber);
 
        void SetDebugSnapshotLastIteration(std::size_t iterationNumber);
 
        std::size_t GetDebugSnapshotFirstIteration() const;
 
        std::size_t GetDebugSnapshotLastIteration() const;
        
    protected:
        virtual void ClearCache() override;
    
    private:
        void Reset(AIEntity& entity, const class planner::Goal& goal);
        void DevisePlan(AIEntity& entity);
 
        planner::Planner planner;
        std::shared_ptr<planner::GoalSelector> goalSelector;
        std::unique_ptr<planner::DomainTranslator> domainTranslator;
        std::unique_ptr<MemoryPool> memory;
 
        Plan currentPlan;
        std::size_t iterationsPerFrame = 0;
        bool usePartialPlans = false;
 
        std::unique_ptr<planner::Goal> chosenGoal = nullptr;
        std::unique_ptr<Behavior> fallbackBehavior = nullptr;
 
        PlannerCallback onPlanningSucceeded;
        PlannerCallback onPartialPlanFound;
        std::function<void(const planner::Goal&)> onPlanningFailed;
        std::function<void()> onPlanExecuted;
 
        bool produceSnapshot = false;
        data::PlannerReasonerSnapshot snapshot;
 
        std::size_t debugSnapshotFirstIteration = 0;
        std::size_t debugSnapshotLastIteration = std::numeric_limits<std::size_t>::max();
    };
}
}
 
#endif  //GRAIL_PLANNER_REASONER_H