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