SimulatedGameNode.h

// Copyright QED Software 2023.
 
#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 simgames
{
    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