SimulatedGame.hh

#ifndef GRAIL_SIMULATED_GAME_H
#define GRAIL_SIMULATED_GAME_H
 
#include "ISimulatedGameUnit.hh"
#include "SimulatedGameActionMetadata.hh"
#include "SimulatedGameHelper.h"
#include "SimulatedGameNode.h"
#include "SimulatedGameSnapshotObserver.h"
 
#include <limits>
#include <memory>
#include <unordered_map>
#include <vector>
 
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