SimulatedGameNode.h

#ifndef GRAIL_SIMULATED_GAME_NODE_H
#define GRAIL_SIMULATED_GAME_NODE_H
 
#include <memory>
#include <random>
#include <unordered_map>
#include <vector>
#include "ISimulatedGameAction.hh"
#include "SimulatedGameActionMetadata.hh"
 
using RandomGenerator = std::mt19937_64;
 
namespace grail
{
    namespace simulation
    {
        class SimulatedGameThinkingUnit;
        class ISimulatedGameUnit;
        class SimulatedGameSnapshotObserver;
        struct SimulatedGameHelper;
 
        class SimulatedGameNode
        {
        public:
            SimulatedGameNode(ISimulatedGameUnit*, SimulatedGameRuntime& runtime);
            SimulatedGameNode(SimulatedGameNode&&) = default;
 
            void Backpropagate(float score);
 
            const ISimulatedGameAction* GetRandomAction(RandomGenerator& rand_gen);
            void PerformActionByIndex(size_t actionIndex, SimulatedGameRuntime& runtime);
 
            ISimulatedGameUnit* GetActiveUnit() const;
 
            SimulatedGameNode* SelectNext(SimulatedGameHelper& helper, RandomGenerator& rand_gen);
            SimulatedGameNode* SelectNext(SimulatedGameHelper& helper,
                                          RandomGenerator& rand_gen,
                                          SimulatedGameSnapshotObserver& observer);
            SimulatedGameNode* PerformUCT(SimulatedGameHelper& helper, RandomGenerator& rand_gen);
 
            std::vector<SimulatedGameActionMetadata> GetActionsWithMetadata() const;
            void FillPlan(std::unordered_map<const ISimulatedGameUnit*, std::vector<const ISimulatedGameAction*>>& plan,
                          int teamIndex) const;
            void FillPlanWithMetadata(
                std::unordered_map<const ISimulatedGameUnit*, std::vector<SimulatedGameActionMetadata>>& plan,
                int teamIndex) const;
            void FillPath(std::vector<std::pair<const ISimulatedGameUnit*, const ISimulatedGameAction*>>& path) const;
 
            const ISimulatedGameAction* GetBestAction() const;
            const SimulatedGameActionMetadata GetBestActionMetadata() const;
            const ISimulatedGameAction& GetActionByIndex(size_t actionIndex) const;
            double GetVisits() const;
 
            std::vector<std::unique_ptr<SimulatedGameNode>> children{};
 
            bool IsTerminal() const;
        private:
            size_t GetBestActionIndex() const;
 
            ISimulatedGameUnit* activeUnit = nullptr;
            double totalScore = 0.0;
            double q = 0.0;
            std::vector<std::unique_ptr<const ISimulatedGameAction>> actions{};
            std::vector<float> terminalScores{};
 
            double visits = 0.0;
 
            friend class SimulatedGame;
        };
    }
}
#endif //GRAIL_SIMULATED_GAME_NODE_H