SimulatedGamesSnapshots.h

// Copyright QED Software 2023.
 
#ifndef GRAIL_SIMULATED_GAMES_SNAPSHOTS_H
#define GRAIL_SIMULATED_GAMES_SNAPSHOTS_H
 
#include "Flatbuffers/SimulatedGameUnitSnapshot_generated.h"
#include "Flatbuffers/SimulatedGameActionMetadataSnapshot_generated.h"
#include "Flatbuffers/SimulatedGameMonteCarloEventSnapshot_generated.h"
#include "Flatbuffers/SimulatedGameUCTEventSnapshot_generated.h"
#include "Flatbuffers/SimulatedGameIterationSnapshot_generated.h"
#include "Flatbuffers/SimulatedGameReasonerSnapshot_generated.h"
 
#include <map>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace grail
{
 namespace simgames
 {
 class ISimulatedGameUnit;
 }
 
namespace data
{
 struct SimulatedGameUnitSnapshot
 {
 int teamIndex = 0;
 
 int orderID = 0;
 
 std::string description = "";
 
 std::map<std::string, std::string> state = {};
 
 SimulatedGameUnitSnapshot(const simgames::ISimulatedGameUnit& unit, int orderID);
 SimulatedGameUnitSnapshot() = default;
 };
 
 flatbuffers::Offset<generated::SimulatedGameUnitSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const SimulatedGameUnitSnapshot& snapshot);
 SimulatedGameUnitSnapshot Unpack(const generated::SimulatedGameUnitSnapshot& snapshot);
 
 struct SimulatedGameActionMetadataSnapshot
 {
 double score = 0;
 
 int visits = 0;
 
 std::string actionDescription = "";
 
 SimulatedGameActionMetadataSnapshot(double score, int visits, const std::string& description);
 SimulatedGameActionMetadataSnapshot() = default;
 };
 
 flatbuffers::Offset<generated::SimulatedGameActionMetadataSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const SimulatedGameActionMetadataSnapshot& snapshot);
 SimulatedGameActionMetadataSnapshot Unpack(const generated::SimulatedGameActionMetadataSnapshot& snapshot);
 
 struct SimulatedGameMonteCarloEventSnapshot
 {
 std::string chosenActionDescription = {};
 
 std::vector<SimulatedGameUnitSnapshot> unitSnapshots = {};
 int activeUnitUID = 0;
 
 SimulatedGameMonteCarloEventSnapshot() = default;
 SimulatedGameMonteCarloEventSnapshot(const SimulatedGameMonteCarloEventSnapshot& other) = default;
 };
 
 flatbuffers::Offset<generated::SimulatedGameMonteCarloEventSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const SimulatedGameMonteCarloEventSnapshot& snapshot);
 SimulatedGameMonteCarloEventSnapshot Unpack(const generated::SimulatedGameMonteCarloEventSnapshot& snapshot);
 
 struct SimulatedGameUCTEventSnapshot : public SimulatedGameMonteCarloEventSnapshot
 {
 std::vector<SimulatedGameActionMetadataSnapshot> actionMetadataSnapshots = {};
 SimulatedGameUCTEventSnapshot() = default;
 SimulatedGameUCTEventSnapshot(const SimulatedGameMonteCarloEventSnapshot& monteCarloEvent);
 };
 
 flatbuffers::Offset<generated::SimulatedGameUCTEventSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const SimulatedGameUCTEventSnapshot& snapshot);
 SimulatedGameUCTEventSnapshot Unpack(const generated::SimulatedGameUCTEventSnapshot& snapshot);
 
 struct SimulatedGameIterationSnapshot
 {
 size_t number = 0;
 
 std::vector<SimulatedGameUCTEventSnapshot> uctSnapshots = {};
 
 std::vector<SimulatedGameMonteCarloEventSnapshot> monteCarloSnapshots = {};
 
 std::vector<float> scores = {};
 
 void Clear();
 };
 
 flatbuffers::Offset<generated::SimulatedGameIterationSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const SimulatedGameIterationSnapshot& snapshot);
 SimulatedGameIterationSnapshot Unpack(const generated::SimulatedGameIterationSnapshot& snapshot);
 
 struct SimulatedGameReasonerSnapshot
 {
 std::vector<SimulatedGameUnitSnapshot> unitSnapshots = {};
 
 std::vector<SimulatedGameIterationSnapshot> iterationSnapshots = {};
 
 float absoluteTime = 0;
 float relativeTime = 0;
 size_t entityId = 0;
 };
 
 flatbuffers::Offset<generated::SimulatedGameReasonerSnapshot> Pack(flatbuffers::FlatBufferBuilder& builder,
 const SimulatedGameReasonerSnapshot& snapshot);
 SimulatedGameReasonerSnapshot Unpack(const generated::SimulatedGameReasonerSnapshot& snapshot);
}
}
 
#endif //GRAIL_SIMULATED_GAMES_SNAPSHOTS_H