SimulatedGame.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_SIMULATED_GAME_H
#define GRAIL_SIMULATED_GAME_H
 
#include "ISimulatedGameUnit.hh"
#include "SimulatedGameActionMetadata.hh"
#include "SimulatedGameNode.hh"
#include "SimulatedGameHelper.h"
#include "SimulatedGameSnapshotObserver.h"
 
#include <limits>
#include <memory>
#include <unordered_map>
#include <vector>
 
namespace grail
{
namespace simgames
{
    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