SimulatedGameReasoner.hh

#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
{
    struct SimulatedGameReasonerSnapshot;
 
    namespace simulation
    {
        class SimulatedGameSnapshotObserver;
    }
 
    class SimulatedGameReasoner final : public Reasoner
    {
    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);
        virtual ~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;
 
        virtual std::unique_ptr<ISnapshotGenerator> CreateSnapshotGenerator(size_t) override;
 
        SimulatedGameReasonerSnapshot ProduceDebugSnapshot();
    private:
        void ResetGame();
 
        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{};
 
        const std::size_t minIterationsPerRun = 2;
 
        std::shared_ptr<simulation::ISimulatedGameUnit> pairedAbstractUnit{};
        std::unique_ptr<simulation::SimulatedGameSnapshotObserver> snapshotObserver{};
        bool isGameDataReady = false;
        bool isComputing = false;
        bool isRecalculating = false;
    };
}
#endif // GRAIL_SIMULATED_GAME_REASONER_H