emulator.hpp

Go to the documentation of this file.

#pragma once
 
#include <SDL2/SDL.h>
#include <inputParser.hpp>
#include <inputSet.hpp>
#include <jaffarCommon/deserializers/contiguous.hpp>
#include <jaffarCommon/file.hpp>
#include <jaffarCommon/json.hpp>
#include <jaffarCommon/serializers/contiguous.hpp>
#include <string>
 
namespace jaffarPlus
{
 
struct property_t
{
  uint8_t* pointer; 
  size_t   size;    
};
 
class Emulator
{
public:
  struct inputEntry_t
  {
    std::string inputString;
 
    jaffar::input_t inputData;
  };
 
  Emulator(const nlohmann::json& config) : _emulatorConfigRemaining(config)
  {
    // Getting emulator name (for runtime use)
    _emulatorName = jaffarCommon::json::popString(_emulatorConfigRemaining, "Emulator Name");
  };
 
  virtual ~Emulator() = default;
 
  __INLINE__ void initialize()
  {
    if (_isInitialized == true) JAFFAR_THROW_LOGIC("This emulator instance was already initialized");
 
    // Calling emulator-specific initializer
    initializeImpl();
 
    // Set this as initialized
    _isInitialized = true;
  }
 
  __INLINE__ InputSet::inputIndex_t registerInput(const std::string inputString)
  {
    // Registration is done only at the beginning with linear complexity O(n) to optimize for read access O(1)
    for (size_t i = 0; i < _inputMap.size(); i++)
      if (inputString == _inputMap[i].inputString) return i;
 
    // Otherwise, getting decoded input data from the emulator
    auto inputData = getInputParser()->parseInputString(inputString);
 
    // Otherwise, register it as a new entry
    _inputMap.push_back({inputString, inputData});
 
    // Returning current index
    return _inputMap.size() - 1;
  }
 
  __INLINE__ const inputEntry_t& getRegisteredInput(const InputSet::inputIndex_t inputIdx) const { return _inputMap[(size_t)inputIdx]; }
 
  void advanceState(const InputSet::inputIndex_t input) { advanceStateImpl(_inputMap[input].inputData); };
 
  size_t getStateSize() const
  {
    jaffarCommon::serializer::Contiguous s;
    serializeState(s);
    return s.getOutputSize();
  }
 
  __INLINE__ bool isInitialized() const { return _isInitialized; }
 
  __INLINE__ std::string getName() const { return _emulatorName; }
 
  virtual void initializeImpl() = 0;
 
  virtual void serializeState(jaffarCommon::serializer::Base& serializer) const = 0;
  virtual void deserializeState(jaffarCommon::deserializer::Base& deserializer) = 0;
 
  virtual jaffar::InputParser* getInputParser() const = 0;
 
  virtual void printInfo() const = 0;
 
  virtual property_t getProperty(const std::string& propertyName) const = 0;
 
  static std::unique_ptr<Emulator> getEmulator(const nlohmann::json& emulatorConfig);
 
 
  virtual void initializeVideoOutput() = 0;
 
  virtual void finalizeVideoOutput() = 0;
 
  virtual void enableRendering() = 0;
 
  virtual void disableRendering() = 0;
 
  virtual void updateRendererState(const size_t stepIdx, const std::string input) = 0;
 
  virtual void serializeRendererState(jaffarCommon::serializer::Base& serializer) const = 0;
 
  virtual void deserializeRendererState(jaffarCommon::deserializer::Base& deserializer) = 0;
 
  virtual size_t getRendererStateSize() const = 0;
 
  virtual void showRender() = 0;
 
  virtual void saveScreenshot(const std::string& /*path*/) {}
 
protected:
  virtual void advanceStateImpl(const jaffar::input_t& input) = 0;
 
  void finalizeEmulatorConfig() { jaffarCommon::json::checkEmpty(_emulatorConfigRemaining, "Emulator Configuration"); }
 
  std::string _emulatorName;
 
  nlohmann::json _emulatorConfigRemaining;
 
  bool _isInitialized = false;
 
private:
  std::vector<inputEntry_t> _inputMap;
};
 
} // namespace jaffarPlus