SimulatedGameSnapshotObserver.h

#ifndef GRAIL_SIMULATED_GAME_SNAPSHOT_OBSERVER_H
#define GRAIL_SIMULATED_GAME_SNAPSHOT_OBSERVER_H
 
#include <limits>
#include <memory>
#include <unordered_map>
#include <vector>
#include "SimulatedGameActionMetadata.hh"
#include "../GrailData/DebugInfo/SimulatedGamesSnapshots.h"
 
namespace grail
{
    namespace simulation
    {
        class SimulatedGameThinkingUnit;
        class SimulatedGameStochasticUnit;
        class ISimulatedGameAction;
        class ISimulatedGameUnit;
        class SimulatedGameNode;
 
        class SimulatedGameSnapshotObserver
        {
        public:
            SimulatedGameReasonerSnapshot& GetSnapshot();
 
            bool IsInitialized() const;
 
            void OnGameStart(const std::vector<std::shared_ptr<SimulatedGameThinkingUnit>>& thinkingUnits,
                             const std::vector<std::shared_ptr<SimulatedGameStochasticUnit>>& stochasticUnits);
            void OnIterationStart(size_t iterationNumber);
            void OnUCTAction(const ISimulatedGameAction& chosenAction, const SimulatedGameNode& node);
            void OnMonteCarloAction(const ISimulatedGameAction& chosenAction, const ISimulatedGameUnit& activeUnit);
            void OnIterationEnd(const std::vector<float>& scores);
 
            void SetMinIteration(size_t iteration);
 
            size_t GetMinIteration() const;
 
            void SetMaxIteration(size_t iteration);
 
            size_t GetMaxIteration() const;
 
        private:
            int GetUnitUID(const ISimulatedGameUnit* unit);
 
            SimulatedGameReasonerSnapshot gameSnapshot;
            SimulatedGameIterationSnapshot currentIteration;
            std::unordered_map<const ISimulatedGameUnit*, int> idMap = {};
            bool isInitialized = false;
            size_t minIteration = 0;
            size_t maxIteration = std::numeric_limits<size_t>::max();
            unsigned long globalIterationIndex = 0;
        };
    }
}
#endif //GRAIL_SIMULATED_GAME_SNAPSHOT_OBSERVER_H