playback.hpp

Go to the documentation of this file.

#pragma once
 
#include "jaffarCommon/deserializers/contiguous.hpp"
#include "jaffarCommon/hash.hpp"
#include "jaffarCommon/serializers/contiguous.hpp"
#include "runner.hpp"
#include <algorithm>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace jaffarPlus
{
 
class Playback final
{
public:
  struct step_t
  {
    std::string inputString;
 
    jaffarPlus::InputSet::inputIndex_t inputIndex;
 
    bool isInputAllowed;
 
    void* gameStateData;
 
    void* rendererStateData;
 
    jaffarCommon::hash::hash_t stateHash;
 
    std::vector<size_t> _repeatedHashSteps;
  };
 
  Playback(Runner& runner) : _runner(&runner)
  {
    // Getting game state size
    _gameStateSize = _runner->getStateSize();
 
    // Getting renderer state size
    _rendererStateSize = _runner->getGame()->getEmulator()->getRendererStateSize();
  };
 
  void initialize(const std::vector<std::string>& inputSequence, bool storeRendererState = true)
  {
    _storeRendererState = storeRendererState;
    // For each input in the sequence, store the game's state
    for (size_t i = 0; i <= inputSequence.size(); i++)
    {
      // Creating new step
      step_t step;
 
      // Checking if this is the end of the sequence
      bool isEndOfSequence = i == inputSequence.size();
 
      // Setting step input string
      step.inputString = isEndOfSequence == false ? inputSequence[i] : "<End Of Sequence>";
 
      // Checking if the input is allowed
      bool isRegisteredInput = _runner->isInputRegistered(step.inputString);
 
      // Getting input index
      if (isEndOfSequence == true) step.inputIndex = 0;
      if (isEndOfSequence == false && isRegisteredInput == true) step.inputIndex = _runner->getInputIndex(step.inputString);
      if (isEndOfSequence == false && isRegisteredInput == false) step.inputIndex = _runner->registerInput(step.inputString);
 
      // Checking if the input is allowed
      step.isInputAllowed = false;
      if (isRegisteredInput == true)
      {
        auto allowedInputs  = _runner->getAllowedInputs();
        step.isInputAllowed = std::find(allowedInputs.begin(), allowedInputs.end(), step.inputIndex) != allowedInputs.end();
      }
 
      // Getting state hash
      step.stateHash = _runner->computeHash();
 
      // Recording duplicate states: any earlier steps already filed under this step's hash are
      // exactly the repeated states the engine would have pruned on encountering them. Looking them
      // up in a hash map is O(1) amortized, versus the previous O(n^2) scan over every prior step,
      // so this scales to long movies. The earlier steps are stored in ascending order, matching the
      // previous behaviour.
      auto& sameHashSteps     = _hashOccurrences[step.stateHash];
      step._repeatedHashSteps = sameHashSteps;
      sameHashSteps.push_back(i);
 
      // Allocating space for the game state data
      step.gameStateData = malloc(_gameStateSize);
 
      // Serializing game state
      jaffarCommon::serializer::Contiguous sg(step.gameStateData, _gameStateSize);
      _runner->serializeState(sg);
 
      // Allocating and serializing renderer state (skipped in headless mode to save ~256KB/step)
      if (_storeRendererState)
      {
        step.rendererStateData = malloc(_rendererStateSize);
 
        // Updating renderer state
        _runner->getGame()->getEmulator()->updateRendererState(i, step.inputString);
 
        // Serializing renderer state
        jaffarCommon::serializer::Contiguous sr(step.rendererStateData, _rendererStateSize);
        _runner->getGame()->getEmulator()->serializeRendererState(sr);
      }
      else
        step.rendererStateData = nullptr;
 
      // Advancing state
      if (i < inputSequence.size()) _runner->advanceState(step.inputIndex);
      if (i == inputSequence.size()) _runner->advanceState(_sequence.rbegin()->inputIndex);
 
      // Diagnostic (JAFFAR_DUMP_FULLSTATE_DIR=<dir>): write each step's full serialized state to
      // <dir>/state<step>.bin. Diffing two replays' dumps at equal depth pinpoints which emulator
      // fields (beyond RAM) distinguish converging-looking states.
      if (const char* dumpDir = std::getenv("JAFFAR_DUMP_FULLSTATE_DIR"); dumpDir != nullptr)
      {
        std::vector<uint8_t>                 buf(_gameStateSize);
        jaffarCommon::serializer::Contiguous s(buf.data(), buf.size());
        _runner->serializeState(s);
        char path[512];
        snprintf(path, sizeof(path), "%s/state%04lu.bin", dumpDir, i + 1);
        jaffarCommon::file::saveStringToFile(std::string((char*)buf.data(), buf.size()), path);
      }
 
      // Diagnostic (JAFFAR_ROUNDTRIP_PER_STEP=1): serialize+deserialize the runner after every
      // advance, mimicking the engine's store/reload dynamics. Diffing a --dumpHashes file produced
      // with this flag against a normal one pinpoints where round-trip advancing forks from live.
      if (std::getenv("JAFFAR_ROUNDTRIP_PER_STEP") != nullptr)
      {
        std::vector<uint8_t> rt(_gameStateSize);
        {
          jaffarCommon::serializer::Contiguous s(rt.data(), rt.size());
          _runner->serializeState(s);
        }
        {
          jaffarCommon::deserializer::Contiguous d(rt.data(), rt.size());
          _runner->deserializeState(d);
        }
      }
 
      // Evaluate game rules
      _runner->getGame()->evaluateRules();
 
      // Determining new game state type
      _runner->getGame()->updateGameStateType();
 
      // Recording the first step at which the solution reaches a win/fail state. Only real applied
      // inputs are considered (i < size); the i == size iteration re-applies the last input as a
      // sentinel. The count is "inputs applied" (i + 1), matching the player's step convention.
      if (i < inputSequence.size())
      {
        const auto stateType = _runner->getGame()->getStateType();
        if (stateType == Game::stateType_t::win && _firstWinStep < 0) _firstWinStep = (ssize_t)i + 1;
        if (stateType == Game::stateType_t::fail && _firstFailStep < 0) _firstFailStep = (ssize_t)i + 1;
      }
 
      // Updating game reward
      _runner->getGame()->updateReward();
 
      // Adding step to the internal storage
      _sequence.push_back(step);
    }
  }
 
  ~Playback()
  {
    // Freeing up memory reserved during initialization
    for (const auto& step : _sequence)
    {
      free(step.gameStateData);
      if (step.rendererStateData != nullptr) free(step.rendererStateData);
    }
  }
 
  __INLINE__ std::string getStateInputString(const size_t currentStep) const { return getStep(currentStep).inputString; }
  __INLINE__ jaffarPlus::InputSet::inputIndex_t getStateInputIndex(const size_t currentStep) const { return getStep(currentStep).inputIndex; }
  __INLINE__ void* getStateData(const size_t currentStep) const { return getStep(currentStep).gameStateData; }
  __INLINE__ const std::vector<size_t> getStateRepeatedHashSteps(const size_t currentStep) const { return getStep(currentStep)._repeatedHashSteps; }
  __INLINE__ jaffarCommon::hash::hash_t getStateHash(const size_t currentStep) const { return getStep(currentStep).stateHash; }
  __INLINE__ bool isInputAllowed(const size_t currentStep) const { return getStep(currentStep).isInputAllowed; }
 
  __INLINE__ ssize_t getFirstWinStep() const { return _firstWinStep; }
  __INLINE__ ssize_t getFirstFailStep() const { return _firstFailStep; }
 
  __INLINE__ void renderFrame(const size_t currentStep)
  {
    const auto&                            step = getStep(currentStep);
    jaffarCommon::deserializer::Contiguous d(step.rendererStateData, _rendererStateSize);
    _runner->getGame()->getEmulator()->deserializeRendererState(d);
    _runner->getGame()->getEmulator()->showRender();
  }
 
  void loadStepData(const size_t stepId)
  {
    // Deserializing appropriate state
    jaffarCommon::deserializer::Contiguous d(getStateData(stepId), _gameStateSize);
    _runner->deserializeState(d);
  }
 
  void printInfo() const
  {
    // Now printing information
    jaffarCommon::logger::log("[J+] Runner Information: \n");
    _runner->printInfo();
    jaffarCommon::logger::log("[J+] Game Information: \n");
    _runner->getGame()->printInfo();
    jaffarCommon::logger::log("[J+] Emulator Information: \n");
    _runner->getGame()->getEmulator()->printInfo();
  }
 
private:
  step_t getStep(const size_t stepId) const
  {
    if (stepId >= _sequence.size()) JAFFAR_THROW_RUNTIME("Requested step %lu which exceeds sequence size %lu", stepId, _sequence.size());
    return _sequence.at(stepId);
  }
 
  struct hashHasher_t
  {
    size_t operator()(const jaffarCommon::hash::hash_t& h) const noexcept { return h.first ^ (h.second + 0x9E3779B97F4A7C15ULL + (h.first << 6) + (h.first >> 2)); }
  };
 
  Runner* _runner;
 
  size_t _gameStateSize;
 
  size_t _rendererStateSize;
 
  bool _storeRendererState = true;
 
  std::vector<step_t> _sequence;
 
  std::unordered_map<jaffarCommon::hash::hash_t, std::vector<size_t>, hashHasher_t> _hashOccurrences;
 
  ssize_t _firstWinStep  = -1; 
  ssize_t _firstFailStep = -1; 
};
 
} // namespace jaffarPlus