PlannerReasoner.hh

#ifndef GRAIL_PLANNER_REASONER_H
#define GRAIL_PLANNER_REASONER_H
 
#include "../GrailSystem/Reasoner.hh"
#include "../GrailSystem/Behavior.hh"
#include "../GrailSystem/Plan.hh"
#include "../GrailData/GrailDebugInfo/PlannerSnapshots.h"
#include "GoalSelector.hh"
 
#include <functional>
 
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(MemoryPool& memory);
        PlannerReasoner(MemoryPool& memory,
            std::shared_ptr<planning::GoalSelector> goalSelector,
            std::unique_ptr<planning::DomainTranslator> actionTranslator,
            const Config& config);
        void SelectBehavior(AIEntity& entity) override;
        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);
        const planning::Goal* GetCurrentGoal() const override;
 
        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
        void SetSnapshotProduction(bool shouldProduce);
        bool IsComputing() const;
 
        PlannerReasonerSnapshot ProduceDebugSnapshot();
        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);
 
        planning::Planner planner;
        std::shared_ptr<planning::GoalSelector> goalSelector;
        std::unique_ptr<planning::DomainTranslator> domainTranslator;
 
        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
        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