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;
 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;
 
 //TODO: revise this approach
 //REVIEW: resolve todo
 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