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();
        
    protected:
        virtual void ClearCache() override;
        
    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