Game.h

/*
 *  Copyright (C) 2014-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "../AddonBase.h"
#include "../c-api/addon-instance/game.h"

#include <algorithm>

#ifdef __cplusplus

namespace kodi
{
namespace addon
{

//==============================================================================

//==============================================================================

//==============================================================================
class GameControllerLayout
{
public:
  explicit GameControllerLayout() = default;
  GameControllerLayout(const game_controller_layout& layout) : controller_id(layout.controller_id)
  {
    provides_input = layout.provides_input;
    for (unsigned int i = 0; i < layout.digital_button_count; ++i)
      digital_buttons.push_back(layout.digital_buttons[i]);
    for (unsigned int i = 0; i < layout.analog_button_count; ++i)
      analog_buttons.push_back(layout.analog_buttons[i]);
    for (unsigned int i = 0; i < layout.analog_stick_count; ++i)
      analog_sticks.push_back(layout.analog_sticks[i]);
    for (unsigned int i = 0; i < layout.accelerometer_count; ++i)
      accelerometers.push_back(layout.accelerometers[i]);
    for (unsigned int i = 0; i < layout.key_count; ++i)
      keys.push_back(layout.keys[i]);
    for (unsigned int i = 0; i < layout.rel_pointer_count; ++i)
      rel_pointers.push_back(layout.rel_pointers[i]);
    for (unsigned int i = 0; i < layout.abs_pointer_count; ++i)
      abs_pointers.push_back(layout.abs_pointers[i]);
    for (unsigned int i = 0; i < layout.motor_count; ++i)
      motors.push_back(layout.motors[i]);
  }
  std::string controller_id;

  bool provides_input{false};

  std::vector<std::string> digital_buttons;

  std::vector<std::string> analog_buttons;

  std::vector<std::string> analog_sticks;

  std::vector<std::string> accelerometers;

  std::vector<std::string> keys;

  std::vector<std::string> rel_pointers;

  std::vector<std::string> abs_pointers;

  std::vector<std::string> motors;
};
//------------------------------------------------------------------------------

//==============================================================================
class ATTR_DLL_LOCAL CInstanceGame : public IAddonInstance
{
public:
  //============================================================================

  //============================================================================
  CInstanceGame() : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance))
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstanceGame: Creation of more as one in single "
                             "instance way is not allowed!");

    SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance);
    CPrivateBase::m_interface->globalSingleInstance = this;
  }
  //----------------------------------------------------------------------------

  //============================================================================
  ~CInstanceGame() override = default;
  //----------------------------------------------------------------------------

  //============================================================================
  std::string GameClientDllPath() const { return m_instanceData->props->game_client_dll_path; }
  //----------------------------------------------------------------------------

  //============================================================================
  bool ProxyDllPaths(std::vector<std::string>& paths)
  {
    for (unsigned int i = 0; i < m_instanceData->props->proxy_dll_count; ++i)
    {
      if (m_instanceData->props->proxy_dll_paths[i] != nullptr)
        paths.push_back(m_instanceData->props->proxy_dll_paths[i]);
    }
    return !paths.empty();
  }
  //----------------------------------------------------------------------------

  //============================================================================
  bool ResourceDirectories(std::vector<std::string>& dirs)
  {
    for (unsigned int i = 0; i < m_instanceData->props->resource_directory_count; ++i)
    {
      if (m_instanceData->props->resource_directories[i] != nullptr)
        dirs.push_back(m_instanceData->props->resource_directories[i]);
    }
    return !dirs.empty();
  }
  //----------------------------------------------------------------------------

  //============================================================================
  std::string ProfileDirectory() const { return m_instanceData->props->profile_directory; }
  //----------------------------------------------------------------------------

  //============================================================================
  bool SupportsVFS() const { return m_instanceData->props->supports_vfs; }
  //----------------------------------------------------------------------------

  //============================================================================
  bool Extensions(std::vector<std::string>& extensions)
  {
    for (unsigned int i = 0; i < m_instanceData->props->extension_count; ++i)
    {
      if (m_instanceData->props->extensions[i] != nullptr)
        extensions.push_back(m_instanceData->props->extensions[i]);
    }
    return !extensions.empty();
  }
  //----------------------------------------------------------------------------


  //--==----==----==----==----==----==----==----==----==----==----==----==----==--

  //============================================================================

  //============================================================================
  virtual GAME_ERROR LoadGame(const std::string& url) { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR LoadGameSpecial(SPECIAL_GAME_TYPE type, const std::vector<std::string>& urls)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR LoadStandalone() { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR UnloadGame() { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR GetGameTiming(game_system_timing& timing_info)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_REGION GetRegion() { return GAME_REGION_UNKNOWN; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual bool RequiresGameLoop() { return false; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR RunFrame() { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR Reset() { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------

  //==========================================================================
  void CloseGame(void) { m_instanceData->toKodi->CloseGame(m_instanceData->toKodi->kodiInstance); }
  //----------------------------------------------------------------------------

  //============================================================================
  class CStream
  {
  public:
    CStream() = default;

    CStream(const game_stream_properties& properties) { Open(properties); }

    ~CStream() { Close(); }

    //==========================================================================
    bool Open(const game_stream_properties& properties)
    {
      if (!CPrivateBase::m_interface->globalSingleInstance)
        return false;

      if (m_handle)
      {
        kodi::Log(ADDON_LOG_INFO, "kodi::addon::CInstanceGame::CStream already becomes reopened");
        Close();
      }

      AddonToKodiFuncTable_Game& cb =
          *static_cast<CInstanceGame*>(CPrivateBase::m_interface->globalSingleInstance)
               ->m_instanceData->toKodi;
      m_handle = cb.OpenStream(cb.kodiInstance, &properties);
      return m_handle != nullptr;
    }
    //--------------------------------------------------------------------------

    //==========================================================================
    void Close()
    {
      if (!m_handle || !CPrivateBase::m_interface->globalSingleInstance)
        return;

      AddonToKodiFuncTable_Game& cb =
          *static_cast<CInstanceGame*>(CPrivateBase::m_interface->globalSingleInstance)
               ->m_instanceData->toKodi;
      cb.CloseStream(cb.kodiInstance, m_handle);
      m_handle = nullptr;
    }
    //--------------------------------------------------------------------------

    //==========================================================================
    bool GetBuffer(unsigned int width, unsigned int height, game_stream_buffer& buffer)
    {
      if (!m_handle || !CPrivateBase::m_interface->globalSingleInstance)
        return false;

      AddonToKodiFuncTable_Game& cb =
          *static_cast<CInstanceGame*>(CPrivateBase::m_interface->globalSingleInstance)
               ->m_instanceData->toKodi;
      return cb.GetStreamBuffer(cb.kodiInstance, m_handle, width, height, &buffer);
    }
    //--------------------------------------------------------------------------

    //==========================================================================
    void AddData(const game_stream_packet& packet)
    {
      if (!m_handle || !CPrivateBase::m_interface->globalSingleInstance)
        return;

      AddonToKodiFuncTable_Game& cb =
          *static_cast<CInstanceGame*>(CPrivateBase::m_interface->globalSingleInstance)
               ->m_instanceData->toKodi;
      cb.AddStreamData(cb.kodiInstance, m_handle, &packet);
    }
    //--------------------------------------------------------------------------

    //==========================================================================
    void ReleaseBuffer(game_stream_buffer& buffer)
    {
      if (!m_handle || !CPrivateBase::m_interface->globalSingleInstance)
        return;

      AddonToKodiFuncTable_Game& cb =
          *static_cast<CInstanceGame*>(CPrivateBase::m_interface->globalSingleInstance)
               ->m_instanceData->toKodi;
      cb.ReleaseStreamBuffer(cb.kodiInstance, m_handle, &buffer);
    }
    //--------------------------------------------------------------------------

    //==========================================================================
    bool IsOpen() const { return m_handle != nullptr; }
    //--------------------------------------------------------------------------

  private:
    KODI_GAME_STREAM_HANDLE m_handle = nullptr;
  };


  //--==----==----==----==----==----==----==----==----==----==----==----==----==--

  //============================================================================

  //============================================================================
  virtual GAME_ERROR HwContextReset() { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR HwContextDestroy() { return GAME_ERROR_NOT_IMPLEMENTED; }

  //============================================================================
  game_proc_address_t HwGetProcAddress(const char* sym)
  {
    return m_instanceData->toKodi->HwGetProcAddress(m_instanceData->toKodi->kodiInstance, sym);
  }
  //----------------------------------------------------------------------------


  //--==----==----==----==----==----==----==----==----==----==----==----==----==--

  //============================================================================

  //============================================================================
  virtual bool HasFeature(const std::string& controller_id, const std::string& feature_name)
  {
    return false;
  }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual game_input_topology* GetTopology() { return nullptr; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual void FreeTopology(game_input_topology* topology) {}
  //----------------------------------------------------------------------------

  //============================================================================
  virtual void SetControllerLayouts(
      const std::vector<kodi::addon::GameControllerLayout>& controllers)
  {
  }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual bool EnableKeyboard(bool enable, const std::string& controller_id) { return false; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual bool EnableMouse(bool enable, const std::string& controller_id) { return false; }
  //--------------------------------------------------------------------------

  //==========================================================================
  virtual bool ConnectController(bool connect,
                                 const std::string& port_address,
                                 const std::string& controller_id)
  {
    return false;
  }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual bool InputEvent(const game_input_event& event) { return false; }
  //----------------------------------------------------------------------------

  //============================================================================
  bool KodiInputEvent(const game_input_event& event)
  {
    return m_instanceData->toKodi->InputEvent(m_instanceData->toKodi->kodiInstance, &event);
  }
  //----------------------------------------------------------------------------


  //--==----==----==----==----==----==----==----==----==----==----==----==----==--

  //============================================================================

  //============================================================================
  virtual size_t SerializeSize() { return 0; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR Serialize(uint8_t* data, size_t size) { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR Deserialize(const uint8_t* data, size_t size)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------


  //--==----==----==----==----==----==----==----==----==----==----==----==----==--

  //============================================================================

  //============================================================================
  virtual GAME_ERROR CheatReset() { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR GetMemory(GAME_MEMORY type, uint8_t*& data, size_t& size)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------

  //============================================================================
  virtual GAME_ERROR SetCheat(unsigned int index, bool enabled, const std::string& code)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }

  //============================================================================
  virtual GAME_ERROR RCGenerateHashFromFile(std::string& hash,
                                            unsigned int consoleID,
                                            const std::string& filePath)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }

  //============================================================================
  virtual GAME_ERROR RCGetGameIDUrl(std::string& url, const std::string& hash)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }

  //============================================================================
  virtual GAME_ERROR RCGetPatchFileUrl(std::string& url,
                                       const std::string& username,
                                       const std::string& token,
                                       unsigned int gameID)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }

  //============================================================================
  virtual GAME_ERROR RCPostRichPresenceUrl(std::string& url,
                                           std::string& postData,
                                           const std::string& username,
                                           const std::string& token,
                                           unsigned int gameID,
                                           const std::string& richPresence)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }

  //============================================================================
  virtual GAME_ERROR RCEnableRichPresence(const std::string& script)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }

  //============================================================================
  virtual GAME_ERROR RCGetRichPresenceEvaluation(std::string& evaluation, unsigned int consoleID)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }

  //============================================================================
  virtual GAME_ERROR RCResetRuntime() { return GAME_ERROR_NOT_IMPLEMENTED; }

  //----------------------------------------------------------------------------


private:
  void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance)
  {
    instance->hdl = this;

    instance->game->toAddon->LoadGame = ADDON_LoadGame;
    instance->game->toAddon->LoadGameSpecial = ADDON_LoadGameSpecial;
    instance->game->toAddon->LoadStandalone = ADDON_LoadStandalone;
    instance->game->toAddon->UnloadGame = ADDON_UnloadGame;
    instance->game->toAddon->GetGameTiming = ADDON_GetGameTiming;
    instance->game->toAddon->GetRegion = ADDON_GetRegion;
    instance->game->toAddon->RequiresGameLoop = ADDON_RequiresGameLoop;
    instance->game->toAddon->RunFrame = ADDON_RunFrame;
    instance->game->toAddon->Reset = ADDON_Reset;

    instance->game->toAddon->HwContextReset = ADDON_HwContextReset;
    instance->game->toAddon->HwContextDestroy = ADDON_HwContextDestroy;

    instance->game->toAddon->HasFeature = ADDON_HasFeature;
    instance->game->toAddon->GetTopology = ADDON_GetTopology;
    instance->game->toAddon->FreeTopology = ADDON_FreeTopology;
    instance->game->toAddon->SetControllerLayouts = ADDON_SetControllerLayouts;
    instance->game->toAddon->EnableKeyboard = ADDON_EnableKeyboard;
    instance->game->toAddon->EnableMouse = ADDON_EnableMouse;
    instance->game->toAddon->ConnectController = ADDON_ConnectController;
    instance->game->toAddon->InputEvent = ADDON_InputEvent;

    instance->game->toAddon->SerializeSize = ADDON_SerializeSize;
    instance->game->toAddon->Serialize = ADDON_Serialize;
    instance->game->toAddon->Deserialize = ADDON_Deserialize;

    instance->game->toAddon->CheatReset = ADDON_CheatReset;
    instance->game->toAddon->GetMemory = ADDON_GetMemory;
    instance->game->toAddon->SetCheat = ADDON_SetCheat;

    instance->game->toAddon->RCGenerateHashFromFile = ADDON_RCGenerateHashFromFile;
    instance->game->toAddon->RCGetGameIDUrl = ADDON_RCGetGameIDUrl;
    instance->game->toAddon->RCGetPatchFileUrl = ADDON_RCGetPatchFileUrl;
    instance->game->toAddon->RCPostRichPresenceUrl = ADDON_RCPostRichPresenceUrl;
    instance->game->toAddon->RCEnableRichPresence = ADDON_RCEnableRichPresence;
    instance->game->toAddon->RCGetRichPresenceEvaluation = ADDON_RCGetRichPresenceEvaluation;
    instance->game->toAddon->RCResetRuntime = ADDON_RCResetRuntime;

    instance->game->toAddon->FreeString = ADDON_FreeString;

    m_instanceData = instance->game;
    m_instanceData->toAddon->addonInstance = this;
  }

  // --- Game operations ---------------------------------------------------------

  inline static GAME_ERROR ADDON_LoadGame(const AddonInstance_Game* instance, const char* url)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->LoadGame(url);
  }

  inline static GAME_ERROR ADDON_LoadGameSpecial(const AddonInstance_Game* instance,
                                                 SPECIAL_GAME_TYPE type,
                                                 const char** urls,
                                                 size_t urlCount)
  {
    std::vector<std::string> urlList;
    for (size_t i = 0; i < urlCount; ++i)
    {
      if (urls[i] != nullptr)
        urlList.push_back(urls[i]);
    }

    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->LoadGameSpecial(type, urlList);
  }

  inline static GAME_ERROR ADDON_LoadStandalone(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->LoadStandalone();
  }

  inline static GAME_ERROR ADDON_UnloadGame(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->UnloadGame();
  }

  inline static GAME_ERROR ADDON_GetGameTiming(const AddonInstance_Game* instance,
                                               game_system_timing* timing_info)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->GetGameTiming(*timing_info);
  }

  inline static GAME_REGION ADDON_GetRegion(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->GetRegion();
  }

  inline static bool ADDON_RequiresGameLoop(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->RequiresGameLoop();
  }

  inline static GAME_ERROR ADDON_RunFrame(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->RunFrame();
  }

  inline static GAME_ERROR ADDON_Reset(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->Reset();
  }

  // --- Hardware rendering operations -------------------------------------------

  inline static GAME_ERROR ADDON_HwContextReset(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->HwContextReset();
  }

  inline static GAME_ERROR ADDON_HwContextDestroy(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->HwContextDestroy();
  }

  // --- Input operations --------------------------------------------------------

  inline static bool ADDON_HasFeature(const AddonInstance_Game* instance,
                                      const char* controller_id,
                                      const char* feature_name)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->HasFeature(controller_id, feature_name);
  }

  inline static game_input_topology* ADDON_GetTopology(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->GetTopology();
  }

  inline static void ADDON_FreeTopology(const AddonInstance_Game* instance,
                                        game_input_topology* topology)
  {
    static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->FreeTopology(topology);
  }

  inline static void ADDON_SetControllerLayouts(const AddonInstance_Game* instance,
                                                const game_controller_layout* controllers,
                                                unsigned int controller_count)
  {
    if (controllers == nullptr)
      return;

    std::vector<GameControllerLayout> controllerList;
    for (unsigned int i = 0; i < controller_count; ++i)
      controllerList.push_back(controllers[i]);

    static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->SetControllerLayouts(controllerList);
  }

  inline static bool ADDON_EnableKeyboard(const AddonInstance_Game* instance,
                                          bool enable,
                                          const char* controller_id)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->EnableKeyboard(enable, controller_id);
  }

  inline static bool ADDON_EnableMouse(const AddonInstance_Game* instance,
                                       bool enable,
                                       const char* controller_id)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->EnableMouse(enable, controller_id);
  }

  inline static bool ADDON_ConnectController(const AddonInstance_Game* instance,
                                             bool connect,
                                             const char* port_address,
                                             const char* controller_id)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->ConnectController(connect, port_address, controller_id);
  }

  inline static bool ADDON_InputEvent(const AddonInstance_Game* instance,
                                      const game_input_event* event)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->InputEvent(*event);
  }

  // --- Serialization operations ------------------------------------------------

  inline static size_t ADDON_SerializeSize(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->SerializeSize();
  }

  inline static GAME_ERROR ADDON_Serialize(const AddonInstance_Game* instance,
                                           uint8_t* data,
                                           size_t size)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->Serialize(data, size);
  }

  inline static GAME_ERROR ADDON_Deserialize(const AddonInstance_Game* instance,
                                             const uint8_t* data,
                                             size_t size)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->Deserialize(data, size);
  }

  // --- Cheat operations --------------------------------------------------------

  inline static GAME_ERROR ADDON_CheatReset(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->CheatReset();
  }

  inline static GAME_ERROR ADDON_GetMemory(const AddonInstance_Game* instance,
                                           GAME_MEMORY type,
                                           uint8_t** data,
                                           size_t* size)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->GetMemory(type, *data, *size);
  }

  inline static GAME_ERROR ADDON_SetCheat(const AddonInstance_Game* instance,
                                          unsigned int index,
                                          bool enabled,
                                          const char* code)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->SetCheat(index, enabled, code);
  }

  inline static GAME_ERROR ADDON_RCGenerateHashFromFile(const AddonInstance_Game* instance,
                                                        char** hash,
                                                        unsigned int consoleID,
                                                        const char* filePath)
  {
    std::string cppHash;

    GAME_ERROR ret = static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
                         ->RCGenerateHashFromFile(cppHash, consoleID, filePath);
    if (!cppHash.empty() && hash)
    {
      *hash = new char[cppHash.size() + 1];
      std::copy(cppHash.begin(), cppHash.end(), *hash);
      (*hash)[cppHash.size()] = '\0';
    }
    return ret;
  }

  inline static GAME_ERROR ADDON_RCGetGameIDUrl(const AddonInstance_Game* instance,
                                                char** url,
                                                const char* hash)
  {
    std::string cppUrl;
    GAME_ERROR ret =
        static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->RCGetGameIDUrl(cppUrl, hash);
    if (!cppUrl.empty() && url)
    {
      *url = new char[cppUrl.size() + 1];
      std::copy(cppUrl.begin(), cppUrl.end(), *url);
      (*url)[cppUrl.size()] = '\0';
    }
    return ret;
  }

  inline static GAME_ERROR ADDON_RCGetPatchFileUrl(const AddonInstance_Game* instance,
                                                   char** url,
                                                   const char* username,
                                                   const char* token,
                                                   unsigned int gameID)
  {
    std::string cppUrl;

    GAME_ERROR ret = static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
                         ->RCGetPatchFileUrl(cppUrl, username, token, gameID);
    if (!cppUrl.empty() && url)
    {
      *url = new char[cppUrl.size() + 1];
      std::copy(cppUrl.begin(), cppUrl.end(), *url);
      (*url)[cppUrl.size()] = '\0';
    }
    return ret;
  }

  inline static GAME_ERROR ADDON_RCPostRichPresenceUrl(const AddonInstance_Game* instance,
                                                       char** url,
                                                       char** postData,
                                                       const char* username,
                                                       const char* token,
                                                       unsigned int gameID,
                                                       const char* richPresence)
  {
    std::string cppUrl;
    std::string cppPostData;
    GAME_ERROR ret =
        static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
            ->RCPostRichPresenceUrl(cppUrl, cppPostData, username, token, gameID, richPresence);
    if (!cppUrl.empty())
    {
      *url = new char[cppUrl.size() + 1];
      std::copy(cppUrl.begin(), cppUrl.end(), *url);
      (*url)[cppUrl.size()] = '\0';
    }
    if (!cppPostData.empty())
    {
      *postData = new char[cppPostData.size() + 1];
      std::copy(cppPostData.begin(), cppPostData.end(), *postData);
      (*postData)[cppPostData.size()] = '\0';
    }

    return ret;
  }

  inline static GAME_ERROR ADDON_RCEnableRichPresence(const AddonInstance_Game* instance,
                                                      const char* script)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->RCEnableRichPresence(script);
  }

  inline static GAME_ERROR ADDON_RCGetRichPresenceEvaluation(const AddonInstance_Game* instance,
                                                             char** evaluation,
                                                             unsigned int consoleID)
  {
    std::string cppEvaluation;
    GAME_ERROR ret = static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
                         ->RCGetRichPresenceEvaluation(cppEvaluation, consoleID);
    if (!cppEvaluation.empty())
    {
      *evaluation = new char[cppEvaluation.size() + 1];
      std::copy(cppEvaluation.begin(), cppEvaluation.end(), *evaluation);
      (*evaluation)[cppEvaluation.size()] = '\0';
    }

    return ret;
  }

  inline static GAME_ERROR ADDON_RCResetRuntime(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->RCResetRuntime();
  }

  inline static void ADDON_FreeString(const AddonInstance_Game* instance, char* str)
  {
    delete[] str;
  }

  AddonInstance_Game* m_instanceData;
};

} /* namespace addon */
} /* namespace kodi */

#endif /* __cplusplus */