Game.h

/*
 *  Copyright (C) 2014-2025 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>
#include <functional>
 
#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.emplace_back(layout.digital_buttons[i]);
    for (unsigned int i = 0; i < layout.analog_button_count; ++i)
      analog_buttons.emplace_back(layout.analog_buttons[i]);
    for (unsigned int i = 0; i < layout.analog_stick_count; ++i)
      analog_sticks.emplace_back(layout.analog_sticks[i]);
    for (unsigned int i = 0; i < layout.accelerometer_count; ++i)
      accelerometers.emplace_back(layout.accelerometers[i]);
    for (unsigned int i = 0; i < layout.key_count; ++i)
      keys.emplace_back(layout.keys[i]);
    for (unsigned int i = 0; i < layout.rel_pointer_count; ++i)
      rel_pointers.emplace_back(layout.rel_pointers[i]);
    for (unsigned int i = 0; i < layout.abs_pointer_count; ++i)
      abs_pointers.emplace_back(layout.abs_pointers[i]);
    for (unsigned int i = 0; i < layout.motor_count; ++i)
      motors.emplace_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: Cannot create more than one game instance!");
    }
    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.emplace_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.emplace_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.emplace_back(m_instanceData->props->extensions[i]);
    }
    return !extensions.empty();
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  std::string LibretroCore() const
  {
    if (!IsInstanceAPIVersionAtLeast(8, 2, 1) || m_instanceData->props->libretro_core == nullptr)
      return "";
    return m_instanceData->props->libretro_core;
  }
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
 
  //============================================================================
  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 RunFrameSpeculative() { 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); }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void ReportMissingFile(const std::string& path)
  {
    if (IsInstanceAPIVersionAtLeast(8, 3, 0))
      m_instanceData->toKodi->ReportMissingFile(m_instanceData->toKodi->kodiInstance, path.c_str());
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  double GetPlaybackSpeed()
  {
    return m_instanceData->toKodi->GetPlaybackSpeed(m_instanceData->toKodi->kodiInstance);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void SetGameTiming(const game_system_timing& timingInfo)
  {
    m_instanceData->toKodi->SetGameTiming(m_instanceData->toKodi->kodiInstance, &timingInfo);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void SetFastForwarding(bool fastForward, double ratio)
  {
    if (IsInstanceAPIVersionAtLeast(8, 4, 0))
      m_instanceData->toKodi->SetFastForwarding(m_instanceData->toKodi->kodiInstance, fastForward,
                                                ratio);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  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 reopened");
        Close();
      }
 
      AddonToKodiFuncTable_Game& cb =
          *static_cast<CInstanceGame*>(CPrivateBase::m_interface->globalSingleInstance)
               ->m_instanceData->toKodi;
      m_handle = cb.OpenStream(cb.kodiInstance, &properties);
      if (m_handle && properties.type == GAME_STREAM_HW_FRAMEBUFFER)
      {
        const KODI_GAME_STREAM_HANDLE handle = m_handle;
        const bool started = cb.StartStream(cb.kodiInstance, handle);
        if (m_handle != handle)
          return false;
        if (!started)
          Close();
      }
      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;
      const KODI_GAME_STREAM_HANDLE handle = m_handle;
      cb.CloseStream(cb.kodiInstance, handle);
      if (m_handle == 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;
  };
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
 
  //==========================================================================
  bool EnableHardwareRendering(const game_hw_rendering_properties& properties)
  {
    return m_instanceData->toKodi->EnableHardwareRendering(m_instanceData->toKodi->kodiInstance,
                                                           &properties);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  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 GAME_ERROR AudioAvailable() { return GAME_ERROR_NOT_IMPLEMENTED; }
  //--------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
 
  //============================================================================
  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 SerializeSpeculative(uint8_t* data, size_t size)
  {
    return Serialize(data, size);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR DeserializeSpeculative(const uint8_t* data, size_t size)
  {
    return Deserialize(data, size);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual size_t AchievementStateSize() { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR SerializeAchievements(uint8_t* data, size_t size)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR DeserializeAchievements(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 SetRetroAchievementsCredentials(const std::string& username,
                                                     const std::string& token)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
 
  //============================================================================
  virtual GAME_ERROR RCSetHardcoreEnabled(bool enabled) { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR RCSetEncoreModeEnabled(bool enabled) { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR RCSetAchievementSetEnabled(unsigned int setId, bool enabled)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
  //============================================================================
  virtual GAME_ERROR ActivateAchievement(unsigned int cheevoId,
                                         const std::string& memAddrExpression)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
 
  //============================================================================
  virtual GAME_ERROR GetCheevoUrlId(
      const std::function<void(const std::string& achievementUrl, unsigned int cheevoId)>& callback)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //============================================================================
  void RCOnGameLoaded(const game_rc_game_loaded& data)
  {
    m_instanceData->toKodi->RCOnGameLoaded(m_instanceData->toKodi->kodiInstance, &data);
  }
 
  //============================================================================
  void RCOnAchievementTriggered(const game_rc_achievement_triggered& data)
  {
    m_instanceData->toKodi->RCOnAchievementTriggered(m_instanceData->toKodi->kodiInstance, &data);
  }
 
  //============================================================================
  void RCOnGameCompleted(const std::string& title, bool hardcore)
  {
    m_instanceData->toKodi->RCOnGameCompleted(m_instanceData->toKodi->kodiInstance, title.c_str(),
                                              hardcore);
  }
 
  //============================================================================
  void RCOnRichPresenceUpdated(const std::string& evaluation)
  {
    m_instanceData->toKodi->RCOnRichPresenceUpdated(m_instanceData->toKodi->kodiInstance,
                                                    evaluation.c_str());
  }
 
  //============================================================================
  void RCOnLoginResult(const game_rc_login_result& data)
  {
    m_instanceData->toKodi->RCOnLoginResult(m_instanceData->toKodi->kodiInstance, &data);
  }
 
  //============================================================================
  void RCOnAchievementProgress(const std::vector<game_rc_achievement_progress>& progress)
  {
    m_instanceData->toKodi->RCOnAchievementProgress(m_instanceData->toKodi->kodiInstance,
                                                    progress.empty() ? nullptr : progress.data(),
                                                    static_cast<unsigned int>(progress.size()));
  }
 
  //============================================================================
  void RCOnServerError(const std::string& message, const std::string& api)
  {
    m_instanceData->toKodi->RCOnServerError(m_instanceData->toKodi->kodiInstance, message.c_str(),
                                            api.c_str());
  }
 
  //============================================================================
  void RCOnConnectionChanged(bool connected)
  {
    m_instanceData->toKodi->RCOnConnectionChanged(m_instanceData->toKodi->kodiInstance, connected);
  }
 
  //============================================================================
  void RCOnChallengeIndicator(const game_rc_achievement_challenge& data, bool show)
  {
    m_instanceData->toKodi->RCOnChallengeIndicator(m_instanceData->toKodi->kodiInstance, &data,
                                                   show);
  }
 
  //============================================================================
  void RCOnAchievementProgressUpdate(const game_rc_achievement_progress_indicator& data)
  {
    m_instanceData->toKodi->RCOnAchievementProgressUpdate(m_instanceData->toKodi->kodiInstance,
                                                          &data);
  }
 
  //============================================================================
  void RCOnLeaderboardStarted(const game_rc_leaderboard& data)
  {
    m_instanceData->toKodi->RCOnLeaderboardStarted(m_instanceData->toKodi->kodiInstance, &data);
  }
 
  //============================================================================
  void RCOnLeaderboardFailed(const game_rc_leaderboard& data)
  {
    m_instanceData->toKodi->RCOnLeaderboardFailed(m_instanceData->toKodi->kodiInstance, &data);
  }
 
  //============================================================================
  void RCOnLeaderboardSubmitted(const game_rc_leaderboard& data)
  {
    m_instanceData->toKodi->RCOnLeaderboardSubmitted(m_instanceData->toKodi->kodiInstance, &data);
  }
 
  //============================================================================
  void RCOnLeaderboardTrackerUpdate(const game_rc_leaderboard_tracker& data)
  {
    m_instanceData->toKodi->RCOnLeaderboardTrackerUpdate(m_instanceData->toKodi->kodiInstance,
                                                         &data);
  }
 
  //============================================================================
  void RCOnLeaderboardScoreboard(const game_rc_leaderboard_scoreboard& data)
  {
    m_instanceData->toKodi->RCOnLeaderboardScoreboard(m_instanceData->toKodi->kodiInstance, &data);
  }
 
  //============================================================================
  void RCOnReset() { m_instanceData->toKodi->RCOnReset(m_instanceData->toKodi->kodiInstance); }
 
  //============================================================================
  void RCOnSubsetCompleted(const std::string& title)
  {
    m_instanceData->toKodi->RCOnSubsetCompleted(m_instanceData->toKodi->kodiInstance,
                                                title.c_str());
  }
 
  //============================================================================
  void RCOnAchievementSets(const game_rc_achievement_sets& data)
  {
    if (IsInstanceAPIVersionAtLeast(8, 5, 0))
      m_instanceData->toKodi->RCOnAchievementSets(m_instanceData->toKodi->kodiInstance, &data);
  }
 
  //============================================================================
  void RCOnAchievementProgressIndicator(const game_rc_achievement_progress_indicator& data,
                                        bool show)
  {
    if (show)
      m_instanceData->toKodi->RCOnAchievementProgressShow(m_instanceData->toKodi->kodiInstance,
                                                          &data);
    else
      m_instanceData->toKodi->RCOnAchievementProgressHide(m_instanceData->toKodi->kodiInstance,
                                                          &data);
  }
 
  //============================================================================
  void RCOnLeaderboardTracker(const game_rc_leaderboard_tracker& data, bool show)
  {
    if (show)
      m_instanceData->toKodi->RCOnLeaderboardTrackerShow(m_instanceData->toKodi->kodiInstance,
                                                         &data);
    else
      m_instanceData->toKodi->RCOnLeaderboardTrackerHide(m_instanceData->toKodi->kodiInstance,
                                                         &data);
  }
 
  //----------------------------------------------------------------------------
 
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==--
 
  //============================================================================
 
  //============================================================================
  virtual bool GetEjectState() { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR SetEjectState(bool ejected) { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual unsigned int GetImageIndex() { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR SetImageIndex(unsigned int imageIndex) { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual unsigned int GetImageCount() { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR AddImageIndex() { return GAME_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR ReplaceImageIndex(unsigned int imageIndex, const std::string& filePath)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR RemoveImageIndex(unsigned int imageIndex)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual GAME_ERROR SetInitialImage(unsigned int imageIndex, const std::string& filePath)
  {
    return GAME_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual std::string GetImagePath(unsigned int imageIndex) { return ""; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual std::string GetImageLabel(unsigned int imageIndex) { return ""; }
  //----------------------------------------------------------------------------
 
 
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->AudioAvailable = ADDON_AudioAvailable;
 
    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->AchievementStateSize = ADDON_AchievementStateSize;
    instance->game->toAddon->SerializeAchievements = ADDON_SerializeAchievements;
    instance->game->toAddon->DeserializeAchievements = ADDON_DeserializeAchievements;
 
    instance->game->toAddon->CheatReset = ADDON_CheatReset;
    instance->game->toAddon->GetMemory = ADDON_GetMemory;
    instance->game->toAddon->SetCheat = ADDON_SetCheat;
 
    instance->game->toAddon->SetRetroAchievementsCredentials =
        ADDON_SetRetroAchievementsCredentials;
    instance->game->toAddon->RCSetHardcoreEnabled = ADDON_RCSetHardcoreEnabled;
    instance->game->toAddon->RCSetEncoreModeEnabled = ADDON_RCSetEncoreModeEnabled;
    instance->game->toAddon->ActivateAchievement = ADDON_ActivateAchievement;
    instance->game->toAddon->GetCheevoUrlId = ADDON_GetCheevoUrlId;
 
    instance->game->toAddon->GetEjectState = ADDON_GetEjectState;
    instance->game->toAddon->SetEjectState = ADDON_SetEjectState;
    instance->game->toAddon->GetImageIndex = ADDON_GetImageIndex;
    instance->game->toAddon->SetImageIndex = ADDON_SetImageIndex;
    instance->game->toAddon->GetImageCount = ADDON_GetImageCount;
    instance->game->toAddon->AddImageIndex = ADDON_AddImageIndex;
    instance->game->toAddon->ReplaceImageIndex = ADDON_ReplaceImageIndex;
    instance->game->toAddon->RemoveImageIndex = ADDON_RemoveImageIndex;
    instance->game->toAddon->SetInitialImage = ADDON_SetInitialImage;
    instance->game->toAddon->GetImagePath = ADDON_GetImagePath;
    instance->game->toAddon->GetImageLabel = ADDON_GetImageLabel;
 
    instance->game->toAddon->FreeString = ADDON_FreeString;
 
    // An older Kodi's table ends before these entries
    if (IsInstanceAPIVersionAtLeast(8, 5, 0))
      instance->game->toAddon->RCSetAchievementSetEnabled = ADDON_RCSetAchievementSetEnabled;
    if (IsInstanceAPIVersionAtLeast(8, 6, 0))
    {
      instance->game->toAddon->RunFrameSpeculative = ADDON_RunFrameSpeculative;
      instance->game->toAddon->SerializeSpeculative = ADDON_SerializeSpeculative;
      instance->game->toAddon->DeserializeSpeculative = ADDON_DeserializeSpeculative;
    }
 
    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.emplace_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_RunFrameSpeculative(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->RunFrameSpeculative();
  }
 
  inline static GAME_ERROR ADDON_SerializeSpeculative(const AddonInstance_Game* instance,
                                                      uint8_t* data,
                                                      size_t size)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->SerializeSpeculative(data, size);
  }
 
  inline static GAME_ERROR ADDON_DeserializeSpeculative(const AddonInstance_Game* instance,
                                                        const uint8_t* data,
                                                        size_t size)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->DeserializeSpeculative(data, size);
  }
 
  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();
  }
 
  // --- Audio operations --------------------------------------------------------
 
  inline static GAME_ERROR ADDON_AudioAvailable(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->AudioAvailable();
  }
 
  // --- 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;
    controllerList.reserve(controller_count);
    for (unsigned int i = 0; i < controller_count; ++i)
      controllerList.emplace_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);
  }
 
  inline static size_t ADDON_AchievementStateSize(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->AchievementStateSize();
  }
 
  inline static GAME_ERROR ADDON_SerializeAchievements(const AddonInstance_Game* instance,
                                                       uint8_t* data,
                                                       size_t size)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->SerializeAchievements(data, size);
  }
 
  inline static GAME_ERROR ADDON_DeserializeAchievements(const AddonInstance_Game* instance,
                                                         const uint8_t* data,
                                                         size_t size)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->DeserializeAchievements(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_SetRetroAchievementsCredentials(const AddonInstance_Game* instance,
                                                                 const char* username,
                                                                 const char* token)
  {
    if (username == nullptr || token == nullptr)
      return GAME_ERROR_INVALID_PARAMETERS;
 
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->SetRetroAchievementsCredentials(username, token);
  }
 
  inline static GAME_ERROR ADDON_RCSetHardcoreEnabled(const AddonInstance_Game* instance,
                                                      bool enabled)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->RCSetHardcoreEnabled(enabled);
  }
 
  inline static GAME_ERROR ADDON_RCSetEncoreModeEnabled(const AddonInstance_Game* instance,
                                                        bool enabled)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->RCSetEncoreModeEnabled(enabled);
  }
 
  inline static GAME_ERROR ADDON_RCSetAchievementSetEnabled(const AddonInstance_Game* instance,
                                                            unsigned int setId,
                                                            bool enabled)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->RCSetAchievementSetEnabled(setId, enabled);
  }
 
  inline static GAME_ERROR ADDON_ActivateAchievement(const AddonInstance_Game* instance,
                                                     unsigned int cheevoId,
                                                     const char* memAddrExpression)
  {
    if (memAddrExpression == nullptr)
      return GAME_ERROR_INVALID_PARAMETERS;
 
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->ActivateAchievement(cheevoId, memAddrExpression);
  }
 
  inline static GAME_ERROR ADDON_GetCheevoUrlId(const AddonInstance_Game* instance,
                                                void(__cdecl* callback)(const void* context,
                                                                        const char* achievementUrl,
                                                                        unsigned int cheevoId),
                                                const void* context)
  {
    if (callback == nullptr)
      return GAME_ERROR_INVALID_PARAMETERS;
 
    const auto cppCallback =
        [callback, context](const std::string& achievementUrl, unsigned int cheevoId)
    { callback(context, achievementUrl.c_str(), cheevoId); };
 
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->GetCheevoUrlId(cppCallback);
  }
 
  inline static bool ADDON_GetEjectState(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->GetEjectState();
  }
 
  inline static GAME_ERROR ADDON_SetEjectState(const AddonInstance_Game* instance, bool ejected)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->SetEjectState(ejected);
  }
 
  inline static unsigned int ADDON_GetImageIndex(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->GetImageIndex();
  }
 
  inline static GAME_ERROR ADDON_SetImageIndex(const AddonInstance_Game* instance,
                                               unsigned int imageIndex)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->SetImageIndex(imageIndex);
  }
 
  inline static unsigned int ADDON_GetImageCount(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->GetImageCount();
  }
 
  inline static GAME_ERROR ADDON_AddImageIndex(const AddonInstance_Game* instance)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->AddImageIndex();
  }
 
  inline static GAME_ERROR ADDON_ReplaceImageIndex(const AddonInstance_Game* instance,
                                                   unsigned int imageIndex,
                                                   const char* filePath)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->ReplaceImageIndex(imageIndex, filePath ? filePath : "");
  }
 
  inline static GAME_ERROR ADDON_RemoveImageIndex(const AddonInstance_Game* instance,
                                                  unsigned int imageIndex)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->RemoveImageIndex(imageIndex);
  }
 
  inline static GAME_ERROR ADDON_SetInitialImage(const AddonInstance_Game* instance,
                                                 unsigned int imageIndex,
                                                 const char* filePath)
  {
    return static_cast<CInstanceGame*>(instance->toAddon->addonInstance)
        ->SetInitialImage(imageIndex, filePath ? filePath : "");
  }
 
  inline static char* ADDON_GetImagePath(const AddonInstance_Game* instance,
                                         unsigned int imageIndex)
  {
    std::string cppPath =
        static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->GetImagePath(imageIndex);
    if (cppPath.empty())
      return nullptr;
 
    char* path = new char[cppPath.size() + 1];
    std::copy(cppPath.begin(), cppPath.end(), path);
    path[cppPath.size()] = '\0';
    return path;
  }
 
  inline static char* ADDON_GetImageLabel(const AddonInstance_Game* instance,
                                          unsigned int imageIndex)
  {
    std::string cppLabel =
        static_cast<CInstanceGame*>(instance->toAddon->addonInstance)->GetImageLabel(imageIndex);
    if (cppLabel.empty())
      return nullptr;
 
    char* label = new char[cppLabel.size() + 1];
    std::copy(cppLabel.begin(), cppLabel.end(), label);
    label[cppLabel.size()] = '\0';
    return label;
  }
 
  inline static void ADDON_FreeString(const AddonInstance_Game* instance, char* str)
  {
    delete[] str;
  }
 
  AddonInstance_Game* m_instanceData;
};
 
} /* namespace addon */
} /* namespace kodi */
 
#endif /* __cplusplus */