player.cpp

Go to the documentation of this file.

 
#include "emulator.hpp"
#include "game.hpp"
#include "playback.hpp"
#include "runner.hpp"
#include <argparse/argparse.hpp>
#include <chrono>
#include <emulatorList.hpp>
#include <gameList.hpp>
#include <jaffarCommon/json.hpp>
#include <jaffarCommon/logger.hpp>
#include <jaffarCommon/string.hpp>
#include <set>
 
bool isUnattended; 
 
bool isExitOnEnd; 
 
bool isReload; 
 
bool isReproduce; 
 
size_t frameskip; 
 
std::string runCommand; 
 
bool printFinalState;
 
std::string dumpHashesPath;
 
std::string dumpRamPath;
 
std::string dumpRewardPath;
 
std::string dumpTracePath;
 
std::string saveStateStepStr;
 
std::string saveStateFilePath;
 
std::string screenshotDir;
std::set<size_t> screenshotSteps;
 
static size_t parseUInt(const std::string& value, const std::string& flag)
{
  try
  {
    size_t       consumed = 0;
    const size_t result   = std::stoul(value, &consumed);
    if (consumed == value.size()) return result;
  }
  catch (const std::exception&)
  {
  }
  JAFFAR_THROW_LOGIC("Invalid value '%s' for %s (expected a non-negative integer)\n", value.c_str(), flag.c_str());
  return 0;
}
 
