gemba 0.1.1 → 0.2.0

data/vendor/rcheevos/src/rc_client_external.c

@@ -0,0 +1,281 @@
+#include "rc_client_external.h"
+
+#include "rc_client_external_versions.h"
+#include "rc_client_internal.h"
+
+#include "rc_api_runtime.h"
+
+#ifdef RC_CLIENT_SUPPORTS_EXTERNAL
+
+#define RC_CONVERSION_FILL(obj, obj_type, src_type) memset((uint8_t*)obj + sizeof(src_type), 0, sizeof(obj_type) - sizeof(src_type))
+
+/* https://media.retroachievements.org/Badge/123456_lock.png is 58 with null terminator */
+#define RC_CLIENT_IMAGE_URL_BUFFER_SIZE 64
+/* https://media.retroachievements.org/UserPic/TwentyCharUserNameXX.png is 69 with null terminator */
+#define RC_CLIENT_USER_IMAGE_URL_BUFFER_SIZE 80
+
+typedef struct rc_client_external_conversions_t {
+  rc_client_user_t user;
+  rc_client_game_t game;
+  rc_client_subset_t subsets[4];
+  rc_client_achievement_t achievements[16];
+  char user_avatar_url[RC_CLIENT_USER_IMAGE_URL_BUFFER_SIZE];
+  char game_badge_url[RC_CLIENT_IMAGE_URL_BUFFER_SIZE];
+  char subset_badge_url[4][RC_CLIENT_IMAGE_URL_BUFFER_SIZE];
+  char achievement_badge_url[16][RC_CLIENT_IMAGE_URL_BUFFER_SIZE];
+  char achievement_badge_locked_url[16][RC_CLIENT_IMAGE_URL_BUFFER_SIZE];
+  uint32_t next_subset_index;
+  uint32_t next_achievement_index;
+} rc_client_external_conversions_t;
+
+static const char* rc_client_external_build_avatar_url(char buffer[], size_t buffer_size, uint32_t image_type, const char* image_name)
+{
+  rc_api_fetch_image_request_t image_request;
+  rc_api_request_t request;
+  int result;
+
+  memset(&image_request, 0, sizeof(image_request));
+  image_request.image_type = image_type;
+  image_request.image_name = image_name;
+
+  result = rc_api_init_fetch_image_request(&request, &image_request);
+  if (result != RC_OK)
+    return NULL;
+
+  snprintf(buffer, buffer_size, "%s", request.url);
+  return buffer;
+}
+
+static void rc_client_external_conversions_init(const rc_client_t* client)
+{
+  if (!client->state.external_client_conversions) {
+    rc_client_t* mutable_client = (rc_client_t*)client;
+    rc_client_external_conversions_t* conversions = (rc_client_external_conversions_t*)
+      rc_buffer_alloc(&mutable_client->state.buffer, sizeof(rc_client_external_conversions_t));
+
+    memset(conversions, 0, sizeof(*conversions));
+
+    mutable_client->state.external_client_conversions = conversions;
+  }
+}
+
+const rc_client_user_t* rc_client_external_convert_v1_user(const rc_client_t* client, const rc_client_user_t* v1_user)
+{
+  rc_client_user_t* converted;
+
+  if (!v1_user)
+    return NULL;
+
+  rc_client_external_conversions_init(client);
+
+  converted = &client->state.external_client_conversions->user;
+  memcpy(converted, v1_user, sizeof(v1_rc_client_user_t));
+  RC_CONVERSION_FILL(converted, rc_client_user_t, v1_rc_client_user_t);
+
+  converted->avatar_url = rc_client_external_build_avatar_url(
+    client->state.external_client_conversions->user_avatar_url,
+    sizeof(client->state.external_client_conversions->user_avatar_url),
+    RC_IMAGE_TYPE_USER, v1_user->username);
+
+  return converted;
+}
+
+const rc_client_game_t* rc_client_external_convert_v1_game(const rc_client_t* client, const rc_client_game_t* v1_game)
+{
+  rc_client_game_t* converted;
+
+  if (!v1_game)
+    return NULL;
+
+  rc_client_external_conversions_init(client);
+
+  converted = &client->state.external_client_conversions->game;
+  memcpy(converted, v1_game, sizeof(v1_rc_client_game_t));
+  RC_CONVERSION_FILL(converted, rc_client_game_t, v1_rc_client_game_t);
+
+  converted->badge_url = rc_client_external_build_avatar_url(
+    client->state.external_client_conversions->game_badge_url,
+    sizeof(client->state.external_client_conversions->game_badge_url),
+    RC_IMAGE_TYPE_GAME, v1_game->badge_name);
+
+  return converted;
+}
+
+const rc_client_subset_t* rc_client_external_convert_v1_subset(const rc_client_t* client, const rc_client_subset_t* v1_subset)
+{
+  rc_client_subset_t* converted = NULL;
+  char* badge_url = NULL;
+  const uint32_t num_subsets = sizeof(client->state.external_client_conversions->subsets) / sizeof(client->state.external_client_conversions->subsets[0]);
+  uint32_t index;
+
+  if (!v1_subset)
+    return NULL;
+
+  rc_client_external_conversions_init(client);
+
+  for (index = 0; index < num_subsets; ++index) {
+    if (client->state.external_client_conversions->subsets[index].id == v1_subset->id) {
+      converted = &client->state.external_client_conversions->subsets[index];
+      badge_url = client->state.external_client_conversions->subset_badge_url[index];
+      break;
+    }
+  }
+
+  if (!converted) {
+    index = client->state.external_client_conversions->next_subset_index;
+    converted = &client->state.external_client_conversions->subsets[index];
+    badge_url = client->state.external_client_conversions->subset_badge_url[client->state.external_client_conversions->next_subset_index];
+    client->state.external_client_conversions->next_subset_index = (index + 1) % num_subsets;
+  }
+
+  memcpy(converted, v1_subset, sizeof(v1_rc_client_subset_t));
+  RC_CONVERSION_FILL(converted, rc_client_subset_t, v1_rc_client_subset_t);
+
+  converted->badge_url = rc_client_external_build_avatar_url(badge_url,
+    sizeof(client->state.external_client_conversions->subset_badge_url[0]),
+    RC_IMAGE_TYPE_GAME, v1_subset->badge_name);
+
+  return converted;
+}
+
+const rc_client_achievement_t* rc_client_external_convert_v1_achievement(const rc_client_t* client, const rc_client_achievement_t* v1_achievement)
+{
+  rc_client_achievement_t* converted = NULL;
+  char* badge_url = NULL;
+  char* badge_locked_url = NULL;
+  const uint32_t num_achievements = sizeof(client->state.external_client_conversions->achievements) / sizeof(client->state.external_client_conversions->achievements[0]);
+  uint32_t index;
+
+  if (!v1_achievement)
+    return NULL;
+
+  rc_client_external_conversions_init(client);
+
+  for (index = 0; index < num_achievements; ++index) {
+    if (client->state.external_client_conversions->achievements[index].id == v1_achievement->id) {
+      converted = &client->state.external_client_conversions->achievements[index];
+      badge_url = client->state.external_client_conversions->achievement_badge_url[index];
+      badge_locked_url = client->state.external_client_conversions->achievement_badge_locked_url[index];
+      break;
+    }
+  }
+
+  if (!converted) {
+    index = client->state.external_client_conversions->next_achievement_index;
+    converted = &client->state.external_client_conversions->achievements[index];
+    badge_url = client->state.external_client_conversions->achievement_badge_url[index];
+    badge_locked_url = client->state.external_client_conversions->achievement_badge_locked_url[index];
+    client->state.external_client_conversions->next_achievement_index = (index + 1) % num_achievements;
+  }
+
+  memcpy(converted, v1_achievement, sizeof(v1_rc_client_achievement_t));
+  RC_CONVERSION_FILL(converted, rc_client_achievement_t, v1_rc_client_achievement_t);
+
+  converted->badge_url = rc_client_external_build_avatar_url(badge_url,
+    sizeof(client->state.external_client_conversions->achievement_badge_url[0]),
+    RC_IMAGE_TYPE_ACHIEVEMENT, v1_achievement->badge_name);
+  converted->badge_locked_url = rc_client_external_build_avatar_url(badge_locked_url,
+    sizeof(client->state.external_client_conversions->achievement_badge_locked_url[0]),
+    RC_IMAGE_TYPE_ACHIEVEMENT_LOCKED, v1_achievement->badge_name);
+
+  return converted;
+}
+
+typedef struct rc_client_achievement_list_wrapper_t {
+  rc_client_achievement_list_info_t info;
+  rc_client_achievement_list_t* source_list;
+  rc_client_achievement_t* achievements;
+  rc_client_achievement_t** achievements_pointers;
+  char* badge_url_buffer;
+} rc_client_achievement_list_wrapper_t;
+
+static void rc_client_destroy_achievement_list_wrapper(rc_client_achievement_list_info_t* info)
+{
+  rc_client_achievement_list_wrapper_t* wrapper = (rc_client_achievement_list_wrapper_t*)info;
+
+  if (wrapper->achievements)
+    free(wrapper->achievements);
+  if (wrapper->achievements_pointers)
+    free(wrapper->achievements_pointers);
+  if (wrapper->info.public_.buckets)
+    free((void*)wrapper->info.public_.buckets);
+  if (wrapper->badge_url_buffer)
+    free(wrapper->badge_url_buffer);
+
+  rc_client_destroy_achievement_list(wrapper->source_list);
+
+  free(wrapper);
+}
+
+rc_client_achievement_list_t* rc_client_external_convert_v1_achievement_list(const rc_client_t* client, rc_client_achievement_list_t* v1_achievement_list)
+{
+  rc_client_achievement_list_wrapper_t* new_list;
+  (void)client;
+
+  if (!v1_achievement_list)
+    return NULL;
+
+  new_list = (rc_client_achievement_list_wrapper_t*)calloc(1, sizeof(*new_list));
+  if (!new_list)
+    return NULL;
+
+  new_list->source_list = v1_achievement_list;
+  new_list->info.destroy_func = rc_client_destroy_achievement_list_wrapper;
+
+  if (v1_achievement_list->num_buckets) {
+    const v1_rc_client_achievement_bucket_t* src_bucket = (const v1_rc_client_achievement_bucket_t*)&v1_achievement_list->buckets[0];
+    const v1_rc_client_achievement_bucket_t* stop_bucket = src_bucket + v1_achievement_list->num_buckets;
+    rc_client_achievement_bucket_t* bucket;
+    uint32_t num_achievements = 0;
+    char* badge_url = NULL;
+
+    new_list->info.public_.buckets = bucket = (rc_client_achievement_bucket_t*)calloc(v1_achievement_list->num_buckets, sizeof(*new_list->info.public_.buckets));
+    if (!new_list->info.public_.buckets)
+      return (rc_client_achievement_list_t*)new_list;
+
+    for (; src_bucket < stop_bucket; src_bucket++)
+      num_achievements += src_bucket->num_achievements;
+
+    if (num_achievements) {
+      new_list->achievements = (rc_client_achievement_t*)calloc(num_achievements, sizeof(*new_list->achievements));
+      new_list->achievements_pointers = (rc_client_achievement_t**)malloc(num_achievements * sizeof(rc_client_achievement_t*));
+      new_list->badge_url_buffer = badge_url = (char*)malloc(num_achievements * 2 * RC_CLIENT_IMAGE_URL_BUFFER_SIZE);
+      if (!new_list->achievements || !new_list->achievements_pointers || !new_list->badge_url_buffer)
+        return (rc_client_achievement_list_t*)new_list;
+    }
+
+    num_achievements = 0;
+    src_bucket = (const v1_rc_client_achievement_bucket_t*)&v1_achievement_list->buckets[0];
+    for (; src_bucket < stop_bucket; src_bucket++, bucket++) {
+      memcpy(bucket, src_bucket, sizeof(*src_bucket));
+
+      if (src_bucket->num_achievements) {
+        const v1_rc_client_achievement_t** src_achievement = (const v1_rc_client_achievement_t**)src_bucket->achievements;
+        const v1_rc_client_achievement_t** stop_achievement = src_achievement + src_bucket->num_achievements;
+        rc_client_achievement_t** achievement = &new_list->achievements_pointers[num_achievements];
+
+        bucket->achievements = (const rc_client_achievement_t**)achievement;
+
+        for (; src_achievement < stop_achievement; ++src_achievement, ++achievement) {
+          *achievement = &new_list->achievements[num_achievements++];
+          memcpy(*achievement, *src_achievement, sizeof(**src_achievement));
+
+          (*achievement)->badge_url = rc_client_external_build_avatar_url(badge_url,
+            sizeof(client->state.external_client_conversions->achievement_badge_url[0]),
+            RC_IMAGE_TYPE_ACHIEVEMENT, (*achievement)->badge_name);
+          badge_url += RC_CLIENT_IMAGE_URL_BUFFER_SIZE;
+          (*achievement)->badge_locked_url = rc_client_external_build_avatar_url(badge_url,
+            sizeof(client->state.external_client_conversions->achievement_badge_locked_url[0]),
+            RC_IMAGE_TYPE_ACHIEVEMENT_LOCKED, (*achievement)->badge_name);
+          badge_url += RC_CLIENT_IMAGE_URL_BUFFER_SIZE;
+        }
+      }
+    }
+
+    new_list->info.public_.num_buckets = v1_achievement_list->num_buckets;
+  }
+
+  return (rc_client_achievement_list_t*)new_list;
+}
+
+#endif /* RC_CLIENT_SUPPORTS_EXTERNAL */

