SimulatedGame.hh

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