update to rcheevos 12.1 (#18298)

Author: Jamiras

deps/rcheevos/CHANGELOG.md

@@ -1,3 +1,19 @@
+# v12.1.0
+* add rc_client_get_user_subset_summary
+* add validation warning for using MeasuredIf without Measured
+* add validation warning for using ResetIf without hit targets
+* add rapi function for update_rich_presence
+* add gap to RC_CONSOLE_WII memory map to make it easier to convert pointers
+* improve range validation logic
+* fix error Remembering float value
+* fix MeasuredIf evaluation in rich presence
+* fix parsing of code notes with addresses above 0x7FFFFFFF
+* fix double evaluation of rich presence parameters
+* fix validation of SubSource chain
+* fix error if rc_client_allow_background_memory_reads called before calling rc_client_begin_load_raintegration
+* fix memory corruption when mixing legacy and new-format macros in rich presence
+* fix invalid pointer reference when iterator gets cloned
+
 # v12.0.0
 * rc_client changes
   * add RC_CLIENT_EVENT_SUBSET_COMPLETED event

deps/rcheevos/include/rc_client.h

@@ -211,6 +211,10 @@ typedef struct rc_client_user_game_summary_t {
 
   uint32_t points_core;
   uint32_t points_unlocked;
+
+  /* minimum version: 12.1 */
+  time_t beaten_time;
+  time_t completed_time;
 } rc_client_user_game_summary_t;
 
 /**
@@ -358,6 +362,8 @@ typedef struct rc_client_subset_t {
 
 RC_EXPORT const rc_client_subset_t* RC_CCONV rc_client_get_subset_info(rc_client_t* client, uint32_t subset_id);
 
+RC_EXPORT void RC_CCONV rc_client_get_user_subset_summary(const rc_client_t* client, uint32_t subset_id, rc_client_user_game_summary_t* summary);
+
 /*****************************************************************************\
 | Fetch Game Hashes                                                           |
 \*****************************************************************************/
@@ -582,7 +588,7 @@ enum {
 RC_EXPORT rc_client_leaderboard_list_t* RC_CCONV rc_client_create_leaderboard_list(rc_client_t* client, int grouping);
 
 /**
- * Destroys a list allocated by rc_client_get_leaderboard_list.
+ * Destroys a list allocated by rc_client_create_leaderboard_list.
  */
 RC_EXPORT void RC_CCONV rc_client_destroy_leaderboard_list(rc_client_leaderboard_list_t* list);
 

deps/rcheevos/src/rapi/rc_api_common.c

@@ -273,17 +273,17 @@ static int rc_json_extract_html_error(rc_api_response_t* response, const rc_api_
   iterator.json = server_response->body;
   iterator.end = server_response->body + server_response->body_length;
 
-  /* if the title contains an HTTP status code(i.e "404 Not Found"), return the title */
+  /* assume the title contains the most appropriate message to display to the user */
   if (rc_json_find_substring(&iterator, "<title>")) {
     const char* title_start = iterator.json + 7;
-    if (isdigit((int)*title_start) && rc_json_find_substring(&iterator, "</title>")) {
+    if (rc_json_find_substring(&iterator, "</title>")) {
       response->error_message = rc_buffer_strncpy(&response->buffer, title_start, iterator.json - title_start);
       response->succeeded = 0;
       return RC_INVALID_JSON;
     }
   }
 
-  /* title not found, or did not start with an error code, return the first line of the response */
+  /* title not found, return the first line of the response (up to 200 characters) */
   iterator.json = server_response->body;
 
   while (iterator.json < iterator.end && *iterator.json != '\n' &&

deps/rcheevos/src/rc_client.c

@@ -905,11 +905,22 @@ int rc_client_user_get_image_url(const rc_client_user_t* user, char buffer[], si
   return rc_client_get_image_url(buffer, buffer_size, RC_IMAGE_TYPE_USER, user->display_name);
 }
 
-static void rc_client_subset_get_user_game_summary(const rc_client_subset_info_t* subset,
-    rc_client_user_game_summary_t* summary, const uint8_t unlock_bit)
+static void rc_client_subset_get_user_game_summary(const rc_client_t* client,
+    const rc_client_subset_info_t* subset, rc_client_user_game_summary_t* summary)
 {
   rc_client_achievement_info_t* achievement = subset->achievements;
   rc_client_achievement_info_t* stop = achievement + subset->public_.num_achievements;
+  time_t last_unlock_time = 0;
+  time_t last_progression_time = 0;
+  time_t first_win_time = 0;
+  int num_progression_achievements = 0;
+  int num_win_achievements = 0;
+  int num_unlocked_progression_achievements = 0;
+  const uint8_t unlock_bit = (client->state.hardcore) ?
+    RC_CLIENT_ACHIEVEMENT_UNLOCKED_HARDCORE : RC_CLIENT_ACHIEVEMENT_UNLOCKED_SOFTCORE;
+
+  rc_mutex_lock((rc_mutex_t*)&client->state.mutex); /* remove const cast for mutex access */
+
   for (; achievement < stop; ++achievement) {
     switch (achievement->public_.category) {
       case RC_CLIENT_ACHIEVEMENT_CATEGORY_CORE:
@@ -919,10 +930,28 @@ static void rc_client_subset_get_user_game_summary(const rc_client_subset_info_t
         if (achievement->public_.unlocked & unlock_bit) {
           ++summary->num_unlocked_achievements;
           summary->points_unlocked += achievement->public_.points;
+
+          if (achievement->public_.unlock_time > last_unlock_time)
+            last_unlock_time = achievement->public_.unlock_time;
+
+          if (achievement->public_.type == RC_CLIENT_ACHIEVEMENT_TYPE_PROGRESSION) {
+            ++num_unlocked_progression_achievements;
+            if (achievement->public_.unlock_time > last_progression_time)
+              last_progression_time = achievement->public_.unlock_time;
+          }
+          else if (achievement->public_.type == RC_CLIENT_ACHIEVEMENT_TYPE_WIN) {
+            if (first_win_time == 0 || achievement->public_.unlock_time < first_win_time)
+              first_win_time = achievement->public_.unlock_time;
+          }
         }
-        if (achievement->public_.bucket == RC_CLIENT_ACHIEVEMENT_BUCKET_UNSUPPORTED) {
+
+        if (achievement->public_.type == RC_CLIENT_ACHIEVEMENT_TYPE_PROGRESSION)
+          ++num_progression_achievements;
+        else if (achievement->public_.type == RC_CLIENT_ACHIEVEMENT_TYPE_WIN)
+          ++num_win_achievements;
+
+        if (achievement->public_.bucket == RC_CLIENT_ACHIEVEMENT_BUCKET_UNSUPPORTED)
           ++summary->num_unsupported_achievements;
-        }
 
         break;
 
@@ -934,13 +963,18 @@ static void rc_client_subset_get_user_game_summary(const rc_client_subset_info_t
         continue;
     }
   }
+
+  rc_mutex_unlock((rc_mutex_t*)&client->state.mutex); /* remove const cast for mutex access */
+
+  if (summary->num_unlocked_achievements == summary->num_core_achievements)
+    summary->completed_time = last_unlock_time;
+
+  if ((first_win_time || num_win_achievements == 0) && num_unlocked_progression_achievements == num_progression_achievements)
+    summary->beaten_time = (first_win_time > last_progression_time) ? first_win_time : last_progression_time;
 }
 
 void rc_client_get_user_game_summary(const rc_client_t* client, rc_client_user_game_summary_t* summary)
 {
-  const uint8_t unlock_bit = (client->state.hardcore) ?
-    RC_CLIENT_ACHIEVEMENT_UNLOCKED_HARDCORE : RC_CLIENT_ACHIEVEMENT_UNLOCKED_SOFTCORE;
-
   if (!summary)
     return;
 
@@ -949,20 +983,47 @@ void rc_client_get_user_game_summary(const rc_client_t* client, rc_client_user_g
     return;
 
 #ifdef RC_CLIENT_SUPPORTS_EXTERNAL
-  if (client->state.external_client && client->state.external_client->get_user_game_summary) {
-    client->state.external_client->get_user_game_summary(summary);
-    return;
+  if (client->state.external_client) {
+    if (client->state.external_client->get_user_game_summary_v5) {
+      client->state.external_client->get_user_game_summary_v5(summary);
+      return;
+    }
+    if (client->state.external_client->get_user_game_summary) {
+      client->state.external_client->get_user_game_summary(summary);
+      return;
+    }
   }
 #endif
 
-  if (!rc_client_is_game_loaded(client))
+  if (rc_client_is_game_loaded(client))
+    rc_client_subset_get_user_game_summary(client, client->game->subsets, summary);
+}
+
+void rc_client_get_user_subset_summary(const rc_client_t* client, uint32_t subset_id, rc_client_user_game_summary_t* summary)
+{
+  if (!summary)
     return;
 
-  rc_mutex_lock((rc_mutex_t*)&client->state.mutex); /* remove const cast for mutex access */
+  memset(summary, 0, sizeof(*summary));
+  if (!client || !subset_id)
+    return;
 
-  rc_client_subset_get_user_game_summary(client->game->subsets, summary, unlock_bit);
+#ifdef RC_CLIENT_SUPPORTS_EXTERNAL
+  if (client->state.external_client && client->state.external_client->get_user_subset_summary) {
+    client->state.external_client->get_user_subset_summary(subset_id, summary);
+    return;
+  }
+#endif
 
-  rc_mutex_unlock((rc_mutex_t*)&client->state.mutex); /* remove const cast for mutex access */
+  if (rc_client_is_game_loaded(client)) {
+    const rc_client_subset_info_t* subset = client->game->subsets;
+    for (; subset; subset = subset->next) {
+      if (subset->public_.id == subset_id) {
+        rc_client_subset_get_user_game_summary(client, subset, summary);
+        break;
+      }
+    }
+  }
 }
 
 typedef struct rc_client_fetch_all_user_progress_callback_data_t {
@@ -1376,29 +1437,34 @@ static uint32_t rc_client_subset_toggle_hardcore_achievements(rc_client_subset_i
           break;
       }
     }
-    else if (achievement->public_.state == RC_CLIENT_ACHIEVEMENT_STATE_ACTIVE ||
-             achievement->public_.state == RC_CLIENT_ACHIEVEMENT_STATE_INACTIVE) {
+    else {
+      achievement->public_.unlock_time = (active_bit == RC_CLIENT_ACHIEVEMENT_UNLOCKED_HARDCORE) ?
+          achievement->unlock_time_hardcore : achievement->unlock_time_softcore;
 
-      /* if it's active despite being unlocked, and we're in encore mode, leave it active */
-      if (client->state.encore_mode) {
-        ++active_count;
-        continue;
-      }
+      if (achievement->public_.state == RC_CLIENT_ACHIEVEMENT_STATE_ACTIVE ||
+          achievement->public_.state == RC_CLIENT_ACHIEVEMENT_STATE_INACTIVE) {
+        /* if it's active despite being unlocked, and we're in encore mode, leave it active */
+        if (client->state.encore_mode) {
+          ++active_count;
+          continue;
+        }
 
-      achievement->public_.state = RC_CLIENT_ACHIEVEMENT_STATE_UNLOCKED;
-      achievement->public_.unlock_time = (active_bit == RC_CLIENT_ACHIEVEMENT_UNLOCKED_HARDCORE) ?
-        achievement->unlock_time_hardcore : achievement->unlock_time_softcore;
+        /* switch to inactive */
+        achievement->public_.state = RC_CLIENT_ACHIEVEMENT_STATE_UNLOCKED;
+
+        if (achievement->trigger && rc_trigger_state_active(achievement->trigger->state)) {
+          /* hide any active challenge indicators */
+          if (achievement->trigger->state == RC_TRIGGER_STATE_PRIMED) {
+            rc_client_event_t client_event;
+            memset(&client_event, 0, sizeof(client_event));
+            client_event.type = RC_CLIENT_EVENT_ACHIEVEMENT_CHALLENGE_INDICATOR_HIDE;
+            client_event.achievement = &achievement->public_;
+            client->callbacks.event_handler(&client_event, client);
+          }
 
-      if (achievement->trigger && achievement->trigger->state == RC_TRIGGER_STATE_PRIMED) {
-        rc_client_event_t client_event;
-        memset(&client_event, 0, sizeof(client_event));
-        client_event.type = RC_CLIENT_EVENT_ACHIEVEMENT_CHALLENGE_INDICATOR_HIDE;
-        client_event.achievement = &achievement->public_;
-        client->callbacks.event_handler(&client_event, client);
+          achievement->trigger->state = RC_TRIGGER_STATE_TRIGGERED;
+        }
       }
-
-      if (achievement->trigger && rc_trigger_state_active(achievement->trigger->state))
-        achievement->trigger->state = RC_TRIGGER_STATE_TRIGGERED;
     }
   }
 
@@ -1728,7 +1794,9 @@ static void rc_client_activate_game(rc_client_load_state_t* load_state, rc_api_s
       if (load_state->hash->hash[0] != '[') {
         if (load_state->client->state.spectator_mode != RC_CLIENT_SPECTATOR_MODE_LOCKED) {
           /* schedule the periodic ping */
-          rc_client_scheduled_callback_data_t* callback_data = (rc_client_scheduled_callback_data_t*)rc_buffer_alloc(&load_state->game->buffer, sizeof(rc_client_scheduled_callback_data_t));
+          rc_client_scheduled_callback_data_t* callback_data = (rc_client_scheduled_callback_data_t*)
+            rc_buffer_alloc(&load_state->game->buffer, sizeof(rc_client_scheduled_callback_data_t));
+
           memset(callback_data, 0, sizeof(*callback_data));
           callback_data->callback = rc_client_ping;
           callback_data->related_id = load_state->game->public_.id;
@@ -1768,7 +1836,9 @@ static void rc_client_dispatch_activate_game(struct rc_client_scheduled_callback
 
 static void rc_client_queue_activate_game(rc_client_load_state_t* load_state)
 {
-  rc_client_scheduled_callback_data_t* scheduled_callback_data = (rc_client_scheduled_callback_data_t*)calloc(1, sizeof(rc_client_scheduled_callback_data_t));
+  rc_client_scheduled_callback_data_t* scheduled_callback_data =
+    (rc_client_scheduled_callback_data_t*)calloc(1, sizeof(rc_client_scheduled_callback_data_t));
+
   if (!scheduled_callback_data) {
     rc_client_load_error(load_state, RC_OUT_OF_MEMORY, rc_error_str(RC_OUT_OF_MEMORY));
     return;
@@ -1805,7 +1875,7 @@ static void rc_client_start_session_callback(const rc_api_server_response_t* ser
   outstanding_requests = rc_client_end_load_state(load_state);
 
   if (error_message) {
-    rc_client_load_error((rc_client_load_state_t*)callback_data, result, error_message);
+    rc_client_load_error(load_state, result, error_message);
   }
   else if (outstanding_requests < 0) {
     /* previous load state was aborted, load_state was free'd */
@@ -1818,7 +1888,7 @@ static void rc_client_start_session_callback(const rc_api_server_response_t* ser
         (rc_api_start_session_response_t*)malloc(sizeof(rc_api_start_session_response_t));
 
     if (!load_state->start_session_response) {
-      rc_client_load_error((rc_client_load_state_t*)callback_data, RC_OUT_OF_MEMORY, rc_error_str(RC_OUT_OF_MEMORY));
+      rc_client_load_error(load_state, RC_OUT_OF_MEMORY, rc_error_str(RC_OUT_OF_MEMORY));
     }
     else {
       /* safer to parse the response again than to try to copy it */
@@ -2796,14 +2866,14 @@ rc_hash_iterator_t* rc_client_get_load_state_hash_iterator(rc_client_t* client)
 
 static void rc_client_log_hash_message_verbose(const char* message, const rc_hash_iterator_t* iterator)
 {
-  rc_client_load_state_t* load_state = (rc_client_load_state_t*)iterator->userdata;
+  const rc_client_load_state_t* load_state = (const rc_client_load_state_t*)iterator->userdata;
   if (load_state->client->state.log_level >= RC_CLIENT_LOG_LEVEL_INFO)
     rc_client_log_message(load_state->client, message);
 }
 
 static void rc_client_log_hash_message_error(const char* message, const rc_hash_iterator_t* iterator)
 {
-  rc_client_load_state_t* load_state = (rc_client_load_state_t*)iterator->userdata;
+  const rc_client_load_state_t* load_state = (const rc_client_load_state_t*)iterator->userdata;
   if (load_state->client->state.log_level >= RC_CLIENT_LOG_LEVEL_ERROR)
     rc_client_log_message(load_state->client, message);
 }
@@ -3113,7 +3183,8 @@ static rc_client_async_handle_t* rc_client_begin_change_media_internal(rc_client
   rc_api_request_t request;
   int result;
 
-  if (game_hash->game_id != RC_CLIENT_UNKNOWN_GAME_ID) {
+  if (game_hash->game_id != RC_CLIENT_UNKNOWN_GAME_ID || /* previously looked up */
+      game_hash->hash[0] == '[') { /* internal use - don't try to look up */
     rc_client_change_media_internal(client, game_hash, callback, callback_userdata);
     return NULL;
   }
@@ -4367,15 +4438,15 @@ rc_client_leaderboard_list_t* rc_client_create_leaderboard_list(rc_client_t* cli
   };
 
   if (!client)
-    return (rc_client_leaderboard_list_t*)calloc(1, sizeof(rc_client_leaderboard_list_t));
+    return (rc_client_leaderboard_list_t*)calloc(1, list_size);
 
 #ifdef RC_CLIENT_SUPPORTS_EXTERNAL
   if (client->state.external_client && client->state.external_client->create_leaderboard_list)
     return (rc_client_leaderboard_list_t*)client->state.external_client->create_leaderboard_list(grouping);
 #endif
 
   if (!client->game)
-    return (rc_client_leaderboard_list_t*)calloc(1, sizeof(rc_client_leaderboard_list_t));
+    return (rc_client_leaderboard_list_t*)calloc(1, list_size);
 
   memset(&bucket_counts, 0, sizeof(bucket_counts));
 
@@ -5809,7 +5880,7 @@ void rc_client_do_frame(rc_client_t* client)
 
     richpresence = client->game->runtime.richpresence;
     if (richpresence && richpresence->richpresence)
-      rc_update_richpresence(richpresence->richpresence, client->state.legacy_peek, client, NULL);
+      rc_update_richpresence_internal(richpresence->richpresence, client->state.legacy_peek, client);
 
     rc_mutex_unlock(&client->state.mutex);
 

deps/rcheevos/src/rc_client_external.h

@@ -35,6 +35,7 @@ typedef rc_client_async_handle_t* (RC_CCONV *rc_client_external_begin_load_subse
   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);
@@ -139,9 +140,13 @@ typedef struct rc_client_external_t
   /* 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;
+
 } rc_client_external_t;
 
-#define RC_CLIENT_EXTERNAL_VERSION 4
+#define RC_CLIENT_EXTERNAL_VERSION 5
 
 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);