mirror of
https://github.com/hrydgard/ppsspp.git
synced 2024-11-27 07:20:49 +00:00
752 lines
25 KiB
C++
752 lines
25 KiB
C++
// SPDX-FileCopyrightText: 2019-2022 Connor McLaughlin <stenzek@gmail.com>
|
|
// SPDX-License-Identifier: (GPL-2.0 OR GPL-3.0 OR CC-BY-NC-ND-4.0)
|
|
|
|
// Derived from Duckstation's RetroAchievements implementation by stenzek as can be seen
|
|
// above, relicensed to GPL 2.0.
|
|
|
|
#include <algorithm>
|
|
#include <atomic>
|
|
#include <cstdarg>
|
|
#include <cstdlib>
|
|
#include <ctime>
|
|
#include <functional>
|
|
#include <set>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <mutex>
|
|
|
|
#include "ext/rcheevos/include/rcheevos.h"
|
|
#include "ext/rcheevos/include/rc_client.h"
|
|
#include "ext/rcheevos/include/rc_api_user.h"
|
|
#include "ext/rcheevos/include/rc_api_info.h"
|
|
#include "ext/rcheevos/include/rc_api_request.h"
|
|
#include "ext/rcheevos/include/rc_api_runtime.h"
|
|
#include "ext/rcheevos/include/rc_api_user.h"
|
|
#include "ext/rcheevos/include/rc_url.h"
|
|
#include "ext/rcheevos/include/rc_hash.h"
|
|
#include "ext/rcheevos/src/rhash/md5.h"
|
|
|
|
#include "ext/rapidjson/include/rapidjson/document.h"
|
|
|
|
#include "Common/Log.h"
|
|
#include "Common/File/Path.h"
|
|
#include "Common/File/FileUtil.h"
|
|
#include "Core/FileLoaders/LocalFileLoader.h"
|
|
#include "Core/FileSystems/BlockDevices.h"
|
|
#include "Common/Net/HTTPClient.h"
|
|
#include "Common/System/OSD.h"
|
|
#include "Common/System/System.h"
|
|
#include "Common/System/NativeApp.h"
|
|
#include "Common/TimeUtil.h"
|
|
#include "Common/Data/Text/I18n.h"
|
|
#include "Common/Serialize/Serializer.h"
|
|
#include "Common/Serialize/SerializeFuncs.h"
|
|
#include "Common/StringUtils.h"
|
|
#include "Common/Crypto/md5.h"
|
|
#include "Common/UI/IconCache.h"
|
|
|
|
#include "Core/MemMap.h"
|
|
#include "Core/Config.h"
|
|
#include "Core/CoreParameter.h"
|
|
#include "Core/ELF/ParamSFO.h"
|
|
#include "Core/System.h"
|
|
#include "Core/FileSystems/MetaFileSystem.h"
|
|
#include "Core/RetroAchievements.h"
|
|
|
|
static inline const char *DeNull(const char *ptr) {
|
|
return ptr ? ptr : "";
|
|
}
|
|
|
|
void OnAchievementsLoginStateChange() {
|
|
System_PostUIMessage("achievements_loginstatechange", "");
|
|
}
|
|
|
|
namespace Achievements {
|
|
|
|
// It's the name of the secret, not a secret name - the value is not secret :)
|
|
static const char *RA_TOKEN_SECRET_NAME = "retroachievements";
|
|
|
|
static Achievements::Statistics g_stats;
|
|
|
|
const std::string g_gameIconCachePrefix = "game:";
|
|
const std::string g_iconCachePrefix = "badge:";
|
|
|
|
Path s_game_path;
|
|
std::string s_game_hash;
|
|
|
|
std::set<uint32_t> g_activeChallenges;
|
|
bool g_isIdentifying = false;
|
|
bool g_isLoggingIn = false;
|
|
|
|
// rc_client implementation
|
|
static rc_client_t *g_rcClient;
|
|
|
|
#define PSP_MEMORY_OFFSET 0x08000000
|
|
|
|
rc_client_t *GetClient() {
|
|
return g_rcClient;
|
|
}
|
|
|
|
bool IsLoggedIn() {
|
|
return rc_client_get_user_info(g_rcClient) != nullptr;
|
|
}
|
|
|
|
bool EncoreModeActive() {
|
|
if (!g_rcClient) {
|
|
return false;
|
|
}
|
|
return rc_client_get_encore_mode_enabled(g_rcClient);
|
|
}
|
|
|
|
bool UnofficialEnabled() {
|
|
if (!g_rcClient) {
|
|
return false;
|
|
}
|
|
return rc_client_get_unofficial_enabled(g_rcClient);
|
|
}
|
|
|
|
bool ChallengeModeActive() {
|
|
if (!g_rcClient) {
|
|
return false;
|
|
}
|
|
return IsLoggedIn() && rc_client_get_hardcore_enabled(g_rcClient);
|
|
}
|
|
|
|
bool WarnUserIfChallengeModeActive(const char *message) {
|
|
if (!ChallengeModeActive()) {
|
|
return false;
|
|
}
|
|
|
|
const char *showMessage = message;
|
|
if (!message) {
|
|
auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS);
|
|
showMessage = ac->T("This feature is not available in Challenge Mode");
|
|
}
|
|
|
|
g_OSD.Show(OSDType::MESSAGE_WARNING, showMessage, 3.0f);
|
|
return true;
|
|
}
|
|
|
|
bool IsBlockingExecution() {
|
|
return g_isIdentifying || g_isLoggingIn;
|
|
}
|
|
|
|
static u32 GetGameID() {
|
|
if (!g_rcClient) {
|
|
return 0;
|
|
}
|
|
|
|
const rc_client_game_t *info = rc_client_get_game_info(g_rcClient);
|
|
if (!info) {
|
|
return 0;
|
|
}
|
|
return info->id; // 0 if not identified
|
|
}
|
|
|
|
bool IsActive() {
|
|
return GetGameID() != 0;
|
|
}
|
|
|
|
static uint32_t read_memory_callback(uint32_t address, uint8_t *buffer, uint32_t num_bytes, rc_client_t *client) {
|
|
// Achievements are traditionally defined relative to the base of main memory of the emulated console.
|
|
// This is some kind of RetroArch-related legacy. In the PSP's case, this is simply a straight offset of 0x08000000.
|
|
uint32_t orig_address = address;
|
|
address += PSP_MEMORY_OFFSET;
|
|
|
|
if (!Memory::ValidSize(address, num_bytes)) {
|
|
// Some achievement packs are really, really spammy.
|
|
// So we'll just count the bad accesses.
|
|
Achievements::g_stats.badMemoryAccessCount++;
|
|
if (g_Config.bAchievementsLogBadMemReads) {
|
|
WARN_LOG(G3D, "RetroAchievements PeekMemory: Bad address %08x (%d bytes) (%08x was passed in)", address, num_bytes, orig_address);
|
|
}
|
|
|
|
// TEMPORARY HACK: rcheevos' handling of bad memory accesses causes a LOT of extra work, since
|
|
// for some reason these invalid accesses keeps happening. So we'll temporarily to back to the previous
|
|
// behavior of simply returning 0. This is fixed in a PR upstream, not yet merged.
|
|
uint32_t temp = 0;
|
|
memcpy(buffer, &temp, num_bytes);
|
|
return num_bytes;
|
|
}
|
|
|
|
Memory::MemcpyUnchecked(buffer, address, num_bytes);
|
|
return num_bytes;
|
|
}
|
|
|
|
// This is the HTTP request dispatcher that is provided to the rc_client. Whenever the client
|
|
// needs to talk to the server, it will call this function.
|
|
static void server_call_callback(const rc_api_request_t *request,
|
|
rc_client_server_callback_t callback, void *callback_data, rc_client_t *client)
|
|
{
|
|
// If post data is provided, we need to make a POST request, otherwise, a GET request will suffice.
|
|
if (request->post_data) {
|
|
g_DownloadManager.AsyncPostWithCallback(std::string(request->url), std::string(request->post_data), "application/x-www-form-urlencoded", [=](http::Download &download) {
|
|
std::string buffer;
|
|
download.buffer().TakeAll(&buffer);
|
|
rc_api_server_response_t response{};
|
|
response.body = buffer.c_str();
|
|
response.body_length = buffer.size();
|
|
response.http_status_code = download.ResultCode();
|
|
callback(&response, callback_data);
|
|
});
|
|
} else {
|
|
g_DownloadManager.StartDownloadWithCallback(std::string(request->url), Path(), [=](http::Download &download) {
|
|
std::string buffer;
|
|
download.buffer().TakeAll(&buffer);
|
|
rc_api_server_response_t response{};
|
|
response.body = buffer.c_str();
|
|
response.body_length = buffer.size();
|
|
response.http_status_code = download.ResultCode();
|
|
callback(&response, callback_data);
|
|
});
|
|
}
|
|
}
|
|
|
|
static void log_message_callback(const char *message, const rc_client_t *client) {
|
|
INFO_LOG(ACHIEVEMENTS, "RetroAchievements: %s", message);
|
|
}
|
|
|
|
// For detailed documentation, see https://github.com/RetroAchievements/rcheevos/wiki/rc_client_set_event_handler.
|
|
static void event_handler_callback(const rc_client_event_t *event, rc_client_t *client) {
|
|
auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS);
|
|
|
|
switch (event->type) {
|
|
case RC_CLIENT_EVENT_ACHIEVEMENT_TRIGGERED:
|
|
// An achievement was earned by the player. The handler should notify the player that the achievement was earned.
|
|
g_OSD.ShowAchievementUnlocked(event->achievement->id);
|
|
System_PostUIMessage("play_sound", "achievement_unlocked");
|
|
INFO_LOG(ACHIEVEMENTS, "Achievement unlocked: '%s' (%d)", event->achievement->title, event->achievement->id);
|
|
break;
|
|
|
|
case RC_CLIENT_EVENT_GAME_COMPLETED:
|
|
{
|
|
// TODO: Do some zany fireworks!
|
|
|
|
// All achievements for the game have been earned. The handler should notify the player that the game was completed or mastered, depending on challenge mode.
|
|
auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS);
|
|
|
|
const rc_client_game_t *gameInfo = rc_client_get_game_info(g_rcClient);
|
|
|
|
// TODO: Translation?
|
|
std::string title = ReplaceAll(ac->T("Mastered %1"), "%1", gameInfo->title);
|
|
rc_client_user_game_summary_t summary;
|
|
rc_client_get_user_game_summary(g_rcClient, &summary);
|
|
|
|
std::string message = StringFromFormat(ac->T("%d achievements"), summary.num_unlocked_achievements);
|
|
|
|
g_OSD.Show(OSDType::MESSAGE_INFO, title, message, DeNull(gameInfo->badge_name), 10.0f);
|
|
|
|
System_PostUIMessage("play_sound", "achievement_unlocked");
|
|
|
|
INFO_LOG(ACHIEVEMENTS, "%s", message.c_str());
|
|
break;
|
|
}
|
|
case RC_CLIENT_EVENT_LEADERBOARD_STARTED:
|
|
// A leaderboard attempt has started. The handler may show a message with the leaderboard title and /or description indicating the attempt started.
|
|
INFO_LOG(ACHIEVEMENTS, "Leaderboard attempt started: %s", event->leaderboard->title);
|
|
g_OSD.Show(OSDType::MESSAGE_INFO, ReplaceAll(ac->T("%1: Leaderboard attempt started"), "%1", event->leaderboard->title), DeNull(event->leaderboard->description), 3.0f);
|
|
break;
|
|
case RC_CLIENT_EVENT_LEADERBOARD_FAILED:
|
|
NOTICE_LOG(ACHIEVEMENTS, "Leaderboard attempt failed: %s", event->leaderboard->title);
|
|
g_OSD.Show(OSDType::MESSAGE_INFO, ReplaceAll(ac->T("%1: Leaderboard attempt failed"), "%1", event->leaderboard->title), 3.0f);
|
|
// A leaderboard attempt has failed.
|
|
break;
|
|
case RC_CLIENT_EVENT_LEADERBOARD_SUBMITTED:
|
|
NOTICE_LOG(ACHIEVEMENTS, "Leaderboard result submitted: %s", event->leaderboard->title);
|
|
g_OSD.Show(OSDType::MESSAGE_SUCCESS, ReplaceAll(ReplaceAll(ac->T("%1: Submitting leaderboard score: %2!"), "%1", DeNull(event->leaderboard->title)), "%2", DeNull(event->leaderboard->tracker_value)), DeNull(event->leaderboard->description), 3.0f);
|
|
System_PostUIMessage("play_sound", "leaderboard_submitted");
|
|
break;
|
|
case RC_CLIENT_EVENT_ACHIEVEMENT_CHALLENGE_INDICATOR_SHOW:
|
|
NOTICE_LOG(ACHIEVEMENTS, "Challenge indicator show: %s", event->achievement->title);
|
|
g_OSD.ShowChallengeIndicator(event->achievement->id, true);
|
|
g_activeChallenges.insert(event->achievement->id);
|
|
// A challenge achievement has become active. The handler should show a small version of the achievement icon
|
|
// to indicate the challenge is active.
|
|
break;
|
|
case RC_CLIENT_EVENT_ACHIEVEMENT_CHALLENGE_INDICATOR_HIDE:
|
|
NOTICE_LOG(ACHIEVEMENTS, "Challenge indicator hide: %s", event->achievement->title);
|
|
g_OSD.ShowChallengeIndicator(event->achievement->id, false);
|
|
g_activeChallenges.erase(event->achievement->id);
|
|
// The handler should hide the small version of the achievement icon that was shown by the corresponding RC_CLIENT_EVENT_ACHIEVEMENT_CHALLENGE_INDICATOR_SHOW event.
|
|
break;
|
|
case RC_CLIENT_EVENT_ACHIEVEMENT_PROGRESS_INDICATOR_SHOW:
|
|
NOTICE_LOG(ACHIEVEMENTS, "Progress indicator show: %s, progress: '%s' (%f)", event->achievement->title, event->achievement->measured_progress, event->achievement->measured_percent);
|
|
// An achievement that tracks progress has changed the amount of progress that has been made.
|
|
// The handler should show a small version of the achievement icon along with the achievement->measured_progress text (for two seconds).
|
|
// Only one progress indicator should be shown at a time.
|
|
// If a progress indicator is already visible, it should be updated with the new icon and text, and the two second timer should be restarted.
|
|
g_OSD.ShowAchievementProgress(event->achievement->id, 2.0f);
|
|
break;
|
|
case RC_CLIENT_EVENT_LEADERBOARD_TRACKER_SHOW:
|
|
NOTICE_LOG(ACHIEVEMENTS, "Leaderboard tracker show: '%s' (id %d)", event->leaderboard_tracker->display, event->leaderboard_tracker->id);
|
|
// A leaderboard_tracker has become active. The handler should show the tracker text on screen.
|
|
// Multiple active leaderboards may share a single tracker if they have the same definition and value.
|
|
// As such, the leaderboard tracker IDs are unique amongst the leaderboard trackers, and have no correlation to the active leaderboard(s).
|
|
// Use event->leaderboard_tracker->id for uniqueness checks, and display event->leaderboard_tracker->display (string)
|
|
g_OSD.ShowLeaderboardTracker(event->leaderboard_tracker->id, event->leaderboard_tracker->display, true);
|
|
break;
|
|
case RC_CLIENT_EVENT_LEADERBOARD_TRACKER_HIDE:
|
|
// A leaderboard_tracker has become inactive. The handler should hide the tracker text from the screen.
|
|
NOTICE_LOG(ACHIEVEMENTS, "Leaderboard tracker hide: '%s' (id %d)", event->leaderboard_tracker->display, event->leaderboard_tracker->id);
|
|
g_OSD.ShowLeaderboardTracker(event->leaderboard_tracker->id, nullptr, false);
|
|
break;
|
|
case RC_CLIENT_EVENT_LEADERBOARD_TRACKER_UPDATE:
|
|
// A leaderboard_tracker value has been updated. The handler should update the tracker text on the screen.
|
|
NOTICE_LOG(ACHIEVEMENTS, "Leaderboard tracker update: '%s' (id %d)", event->leaderboard_tracker->display, event->leaderboard_tracker->id);
|
|
g_OSD.ShowLeaderboardTracker(event->leaderboard_tracker->id, event->leaderboard_tracker->display, true);
|
|
break;
|
|
case RC_CLIENT_EVENT_RESET:
|
|
WARN_LOG(ACHIEVEMENTS, "Resetting game due to achievement setting change!");
|
|
// Challenge mode was enabled, or something else that forces a game reset.
|
|
System_PostUIMessage("reset", "");
|
|
break;
|
|
case RC_CLIENT_EVENT_SERVER_ERROR:
|
|
ERROR_LOG(ACHIEVEMENTS, "Server error: %s: %s", event->server_error->api, event->server_error->error_message);
|
|
g_OSD.Show(OSDType::MESSAGE_ERROR, "Server error");
|
|
break;
|
|
default:
|
|
WARN_LOG(ACHIEVEMENTS, "Unhandled rc_client event %d, ignoring", event->type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void login_token_callback(int result, const char *error_message, rc_client_t *client, void *userdata) {
|
|
switch (result) {
|
|
case RC_OK:
|
|
OnAchievementsLoginStateChange();
|
|
break;
|
|
case RC_NO_RESPONSE:
|
|
{
|
|
auto di = GetI18NCategory(I18NCat::DIALOG);
|
|
g_OSD.Show(OSDType::MESSAGE_WARNING, di->T("Failed to connect to server, check your internet connection."));
|
|
break;
|
|
}
|
|
case RC_INVALID_STATE:
|
|
case RC_API_FAILURE:
|
|
case RC_MISSING_VALUE:
|
|
case RC_INVALID_JSON:
|
|
default:
|
|
ERROR_LOG(ACHIEVEMENTS, "Failure logging in via token: %d, %s", result, error_message);
|
|
OnAchievementsLoginStateChange();
|
|
break;
|
|
}
|
|
g_isLoggingIn = false;
|
|
}
|
|
|
|
void Initialize() {
|
|
if (!g_Config.bAchievementsEnable) {
|
|
_dbg_assert_(!g_rcClient);
|
|
INFO_LOG(ACHIEVEMENTS, "Achievements are disabled, not initializing.");
|
|
return;
|
|
}
|
|
_assert_msg_(!g_rcClient, "Achievements already initialized");
|
|
|
|
g_rcClient = rc_client_create(read_memory_callback, server_call_callback);
|
|
if (!g_rcClient) {
|
|
// Shouldn't happen really.
|
|
return;
|
|
}
|
|
|
|
// Provide a logging function to simplify debugging
|
|
rc_client_enable_logging(g_rcClient, RC_CLIENT_LOG_LEVEL_VERBOSE, log_message_callback);
|
|
|
|
// Disable SSL for now.
|
|
rc_client_set_host(g_rcClient, "http://retroachievements.org");
|
|
|
|
rc_client_set_event_handler(g_rcClient, event_handler_callback);
|
|
|
|
std::string api_token = NativeLoadSecret(RA_TOKEN_SECRET_NAME);
|
|
if (!api_token.empty()) {
|
|
g_isLoggingIn = true;
|
|
rc_client_begin_login_with_token(g_rcClient, g_Config.sAchievementsUserName.c_str(), api_token.c_str(), &login_token_callback, nullptr);
|
|
}
|
|
|
|
INFO_LOG(ACHIEVEMENTS, "Achievements initialized.");
|
|
}
|
|
|
|
static void login_password_callback(int result, const char *error_message, rc_client_t *client, void *userdata) {
|
|
auto di = GetI18NCategory(I18NCat::DIALOG);
|
|
switch (result) {
|
|
case RC_OK:
|
|
{
|
|
// Get the token and store it.
|
|
const rc_client_user_t *user = rc_client_get_user_info(client);
|
|
g_Config.sAchievementsUserName = user->username;
|
|
NativeSaveSecret(RA_TOKEN_SECRET_NAME, std::string(user->token));
|
|
OnAchievementsLoginStateChange();
|
|
g_OSD.Show(OSDType::MESSAGE_SUCCESS, di->T("Logged in!"));
|
|
break;
|
|
}
|
|
case RC_NO_RESPONSE:
|
|
{
|
|
auto di = GetI18NCategory(I18NCat::DIALOG);
|
|
g_OSD.Show(OSDType::MESSAGE_WARNING, di->T("Failed to connect to server, check your internet connection."));
|
|
break;
|
|
}
|
|
case RC_INVALID_STATE:
|
|
case RC_API_FAILURE:
|
|
case RC_MISSING_VALUE:
|
|
case RC_INVALID_JSON:
|
|
default:
|
|
{
|
|
ERROR_LOG(ACHIEVEMENTS, "Failure logging in via password: %d, %s", result, error_message);
|
|
g_OSD.Show(OSDType::MESSAGE_WARNING, di->T("Failed to log in, check your username and password."));
|
|
OnAchievementsLoginStateChange();
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_OSD.RemoveProgressBar("cheevos_async_login");
|
|
g_isLoggingIn = false;
|
|
}
|
|
|
|
bool LoginAsync(const char *username, const char *password) {
|
|
auto di = GetI18NCategory(I18NCat::DIALOG);
|
|
if (IsLoggedIn() || std::strlen(username) == 0 || std::strlen(password) == 0 || IsUsingRAIntegration())
|
|
return false;
|
|
|
|
g_OSD.SetProgressBar("cheevos_async_login", di->T("Logging in..."), 0, 0, 0);
|
|
|
|
g_isLoggingIn = true;
|
|
rc_client_begin_login_with_password(g_rcClient, username, password, &login_password_callback, nullptr);
|
|
return true;
|
|
}
|
|
|
|
void Logout() {
|
|
rc_client_logout(g_rcClient);
|
|
// remove from config
|
|
g_Config.sAchievementsUserName.clear();
|
|
NativeSaveSecret(RA_TOKEN_SECRET_NAME, "");
|
|
g_Config.Save("Achievements logout");
|
|
g_activeChallenges.clear();
|
|
|
|
OnAchievementsLoginStateChange();
|
|
}
|
|
|
|
void UpdateSettings() {
|
|
if (g_rcClient && !g_Config.bAchievementsEnable) {
|
|
// we're done here
|
|
Shutdown();
|
|
return;
|
|
}
|
|
|
|
if (!g_rcClient && g_Config.bAchievementsEnable) {
|
|
// we just got enabled.
|
|
Initialize();
|
|
}
|
|
}
|
|
|
|
bool Shutdown() {
|
|
g_activeChallenges.clear();
|
|
rc_client_destroy(g_rcClient);
|
|
g_rcClient = nullptr;
|
|
INFO_LOG(ACHIEVEMENTS, "Achievements shut down.");
|
|
return true;
|
|
}
|
|
|
|
void ResetRuntime() {
|
|
INFO_LOG(ACHIEVEMENTS, "Resetting rcheevos state...");
|
|
rc_client_reset(g_rcClient);
|
|
g_activeChallenges.clear();
|
|
}
|
|
|
|
void FrameUpdate() {
|
|
if (!g_rcClient)
|
|
return;
|
|
rc_client_do_frame(g_rcClient);
|
|
}
|
|
|
|
void Idle() {
|
|
rc_client_idle(g_rcClient);
|
|
}
|
|
|
|
void DoState(PointerWrap &p) {
|
|
auto sw = p.Section("Achievements", 0, 1);
|
|
if (!sw) {
|
|
// Save state is missing the section.
|
|
// Reset the runtime.
|
|
if (HasAchievementsOrLeaderboards()) {
|
|
auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS);
|
|
g_OSD.Show(OSDType::MESSAGE_WARNING, ac->T("Save state loaded without achievement data"), 5.0f);
|
|
}
|
|
rc_client_reset(g_rcClient);
|
|
return;
|
|
}
|
|
|
|
uint32_t data_size = 0;
|
|
|
|
if (!IsActive()) {
|
|
Do(p, data_size);
|
|
if (p.mode == PointerWrap::MODE_READ) {
|
|
WARN_LOG(ACHIEVEMENTS, "Save state contained achievement data, but achievements are not active. Ignore.");
|
|
}
|
|
p.SkipBytes(data_size);
|
|
return;
|
|
}
|
|
|
|
if (p.mode == PointerWrap::MODE_MEASURE || p.mode == PointerWrap::MODE_WRITE || p.mode == PointerWrap::MODE_VERIFY || p.mode == PointerWrap::MODE_NOOP) {
|
|
data_size = (uint32_t)(g_rcClient ? rc_client_progress_size(g_rcClient) : 0);
|
|
}
|
|
Do(p, data_size);
|
|
|
|
if (data_size > 0) {
|
|
uint8_t *buffer = new uint8_t[data_size];
|
|
switch (p.mode) {
|
|
case PointerWrap::MODE_NOOP:
|
|
case PointerWrap::MODE_MEASURE:
|
|
case PointerWrap::MODE_WRITE:
|
|
case PointerWrap::MODE_VERIFY:
|
|
{
|
|
int retval = rc_client_serialize_progress(g_rcClient, buffer);
|
|
if (retval != RC_OK) {
|
|
ERROR_LOG(ACHIEVEMENTS, "Error %d serializing achievement data. Ignoring.", retval);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
DoArray(p, buffer, data_size);
|
|
|
|
switch (p.mode) {
|
|
case PointerWrap::MODE_READ:
|
|
{
|
|
int retval = rc_client_deserialize_progress(g_rcClient, buffer);
|
|
if (retval != RC_OK) {
|
|
// TODO: What should we really do here?
|
|
ERROR_LOG(ACHIEVEMENTS, "Error %d deserializing achievement data. Ignoring.", retval);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
delete[] buffer;
|
|
} else {
|
|
if (IsActive()) {
|
|
auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS);
|
|
g_OSD.Show(OSDType::MESSAGE_WARNING, ac->T("Save state loaded without achievement data"), 5.0f);
|
|
}
|
|
rc_client_reset(g_rcClient);
|
|
}
|
|
}
|
|
|
|
bool HasAchievementsOrLeaderboards() {
|
|
if (!g_rcClient) {
|
|
return false;
|
|
}
|
|
return IsActive();
|
|
}
|
|
|
|
void DownloadImageIfMissing(const std::string &cache_key, std::string &&url) {
|
|
if (g_iconCache.MarkPending(cache_key)) {
|
|
INFO_LOG(ACHIEVEMENTS, "Downloading image: %s (%s)", url.c_str(), cache_key.c_str());
|
|
g_DownloadManager.StartDownloadWithCallback(url, Path(), [cache_key](http::Download &download) {
|
|
if (download.ResultCode() != 200)
|
|
return;
|
|
std::string data;
|
|
download.buffer().TakeAll(&data);
|
|
g_iconCache.InsertIcon(cache_key, IconFormat::PNG, std::move(data));
|
|
});
|
|
}
|
|
}
|
|
|
|
Statistics GetStatistics() {
|
|
return g_stats;
|
|
}
|
|
|
|
std::string GetGameAchievementSummary() {
|
|
auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS);
|
|
|
|
rc_client_user_game_summary_t summary;
|
|
rc_client_get_user_game_summary(g_rcClient, &summary);
|
|
|
|
std::string summaryString;
|
|
if (summary.num_core_achievements + summary.num_unofficial_achievements == 0) {
|
|
summaryString = ac->T("This game has no achievements");
|
|
} else {
|
|
summaryString = StringFromFormat(ac->T("Earned", "You have unlocked %d of %d achievements, earning %d of %d points"),
|
|
summary.num_unlocked_achievements, summary.num_core_achievements + summary.num_unofficial_achievements,
|
|
summary.points_unlocked, summary.points_core);
|
|
if (ChallengeModeActive()) {
|
|
summaryString.append("\n");
|
|
summaryString.append(ac->T("Challenge Mode"));
|
|
}
|
|
if (EncoreModeActive()) {
|
|
summaryString.append("\n");
|
|
summaryString.append(ac->T("Encore Mode"));
|
|
}
|
|
if (UnofficialEnabled()) {
|
|
summaryString.append("\n");
|
|
summaryString.append(ac->T("Unofficial achievements"));
|
|
}
|
|
}
|
|
return summaryString;
|
|
}
|
|
|
|
void identify_and_load_callback(int result, const char *error_message, rc_client_t *client, void *userdata) {
|
|
auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS);
|
|
|
|
NOTICE_LOG(ACHIEVEMENTS, "Load callback: %d (%s)", result, error_message);
|
|
|
|
switch (result) {
|
|
case RC_OK:
|
|
{
|
|
// Successful! Show a message that we're active.
|
|
const rc_client_game_t *gameInfo = rc_client_get_game_info(client);
|
|
|
|
char cacheId[128];
|
|
snprintf(cacheId, sizeof(cacheId), "gi:%s", gameInfo->badge_name);
|
|
|
|
char temp[512];
|
|
if (RC_OK == rc_client_game_get_image_url(gameInfo, temp, sizeof(temp))) {
|
|
Achievements::DownloadImageIfMissing(cacheId, std::move(std::string(temp)));
|
|
}
|
|
g_OSD.Show(OSDType::MESSAGE_INFO, std::string(gameInfo->title), GetGameAchievementSummary(), cacheId, 5.0f);
|
|
break;
|
|
}
|
|
case RC_NO_GAME_LOADED:
|
|
// The current game does not support achievements.
|
|
g_OSD.Show(OSDType::MESSAGE_INFO, ac->T("RetroAchievements are not available for this game"), 3.0f);
|
|
break;
|
|
default:
|
|
// Other various errors.
|
|
ERROR_LOG(ACHIEVEMENTS, "Failed to identify/load game: %d (%s)", result, error_message);
|
|
break;
|
|
}
|
|
|
|
g_isIdentifying = false;
|
|
}
|
|
|
|
struct FileContext {
|
|
BlockDevice *bd;
|
|
int64_t seekPos;
|
|
};
|
|
|
|
static BlockDevice *g_blockDevice;
|
|
|
|
void SetGame(const Path &path, FileLoader *fileLoader) {
|
|
// If we are currently logging in, give it a couple of seconds. This is not ideal, but works.
|
|
if (g_isLoggingIn) {
|
|
for (int i = 0; i < 3000 / 50; i++) {
|
|
sleep_ms(50);
|
|
}
|
|
}
|
|
|
|
if (!g_rcClient || !IsLoggedIn()) {
|
|
// Nothing to do.
|
|
return;
|
|
}
|
|
|
|
_dbg_assert_(!g_blockDevice);
|
|
|
|
// TODO: Fish the block device out of the loading process somewhere else. Though, probably easier to just do it here.
|
|
g_blockDevice = constructBlockDevice(fileLoader);
|
|
if (!g_blockDevice) {
|
|
ERROR_LOG(ACHIEVEMENTS, "Failed to construct block device for '%s' - can't identify", path.c_str());
|
|
return;
|
|
}
|
|
|
|
rc_hash_filereader rc_filereader;
|
|
rc_filereader.open = [](const char *utf8Path) -> void * {
|
|
if (!g_blockDevice) {
|
|
ERROR_LOG(ACHIEVEMENTS, "No block device");
|
|
return nullptr;
|
|
}
|
|
|
|
return (void *) new FileContext{ g_blockDevice, 0 };
|
|
};
|
|
rc_filereader.seek = [](void *file_handle, int64_t offset, int origin) {
|
|
FileContext *ctx = (FileContext *)file_handle;
|
|
switch (origin) {
|
|
case SEEK_SET: ctx->seekPos = offset; break;
|
|
case SEEK_END: ctx->seekPos = ctx->bd->GetBlockSize() * ctx->bd->GetNumBlocks() + offset; break;
|
|
case SEEK_CUR: ctx->seekPos += offset; break;
|
|
default: break;
|
|
}
|
|
};
|
|
rc_filereader.tell = [](void *file_handle) -> int64_t {
|
|
return ((FileContext *)file_handle)->seekPos;
|
|
};
|
|
rc_filereader.read = [](void *file_handle, void *buffer, size_t requested_bytes) -> size_t {
|
|
FileContext *ctx = (FileContext *)file_handle;
|
|
|
|
int blockSize = ctx->bd->GetBlockSize();
|
|
|
|
int64_t offset = ctx->seekPos;
|
|
int64_t endOffset = ctx->seekPos + requested_bytes;
|
|
int firstBlock = offset / blockSize;
|
|
int afterLastBlock = (endOffset + blockSize - 1) / blockSize;
|
|
int numBlocks = afterLastBlock - firstBlock;
|
|
// This is suboptimal, but good enough since we're not doing a lot of accesses.
|
|
uint8_t *buf = new uint8_t[numBlocks * blockSize];
|
|
bool success = ctx->bd->ReadBlocks(firstBlock, numBlocks, (u8 *)buf);
|
|
if (success) {
|
|
int64_t firstOffset = firstBlock * blockSize;
|
|
memcpy(buffer, buf + (offset - firstOffset), requested_bytes);
|
|
ctx->seekPos += requested_bytes;
|
|
delete[] buf;
|
|
return requested_bytes;
|
|
} else {
|
|
delete[] buf;
|
|
ERROR_LOG(ACHIEVEMENTS, "Block device load fail");
|
|
return 0;
|
|
}
|
|
};
|
|
rc_filereader.close = [](void *file_handle) {
|
|
FileContext *ctx = (FileContext *)file_handle;
|
|
delete ctx->bd;
|
|
delete ctx;
|
|
};
|
|
|
|
// The caller should hold off on executing game code until this turns false, checking with IsBlockingExecution()
|
|
g_isIdentifying = true;
|
|
|
|
// Apply pre-load settings.
|
|
rc_client_set_hardcore_enabled(g_rcClient, g_Config.bAchievementsChallengeMode ? 1 : 0);
|
|
rc_client_set_encore_mode_enabled(g_rcClient, g_Config.bAchievementsEncoreMode ? 1 : 0);
|
|
rc_client_set_unofficial_enabled(g_rcClient, g_Config.bAchievementsUnofficial ? 1 : 0);
|
|
|
|
rc_hash_init_custom_filereader(&rc_filereader);
|
|
rc_hash_init_default_cdreader();
|
|
rc_client_begin_identify_and_load_game(g_rcClient, RC_CONSOLE_PSP, path.c_str(), nullptr, 0, &identify_and_load_callback, nullptr);
|
|
|
|
// fclose above will have deleted it.
|
|
g_blockDevice = nullptr;
|
|
}
|
|
|
|
void UnloadGame() {
|
|
if (g_rcClient) {
|
|
rc_client_unload_game(g_rcClient);
|
|
}
|
|
}
|
|
|
|
void change_media_callback(int result, const char *error_message, rc_client_t *client, void *userdata) {
|
|
NOTICE_LOG(ACHIEVEMENTS, "Change media callback: %d (%s)", result, error_message);
|
|
g_isIdentifying = false;
|
|
}
|
|
|
|
void ChangeUMD(const Path &path) {
|
|
if (!IsActive()) {
|
|
// Nothing to do.
|
|
return;
|
|
}
|
|
|
|
rc_client_begin_change_media(g_rcClient,
|
|
path.c_str(),
|
|
nullptr,
|
|
0,
|
|
&change_media_callback,
|
|
nullptr
|
|
);
|
|
|
|
g_isIdentifying = true;
|
|
}
|
|
|
|
std::set<uint32_t> GetActiveChallengeIDs() {
|
|
return g_activeChallenges;
|
|
}
|
|
|
|
} // namespace Achievements
|