PlannerReasoner.hh

#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
{
    using PlannerCallback = std::function<void(const planning::Plan&, const planning::Goal&)>;
 
    namespace planning
    {
        class DomainTranslator;
    }
 
    class PlannerReasoner final : public grail::Reasoner, public planning::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<planning::GoalSelector> goalSelector,
                        std::unique_ptr<planning::DomainTranslator> domainTranslator,
                        const Config& config);
        virtual void SelectBehavior(AIEntity& entity) override;
        virtual void SetNewGoal(std::unique_ptr<planning::Goal> newGoal, AIEntity& entity) override;
 
        void SetupNewPlanner(std::unique_ptr<planning::DomainTranslator> domainTranslator, const Config& config);
 
        void SetFallbackBehavior(std::unique_ptr<Behavior> behavior);
 
        virtual const planning::Goal* GetCurrentGoal() const override;
 
        //REVIEW: method names are pretty self explanatory, but some of them could be commented, e.g., what it means that a partial plan has been found or planning failed and explain exemplar handling of them
        void BindPlanningSucceededCallback(PlannerCallback callback);
        void BindPartialPlanFoundCallback(PlannerCallback callback);
        void BindPlanningFailedCallback(std::function<void(const planning::Goal&)> callback);
        void BindPlanExecutedCallback(std::function<void()> callback);
 
        //TODO: revise this approach
        //REVIEW: resolve todo
        void SetSnapshotProduction(bool shouldProduce);
        bool IsComputing() const;
 
        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;
    private:
        void Reset(AIEntity& entity, const class planning::Goal& goal);
        void DevisePlan(AIEntity& entity);
 
        planning::Planner planner;
        std::shared_ptr<planning::GoalSelector> goalSelector;
        std::unique_ptr<planning::DomainTranslator> domainTranslator;
        std::unique_ptr<MemoryPool> memory;
 
        planning::Plan currentPlan;
        std::size_t iterationsPerFrame = 0;
        bool usePartialPlans = false;
 
        std::unique_ptr<planning::Goal> chosenGoal = nullptr;
        std::unique_ptr<Behavior> fallbackBehavior = nullptr;
 
        PlannerCallback onPlanningSucceeded;
        PlannerCallback onPartialPlanFound;
        std::function<void(const planning::Goal&)> onPlanningFailed;
        std::function<void()> onPlanExecuted;
 
        //TODO: revise this approach
        //REVIEW: resolve todo
        bool produceSnapshot = false;
        PlannerReasonerSnapshot snapshot;
 
        std::size_t debugSnapshotFirstIteration = 0;
        std::size_t debugSnapshotLastIteration = std::numeric_limits<std::size_t>::max();
    };
}
#endif  //GRAIL_PLANNER_REASONER_H