SimulatedGame.hh

#ifndef GRAIL_SIMULATED_GAME_H
#define GRAIL_SIMULATED_GAME_H
 
#include "SimulatedGameActionMetadata.hh"
#include "SimulatedGameSnapshotObserver.h"
#include "ISimulatedGameUnit.hh"
#include "SimulatedGameHelper.h"
#include "SimulatedGameNode.h"
 
 
#include <unordered_map>
#include <memory>
#include <vector>
#include <limits>
 
namespace grail
{
    namespace simulation
    {
        class SimulatedGameThinkingUnit;
        class SimulatedGameStochasticUnit;
        class ISimulatedGameAction;
        class SimulatedGameNode;
    
        class SimulatedGame
        {
        public:
            SimulatedGame(int teamCount = 2, double maxScore = 1.0, double explorationBoost = 1.0, size_t freezeVisitsTreshold = std::numeric_limits<size_t>::max(), RandomGenerator::result_type seed = std::random_device{}());
 
            virtual ~SimulatedGame();
 
            SimulatedGameThinkingUnit& AddUnit(std::shared_ptr<SimulatedGameThinkingUnit> unit);
 
            void AddUnits(std::vector<std::shared_ptr<SimulatedGameThinkingUnit>> units);
 
            SimulatedGameStochasticUnit& AddUnit(std::shared_ptr<SimulatedGameStochasticUnit> unit);
 
            void RemoveUnit(const SimulatedGameThinkingUnit* unit);
 
            void RemoveUnit(const SimulatedGameStochasticUnit* unit);
 
            const ISimulatedGameAction* GetStartingUnitBestAction() const;
 
            const SimulatedGameActionMetadata GetStartingUnitBestActionMetadata() const;
 
            std::vector<std::pair<const ISimulatedGameUnit*, const ISimulatedGameAction*>> GetExpectedPlayout() const;
 
            std::vector<SimulatedGameActionMetadata> GetStartingUnitActionsWithMetadata() const;
            
            std::unordered_map<const ISimulatedGameUnit*, std::vector<const ISimulatedGameAction*>> GetExpectedPlans();
 
            std::unordered_map<const ISimulatedGameUnit*, std::vector<SimulatedGameActionMetadata>> GetExpectedPlansWithMetadata();
 
            virtual size_t Run(size_t milisecondsTotal, size_t maxIterationCount, SimulatedGameSnapshotObserver* observer = nullptr);
 
            void DebugPrintPlan(std::unordered_map<const ISimulatedGameUnit*, std::vector<const ISimulatedGameAction*>>& plan) const;
            void DebugPrintPlanWithMetadata(std::unordered_map<const ISimulatedGameUnit*, std::vector<SimulatedGameActionMetadata>>& plan) const;
            void DebugPrintFullPlayout(std::vector<std::pair<const ISimulatedGameUnit*, const ISimulatedGameAction*>>& playout) const;
            
            void SetStartingUnit(SimulatedGameThinkingUnit& unit);
                        
            void ClearStatistics();
 
        private:
            void Iteration();
            void IterationWithDebug(SimulatedGameSnapshotObserver& observer);
 
            void Reset();
            void CreateRoot();
 
            std::vector<std::shared_ptr<SimulatedGameThinkingUnit>> thinkingUnits{};
            std::vector<std::shared_ptr<SimulatedGameStochasticUnit>> stochasticUnits{};
 
            RandomGenerator rand_gen{};
            std::unique_ptr<SimulatedGameNode> rootNode{};
            SimulatedGameNode* currentNode{};
            SimulatedGameHelper mctsHelper = SimulatedGameHelper{};
            SimulatedGameThinkingUnit* startingUnit{};
        };
    }
}
#endif //GRAIL_SIMULATED_GAME_H