data/vendor/rcheevos/src/rc_client_external.h

@@ -0,0 +1,177 @@
+#ifndef RC_CLIENT_EXTERNAL_H
+#define RC_CLIENT_EXTERNAL_H
+
+#include "rc_client.h"
+
+RC_BEGIN_C_DECLS
+
+/* NOTE: any function that is passed a callback also needs to be passed a client instance to pass
+ * to the callback, and the external interface has to capture both. */
+
+typedef void (RC_CCONV *rc_client_external_enable_logging_func_t)(rc_client_t* client, int level, rc_client_message_callback_t callback);
+typedef void (RC_CCONV *rc_client_external_set_event_handler_func_t)(rc_client_t* client, rc_client_event_handler_t handler);
+typedef void (RC_CCONV *rc_client_external_set_read_memory_func_t)(rc_client_t* client, rc_client_read_memory_func_t handler);
+typedef void (RC_CCONV *rc_client_external_set_get_time_millisecs_func_t)(rc_client_t* client, rc_get_time_millisecs_func_t handler);
+typedef int (RC_CCONV *rc_client_external_can_pause_func_t)(uint32_t* frames_remaining);
+
+typedef void (RC_CCONV *rc_client_external_set_int_func_t)(int value);
+typedef int (RC_CCONV *rc_client_external_get_int_func_t)(void);
+typedef void (RC_CCONV *rc_client_external_set_string_func_t)(const char* value);
+typedef size_t (RC_CCONV *rc_client_external_copy_string_func_t)(char buffer[], size_t buffer_size);
+typedef void (RC_CCONV *rc_client_external_action_func_t)(void);
+
+typedef void (RC_CCONV *rc_client_external_async_handle_func_t)(rc_client_async_handle_t* handle);
+
+typedef rc_client_async_handle_t* (RC_CCONV *rc_client_external_begin_login_func_t)(rc_client_t* client,
+    const char* username, const char* pass_token, rc_client_callback_t callback, void* callback_userdata);
+typedef const rc_client_user_t* (RC_CCONV *rc_client_external_get_user_info_func_t)(void);
+
+typedef rc_client_async_handle_t* (RC_CCONV *rc_client_external_begin_identify_and_load_game_func_t)(
+  rc_client_t* client, uint32_t console_id, const char* file_path,
+  const uint8_t* data, size_t data_size, rc_client_callback_t callback, void* callback_userdata);
+typedef rc_client_async_handle_t* (RC_CCONV *rc_client_external_begin_load_game_func_t)(rc_client_t* client,
+  const char* hash, rc_client_callback_t callback, void* callback_userdata);
+typedef rc_client_async_handle_t* (RC_CCONV *rc_client_external_begin_load_subset_t)(rc_client_t* client,
+  uint32_t subset_id, rc_client_callback_t callback, void* callback_userdata);
+typedef const rc_client_game_t* (RC_CCONV *rc_client_external_get_game_info_func_t)(void);
+typedef const rc_client_subset_t* (RC_CCONV *rc_client_external_get_subset_info_func_t)(uint32_t subset_id);
+typedef void (RC_CCONV* rc_client_external_get_user_subset_summary_func_t)(uint32_t subset_id, rc_client_user_game_summary_t* summary);
+typedef void (RC_CCONV *rc_client_external_get_user_game_summary_func_t)(rc_client_user_game_summary_t* summary);
+typedef rc_client_async_handle_t* (RC_CCONV *rc_client_external_begin_change_media_func_t)(rc_client_t* client, const char* file_path,
+  const uint8_t* data, size_t data_size, rc_client_callback_t callback, void* callback_userdata);
+typedef void (RC_CCONV* rc_client_external_add_game_hash_func_t)(const char* hash, uint32_t game_id);
+
+/* NOTE: rc_client_external_create_achievement_list_func_t returns an internal wrapper structure which contains the public list
+ * and a destructor function. */
+struct rc_client_achievement_list_info_t;
+typedef struct rc_client_achievement_list_info_t* (RC_CCONV *rc_client_external_create_achievement_list_func_t)(int category, int grouping);
+typedef const rc_client_achievement_t* (RC_CCONV *rc_client_external_get_achievement_info_func_t)(uint32_t id);
+typedef const rc_client_achievement_t* (RC_CCONV* rc_client_external_get_next_achievement_info_func_t)(uint32_t id, int grouping);
+
+/* NOTE: rc_client_external_create_leaderboard_list_func_t returns an internal wrapper structure which contains the public list
+ * and a destructor function. */
+struct rc_client_leaderboard_list_info_t;
+typedef struct rc_client_leaderboard_list_info_t* (RC_CCONV *rc_client_external_create_leaderboard_list_func_t)(int grouping);
+typedef const rc_client_leaderboard_t* (RC_CCONV *rc_client_external_get_leaderboard_info_func_t)(uint32_t id);
+
+/* NOTE: rc_client_external_begin_fetch_leaderboard_entries_func_t and rc_client_external_begin_fetch_leaderboard_entries_around_user_func_t
+ * pass an internal wrapper structure around the list, which contains the public list and a destructor function. */
+typedef rc_client_async_handle_t* (RC_CCONV *rc_client_external_begin_fetch_leaderboard_entries_func_t)(rc_client_t* client,
+  uint32_t leaderboard_id, uint32_t first_entry, uint32_t count,
+  rc_client_fetch_leaderboard_entries_callback_t callback, void* callback_userdata);
+typedef rc_client_async_handle_t* (RC_CCONV *rc_client_external_begin_fetch_leaderboard_entries_around_user_func_t)(rc_client_t* client,
+  uint32_t leaderboard_id, uint32_t count, rc_client_fetch_leaderboard_entries_callback_t callback, void* callback_userdata);
+
+/* NOTE: rc_client_external_create_subset_list_func_t returns an internal wrapper structure which contains the public list
+ * and a destructor function. */
+struct rc_client_subset_list_info_t;
+typedef struct rc_client_subset_list_info_t* (RC_CCONV* rc_client_external_create_subset_list_func_t)();
+
+
+typedef size_t (RC_CCONV *rc_client_external_progress_size_func_t)(void);
+typedef int (RC_CCONV *rc_client_external_serialize_progress_func_t)(uint8_t* buffer, size_t buffer_size);
+typedef int (RC_CCONV *rc_client_external_deserialize_progress_func_t)(const uint8_t* buffer, size_t buffer_size);
+
+typedef struct rc_client_external_t
+{
+  rc_client_external_action_func_t destroy;
+
+  rc_client_external_enable_logging_func_t enable_logging;
+  rc_client_external_set_event_handler_func_t set_event_handler;
+  rc_client_external_set_read_memory_func_t set_read_memory;
+  rc_client_external_set_get_time_millisecs_func_t set_get_time_millisecs;
+  rc_client_external_set_string_func_t set_host;
+  rc_client_external_copy_string_func_t get_user_agent_clause;
+
+  rc_client_external_set_int_func_t set_hardcore_enabled;
+  rc_client_external_get_int_func_t get_hardcore_enabled;
+  rc_client_external_set_int_func_t set_unofficial_enabled;
+  rc_client_external_get_int_func_t get_unofficial_enabled;
+  rc_client_external_set_int_func_t set_encore_mode_enabled;
+  rc_client_external_get_int_func_t get_encore_mode_enabled;
+  rc_client_external_set_int_func_t set_spectator_mode_enabled;
+  rc_client_external_get_int_func_t get_spectator_mode_enabled;
+
+  rc_client_external_async_handle_func_t abort_async;
+
+  rc_client_external_begin_login_func_t begin_login_with_password;
+  rc_client_external_begin_login_func_t begin_login_with_token;
+  rc_client_external_action_func_t logout;
+  rc_client_external_get_user_info_func_t get_user_info;
+
+  rc_client_external_begin_identify_and_load_game_func_t begin_identify_and_load_game;
+  rc_client_external_begin_load_game_func_t begin_load_game;
+  rc_client_external_get_game_info_func_t get_game_info;
+  rc_client_external_begin_load_subset_t begin_load_subset; /* DEPRECATED */
+  rc_client_external_get_subset_info_func_t get_subset_info;
+  rc_client_external_action_func_t unload_game;
+  rc_client_external_get_user_game_summary_func_t get_user_game_summary;
+  rc_client_external_begin_change_media_func_t begin_identify_and_change_media;
+  rc_client_external_begin_load_game_func_t begin_change_media;
+
+  rc_client_external_create_achievement_list_func_t create_achievement_list;
+  rc_client_external_get_int_func_t has_achievements;
+  rc_client_external_get_achievement_info_func_t get_achievement_info;
+
+  rc_client_external_create_leaderboard_list_func_t create_leaderboard_list;
+  rc_client_external_get_int_func_t has_leaderboards;
+  rc_client_external_get_leaderboard_info_func_t get_leaderboard_info;
+  rc_client_external_begin_fetch_leaderboard_entries_func_t begin_fetch_leaderboard_entries;
+  rc_client_external_begin_fetch_leaderboard_entries_around_user_func_t begin_fetch_leaderboard_entries_around_user;
+
+  rc_client_external_copy_string_func_t get_rich_presence_message;
+  rc_client_external_get_int_func_t has_rich_presence;
+
+  rc_client_external_action_func_t do_frame;
+  rc_client_external_action_func_t idle;
+  rc_client_external_get_int_func_t is_processing_required;
+  rc_client_external_can_pause_func_t can_pause;
+  rc_client_external_action_func_t reset;
+
+  rc_client_external_progress_size_func_t progress_size;
+  rc_client_external_serialize_progress_func_t serialize_progress;
+  rc_client_external_deserialize_progress_func_t deserialize_progress;
+
+  /* VERSION 2 */
+  rc_client_external_add_game_hash_func_t add_game_hash;
+  rc_client_external_set_string_func_t load_unknown_game;
+
+  /* VERSION 3 */
+  rc_client_external_get_user_info_func_t get_user_info_v3;
+  rc_client_external_get_game_info_func_t get_game_info_v3;
+  rc_client_external_get_subset_info_func_t get_subset_info_v3;
+  rc_client_external_get_achievement_info_func_t get_achievement_info_v3;
+  rc_client_external_create_achievement_list_func_t create_achievement_list_v3;
+
+  /* VERSION 4 */
+  rc_client_external_set_int_func_t set_allow_background_memory_reads;
+
+  /* VERSION 5 */
+  rc_client_external_get_user_game_summary_func_t get_user_game_summary_v5;
+  rc_client_external_get_user_subset_summary_func_t get_user_subset_summary;
+
+  /* VERSION 6 */
+  rc_client_external_create_subset_list_func_t create_subset_list;
+
+  /* VERSION 7 */
+  rc_client_external_get_next_achievement_info_func_t get_next_achievement_info;
+
+} rc_client_external_t;
+
+#define RC_CLIENT_EXTERNAL_VERSION 7
+
+void rc_client_add_game_hash(rc_client_t* client, const char* hash, uint32_t game_id);
+void rc_client_load_unknown_game(rc_client_t* client, const char* hash);
+
+/* conversion support */
+
+struct rc_client_external_conversions_t;
+const rc_client_user_t* rc_client_external_convert_v1_user(const rc_client_t* client, const rc_client_user_t* v1_user);
+const rc_client_game_t* rc_client_external_convert_v1_game(const rc_client_t* client, const rc_client_game_t* v1_game);
+const rc_client_subset_t* rc_client_external_convert_v1_subset(const rc_client_t* client, const rc_client_subset_t* v1_subset);
+const rc_client_achievement_t* rc_client_external_convert_v1_achievement(const rc_client_t* client, const rc_client_achievement_t* v1_achievement);
+rc_client_achievement_list_t* rc_client_external_convert_v1_achievement_list(const rc_client_t* client, rc_client_achievement_list_t* v1_achievement_list);
+
+RC_END_C_DECLS
+
+#endif /* RC_CLIENT_EXTERNAL_H */

