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