SimulatedGameReasoner.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_SIMULATED_GAME_REASONER_H
#define GRAIL_SIMULATED_GAME_REASONER_H
 
#include <memory>
 
#include "../ISimulatedActionTranslator.hh"
#include "../ISimulatedGameStateTranslator.hh"
#include "../ISimulatedGameUnit.hh"
#include "../SimulatedGame.hh"
#include "../../GrailCore/AIEntity.hh"
#include "../../GrailCore/Plan.hh"
#include "../../GrailCore/Reasoner.hh"
 
namespace grail
{
 namespace data
 {
 struct SimulatedGameReasonerSnapshot;
 }
 
namespace simgames
{
 class SimulatedGameSnapshotObserver;
 
 class SimulatedGameReasoner final : public Reasoner
 {
 public:
 SimulatedGameReasoner(std::unique_ptr<simgames::ISimulatedGameStateTranslator> worldStateTranslator,
 std::unique_ptr<simgames::ISimulatedActionTranslator> actionTranslator,
 std::size_t iterationsPerFrame,
 std::size_t maxIterations = 1000,
 std::size_t maxRecalculationIterations = 1000);
 virtual ~SimulatedGameReasoner() override;
 
 virtual void StageBehavior(AIEntity& entity) override;
 
 void SetFallbackBehavior(std::unique_ptr<Behavior> _fallbackBehavior);
 
 const simgames::SimulatedGame& getGame() const;
 
 void RequestRecalculation(AIEntity& entity);
 
 void SetSnapshotProduction(bool shouldProduce);
 
 void SetDebugSnapshotFirstIteration(size_t iterationNumber);
 
 void SetDebugSnapshotLastIteration(size_t iterationNumber);
 
 size_t GetDebugSnapshotFirstIteration() const;
 
 size_t GetDebugSnapshotLastIteration() const;
 
 bool IsComputing() const;
 
 virtual std::unique_ptr<ISnapshotGenerator> CreateSnapshotGenerator(size_t) override;
 
 data::SimulatedGameReasonerSnapshot ProduceDebugSnapshot();
 private:
 void ResetGame();
 
 std::unique_ptr<simgames::SimulatedGame> game;
 std::unique_ptr<Behavior> fallbackBehavior;
 
 std::unique_ptr<simgames::ISimulatedGameStateTranslator> worldStateTranslator;
 std::unique_ptr<simgames::ISimulatedActionTranslator> actionTranslator;
 Plan plan;
 
 std::size_t iterationsPerFrame{};
 std::size_t maxIterations{};
 std::size_t maxRecalculationIterations{};
 std::size_t maxRecalculationIterationsLeft{};
 std::size_t iterationCounter{};
 
 const std::size_t minIterationsPerRun = 2;
 
 std::shared_ptr<simgames::ISimulatedGameUnit> pairedAbstractUnit{};
 std::unique_ptr<simgames::SimulatedGameSnapshotObserver> snapshotObserver{};
 bool isGameDataReady = false;
 bool isComputing = false;
 bool isRecalculating = false;
 };
}
}
 
#endif // GRAIL_SIMULATED_GAME_REASONER_H