bool mainCycle(jaffarPlus::Runner& r, const std::string& solutionFile, bool disableRender)
{
  // If sequence file defined, load it and play it
  std::string solutionFileString;
  if (jaffarCommon::file::loadStringFromFile(solutionFileString, solutionFile) == false)
    JAFFAR_THROW_LOGIC("[ERROR] Could not find or read from solution sequence file: %s\n", solutionFile.c_str());
 
  // Getting input sequence
  const auto solutionSequence = jaffarCommon::string::split(solutionFileString, '\0');
 
  // Variable for current step in view
  ssize_t currentStep = 0;
 
  // Getting sequence length
  const ssize_t sequenceLength = solutionSequence.size();
 
  // Getting inverse frame rate from game
  const auto     frameRate        = r.getGame()->getFrameRate();
  const uint32_t inverseFrameRate = std::round((1.0 / frameRate) * 1.0e+6);
 
  // Getting game state size
  const auto stateSize = r.getStateSize();
 
  // Printing information
  jaffarCommon::logger::refreshTerminal();
 
  // Instantiating playback instance
  jaffarPlus::Playback p(r);
 
  // Initializing playback instance
  p.initialize(solutionSequence);
 
  // Flag to display frame information
  bool showFrameInfo = true;
 
  // Finalization flag
  bool isFinalize = false;
 
  // Checking for repeated state hashes
  std::vector<ssize_t> repeatedHashStates;
  for (ssize_t i = 0; i < sequenceLength; i++)
  {
    const auto repeatedHashSteps = p.getStateRepeatedHashSteps(i);
    if (repeatedHashSteps.size() > 0) repeatedHashStates.push_back(i);
  }
 
  // Checking for not-allowed inputs
  std::vector<ssize_t> notAllowedInputStates;
  for (ssize_t i = 0; i < sequenceLength; i++)
  {
    const auto isInputAllowed = p.isInputAllowed(i);
    if (isInputAllowed == false) notAllowedInputStates.push_back(i);
  }
 
  // If requested, dump the per-step game-state hash for every step (including the end-of-sequence
  // step) to a file. Diffing the dumps of two emulators replaying the same solution pinpoints the
  // exact first frame at which their hashed game RAM diverges.
  if (dumpHashesPath.empty() == false)
  {
    std::string dump;
    char        line[64];
    for (ssize_t i = 0; i <= sequenceLength; i++)
    {
      const auto hash = p.getStateHash(i);
      snprintf(line, sizeof(line), "%ld\t%016lX%016lX\n", i, hash.first, hash.second);
      dump += line;
    }
    if (jaffarCommon::file::saveStringToFile(dump, dumpHashesPath.c_str()) == false)
      JAFFAR_THROW_LOGIC("[ERROR] Could not write per-step hash dump to: %s\n", dumpHashesPath.c_str());
  }
 
  // If requested, dump the full low work-RAM for every step as a flat binary blob. Reading the RAM
  // requires restoring each step's state into the live emulator first (loadStepData), so this mutates
  // the live state -- harmless here since the interactive loop re-loads per step regardless.
  if (dumpRamPath.empty() == false)
  {
    const auto  lram = r.getGame()->getEmulator()->getProperty("LRAM");
    std::string dump;
    dump.reserve((size_t)(sequenceLength + 1) * lram.size);
    for (ssize_t i = 0; i <= sequenceLength; i++)
    {
      p.loadStepData(i);
      dump.append((const char*)lram.pointer, lram.size);
    }
    if (jaffarCommon::file::saveStringToFile(dump, dumpRamPath.c_str()) == false) JAFFAR_THROW_LOGIC("[ERROR] Could not write per-step RAM dump to: %s\n", dumpRamPath.c_str());
  }
 
  // If requested, write the per-step game reward (one value per line) to a file. The reward is part of the
  // serialized game state, so loadStepData restores each step's reward directly -- this is exactly the value
  // the search compares against, suitable as a "Reference Reward Floor" trace.
  if (dumpRewardPath.empty() == false)
  {
    std::string dump;
    for (ssize_t i = 0; i <= sequenceLength; i++)
    {
      p.loadStepData(i);
      // Full precision (NOT std::to_string, which truncates to 6 decimals): the reward is on the 1/256
      // sub-pixel grid, so 6 decimals (e.g. 0.246094) does not round-trip the exact value (0.24609375),
      // which makes a "Reference Reward Floor" with tolerance 0 false-cancel on an EXACT match. %.17g
      // preserves the value so a tol=0 floor only cancels when the search is genuinely behind.
      char rbuf[64];
      snprintf(rbuf, sizeof(rbuf), "%.17g", (double)r.getGame()->getReward());
      dump += std::string(rbuf) + "\n";
    }
    if (jaffarCommon::file::saveStringToFile(dump, dumpRewardPath.c_str()) == false)
      JAFFAR_THROW_LOGIC("[ERROR] Could not write per-step reward dump to: %s\n", dumpRewardPath.c_str());
  }
 
  // If requested, write the game's per-step trace line (Game::getTraceLine) to a file, one line per step. Like the
  // reward dump, loadStepData restores each step's full state first, so the coordinates are exact. Suitable as a
  // game "Trace File Path" for the trace magnet.
  if (dumpTracePath.empty() == false)
  {
    std::string dump;
    for (ssize_t i = 0; i <= sequenceLength; i++)
    {
      p.loadStepData(i);
      dump += r.getGame()->getTraceLine() + "\n";
    }
    if (jaffarCommon::file::saveStringToFile(dump, dumpTracePath.c_str()) == false)
      JAFFAR_THROW_LOGIC("[ERROR] Could not write per-step trace dump to: %s\n", dumpTracePath.c_str());
  }
 
  // If requested, restore the state at a single step and save the emulator's FULL state to a file (for use
  // as the Emulator "Initial State File Path" -- a mid-run seed). Prints the bike posX so the caller can set
  // the game's "Initial Block Transitions" to make _bikePosX absolute. Then exits.
  if (saveStateFilePath.empty() == false)
  {
    const auto step = (ssize_t)parseUInt(saveStateStepStr, "--saveStateStep");
    p.loadStepData(step);
    std::string  saveData;
    const size_t stateSize = r.getGame()->getEmulator()->getStateSize();
    saveData.resize(stateSize);
    jaffarCommon::serializer::Contiguous s(saveData.data(), stateSize);
    r.getGame()->getEmulator()->serializeState(s);
    if (jaffarCommon::file::saveStringToFile(saveData, saveStateFilePath.c_str()) == false)
      JAFFAR_THROW_LOGIC("[ERROR] Could not write state at step %ld to: %s\n", (long)step, saveStateFilePath.c_str());
    jaffarCommon::logger::log("[J+] Saved emulator state at step %ld to %s (%lu bytes)\n", (long)step, saveStateFilePath.c_str(), stateSize);
    r.getGame()->printInfo();
    return 0;
  }
 
  // Interactive section
  while (isFinalize == false)
  {
    // Updating display
    if (disableRender == false)
      if (currentStep % frameskip == 0)
      {
        p.renderFrame(currentStep);
 
        // Capture this frame if requested (whole list, or every rendered frame if no list). The
        // actual save is emulator-specific (no-op for emulators without a screenshot backend), so
        // the player stays emulator-agnostic and links without SDL/SDLPoP symbols.
        if (screenshotDir.empty() == false && (screenshotSteps.empty() || screenshotSteps.count((size_t)currentStep) > 0))
        {
          char path[1024];
          snprintf(path, sizeof(path), "%s/step_%06ld.bmp", screenshotDir.c_str(), currentStep);
          r.getGame()->getEmulator()->saveScreenshot(path);
        }
      }
 
    // Loading step data
    p.loadStepData(currentStep);
 
    // Getting input string
    const auto& inputString = p.getStateInputString(currentStep);
 
    // Getting input index
    const auto& inputIndex = p.getStateInputIndex(currentStep);
 
    // Getting state hash
    const auto hash = p.getStateHash(currentStep);
 
    // Getting repeated step hashes (if any)
    const auto repeatedHashSteps = p.getStateRepeatedHashSteps(currentStep);
 
    // Checking if the current input is within the allowed inputs for this state
    const auto isInputAllowed = p.isInputAllowed(currentStep);
 
    // If running a command, don't print frame info, and finalize immediately after
    if (runCommand != "")
    {
      isFinalize    = true;
      showFrameInfo = false;
      isReproduce   = false;
      isUnattended  = true;
    }
 
    // Printing data and commands
    if (showFrameInfo)
    {
      jaffarCommon::logger::clearTerminal();
 
      jaffarCommon::logger::log("[J+] ----------------------------------------------------------------\n");
      jaffarCommon::logger::log("[J+] Current Step #:              %lu / %lu\n", currentStep, sequenceLength);
      jaffarCommon::logger::log("[J+] Playback:                    %s\n", isReproduce ? "Playing" : "Stopped");
      jaffarCommon::logger::log("[J+] Input:                       %s (0x%X)\n", inputString.c_str(), inputIndex);
      jaffarCommon::logger::log("[J+] On Finish:                   %s\n", isReload ? "Auto Reload" : "Stop");
 
      jaffarCommon::logger::log("[J+] Repeated Hash Steps:         %lu total [ ", repeatedHashStates.size());
      if (repeatedHashStates.size() < 5)
        for (const auto step : repeatedHashStates) jaffarCommon::logger::log(" %ld ", step);
      else
      {
        for (size_t i = 0; i < 5; i++) jaffarCommon::logger::log(" %ld ", repeatedHashStates[i]);
        jaffarCommon::logger::log(" ... ");
      }
      jaffarCommon::logger::log(" ] \n");
 
      jaffarCommon::logger::log("[J+] Not Allowed Input Steps:     %lu total [ ", notAllowedInputStates.size());
      if (notAllowedInputStates.size() < 5)
        for (const auto step : notAllowedInputStates) jaffarCommon::logger::log(" %ld ", step);
      else
      {
        for (size_t i = 0; i < 5; i++) jaffarCommon::logger::log(" %ld ", notAllowedInputStates[i]);
        jaffarCommon::logger::log(" ... ");
      }
      jaffarCommon::logger::log(" ] \n");
 
      jaffarCommon::logger::log("[J+] Game Name:                  '%s'\n", r.getGame()->getName().c_str());
      jaffarCommon::logger::log("[J+] Emulator Name:              '%s'\n", r.getGame()->getEmulator()->getName().c_str());
      jaffarCommon::logger::log("[J+] State Hash:                  0x%lX%lX\n", hash.first, hash.second);
      jaffarCommon::logger::log("[J+] State Repeated Hash Steps:   [ ");
      for (const auto step : repeatedHashSteps) jaffarCommon::logger::log(" %lu ", step);
      jaffarCommon::logger::log(" ] \n");
      jaffarCommon::logger::log("[J+] Is Input Allowed:            %s\n", isInputAllowed ? "True" : "False");
      jaffarCommon::logger::log("[J+] State Size:                  %lu\n", stateSize);
      jaffarCommon::logger::log("[J+] Solution File:              '%s'\n", solutionFile.c_str());
      jaffarCommon::logger::log("[J+] Sequence Length:             %lu\n", sequenceLength);
      jaffarCommon::logger::log("[J+] Frame Rate:                  %f (%u)\n", frameRate, inverseFrameRate);
      jaffarCommon::logger::log("[J+] Checkpoint:                  Level: %lu, Tolerance: %lu\n", r.getGame()->getCheckpointLevel(), r.getGame()->getCheckpointTolerance());
      jaffarCommon::logger::log("[J+] Manual Save Solution:        Active: %s, Path: '%s', Last Rule: (Current: %ld), (Prev: %ld)\n", r.getGame()->isSaveSolution() ? "Yes" : "No",
                                r.getGame()->getSaveSolutionPath().c_str(), r.getGame()->getSaveSolutionCurrentLastRuleIdx(), r.getGame()->getSaveSolutionPrevLastRuleIdx());
      p.printInfo();
 
      // Print General Commands
      jaffarCommon::logger::log("[J+] Commands: n: -1 m: +1 | h: -10 | j: +10 | y: -100 | u: +100 | k: -1000 | i: +1000 | s: quicksave | p: play | r: autoreload | q: quit\n");
 
      // Print any game-specific commands (optional)
      r.getGame()->playerPrintCommands();
 
      jaffarCommon::logger::refreshTerminal();
    }
 
    // Resetting show frame info flag
    showFrameInfo = true;
 
    // Specifies the command to execute next
    int command = 0;
 
    // If it's reproducing,
    if (isReproduce == true)
    {
      // Introducing sleep related to the frame rate
      usleep(inverseFrameRate);
 
      // Advance to the next frame
      currentStep++;
 
      // Get command without interrupting
      command = jaffarCommon::logger::getKeyPress();
    }
 
    // If it's not reproducing, grab command with a wait
    if (isReproduce == false && isUnattended == false) command = jaffarCommon::logger::waitForKeyPress();
 
    // Headless fast-forward: when unattended and not actively reproducing (and not running a one-shot
    // command), advance through the sequence as fast as possible -- no key wait, no frame-rate sleep.
    // This is what makes --unattended --exitOnEnd terminate promptly for batch/verification runs
    // (otherwise neither branch above advances and the loop spins forever).
    if (isReproduce == false && isUnattended == true && runCommand == "") currentStep++;
 
    // If running a command given from the console, set it now
    if (runCommand != "") command = runCommand[0];
 
    // Handle commands
    switch (command)
    {
      // Advance/Rewind commands
      case 'n': currentStep = currentStep - 1; break;
      case 'm': currentStep = currentStep + 1; break;
      case 'h': currentStep = currentStep - 10; break;
      case 'j': currentStep = currentStep + 10; break;
      case 'y': currentStep = currentStep - 100; break;
      case 'u': currentStep = currentStep + 100; break;
      case 'k': currentStep = currentStep - 1000; break;
      case 'i': currentStep = currentStep + 1000; break;
 
      case 's':
      {
        // Storing state file
        std::string saveFileName = "quicksave.state";
 
        std::string saveData;
        size_t      stateSize = r.getGame()->getEmulator()->getStateSize();
        saveData.resize(stateSize);
        jaffarCommon::serializer::Contiguous s(saveData.data(), stateSize);
        r.getGame()->getEmulator()->serializeState(s);
        if (jaffarCommon::file::saveStringToFile(saveData, saveFileName.c_str()) == false) JAFFAR_THROW_LOGIC("[ERROR] Could not save state file: %s\n", saveFileName.c_str());
        jaffarCommon::logger::log("[J+] Saved state to %s\n", saveFileName.c_str());
 
        // Do no show frame info again after this action
        showFrameInfo = false;
 
        break;
      }
 
      // Toggles playback from current point
      case 'p': isReproduce = !isReproduce; break;
 
      // Toggles Auto Reload
      case 'r': isReload = !isReload; break;
 
      // Triggers the exit
      case 'q': isFinalize = true; break;
 
      // Handle any game-specific commands. If such command is executed, do not clear output
      default: showFrameInfo = r.getGame()->playerParseCommand(command) == false;
    }
 
    // Correct current step if requested more than possible
    if (currentStep < 0) currentStep = 0;
 
    // If reloading on finish, do it now
    if (currentStep > sequenceLength && isReload == true) break;
 
    // If exiting on finish, do it now
    if (currentStep > sequenceLength && isExitOnEnd == true) break;
 
    // If not reloading on finish, simply stop
    if (currentStep > sequenceLength)
    {
      currentStep = sequenceLength;
      isReproduce = false;
    }
  }
 
  // If requested, print a stable summary of the final (end-of-sequence) state. This is the
  // machine-checkable oracle for headless reproduction tests: the hash is deterministic, so the
  // same config+solution must always produce the same value here.
  if (printFinalState)
  {
    const auto        finalHash       = p.getStateHash(sequenceLength);
    const auto        stateType       = r.getGame()->getStateType();
    const std::string stateTypeString = stateType == jaffarPlus::Game::stateType_t::win ? "Win" : (stateType == jaffarPlus::Game::stateType_t::fail ? "Fail" : "Normal");
    jaffarCommon::logger::log("[J+] Final Step:                  %ld\n", sequenceLength);
    jaffarCommon::logger::log("[J+] Final State Type:            %s\n", stateTypeString.c_str());
    // First step (inputs applied) at which the solution reaches a win / fail state. Useful to spot a
    // movie that wins before its end (wasted trailing inputs) or fails midway. "none" if it never does.
    const auto        firstWinStep        = p.getFirstWinStep();
    const auto        firstFailStep       = p.getFirstFailStep();
    const std::string firstWinStepString  = firstWinStep < 0 ? "none" : std::to_string(firstWinStep);
    const std::string firstFailStepString = firstFailStep < 0 ? "none" : std::to_string(firstFailStep);
    jaffarCommon::logger::log("[J+] First Win Step:              %s\n", firstWinStepString.c_str());
    jaffarCommon::logger::log("[J+] First Fail Step:             %s\n", firstFailStepString.c_str());
    jaffarCommon::logger::log("[J+] Final State Hash:            0x%lX%lX\n", finalHash.first, finalHash.second);
    // Solution-quality counts: inputs the engine would not have considered at their frame, and
    // states the engine would have pruned as duplicates. Both are 0 for a clean engine-found path.
    jaffarCommon::logger::log("[J+] Not Allowed Input Count:     %lu\n", notAllowedInputStates.size());
    jaffarCommon::logger::log("[J+] Repeated State Count:        %lu\n", repeatedHashStates.size());
  }
 
  // returning false on exit to trigger the finalization
  if (isFinalize) return false;
 
  // Otherwise, keep looping
  return true;
}
 
