SimulatedGameReasoner.hh

#ifndef GRAIL_SIMULATED_GAME_REASONER_H
#define GRAIL_SIMULATED_GAME_REASONER_H
 
#include <memory>
 
#include "../GrailSystem/AIEntity.hh"
#include "../GrailSystem/Reasoner.hh"
#include "SimulatedGame.hh"
#include "ISimulatedGameUnit.hh"
#include "ISimulatedActionTranslator.hh"
#include "ISimulatedGameStateTranslator.hh"
#include "../GrailSystem/Plan.hh"
 
namespace grail
{
 struct SimulatedGameReasonerSnapshot;
 
 namespace simulation
 {
 class SimulatedGameObserverForGUI;
 }
 
 class SimulatedGameReasoner final : public Reasoner
 {
 private:
 std::unique_ptr<simulation::SimulatedGame> game;
 std::unique_ptr<Behavior> fallbackBehavior;
 
 std::unique_ptr<simulation::ISimulatedGameStateTranslator> worldStateTranslator;
 std::unique_ptr<simulation::ISimulatedActionTranslator> actionTranslator;
 planning::Plan plan;
 
 std::size_t iterationsPerFrame;
 std::size_t maxIterations;
 std::size_t maxRecalculationIterations;
 std::size_t maxRecalculationIterationsLeft;
 std::size_t iterationCounter = 0;
 
 const std::size_t minIterationsPerRun = 2;
 
 std::shared_ptr<simulation::ISimulatedGameUnit> pairedAbstractUnit;
 std::unique_ptr<simulation::SimulatedGameObserverForGUI> guiObserver;
 bool isGameDataReady = false;
 bool isComputing = false;
 bool isRecalculating = false;
 public:
 SimulatedGameReasoner(std::unique_ptr<simulation::ISimulatedGameStateTranslator> worldStateTranslator,
 std::unique_ptr<simulation::ISimulatedActionTranslator> actionTranslator,
 std::size_t iterationsPerFrame, std::size_t maxIterations = 1000, std::size_t maxRecalculationIterations = 1000);
 ~SimulatedGameReasoner() override;
 
 virtual void SelectBehavior(AIEntity& entity) override;
 
 void SetFallbackBehavior(std::unique_ptr<Behavior> _fallbackBehavior);
 
 const simulation::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;
 
 std::unique_ptr<ISnapshotGenerator> CreateSnapshotGenerator(size_t) override;
 
 SimulatedGameReasonerSnapshot ProduceDebugSnapshot();
 private:
 void resetGame();
 };
}
#endif // GRAIL_SIMULATED_GAME_REASONER_H