data/vendor/rcheevos/src/rc_client_external_versions.h

@@ -0,0 +1,171 @@
+#ifndef RC_CLIENT_EXTERNAL_CONVERSIONS_H
+#define RC_CLIENT_EXTERNAL_CONVERSIONS_H
+
+#include "rc_client_internal.h"
+
+RC_BEGIN_C_DECLS
+
+/* user */
+
+typedef struct v1_rc_client_user_t {
+  const char* display_name;
+  const char* username;
+  const char* token;
+  uint32_t score;
+  uint32_t score_softcore;
+  uint32_t num_unread_messages;
+} v1_rc_client_user_t;
+
+typedef struct v3_rc_client_user_t {
+  const char* display_name;
+  const char* username;
+  const char* token;
+  uint32_t score;
+  uint32_t score_softcore;
+  uint32_t num_unread_messages;
+  const char* avatar_url;
+} v3_rc_client_user_t;
+
+/* game */
+
+typedef struct v1_rc_client_game_t {
+  uint32_t id;
+  uint32_t console_id;
+  const char* title;
+  const char* hash;
+  const char* badge_name;
+} v1_rc_client_game_t;
+
+typedef struct v3_rc_client_game_t {
+  uint32_t id;
+  uint32_t console_id;
+  const char* title;
+  const char* hash;
+  const char* badge_name;
+  const char* badge_url;
+} v3_rc_client_game_t;
+
+/* subset */
+
+typedef struct v1_rc_client_subset_t {
+  uint32_t id;
+  const char* title;
+  char badge_name[16];
+  uint32_t num_achievements;
+  uint32_t num_leaderboards;
+} v1_rc_client_subset_t;
+
+typedef struct v3_rc_client_subset_t {
+  uint32_t id;
+  const char* title;
+  char badge_name[16];
+  uint32_t num_achievements;
+  uint32_t num_leaderboards;
+  const char* badge_url;
+} v3_rc_client_subset_t;
+
+/* achievement */
+
+typedef struct v1_rc_client_achievement_t {
+  const char* title;
+  const char* description;
+  char badge_name[8];
+  char measured_progress[24];
+  float measured_percent;
+  uint32_t id;
+  uint32_t points;
+  time_t unlock_time;
+  uint8_t state;
+  uint8_t category;
+  uint8_t bucket;
+  uint8_t unlocked;
+  float rarity;
+  float rarity_hardcore;
+  uint8_t type;
+} v1_rc_client_achievement_t;
+
+typedef struct v3_rc_client_achievement_t {
+  const char* title;
+  const char* description;
+  char badge_name[8];
+  char measured_progress[24];
+  float measured_percent;
+  uint32_t id;
+  uint32_t points;
+  time_t unlock_time;
+  uint8_t state;
+  uint8_t category;
+  uint8_t bucket;
+  uint8_t unlocked;
+  float rarity;
+  float rarity_hardcore;
+  uint8_t type;
+  const char* badge_url;
+  const char* badge_locked_url;
+} v3_rc_client_achievement_t;
+
+/* achievement list */
+
+typedef struct v1_rc_client_achievement_bucket_t {
+  v1_rc_client_achievement_t** achievements;
+  uint32_t num_achievements;
+
+  const char* label;
+  uint32_t subset_id;
+  uint8_t bucket_type;
+} v1_rc_client_achievement_bucket_t;
+
+typedef struct v1_rc_client_achievement_list_t {
+  v1_rc_client_achievement_bucket_t* buckets;
+  uint32_t num_buckets;
+} v1_rc_client_achievement_list_t;
+
+typedef struct v1_rc_client_achievement_list_info_t {
+  v1_rc_client_achievement_list_t public_;
+  rc_client_destroy_achievement_list_func_t destroy_func;
+} v1_rc_client_achievement_list_info_t;
+
+typedef struct v3_rc_client_achievement_bucket_t {
+  const v3_rc_client_achievement_t** achievements;
+  uint32_t num_achievements;
+
+  const char* label;
+  uint32_t subset_id;
+  uint8_t bucket_type;
+} v3_rc_client_achievement_bucket_t;
+
+typedef struct v3_rc_client_achievement_list_t {
+  const v3_rc_client_achievement_bucket_t* buckets;
+  uint32_t num_buckets;
+} v3_rc_client_achievement_list_t;
+
+typedef struct v3_rc_client_achievement_list_info_t {
+  v3_rc_client_achievement_list_t public_;
+  rc_client_destroy_achievement_list_func_t destroy_func;
+} v3_rc_client_achievement_list_info_t;
+
+/* user_game_summary */
+
+typedef struct v1_rc_client_user_game_summary_t {
+  uint32_t num_core_achievements;
+  uint32_t num_unofficial_achievements;
+  uint32_t num_unlocked_achievements;
+  uint32_t num_unsupported_achievements;
+  uint32_t points_core;
+  uint32_t points_unlocked;
+} v1_rc_client_user_game_summary_t;
+
+typedef struct v5_rc_client_user_game_summary_t {
+  uint32_t num_core_achievements;
+  uint32_t num_unofficial_achievements;
+  uint32_t num_unlocked_achievements;
+  uint32_t num_unsupported_achievements;
+  uint32_t points_core;
+  uint32_t points_unlocked;
+  time_t beaten_time;
+  time_t completed_time;
+} v5_rc_client_user_game_summary_t;
+
+RC_END_C_DECLS
+
+#endif /* RC_CLIENT_EXTERNAL_CONVERSIONS_H */