int main(int argc, char* argv[])
{
  // Parsing command line arguments
  argparse::ArgumentParser program("jaffar-tester", "2.0.0");
 
  program.add_argument("configFile").help("path to the Jaffar configuration script (.jaffar) file to run.").required();
  program.add_argument("solutionFile").help("path to the solution sequence file (.sol) to reproduce.").required();
  program.add_argument("--reproduce").help("Starts playing from the start").default_value(false).implicit_value(true);
  program.add_argument("--reload").help("Reloads the solution after reaching the end").default_value(false).implicit_value(true);
  program.add_argument("--exitOnEnd").help("Exits the program upon reaching the last step").default_value(false).implicit_value(true);
  program.add_argument("--unattended").help("Indicates the player not to print the interactive prompt nor wait for inputs").default_value(false).implicit_value(true);
  program.add_argument("--disableRender").help("Do not render game window.").default_value(false).implicit_value(true);
  program.add_argument("--frameskip").help("How many frames to skip between renderings.").default_value(std::string("1"));
  program.add_argument("--initialSequence").help("Overrides the solution file to use as initial sequence to play before starting.").default_value(std::string(""));
  program.add_argument("--runCommand").help("Specifies a command to run and then exit").default_value(std::string(""));
  program.add_argument("--screenshotDir").help("Directory to write per-frame screenshots (BMP) into (requires rendering enabled).").default_value(std::string(""));
  program.add_argument("--screenshotSteps").help("Comma-separated list of steps to screenshot (empty = every rendered frame).").default_value(std::string(""));
  program.add_argument("--printFinalState")
      .help("Prints a stable summary (step, state type, state hash) of the final state on exit, for headless verification.")
      .default_value(false)
      .implicit_value(true);
  program.add_argument("--dumpHashes")
      .help("Writes the per-step game-state hash for every step to the given file (for cross-emulator divergence checks).")
      .default_value(std::string(""));
  program.add_argument("--dumpRam")
      .help("Writes the full low work-RAM (LRAM) for every step to the given file as flat binary (for byte-level cross-emulator diffs).")
      .default_value(std::string(""));
  program.add_argument("--dumpReward")
      .help("Writes the per-step game reward (one value per line) to the given file (for use as a 'Reference Reward Floor' trace).")
      .default_value(std::string(""));
  program.add_argument("--dumpTrace")
      .help("Writes the game's per-step trace line (Game::getTraceLine) to the given file (for use as a game 'Trace File Path' / trace magnet).")
      .default_value(std::string(""));
  program.add_argument("--saveStateStep").help("Step at which to save the emulator state (used with --saveStateFile), then exit.").default_value(std::string(""));
  program.add_argument("--saveStateFile")
      .help("File to write the emulator's full state at --saveStateStep to (load as Emulator 'Initial State File Path').")
      .default_value(std::string(""));
 
  // Try to parse arguments
  try
  {
    program.parse_args(argc, argv);
  }
  catch (const std::runtime_error& err)
  {
    JAFFAR_THROW_LOGIC("%s\n%s", err.what(), program.help().str().c_str());
  }
 
  // Parsing config file
  const std::string configFile = program.get<std::string>("configFile");
 
  // Parsin solution file
  const std::string solutionFile = program.get<std::string>("solutionFile");
 
  // Getting reload flag
  bool doReload = program.get<bool>("--reload");
 
  // Getting reproduce flag
  bool reproduceStart = program.get<bool>("--reproduce");
 
  // Getting disablerender flag
  bool disableRender = program.get<bool>("--disableRender");
 
  // Getting screenshot options
  screenshotDir = program.get<std::string>("--screenshotDir");
  {
    const auto stepsStr = program.get<std::string>("--screenshotSteps");
    if (stepsStr.empty() == false)
      for (const auto& tok : jaffarCommon::string::split(stepsStr, ','))
        if (tok.empty() == false) screenshotSteps.insert(parseUInt(tok, "--screenshotSteps"));
  }
 
  // Getting exitOnEnd flag
  bool exitOnEnd = program.get<bool>("--exitOnEnd");
 
  // Getting unattended flag
  bool unattended = program.get<bool>("--unattended");
 
  // Getting frameskip
  frameskip = parseUInt(program.get<std::string>("--frameskip"), "--frameskip");
 
  // Getting frameskip
  const std::string initialSequence = program.get<std::string>("--initialSequence");
 
  // Getting command to run (if any)
  runCommand = program.get<std::string>("--runCommand");
 
  // Getting the print-final-state flag
  printFinalState = program.get<bool>("--printFinalState");
 
  // Getting the per-step hash dump path (if any)
  dumpHashesPath = program.get<std::string>("--dumpHashes");
 
  // Getting the per-step RAM dump path (if any)
  dumpRamPath       = program.get<std::string>("--dumpRam");
  dumpRewardPath    = program.get<std::string>("--dumpReward");
  dumpTracePath     = program.get<std::string>("--dumpTrace");
  saveStateStepStr  = program.get<std::string>("--saveStateStep");
  saveStateFilePath = program.get<std::string>("--saveStateFile");
 
  // Initializing terminal
  jaffarCommon::logger::initializeTerminal();
 
  // Setting initial reproduction values
  isReload     = doReload;
  isReproduce  = reproduceStart;
  isExitOnEnd  = exitOnEnd;
  isUnattended = unattended;
 
  // If config file defined, read it now
  std::string configFileString;
  if (jaffarCommon::file::loadStringFromFile(configFileString, configFile) == false)
    JAFFAR_THROW_LOGIC("[ERROR] Could not find or read from Jaffar config file: %s\n", configFile.c_str());
 
  // Parsing configuration file
  nlohmann::json config;
  try
  {
    config = nlohmann::json::parse(configFileString);
  }
  catch (const std::exception& err)
  {
    JAFFAR_THROW_LOGIC("[ERROR] Parsing configuration file %s. Details:\n%s\n", configFile.c_str(), err.what());
  }
 
  // Getting component configurations
  auto emulatorConfig = jaffarCommon::json::getObject(config, "Emulator Configuration");
  auto gameConfig     = jaffarCommon::json::getObject(config, "Game Configuration");
  auto runnerConfig   = jaffarCommon::json::getObject(config, "Runner Configuration");
 
  // Overriding initial solution file, if provided
  if (initialSequence != "") emulatorConfig["Initial Sequence File Path"] = initialSequence;
 
  // Disabling frameskip, if enabled
  runnerConfig["Frameskip"]["Rate"] = 0;
 
  // Creating runner from the configuration
  auto r = jaffarPlus::Runner::getRunner(emulatorConfig, gameConfig, runnerConfig);
 
  // Initializing runner
  r->initialize();
 
  // Enabling rendering, if required
  if (disableRender == false)
  {
    r->getGame()->getEmulator()->initializeVideoOutput();
    r->getGame()->getEmulator()->enableRendering();
  }
 
  // Getting game state size
  const auto stateSize = r->getStateSize();
 
  // Storage for the initial state
  std::string initialState;
  initialState.resize(stateSize);
 
  // Getting initial state
  jaffarCommon::serializer::Contiguous s(initialState.data(), initialState.size());
  r->serializeState(s);
 
  // Running main cycle
  bool continueRunning = true;
  while (continueRunning == true)
  {
    // Running main cycle
    continueRunning = mainCycle(*r, solutionFile, disableRender);
 
    // If the exit-on-end flag is set, then do not repeat reproduction
    if (exitOnEnd == true) break;
 
    // If the playback repeats, then sleep and restore the initial state
    if (continueRunning == true)
    {
      // If repeating, then wait a bit before repeating to prevent fast repetition of short movies
      sleep(1);
 
      // Reloading the initial state (captured at step 0); the step counter is not in the stream, so reset
      // it here before deserializing (the player advances it itself as it replays).
      r->setStepCount(0);
      jaffarCommon::deserializer::Contiguous d(initialState.data(), initialState.size());
      r->deserializeState(d);
    }
  }
 
  // If redering was enabled, finish it now
  if (disableRender == false) r->getGame()->getEmulator()->finalizeVideoOutput();
 
  // Ending ncurses window
  jaffarCommon::logger::finalizeTerminal();
}