Map UDS events to trophies from dumped metadata; trophy viewer/overview improvements (#1088)
* Map UDS events to trophies via dumped metadata and redesign trophy UI Correlate each UDS event to its stat ID (uds00.ucp) and trophy target (trophy00.ucp) instead of a hard-coded event, store trophy JSON with unlock date/time outside _SaveData, and add a PS5-style toast, viewer and overview. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> * Fix trophy rule evaluation and share progress accounting * Match trophy and reload toolbar styling --------- Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Co-authored-by: nmzik <Nmzik@mail.ru>
This commit is contained in:
Felipe
GitHub
parent
7d2422abbe
commit
fb7ff7ec03
|
|
@ -413,6 +413,12 @@ add_executable(archive_file_tests EXCLUDE_FROM_ALL
|
|||
target_link_libraries(archive_file_tests common ZArchive::zarchive)
|
||||
target_include_directories(archive_file_tests PRIVATE ${inc_headers})
|
||||
|
||||
add_executable(trophy_system_tests EXCLUDE_FROM_ALL
|
||||
"${KYTY_TESTS_DIR}/TrophySystemTests.cpp"
|
||||
)
|
||||
target_link_libraries(trophy_system_tests common)
|
||||
target_include_directories(trophy_system_tests PRIVATE ${inc_headers})
|
||||
|
||||
add_executable(avplayer_file_tests EXCLUDE_FROM_ALL "${KYTY_TESTS_DIR}/AvPlayerFileTests.cpp")
|
||||
target_link_libraries(avplayer_file_tests common FFmpeg::ffmpeg ZArchive::zarchive)
|
||||
target_include_directories(avplayer_file_tests PRIVATE ${inc_headers})
|
||||
|
|
@ -606,6 +612,7 @@ if(BUILD_TESTING)
|
|||
add_test(NAME memory_tracker COMMAND $<TARGET_FILE:memory_tracker_tests>)
|
||||
add_test(NAME page_manager COMMAND $<TARGET_FILE:page_manager_tests>)
|
||||
add_test(NAME archive_file COMMAND $<TARGET_FILE:archive_file_tests>)
|
||||
add_test(NAME trophy_system COMMAND $<TARGET_FILE:trophy_system_tests>)
|
||||
add_test(NAME avplayer_file COMMAND $<TARGET_FILE:avplayer_file_tests>)
|
||||
add_test(NAME bit_array COMMAND $<TARGET_FILE:bit_array_tests>)
|
||||
add_test(NAME lru_cache COMMAND $<TARGET_FILE:lru_cache_tests>)
|
||||
|
|
|
|||
Binary file not shown.
|
After Width: | Height: | Size: 8.8 KiB |
|
|
@ -5,9 +5,9 @@
|
|||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <charconv>
|
||||
#include <span>
|
||||
#include <fmt/format.h>
|
||||
#include <nlohmann/json.hpp>
|
||||
#include <span>
|
||||
|
||||
namespace Common::Trophies {
|
||||
namespace {
|
||||
|
|
@ -40,6 +40,25 @@ int ReadId(const Json& value) {
|
|||
return error == std::errc {} && end == text.data() + text.size() && id >= 0 ? id : -1;
|
||||
}
|
||||
|
||||
std::optional<uint64_t> ReadUnsigned(const Json& value) {
|
||||
if (value.is_number_unsigned()) {
|
||||
return value.get<uint64_t>();
|
||||
}
|
||||
if (value.is_number_integer()) {
|
||||
const auto number = value.get<int64_t>();
|
||||
return number >= 0 ? std::optional<uint64_t>(static_cast<uint64_t>(number)) : std::nullopt;
|
||||
}
|
||||
if (!value.is_string()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
const auto& text = value.get_ref<const std::string&>();
|
||||
uint64_t number = 0;
|
||||
const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), number);
|
||||
return error == std::errc {} && end == text.data() + text.size()
|
||||
? std::optional<uint64_t>(number)
|
||||
: std::nullopt;
|
||||
}
|
||||
|
||||
Json ReadJson(const Files& files, std::string_view name) {
|
||||
const auto entry = files.find(name);
|
||||
if (entry == files.end()) {
|
||||
|
|
@ -48,19 +67,18 @@ Json ReadJson(const Files& files, std::string_view name) {
|
|||
return Json::parse(entry->second.begin(), entry->second.end(), nullptr, false);
|
||||
}
|
||||
|
||||
Package ParsePackage(std::span<const std::byte> data, int console_language) {
|
||||
bool ReadFiles(std::span<const std::byte> data, Files& files, uint64_t& size) {
|
||||
if (data.size() < 0x40 || data.size() > MaxPackageSize ||
|
||||
ReadBigEndian(data.data(), 4) != 0xb228c60a || ReadBigEndian(data.data() + 4, 4) != 1) {
|
||||
return {};
|
||||
return false;
|
||||
}
|
||||
const auto size = ReadBigEndian(data.data() + 8, 8);
|
||||
size = ReadBigEndian(data.data() + 8, 8);
|
||||
const auto count = ReadBigEndian(data.data() + 0x10, 4);
|
||||
const auto toc = ReadBigEndian(data.data() + 0x14, 4);
|
||||
if (size < 0x40 || size > data.size() || count > 4096 || toc > size ||
|
||||
0x20 + count * 0x40 > size - toc) {
|
||||
return {};
|
||||
return false;
|
||||
}
|
||||
Files files;
|
||||
for (uint64_t i = 0; i < count; ++i) {
|
||||
const auto* entry = data.data() + toc + 0x20 + i * 0x40;
|
||||
const auto* name = reinterpret_cast<const char*>(entry);
|
||||
|
|
@ -68,10 +86,19 @@ Package ParsePackage(std::span<const std::byte> data, int console_language) {
|
|||
const auto offset = ReadBigEndian(entry + 0x20, 8);
|
||||
const auto length = ReadBigEndian(entry + 0x28, 8);
|
||||
if (offset > size || length > size - offset) {
|
||||
return {};
|
||||
return false;
|
||||
}
|
||||
files.emplace(filename, data.subspan(offset, length));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
Package ParsePackage(std::span<const std::byte> data, int console_language) {
|
||||
Files files;
|
||||
uint64_t size = 0;
|
||||
if (!ReadFiles(data, files, size)) {
|
||||
return {};
|
||||
}
|
||||
const auto conf = ReadJson(files, "tropconf.json");
|
||||
if (!conf.is_object() || !conf.contains("trophies") || !conf["trophies"].is_array() ||
|
||||
conf["trophies"].size() > 1000 || !conf.contains("defaultLanguage") ||
|
||||
|
|
@ -129,19 +156,29 @@ Package ParsePackage(std::span<const std::byte> data, int console_language) {
|
|||
trophy.has_reward = definition.contains("hasReward") && definition["hasReward"] == true;
|
||||
if (definition.contains("unlockCondition")) {
|
||||
const auto& condition = definition["unlockCondition"];
|
||||
if (condition.is_object() && condition.contains("progressive") &&
|
||||
condition["progressive"] == true) {
|
||||
if (!condition.contains("targetValue") || !condition["targetValue"].is_string()) {
|
||||
return {};
|
||||
if (condition.is_object()) {
|
||||
trophy.progressive =
|
||||
condition.contains("progressive") && condition["progressive"] == true;
|
||||
if (condition.contains("udsStatId")) {
|
||||
trophy.uds_stat_id = ReadUnsigned(condition["udsStatId"]);
|
||||
if (!trophy.uds_stat_id) {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
const auto& value = condition["targetValue"].get_ref<const std::string&>();
|
||||
uint64_t target = 0;
|
||||
const auto [end, error] =
|
||||
std::from_chars(value.data(), value.data() + value.size(), target);
|
||||
if (error != std::errc {} || end != value.data() + value.size()) {
|
||||
return {};
|
||||
if (condition.contains("targetValue")) {
|
||||
trophy.target = ReadUnsigned(condition["targetValue"]);
|
||||
}
|
||||
const auto comparison = condition.find("comparator");
|
||||
if (comparison != condition.end()) {
|
||||
if (*comparison == "ge")
|
||||
trophy.comparison = Comparison::GreaterEqual;
|
||||
else if (*comparison == "gt")
|
||||
trophy.comparison = Comparison::Greater;
|
||||
else if (*comparison == "le")
|
||||
trophy.comparison = Comparison::LessEqual;
|
||||
else if (*comparison == "lt")
|
||||
trophy.comparison = Comparison::Less;
|
||||
}
|
||||
trophy.target = target;
|
||||
}
|
||||
}
|
||||
const auto icon = files.find(fmt::format("trop{:04}.png", trophy.id));
|
||||
|
|
@ -210,11 +247,11 @@ std::filesystem::path UnlocksPath(const std::filesystem::path& root, std::string
|
|||
})) {
|
||||
return {};
|
||||
}
|
||||
return root / "_SaveData" / title_id /
|
||||
return root / "_Trophies" / title_id /
|
||||
fmt::format("trophies_{}_{}.json", user_id, service_label);
|
||||
}
|
||||
|
||||
std::set<int> LoadUnlocks(const std::filesystem::path& path) {
|
||||
UnlockData LoadUnlockData(const std::filesystem::path& path) {
|
||||
File file(path, File::Mode::Read);
|
||||
if (file.IsInvalid() || file.Size() > MaxUnlocksSize) {
|
||||
return {};
|
||||
|
|
@ -225,22 +262,40 @@ std::set<int> LoadUnlocks(const std::filesystem::path& path) {
|
|||
!json["unlockedTrophies"].is_array()) {
|
||||
return {};
|
||||
}
|
||||
std::set<int> unlocked;
|
||||
UnlockData unlocks;
|
||||
for (const auto& value: json["unlockedTrophies"]) {
|
||||
const auto id = ReadId(value);
|
||||
if (id >= 0) {
|
||||
unlocked.insert(id);
|
||||
unlocks.unlocked.insert(id);
|
||||
}
|
||||
}
|
||||
return unlocked;
|
||||
if (json.contains("unlockedAt") && json["unlockedAt"].is_object()) {
|
||||
for (auto it = json["unlockedAt"].begin(); it != json["unlockedAt"].end(); ++it) {
|
||||
const auto id = ReadId(Json(it.key()));
|
||||
if (id >= 0 && unlocks.unlocked.contains(id)) {
|
||||
const auto tick = ReadUnsigned(it.value());
|
||||
if (tick && *tick >= UnixEpochTick && *tick <= 315537897599999999ULL) {
|
||||
unlocks.timestamps.emplace(id, *tick);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return unlocks;
|
||||
}
|
||||
|
||||
bool SaveUnlocks(const std::filesystem::path& path, const std::set<int>& unlocked) {
|
||||
bool SaveUnlockData(const std::filesystem::path& path, const UnlockData& unlocks) {
|
||||
if (path.empty() || !File::CreateDirectories(path.parent_path())) {
|
||||
return false;
|
||||
}
|
||||
const auto text = Json {{"unlockedTrophies", unlocked}}.dump();
|
||||
auto temporary = path;
|
||||
Json timestamps = Json::object();
|
||||
for (const auto& [id, tick]: unlocks.timestamps) {
|
||||
if (unlocks.unlocked.contains(id)) {
|
||||
timestamps[std::to_string(id)] = tick;
|
||||
}
|
||||
}
|
||||
const auto text =
|
||||
Json {{"unlockedTrophies", unlocks.unlocked}, {"unlockedAt", timestamps}}.dump();
|
||||
auto temporary = path;
|
||||
temporary += ".tmp";
|
||||
File file;
|
||||
if (text.size() > MaxUnlocksSize || !file.Create(temporary)) {
|
||||
|
|
@ -261,4 +316,138 @@ bool SaveUnlocks(const std::filesystem::path& path, const std::set<int>& unlocke
|
|||
return false;
|
||||
}
|
||||
|
||||
UdsRules LoadUdsRules(const std::filesystem::path& path) {
|
||||
File file(path, File::Mode::Read);
|
||||
if (file.IsInvalid() || file.Size() > MaxPackageSize) {
|
||||
return {};
|
||||
}
|
||||
const auto bytes = file.ReadWholeBuffer();
|
||||
Files files;
|
||||
uint64_t size = 0;
|
||||
if (!ReadFiles(bytes, files, size)) {
|
||||
return {};
|
||||
}
|
||||
const auto definitions = ReadJson(files, "stats_definition.json");
|
||||
const auto extraction = ReadJson(files, "stats_extraction.json");
|
||||
if (!definitions.is_object() || !definitions.contains("statDefinitionArray") ||
|
||||
!definitions["statDefinitionArray"].is_array() || !extraction.is_object() ||
|
||||
!extraction.contains("statsExtractionRuleArray") ||
|
||||
!extraction["statsExtractionRuleArray"].is_array()) {
|
||||
return {};
|
||||
}
|
||||
// Only direct unsigned latest-value stats are evaluated here. Aggregated stats
|
||||
// and filtered/nested extraction require UDS state and event types we do not implement.
|
||||
std::map<uint64_t, bool> stats;
|
||||
for (const auto& definition: definitions["statDefinitionArray"]) {
|
||||
if (!definition.is_object() || !definition.contains("statId") ||
|
||||
!definition.contains("aggregation") || definition["aggregation"] != "latest" ||
|
||||
!definition.contains("dataType")) {
|
||||
continue;
|
||||
}
|
||||
const auto id = ReadUnsigned(definition["statId"]);
|
||||
const auto& type = definition["dataType"];
|
||||
if (!id || (type != "uint64" && type != "uint32")) {
|
||||
continue;
|
||||
}
|
||||
const uint64_t maximum = type == "uint32" ? UINT32_MAX : UINT64_MAX;
|
||||
if ((definition.contains("minValue") && ReadUnsigned(definition["minValue"]) != 0) ||
|
||||
(definition.contains("maxValue") && ReadUnsigned(definition["maxValue"]) != maximum)) {
|
||||
continue;
|
||||
}
|
||||
stats.emplace(*id, type == "uint32");
|
||||
}
|
||||
UdsRules events;
|
||||
for (const auto& rule: extraction["statsExtractionRuleArray"]) {
|
||||
if (!rule.is_object() || !rule.contains("condition") || !rule.contains("action")) {
|
||||
continue;
|
||||
}
|
||||
const auto& condition = rule["condition"];
|
||||
const auto& action = rule["action"];
|
||||
if (!condition.is_object() || condition.size() != 1 || !condition.contains("eventName") ||
|
||||
!condition["eventName"].is_string() || !action.is_object() ||
|
||||
!action.contains("input") || !action["input"].is_string() ||
|
||||
!action.contains("output") || !action["output"].is_object() ||
|
||||
!action["output"].contains("statId")) {
|
||||
continue;
|
||||
}
|
||||
const auto id = ReadUnsigned(action["output"]["statId"]);
|
||||
const auto& input = action["input"].get_ref<const std::string&>();
|
||||
if (!id || !stats.contains(*id) || !input.starts_with("$.") || input.size() == 2 ||
|
||||
input.find_first_not_of(
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_", 2) !=
|
||||
std::string::npos) {
|
||||
continue;
|
||||
}
|
||||
events[condition["eventName"].get<std::string>()].push_back(
|
||||
{*id, input.substr(2), stats.at(*id)});
|
||||
}
|
||||
return events;
|
||||
}
|
||||
|
||||
std::filesystem::path UdsPackagePath(uint32_t service_label) {
|
||||
return std::filesystem::path("sce_sys/uds") / fmt::format("uds{:02}.ucp", service_label);
|
||||
}
|
||||
|
||||
std::vector<int> FindUdsTrophies(const Package& package, std::string_view event_name,
|
||||
const std::map<std::string, UdsInteger>& properties) {
|
||||
const auto rules = package.event_rules.find(std::string(event_name));
|
||||
if (rules == package.event_rules.end()) {
|
||||
return {};
|
||||
}
|
||||
std::vector<int> ids;
|
||||
for (const auto& [id, trophy]: package.trophies) {
|
||||
if (trophy.grade == 1 || !trophy.uds_stat_id || !trophy.target) {
|
||||
continue;
|
||||
}
|
||||
for (const auto& rule: rules->second) {
|
||||
const auto value = properties.find(rule.input);
|
||||
if (rule.stat_id != *trophy.uds_stat_id || value == properties.end()) {
|
||||
continue;
|
||||
}
|
||||
std::optional<uint64_t> number;
|
||||
if (rule.is_uint32) {
|
||||
if (const auto* input = std::get_if<uint32_t>(&value->second)) number = *input;
|
||||
} else if (const auto* input = std::get_if<uint64_t>(&value->second)) {
|
||||
number = *input;
|
||||
}
|
||||
if (!number) continue;
|
||||
bool matched = false;
|
||||
switch (trophy.comparison) {
|
||||
case Comparison::GreaterEqual: matched = *number >= *trophy.target; break;
|
||||
case Comparison::Greater: matched = *number > *trophy.target; break;
|
||||
case Comparison::LessEqual: matched = *number <= *trophy.target; break;
|
||||
case Comparison::Less: matched = *number < *trophy.target; break;
|
||||
case Comparison::None: break;
|
||||
}
|
||||
if (matched) {
|
||||
ids.push_back(id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ids;
|
||||
}
|
||||
|
||||
uint32_t Progress::Percentage() const {
|
||||
const auto points = total_grade[2] * 6 + total_grade[3] * 2 + total_grade[4];
|
||||
const auto earned_points = earned_grade[2] * 6 + earned_grade[3] * 2 + earned_grade[4];
|
||||
return points == 0 ? 0 : earned_points * 100 / points;
|
||||
}
|
||||
|
||||
Progress GetProgress(const Package& package, const UnlockData& unlocks, std::optional<int> group) {
|
||||
Progress progress;
|
||||
for (const auto& [id, trophy]: package.trophies) {
|
||||
if (group && trophy.group_id != *group) {
|
||||
continue;
|
||||
}
|
||||
++progress.total;
|
||||
++progress.total_grade[trophy.grade];
|
||||
if (unlocks.unlocked.contains(id)) {
|
||||
++progress.earned;
|
||||
++progress.earned_grade[trophy.grade];
|
||||
}
|
||||
}
|
||||
return progress;
|
||||
}
|
||||
|
||||
} // namespace Common::Trophies
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#ifndef KYTY_COMMON_TROPHIES_H_
|
||||
#define KYTY_COMMON_TROPHIES_H_
|
||||
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <filesystem>
|
||||
|
|
@ -9,11 +10,15 @@
|
|||
#include <set>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <variant>
|
||||
#include <vector>
|
||||
|
||||
namespace Common::Trophies {
|
||||
|
||||
inline constexpr char PackageDirectory[] = "sce_sys/trophy2";
|
||||
inline constexpr char PackageDirectory[] = "sce_sys/trophy2";
|
||||
inline constexpr uint64_t UnixEpochTick = 62135596800000000ULL;
|
||||
|
||||
enum class Comparison { None, GreaterEqual, Greater, LessEqual, Less };
|
||||
|
||||
struct Trophy {
|
||||
int id = 0;
|
||||
|
|
@ -21,6 +26,9 @@ struct Trophy {
|
|||
int platinum_id = -1;
|
||||
int grade = 0;
|
||||
std::optional<uint64_t> target;
|
||||
std::optional<uint64_t> uds_stat_id;
|
||||
Comparison comparison = Comparison::None;
|
||||
bool progressive = false;
|
||||
std::string name;
|
||||
std::string description;
|
||||
std::string reward;
|
||||
|
|
@ -29,19 +37,50 @@ struct Trophy {
|
|||
bool has_reward = false;
|
||||
};
|
||||
|
||||
struct UdsRule {
|
||||
uint64_t stat_id;
|
||||
std::string input;
|
||||
bool is_uint32;
|
||||
};
|
||||
|
||||
using UdsRules = std::map<std::string, std::vector<UdsRule>>;
|
||||
using UdsInteger = std::variant<int32_t, uint32_t, uint64_t>;
|
||||
|
||||
struct Package {
|
||||
std::string title;
|
||||
std::map<int, std::string> groups;
|
||||
std::map<int, Trophy> trophies;
|
||||
UdsRules event_rules;
|
||||
};
|
||||
|
||||
struct UnlockData {
|
||||
std::set<int> unlocked;
|
||||
std::map<int, uint64_t> timestamps;
|
||||
};
|
||||
|
||||
struct Progress {
|
||||
std::array<uint32_t, 5> total_grade {};
|
||||
std::array<uint32_t, 5> earned_grade {};
|
||||
uint32_t total = 0;
|
||||
uint32_t earned = 0;
|
||||
|
||||
[[nodiscard]] uint32_t Percentage() const;
|
||||
};
|
||||
|
||||
[[nodiscard]] Progress GetProgress(const Package& package, const UnlockData& unlocks,
|
||||
std::optional<int> group = std::nullopt);
|
||||
|
||||
[[nodiscard]] Package LoadPackage(const std::filesystem::path& path, int console_language);
|
||||
[[nodiscard]] std::filesystem::path PackagePath(uint32_t service_label);
|
||||
[[nodiscard]] std::filesystem::path UdsPackagePath(uint32_t service_label);
|
||||
[[nodiscard]] UdsRules LoadUdsRules(const std::filesystem::path& path);
|
||||
[[nodiscard]] std::vector<int> FindUdsTrophies(const Package& package, std::string_view event_name,
|
||||
const std::map<std::string, UdsInteger>& properties);
|
||||
[[nodiscard]] std::filesystem::path UnlocksPath(const std::filesystem::path& root,
|
||||
std::string_view title_id, int user_id,
|
||||
uint32_t service_label);
|
||||
[[nodiscard]] std::set<int> LoadUnlocks(const std::filesystem::path& path);
|
||||
[[nodiscard]] bool SaveUnlocks(const std::filesystem::path& path, const std::set<int>& unlocked);
|
||||
[[nodiscard]] UnlockData LoadUnlockData(const std::filesystem::path& path);
|
||||
[[nodiscard]] bool SaveUnlockData(const std::filesystem::path& path, const UnlockData& unlocks);
|
||||
|
||||
} // namespace Common::Trophies
|
||||
|
||||
|
|
|
|||
|
|
@ -1100,56 +1100,68 @@ struct SystemOverlay::Impl {
|
|||
static_cast<float>(frame_extent.height) / 1080.0f),
|
||||
0.65f, 1.25f);
|
||||
const float width = std::max(
|
||||
0.0f, std::min(440.0f * screen_scale, static_cast<float>(frame_extent.width) - 32.0f));
|
||||
0.0f, std::min(520.0f * screen_scale, static_cast<float>(frame_extent.width) - 32.0f));
|
||||
const float height = 104.0f * screen_scale;
|
||||
const float rounding = 14.0f * screen_scale;
|
||||
const float fade_in = std::clamp(age / 0.22f, 0.0f, 1.0f);
|
||||
const float fade_out = std::clamp((TOAST_LIFETIME - age) / 0.4f, 0.0f, 1.0f);
|
||||
const float alpha = std::min(fade_in, fade_out);
|
||||
const float slide = (1.0f - fade_in) * (width + 24.0f);
|
||||
const ImVec2 top_left {static_cast<float>(frame_extent.width) - 24.0f - width + slide,
|
||||
const ImVec2 top_left {static_cast<float>(frame_extent.width) - 32.0f - width + slide,
|
||||
32.0f};
|
||||
const ImVec2 bottom_right {top_left.x + width, top_left.y + height};
|
||||
auto* draw = ImGui::GetForegroundDrawList();
|
||||
draw->AddRectFilled({top_left.x + 5.0f, top_left.y + 6.0f},
|
||||
{bottom_right.x + 5.0f, bottom_right.y + 6.0f},
|
||||
IM_COL32(0, 0, 0, static_cast<int>(95.0f * alpha)), 10.0f);
|
||||
draw->AddRectFilled(top_left, bottom_right,
|
||||
IM_COL32(18, 21, 29, static_cast<int>(242.0f * alpha)), 10.0f);
|
||||
draw->AddRect(top_left, bottom_right,
|
||||
IM_COL32(190, 154, 78, static_cast<int>(200.0f * alpha)), 10.0f,
|
||||
ImDrawFlags_RoundCornersAll, 1.5f);
|
||||
const auto fade = [alpha](int r, int g, int b, int a) {
|
||||
return IM_COL32(r, g, b, static_cast<int>(static_cast<float>(a) * alpha));
|
||||
};
|
||||
draw->AddRectFilled({top_left.x + 3.0f, top_left.y + 5.0f},
|
||||
{bottom_right.x + 3.0f, bottom_right.y + 5.0f}, fade(0, 0, 0, 90),
|
||||
rounding);
|
||||
draw->AddRectFilled(top_left, bottom_right, fade(24, 26, 32, 235), rounding);
|
||||
draw->AddRect(top_left, bottom_right, fade(255, 255, 255, 28), rounding,
|
||||
ImDrawFlags_RoundCornersAll, 1.0f);
|
||||
|
||||
const float pad = 10.0f * screen_scale;
|
||||
const float icon_size = height - 2.0f * pad;
|
||||
float text_left = top_left.x + 20.0f * screen_scale;
|
||||
if (trophy_notification_image != nullptr) {
|
||||
constexpr float ICON_SIZE = 88.0f;
|
||||
const ImVec2 icon_min {top_left.x + 8.0f * screen_scale,
|
||||
top_left.y + (height - ICON_SIZE * screen_scale) * 0.5f};
|
||||
const ImVec2 icon_max {icon_min.x + ICON_SIZE * screen_scale,
|
||||
icon_min.y + ICON_SIZE * screen_scale};
|
||||
draw->AddImage(trophy_notification_image->GetTexRef(), icon_min, icon_max, {0, 0},
|
||||
{1, 1}, IM_COL32(255, 255, 255, static_cast<int>(255.0f * alpha)));
|
||||
const ImVec2 icon_min {top_left.x + pad, top_left.y + pad};
|
||||
const ImVec2 icon_max {icon_min.x + icon_size, icon_min.y + icon_size};
|
||||
draw->AddImageRounded(trophy_notification_image->GetTexRef(), icon_min, icon_max,
|
||||
{0, 0}, {1, 1}, fade(255, 255, 255, 255), 8.0f * screen_scale);
|
||||
draw->AddRect(icon_min, icon_max, fade(255, 255, 255, 40), 8.0f * screen_scale,
|
||||
ImDrawFlags_RoundCornersAll, 1.0f);
|
||||
text_left = icon_max.x + 18.0f * screen_scale;
|
||||
}
|
||||
|
||||
const ImVec2 text_position {top_left.x +
|
||||
(trophy_notification_image ? 112.0f : 18.0f) * screen_scale,
|
||||
top_left.y + 18.0f * screen_scale};
|
||||
draw->PushClipRect(top_left, {bottom_right.x - 12.0f * screen_scale, bottom_right.y}, true);
|
||||
draw->AddText(nullptr, 13.0f * screen_scale, text_position,
|
||||
IM_COL32(232, 203, 139, static_cast<int>(255.0f * alpha)), "Trophy earned");
|
||||
draw->AddText(nullptr, 21.0f * screen_scale,
|
||||
{text_position.x, text_position.y + 22.0f * screen_scale},
|
||||
IM_COL32(255, 255, 255, static_cast<int>(255.0f * alpha)),
|
||||
trophy_notification->name.c_str());
|
||||
constexpr std::array GRADE_LABELS {"Platinum", "Gold", "Silver", "Bronze"};
|
||||
constexpr std::array GRADE_COLORS {
|
||||
IM_COL32(161, 225, 245, 255), IM_COL32(255, 207, 82, 255), IM_COL32(211, 220, 232, 255),
|
||||
IM_COL32(211, 142, 91, 255)};
|
||||
const int grade = trophy_notification->grade;
|
||||
if (grade > 0 && grade <= static_cast<int>(GRADE_LABELS.size())) {
|
||||
draw->AddText(nullptr, 13.0f * screen_scale,
|
||||
{text_position.x, text_position.y + 50.0f * screen_scale},
|
||||
ImGui::GetColorU32(GRADE_COLORS[grade - 1], alpha),
|
||||
GRADE_LABELS[grade - 1]);
|
||||
constexpr std::array GRADE_COLORS {IM_COL32(161, 225, 245, 255), IM_COL32(255, 207, 82, 255),
|
||||
IM_COL32(211, 220, 232, 255),
|
||||
IM_COL32(211, 142, 91, 255)};
|
||||
const int grade = trophy_notification->grade;
|
||||
const float title_y = top_left.y + height * 0.5f - 25.0f * screen_scale;
|
||||
float title_x = text_left;
|
||||
if (grade > 0 && grade <= static_cast<int>(GRADE_COLORS.size())) {
|
||||
// Small cup glyph tinted with the trophy grade.
|
||||
const ImU32 cup = ImGui::GetColorU32(GRADE_COLORS[grade - 1], alpha);
|
||||
const float u = screen_scale;
|
||||
const float cx = text_left + 9.0f * u;
|
||||
const float cy = title_y + 15.0f * u;
|
||||
draw->AddRectFilled({cx - 8.0f * u, cy - 11.0f * u}, {cx + 8.0f * u, cy + 2.0f * u},
|
||||
cup, 2.0f * u, ImDrawFlags_RoundCornersBottom);
|
||||
draw->AddRect({cx - 11.0f * u, cy - 9.0f * u}, {cx - 6.0f * u, cy - 3.0f * u}, cup,
|
||||
2.0f * u, ImDrawFlags_RoundCornersLeft, 1.8f * u);
|
||||
draw->AddRect({cx + 6.0f * u, cy - 9.0f * u}, {cx + 11.0f * u, cy - 3.0f * u}, cup,
|
||||
2.0f * u, ImDrawFlags_RoundCornersRight, 1.8f * u);
|
||||
draw->AddRectFilled({cx - 1.5f * u, cy + 2.0f * u}, {cx + 1.5f * u, cy + 7.0f * u}, cup);
|
||||
draw->AddRectFilled({cx - 5.0f * u, cy + 7.0f * u}, {cx + 5.0f * u, cy + 10.0f * u}, cup,
|
||||
1.5f * u);
|
||||
title_x += 30.0f * u;
|
||||
}
|
||||
draw->PushClipRect(top_left, {bottom_right.x - 16.0f * screen_scale, bottom_right.y}, true);
|
||||
draw->AddText(nullptr, 26.0f * screen_scale, {title_x, title_y},
|
||||
fade(255, 255, 255, 255), trophy_notification->name.c_str());
|
||||
draw->AddText(nullptr, 20.0f * screen_scale, {text_left, title_y + 38.0f * screen_scale},
|
||||
fade(176, 180, 192, 255), "Trophy earned!");
|
||||
draw->PopClipRect();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -169,6 +169,28 @@
|
|||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QToolButton" name="trophy_overview_button">
|
||||
<property name="minimumSize">
|
||||
<size>
|
||||
<width>36</width>
|
||||
<height>36</height>
|
||||
</size>
|
||||
</property>
|
||||
<property name="toolTip">
|
||||
<string>View saved trophies</string>
|
||||
</property>
|
||||
<property name="iconSize">
|
||||
<size>
|
||||
<width>32</width>
|
||||
<height>32</height>
|
||||
</size>
|
||||
</property>
|
||||
<property name="autoRaise">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<spacer name="horizontalSpacer">
|
||||
<property name="orientation">
|
||||
|
|
|
|||
|
|
@ -1 +1,6 @@
|
|||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path fill="#000" d="M17.65 6.35A7.96 7.96 0 0 0 12 4a8 8 0 1 0 7.73 10h-2.08A6 6 0 1 1 12 6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"/></svg>
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
|
||||
<g fill="none" stroke="#000000" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
|
||||
<path d="M26 16a10 10 0 1 1-2.93-7.07L27 13"/>
|
||||
<path d="M27 5v8h-8"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
|
|
|||
|
Before Width: | Height: | Size: 232 B After Width: | Height: | Size: 252 B |
|
|
@ -0,0 +1,7 @@
|
|||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
|
||||
<g fill="none" stroke="#000000" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
|
||||
<path d="M9 5h14v8a7 7 0 0 1-14 0Z"/>
|
||||
<path d="M9 8H5v3a4 4 0 0 0 4 4M23 8h4v3a4 4 0 0 1-4 4"/>
|
||||
<path d="M16 20v4M12 28v-4h8v4M11 28h10"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 325 B |
|
|
@ -43,6 +43,7 @@ public:
|
|||
bool EnsureGameDirectory();
|
||||
void ScanGameDirectory();
|
||||
void ViewTrophies();
|
||||
void ViewTrophyOverview();
|
||||
|
||||
signals:
|
||||
|
||||
|
|
|
|||
|
|
@ -3,6 +3,8 @@
|
|||
|
||||
#include <QDialog>
|
||||
|
||||
#include <vector>
|
||||
|
||||
class QTabWidget;
|
||||
class QWidget;
|
||||
|
||||
|
|
@ -14,6 +16,8 @@ public:
|
|||
static bool HasTrophyData(const Configuration* info);
|
||||
static void ShowForGame(const Configuration* info, const QString& runtime_directory,
|
||||
QWidget* parent);
|
||||
static void ShowOverview(const std::vector<const Configuration*>& games,
|
||||
const QString& runtime_directory, QWidget* parent);
|
||||
|
||||
private:
|
||||
bool LoadGame(const Configuration& info, const QString& runtime_directory, QString& error);
|
||||
|
|
|
|||
|
|
@ -5,6 +5,8 @@
|
|||
<file alias="input-mapping.svg">icons/input-mapping.svg</file>
|
||||
<file alias="refresh.svg">icons/refresh.svg</file>
|
||||
<file alias="remove-configuration.svg">icons/remove-configuration.svg</file>
|
||||
<file alias="trophy.svg">icons/trophy.svg</file>
|
||||
<file alias="hidden-trophy.png">../../assets/images/hidden-trophy.png</file>
|
||||
</qresource>
|
||||
<qresource prefix="/styles">
|
||||
<file alias="launcher.qss">styles/launcher.qss</file>
|
||||
|
|
|
|||
|
|
@ -56,6 +56,7 @@
|
|||
#endif
|
||||
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "ui_configuration_list_widget.h"
|
||||
|
||||
|
|
@ -241,6 +242,8 @@ ConfigurationListWidget::ConfigurationListWidget(QWidget* parent)
|
|||
&ConfigurationListWidget::edit_configuration);
|
||||
connect(m_ui->delete_button, &QToolButton::clicked, this,
|
||||
&ConfigurationListWidget::delete_configuartion);
|
||||
connect(m_ui->trophy_overview_button, &QToolButton::clicked, this,
|
||||
&ConfigurationListWidget::ViewTrophyOverview);
|
||||
connect(m_ui->cfgs_list, &QTreeWidget::currentItemChanged, this,
|
||||
&ConfigurationListWidget::SelectItem);
|
||||
connect(m_ui->cfgs_list, &QTreeWidget::itemDoubleClicked, this,
|
||||
|
|
@ -293,6 +296,7 @@ void ConfigurationListWidget::UpdateToolbarIcons() {
|
|||
set_icon(m_ui->input_mapping_button, QStringLiteral(":/icons/input-mapping.svg"));
|
||||
set_icon(m_ui->edit_button, QStringLiteral(":/icons/edit-configuration.svg"));
|
||||
set_icon(m_ui->delete_button, QStringLiteral(":/icons/remove-configuration.svg"));
|
||||
set_icon(m_ui->trophy_overview_button, QStringLiteral(":/icons/trophy.svg"));
|
||||
}
|
||||
|
||||
void ConfigurationListWidget::WriteSettings() {
|
||||
|
|
@ -840,6 +844,20 @@ void ConfigurationListWidget::ViewTrophies() {
|
|||
TrophyViewerDialog::ShowForGame(config.get(), m_runtime_directory, this);
|
||||
}
|
||||
|
||||
void ConfigurationListWidget::ViewTrophyOverview() {
|
||||
std::vector<std::unique_ptr<Configuration>> configurations;
|
||||
std::vector<const Configuration*> games;
|
||||
configurations.reserve(static_cast<size_t>(m_ui->cfgs_list->topLevelItemCount()));
|
||||
games.reserve(static_cast<size_t>(m_ui->cfgs_list->topLevelItemCount()));
|
||||
for (int index = 0; index < m_ui->cfgs_list->topLevelItemCount(); ++index) {
|
||||
const auto* item =
|
||||
static_cast<const ConfigurationItem*>(m_ui->cfgs_list->topLevelItem(index));
|
||||
configurations.push_back(CreateConfiguration(*item));
|
||||
games.push_back(configurations.back().get());
|
||||
}
|
||||
TrophyViewerDialog::ShowOverview(games, m_runtime_directory, this);
|
||||
}
|
||||
|
||||
void ConfigurationListWidget::open_game_folder() {
|
||||
auto* item = static_cast<ConfigurationItem*>(m_ui->cfgs_list->currentItem());
|
||||
if (item == nullptr) {
|
||||
|
|
|
|||
|
|
@ -6,18 +6,23 @@
|
|||
#include "gameContent.h"
|
||||
|
||||
#include <QAbstractItemView>
|
||||
#include <QDateTime>
|
||||
#include <QDialogButtonBox>
|
||||
#include <QFileInfo>
|
||||
#include <QFont>
|
||||
#include <QHeaderView>
|
||||
#include <QIcon>
|
||||
#include <QHBoxLayout>
|
||||
#include <QImage>
|
||||
#include <QLabel>
|
||||
#include <QListWidget>
|
||||
#include <QMessageBox>
|
||||
#include <QPainter>
|
||||
#include <QPainterPath>
|
||||
#include <QPixmap>
|
||||
#include <QProgressBar>
|
||||
#include <QRegularExpression>
|
||||
#include <QSize>
|
||||
#include <QStringList>
|
||||
#include <QTabBar>
|
||||
#include <QTabWidget>
|
||||
#include <QTableWidget>
|
||||
#include <QVBoxLayout>
|
||||
|
||||
namespace {
|
||||
|
|
@ -49,26 +54,6 @@ static QString GradeToText(int grade) {
|
|||
}
|
||||
}
|
||||
|
||||
static void PrepareTable(QTableWidget* table) {
|
||||
table->setHorizontalHeaderLabels({QObject::tr("Unlocked"), QObject::tr("Trophy"),
|
||||
QObject::tr("Name"), QObject::tr("Description")});
|
||||
table->setAlternatingRowColors(true);
|
||||
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
|
||||
table->setSelectionBehavior(QAbstractItemView::SelectRows);
|
||||
table->setSelectionMode(QAbstractItemView::SingleSelection);
|
||||
table->setIconSize(QSize(96, 96));
|
||||
table->setShowGrid(false);
|
||||
table->setWordWrap(true);
|
||||
table->verticalHeader()->setVisible(false);
|
||||
table->verticalHeader()->setDefaultSectionSize(112);
|
||||
table->horizontalHeader()->setStretchLastSection(true);
|
||||
table->horizontalHeader()->setHighlightSections(false);
|
||||
table->setColumnWidth(0, 100);
|
||||
table->setColumnWidth(1, 132);
|
||||
table->setColumnWidth(2, 260);
|
||||
table->setColumnWidth(3, 480);
|
||||
}
|
||||
|
||||
static QString TrophyTooltip(const Common::Trophies::Trophy& trophy) {
|
||||
QStringList lines {QString::fromStdString(trophy.name),
|
||||
QString::fromStdString(trophy.description),
|
||||
|
|
@ -102,6 +87,225 @@ bool TrophyViewerDialog::HasTrophyData(const Configuration* info) {
|
|||
return !FindTrophyFiles(info).isEmpty();
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
using Common::Trophies::Progress;
|
||||
|
||||
Common::Trophies::UnlockData LoadUnlocks(const Configuration& info,
|
||||
const QString& runtime_directory, const QString& file) {
|
||||
const auto label = TrophyFilePattern.match(QFileInfo(file).fileName()).captured(1).toUInt();
|
||||
return Common::Trophies::LoadUnlockData(Common::Trophies::UnlocksPath(
|
||||
GameContent::ToPath(runtime_directory), info.title_id.toStdString(), info.user_id, label));
|
||||
}
|
||||
|
||||
Progress GetGameProgress(const Configuration* info, const QString& runtime_directory) {
|
||||
Progress result;
|
||||
if (info == nullptr) {
|
||||
return result;
|
||||
}
|
||||
const auto reader = Common::OpenArchive(GameContent::ToPath(info->basedir));
|
||||
for (const auto& file: FindTrophyFiles(info)) {
|
||||
const auto package =
|
||||
Common::Trophies::LoadPackage(GameContent::ToPath(file), info->console_language);
|
||||
const auto progress =
|
||||
Common::Trophies::GetProgress(package, LoadUnlocks(*info, runtime_directory, file));
|
||||
result.total += progress.total;
|
||||
result.earned += progress.earned;
|
||||
for (size_t grade = 1; grade < result.total_grade.size(); ++grade) {
|
||||
result.total_grade[grade] += progress.total_grade[grade];
|
||||
result.earned_grade[grade] += progress.earned_grade[grade];
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
QPixmap MakeCupIcon(const QColor& color, int size) {
|
||||
QPixmap pixmap(size, size);
|
||||
pixmap.fill(Qt::transparent);
|
||||
QPainter painter(&pixmap);
|
||||
painter.setRenderHint(QPainter::Antialiasing);
|
||||
const double u = size / 20.0;
|
||||
painter.setPen(Qt::NoPen);
|
||||
painter.setBrush(color);
|
||||
QPainterPath cup;
|
||||
cup.moveTo(5 * u, 2 * u);
|
||||
cup.lineTo(15 * u, 2 * u);
|
||||
cup.lineTo(14 * u, 9 * u);
|
||||
cup.quadTo(10 * u, 13 * u, 6 * u, 9 * u);
|
||||
cup.closeSubpath();
|
||||
painter.drawPath(cup);
|
||||
painter.setPen(QPen(color, 1.6 * u));
|
||||
painter.setBrush(Qt::NoBrush);
|
||||
painter.drawArc(QRectF(1.5 * u, 3 * u, 5 * u, 5 * u), 90 * 16, 180 * 16);
|
||||
painter.drawArc(QRectF(13.5 * u, 3 * u, 5 * u, 5 * u), 90 * 16, -180 * 16);
|
||||
painter.drawLine(QPointF(10 * u, 12 * u), QPointF(10 * u, 16 * u));
|
||||
painter.setPen(Qt::NoPen);
|
||||
painter.setBrush(color);
|
||||
painter.drawRoundedRect(QRectF(6 * u, 16 * u, 8 * u, 2.5 * u), u, u);
|
||||
return pixmap;
|
||||
}
|
||||
|
||||
QColor GradeColor(int grade) {
|
||||
switch (grade) {
|
||||
case 1: return QColor(0x7fc8ff);
|
||||
case 2: return QColor(0xf5c542);
|
||||
case 3: return QColor(0xc4cad2);
|
||||
default: return QColor(0xcd7f4f);
|
||||
}
|
||||
}
|
||||
|
||||
QWidget* MakeGradeCount(QWidget* parent, int grade, int value, int icon_size, int font_size) {
|
||||
auto* box = new QWidget(parent);
|
||||
auto* row = new QHBoxLayout(box);
|
||||
row->setContentsMargins(0, 0, 0, 0);
|
||||
auto* icon = new QLabel(box);
|
||||
icon->setPixmap(MakeCupIcon(GradeColor(grade), icon_size));
|
||||
auto* text = new QLabel(QString::number(value), box);
|
||||
text->setStyleSheet(QStringLiteral("font-size: %1px;").arg(font_size));
|
||||
row->addWidget(icon);
|
||||
row->addWidget(text);
|
||||
return box;
|
||||
}
|
||||
|
||||
QPixmap LoadGameArt(const Configuration* game, int height) {
|
||||
QPixmap art;
|
||||
const auto data = GameContent::ReadFile(game->basedir, QStringLiteral("sce_sys/icon0.png"),
|
||||
GameContent::MaxImageSize);
|
||||
if (!data.isEmpty() && art.loadFromData(data)) {
|
||||
return art.scaledToHeight(height, Qt::SmoothTransformation);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void TrophyViewerDialog::ShowOverview(const std::vector<const Configuration*>& games,
|
||||
const QString& runtime_directory, QWidget* parent) {
|
||||
QDialog dialog(parent);
|
||||
dialog.setWindowTitle(QObject::tr("Trophies"));
|
||||
dialog.resize(820, 640);
|
||||
dialog.setStyleSheet(QStringLiteral(
|
||||
"QDialog { background: palette(window); }"
|
||||
"QLabel { color: palette(text); }"
|
||||
"QListWidget { background: transparent; border: none; outline: none; }"
|
||||
"QListWidget::item { border-bottom: 1px solid palette(mid); padding: 4px; }"
|
||||
"QListWidget::item:selected, QListWidget::item:hover { background: palette(midlight); "
|
||||
"border: 1px solid palette(highlight); }"
|
||||
"QProgressBar { background: palette(mid); border: none; height: 4px; }"
|
||||
"QProgressBar::chunk { background: palette(highlight); }"));
|
||||
auto* layout = new QVBoxLayout(&dialog);
|
||||
|
||||
struct GameProgress {
|
||||
const Configuration* game;
|
||||
Progress progress;
|
||||
};
|
||||
std::vector<GameProgress> trophy_games;
|
||||
Progress totals;
|
||||
for (const auto* game: games) {
|
||||
const auto progress = GetGameProgress(game, runtime_directory);
|
||||
if (progress.total == 0) {
|
||||
continue;
|
||||
}
|
||||
trophy_games.push_back({game, progress});
|
||||
totals.earned += progress.earned;
|
||||
for (size_t grade = 1; grade < totals.earned_grade.size(); ++grade) {
|
||||
totals.earned_grade[grade] += progress.earned_grade[grade];
|
||||
}
|
||||
}
|
||||
|
||||
auto* header = new QHBoxLayout;
|
||||
auto* title = new QLabel(QObject::tr("Trophies"), &dialog);
|
||||
title->setStyleSheet(QStringLiteral("font-size: 30px;"));
|
||||
header->addWidget(title);
|
||||
header->addStretch(1);
|
||||
auto* total = new QLabel(QObject::tr("Total %1").arg(totals.earned), &dialog);
|
||||
total->setAlignment(Qt::AlignCenter);
|
||||
total->setStyleSheet(QStringLiteral("font-size: 16px;"));
|
||||
header->addWidget(total);
|
||||
for (int grade = 1; grade <= 4; ++grade) {
|
||||
header->addWidget(MakeGradeCount(&dialog, grade, totals.earned_grade[grade], 32, 18));
|
||||
}
|
||||
layout->addLayout(header);
|
||||
|
||||
auto* list = new QListWidget(&dialog);
|
||||
list->setSelectionMode(QAbstractItemView::SingleSelection);
|
||||
list->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
|
||||
layout->addWidget(list, 1);
|
||||
|
||||
for (size_t index = 0; index < trophy_games.size(); ++index) {
|
||||
const auto& [game, progress] = trophy_games[index];
|
||||
auto* item = new QListWidgetItem(list);
|
||||
item->setSizeHint(QSize(760, 112));
|
||||
item->setData(Qt::UserRole, static_cast<int>(index));
|
||||
|
||||
auto* row_widget = new QWidget(list);
|
||||
row_widget->setAttribute(Qt::WA_TransparentForMouseEvents);
|
||||
auto* row = new QHBoxLayout(row_widget);
|
||||
auto* art = new QLabel(row_widget);
|
||||
art->setFixedSize(80, 80);
|
||||
art->setAlignment(Qt::AlignCenter);
|
||||
const auto pixmap = LoadGameArt(game, 80);
|
||||
if (!pixmap.isNull()) {
|
||||
art->setPixmap(pixmap);
|
||||
} else {
|
||||
art->setStyleSheet(QStringLiteral("background: palette(mid);"));
|
||||
}
|
||||
row->addWidget(art);
|
||||
const auto name = !game->name.isEmpty() ? game->name : game->title_id;
|
||||
auto* text = new QLabel(QStringLiteral("%1\n%2").arg(name, game->title_id), row_widget);
|
||||
text->setStyleSheet(QStringLiteral("font-size: 18px;"));
|
||||
row->addWidget(text, 1);
|
||||
|
||||
auto* percent_box = new QVBoxLayout;
|
||||
percent_box->setSpacing(2);
|
||||
percent_box->setContentsMargins(0, 0, 0, 0);
|
||||
auto* percent = new QLabel(QStringLiteral("%1%").arg(progress.Percentage()), row_widget);
|
||||
percent->setAlignment(Qt::AlignRight);
|
||||
percent->setStyleSheet(QStringLiteral("font-size: 24px;"));
|
||||
percent->setMinimumHeight(34);
|
||||
auto* earned = new QLabel(
|
||||
QObject::tr("Earned %1/%2").arg(progress.earned).arg(progress.total), row_widget);
|
||||
earned->setAlignment(Qt::AlignRight);
|
||||
earned->setMinimumHeight(18);
|
||||
auto* bar = new QProgressBar(row_widget);
|
||||
bar->setRange(0, 100);
|
||||
bar->setValue(progress.Percentage());
|
||||
bar->setTextVisible(false);
|
||||
bar->setFixedWidth(130);
|
||||
percent_box->addWidget(percent);
|
||||
percent_box->addWidget(earned);
|
||||
percent_box->addWidget(bar);
|
||||
row->addLayout(percent_box);
|
||||
for (int grade = 1; grade <= 4; ++grade) {
|
||||
if (grade == 1 && progress.total_grade[1] == 0) {
|
||||
continue;
|
||||
}
|
||||
row->addWidget(MakeGradeCount(row_widget, grade, progress.earned_grade[grade], 24, 18));
|
||||
}
|
||||
list->setItemWidget(item, row_widget);
|
||||
}
|
||||
if (trophy_games.empty()) {
|
||||
auto* empty =
|
||||
new QLabel(QObject::tr("No games with trophies found in the game folders."), &dialog);
|
||||
empty->setAlignment(Qt::AlignCenter);
|
||||
layout->insertWidget(1, empty);
|
||||
list->hide();
|
||||
}
|
||||
|
||||
connect(list, &QListWidget::itemClicked, &dialog,
|
||||
[&dialog, &trophy_games, &runtime_directory](QListWidgetItem* item) {
|
||||
const auto index = item->data(Qt::UserRole).toInt();
|
||||
if (index >= 0 && static_cast<size_t>(index) < trophy_games.size()) {
|
||||
ShowForGame(trophy_games[static_cast<size_t>(index)].game, runtime_directory,
|
||||
&dialog);
|
||||
}
|
||||
});
|
||||
auto* buttons = new QDialogButtonBox(QDialogButtonBox::Close, &dialog);
|
||||
connect(buttons, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
|
||||
layout->addWidget(buttons);
|
||||
dialog.exec();
|
||||
}
|
||||
|
||||
void TrophyViewerDialog::ShowForGame(const Configuration* info, const QString& runtime_directory,
|
||||
QWidget* parent) {
|
||||
if (info == nullptr) {
|
||||
|
|
@ -139,51 +343,131 @@ bool TrophyViewerDialog::LoadGame(const Configuration& info, const QString& runt
|
|||
errors.append(tr("Could not read trophy package %1.").arg(QFileInfo(file).fileName()));
|
||||
continue;
|
||||
}
|
||||
const auto label = TrophyFilePattern.match(QFileInfo(file).fileName()).captured(1).toUInt();
|
||||
const auto unlocked = Common::Trophies::LoadUnlocks(
|
||||
Common::Trophies::UnlocksPath(GameContent::ToPath(runtime_directory),
|
||||
info.title_id.toStdString(), info.user_id, label));
|
||||
auto* table = new QTableWidget(static_cast<int>(package.trophies.size()), 4, m_tabs);
|
||||
PrepareTable(table);
|
||||
int row_index = 0;
|
||||
for (const auto& [id, trophy]: package.trophies) {
|
||||
const bool trophy_unlocked = unlocked.contains(id);
|
||||
auto* status = new QTableWidgetItem(trophy_unlocked ? tr("UNLOCKED") : tr("LOCKED"));
|
||||
status->setTextAlignment(Qt::AlignCenter);
|
||||
auto status_font = status->font();
|
||||
status_font.setBold(true);
|
||||
status->setFont(status_font);
|
||||
table->setItem(row_index, 0, status);
|
||||
const auto unlocks = LoadUnlocks(info, runtime_directory, file);
|
||||
const auto counts = Common::Trophies::GetProgress(package, unlocks);
|
||||
auto* page = new QWidget(m_tabs);
|
||||
auto* page_layout = new QVBoxLayout(page);
|
||||
|
||||
auto* icon_item = new QTableWidgetItem;
|
||||
icon_item->setTextAlignment(Qt::AlignCenter);
|
||||
QPixmap icon;
|
||||
if (icon.loadFromData(reinterpret_cast<const uchar*>(trophy.icon_png.data()),
|
||||
static_cast<uint>(trophy.icon_png.size()))) {
|
||||
if (!trophy_unlocked) {
|
||||
icon = QPixmap::fromImage(
|
||||
icon.toImage().convertToFormat(QImage::Format_Grayscale8));
|
||||
}
|
||||
icon_item->setIcon(QIcon(icon));
|
||||
}
|
||||
table->setItem(row_index, 1, icon_item);
|
||||
|
||||
const auto name_text = trophy.name.empty() ? (trophy.hidden ? tr("Hidden Trophy")
|
||||
: tr("Trophy %1").arg(id))
|
||||
: QString::fromStdString(trophy.name);
|
||||
auto* name = new QTableWidgetItem(name_text);
|
||||
auto font = name->font();
|
||||
font.setBold(true);
|
||||
name->setFont(font);
|
||||
name->setToolTip(TrophyTooltip(trophy));
|
||||
auto* detail = new QTableWidgetItem(QString::fromStdString(trophy.description));
|
||||
detail->setToolTip(name->toolTip());
|
||||
table->setItem(row_index, 2, name);
|
||||
table->setItem(row_index, 3, detail);
|
||||
++row_index;
|
||||
auto* header = new QHBoxLayout;
|
||||
auto* art = new QLabel(page);
|
||||
if (const auto pixmap = LoadGameArt(&info, 56); !pixmap.isNull()) {
|
||||
art->setPixmap(pixmap);
|
||||
header->addWidget(art);
|
||||
}
|
||||
m_tabs->addTab(table, tr("Trophy %1").arg(label));
|
||||
auto* title = new QLabel(QString::fromStdString(package.title), page);
|
||||
title->setStyleSheet(QStringLiteral("font-size: 28px;"));
|
||||
header->addWidget(title, 1);
|
||||
const auto make_stat = [page](const QString& label, const QString& value) {
|
||||
auto* box = new QVBoxLayout;
|
||||
auto* name = new QLabel(label, page);
|
||||
auto* number = new QLabel(value, page);
|
||||
name->setStyleSheet(QStringLiteral("font-size: 14px;"));
|
||||
number->setStyleSheet(QStringLiteral("font-size: 22px;"));
|
||||
box->addWidget(name);
|
||||
box->addWidget(number);
|
||||
return box;
|
||||
};
|
||||
header->addLayout(
|
||||
make_stat(tr("Progress"), QStringLiteral("%1%").arg(counts.Percentage())));
|
||||
header->addLayout(
|
||||
make_stat(tr("Earned"), QStringLiteral("%1/%2").arg(counts.earned).arg(counts.total)));
|
||||
for (int grade = 1; grade <= 4; ++grade) {
|
||||
if (counts.total_grade[grade] > 0) {
|
||||
header->addWidget(MakeGradeCount(page, grade, counts.earned_grade[grade], 30, 20));
|
||||
}
|
||||
}
|
||||
page_layout->addLayout(header);
|
||||
auto* progress = new QProgressBar(page);
|
||||
progress->setRange(0, 100);
|
||||
progress->setValue(counts.Percentage());
|
||||
progress->setTextVisible(false);
|
||||
page_layout->addWidget(progress);
|
||||
auto* count_label = new QLabel(tr("All trophies: %1").arg(counts.total), page);
|
||||
page_layout->addWidget(count_label);
|
||||
|
||||
auto* list = new QListWidget(page);
|
||||
list->setSelectionMode(QAbstractItemView::NoSelection);
|
||||
list->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
|
||||
list->setSpacing(4);
|
||||
page_layout->addWidget(list, 1);
|
||||
for (const auto& [id, trophy]: package.trophies) {
|
||||
const bool trophy_unlocked = unlocks.unlocked.contains(id);
|
||||
const auto hidden_locked = trophy.hidden && !trophy_unlocked;
|
||||
auto* item = new QListWidgetItem(list);
|
||||
item->setSizeHint(QSize(900, 96));
|
||||
|
||||
auto* card = new QWidget(list);
|
||||
card->setStyleSheet(
|
||||
QStringLiteral("QWidget#card { background: palette(base); border-radius: 12px; }"));
|
||||
card->setObjectName(QStringLiteral("card"));
|
||||
auto* row = new QHBoxLayout(card);
|
||||
auto* icon = new QLabel(card);
|
||||
icon->setFixedSize(76, 76);
|
||||
icon->setAlignment(Qt::AlignCenter);
|
||||
QPixmap pixmap;
|
||||
if (hidden_locked) {
|
||||
pixmap = QPixmap(QStringLiteral(":/icons/hidden-trophy.png"));
|
||||
} else if (pixmap.loadFromData(reinterpret_cast<const uchar*>(trophy.icon_png.data()),
|
||||
static_cast<uint>(trophy.icon_png.size())) &&
|
||||
!trophy_unlocked) {
|
||||
pixmap =
|
||||
QPixmap::fromImage(pixmap.toImage().convertToFormat(QImage::Format_Grayscale8));
|
||||
}
|
||||
if (!pixmap.isNull()) {
|
||||
icon->setPixmap(
|
||||
pixmap.scaled(76, 76, Qt::KeepAspectRatio, Qt::SmoothTransformation));
|
||||
}
|
||||
row->addWidget(icon);
|
||||
|
||||
auto* left = new QVBoxLayout;
|
||||
const auto name_text = hidden_locked ? tr("Hidden trophy")
|
||||
: trophy.name.empty() ? tr("Trophy %1").arg(id)
|
||||
: QString::fromStdString(trophy.name);
|
||||
auto* name = new QLabel(name_text, card);
|
||||
name->setStyleSheet(QStringLiteral("font-size: 20px; font-weight: bold;"));
|
||||
left->addWidget(name);
|
||||
if (!hidden_locked) {
|
||||
auto* grade_row = new QHBoxLayout;
|
||||
auto* cup = new QLabel(card);
|
||||
cup->setPixmap(MakeCupIcon(GradeColor(trophy.grade), 18));
|
||||
auto* grade_text = new QLabel(GradeToText(trophy.grade), card);
|
||||
grade_text->setStyleSheet(QStringLiteral("font-size: 15px;"));
|
||||
grade_row->addWidget(cup);
|
||||
grade_row->addWidget(grade_text);
|
||||
grade_row->addStretch(1);
|
||||
left->addLayout(grade_row);
|
||||
}
|
||||
|
||||
row->addLayout(left, 2);
|
||||
|
||||
auto* right = new QVBoxLayout;
|
||||
QString date_text;
|
||||
if (const auto found = unlocks.timestamps.find(id); found != unlocks.timestamps.end()) {
|
||||
date_text = QDateTime::fromMSecsSinceEpoch(
|
||||
static_cast<qint64>(
|
||||
(found->second - Common::Trophies::UnixEpochTick) / 1000))
|
||||
.toLocalTime()
|
||||
.toString(QStringLiteral("yyyy-MM-dd HH:mm:ss"));
|
||||
} else if (trophy_unlocked) {
|
||||
date_text = tr("Earned");
|
||||
}
|
||||
auto* date = new QLabel(date_text, card);
|
||||
date->setAlignment(Qt::AlignRight);
|
||||
date->setStyleSheet(QStringLiteral("font-size: 15px;"));
|
||||
auto* detail = new QLabel(
|
||||
hidden_locked ? QString {} : QString::fromStdString(trophy.description), card);
|
||||
detail->setWordWrap(true);
|
||||
detail->setAlignment(Qt::AlignLeft | Qt::AlignTop);
|
||||
detail->setStyleSheet(QStringLiteral("font-size: 17px;"));
|
||||
right->addWidget(date);
|
||||
right->addWidget(detail, 1);
|
||||
row->addLayout(right, 3);
|
||||
card->setToolTip(hidden_locked ? name_text : TrophyTooltip(trophy));
|
||||
list->setItemWidget(item, card);
|
||||
}
|
||||
m_tabs->addTab(page, QString::fromStdString(package.title));
|
||||
}
|
||||
m_tabs->tabBar()->setVisible(m_tabs->count() > 1);
|
||||
if (m_tabs->count() == 0) {
|
||||
error = errors.join(QLatin1Char('\n'));
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -39,9 +39,11 @@ QLineEdit#search_line_edit:focus {
|
|||
border-color: palette(highlight);
|
||||
}
|
||||
|
||||
QToolButton#refresh_button,
|
||||
QToolButton#global_settings_button,
|
||||
QToolButton#input_mapping_button,
|
||||
QToolButton#edit_button,
|
||||
QToolButton#trophy_overview_button,
|
||||
QToolButton#delete_button {
|
||||
background: transparent;
|
||||
border: 1px solid transparent;
|
||||
|
|
@ -49,17 +51,21 @@ QToolButton#delete_button {
|
|||
padding: 3px;
|
||||
}
|
||||
|
||||
QToolButton#refresh_button:hover,
|
||||
QToolButton#global_settings_button:hover,
|
||||
QToolButton#input_mapping_button:hover,
|
||||
QToolButton#edit_button:hover,
|
||||
QToolButton#trophy_overview_button:hover,
|
||||
QToolButton#delete_button:hover {
|
||||
background: palette(button);
|
||||
border-color: palette(mid);
|
||||
}
|
||||
|
||||
QToolButton#refresh_button:pressed,
|
||||
QToolButton#global_settings_button:pressed,
|
||||
QToolButton#input_mapping_button:pressed,
|
||||
QToolButton#edit_button:pressed,
|
||||
QToolButton#trophy_overview_button:pressed,
|
||||
QToolButton#delete_button:pressed {
|
||||
background: palette(midlight);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,13 +7,12 @@
|
|||
#include "loader/systemContent.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <chrono>
|
||||
#include <cstring>
|
||||
#include <filesystem>
|
||||
#include <map>
|
||||
#include <mutex>
|
||||
#include <optional>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
|
|
@ -104,7 +103,7 @@ using TrophyKey = std::pair<int, uint32_t>;
|
|||
|
||||
struct TrophyState {
|
||||
const Trophies::Package* package = nullptr;
|
||||
std::set<int> unlocked;
|
||||
Trophies::UnlockData unlocks;
|
||||
std::filesystem::path path;
|
||||
};
|
||||
|
||||
|
|
@ -130,20 +129,33 @@ static TrophyState* LoadTrophyState(TrophyKey key) {
|
|||
if (const auto it = g_states.find(key); it != g_states.end()) {
|
||||
return &it->second;
|
||||
}
|
||||
std::string title_id;
|
||||
Loader::SystemContentParamSfoGetString("TITLE_ID", &title_id);
|
||||
auto& package = g_packages[key.second];
|
||||
if (package.trophies.empty()) {
|
||||
const auto filename = "/app0/" + Trophies::PackagePath(key.second).generic_string();
|
||||
package = Trophies::LoadPackage(LibKernel::FileSystem::GetRealFilename(filename),
|
||||
Config::GetConsoleLanguage());
|
||||
if (package.trophies.empty()) {
|
||||
LOGF("[Trophy] could not load trophy package %s for %s\n", filename.c_str(),
|
||||
title_id.c_str());
|
||||
return nullptr;
|
||||
}
|
||||
LOGF("[Trophy] loaded %zu trophy definitions for %s (service %u)\n",
|
||||
package.trophies.size(), title_id.c_str(), key.second);
|
||||
const auto uds_filename = "/app0/" + Trophies::UdsPackagePath(key.second).generic_string();
|
||||
package.event_rules =
|
||||
Trophies::LoadUdsRules(LibKernel::FileSystem::GetRealFilename(uds_filename));
|
||||
if (package.event_rules.empty()) {
|
||||
LOGF("[Trophy] no supported UDS extraction rules in %s\n", uds_filename.c_str());
|
||||
} else {
|
||||
LOGF("[Trophy] loaded UDS extraction rules for %zu events from %s\n",
|
||||
package.event_rules.size(), uds_filename.c_str());
|
||||
}
|
||||
}
|
||||
std::string title_id;
|
||||
Loader::SystemContentParamSfoGetString("TITLE_ID", &title_id);
|
||||
auto path = Trophies::UnlocksPath({}, title_id, key.first, key.second);
|
||||
auto unlocked = Trophies::LoadUnlocks(path);
|
||||
return &g_states.emplace(key, TrophyState {&package, std::move(unlocked), std::move(path)})
|
||||
auto path = Trophies::UnlocksPath({}, title_id, key.first, key.second);
|
||||
auto unlocks = Trophies::LoadUnlockData(path);
|
||||
return &g_states.emplace(key, TrophyState {&package, std::move(unlocks), std::move(path)})
|
||||
.first->second;
|
||||
}
|
||||
|
||||
|
|
@ -165,7 +177,7 @@ static void FillTrophyInfo(const TrophyState& state, const Trophies::Trophy& tro
|
|||
details->group_id = trophy.group_id;
|
||||
details->hidden = trophy.hidden;
|
||||
details->has_reward = trophy.has_reward;
|
||||
if (trophy.target) {
|
||||
if (trophy.progressive && trophy.target) {
|
||||
details->target.type = 1;
|
||||
details->target.value = *trophy.target;
|
||||
}
|
||||
|
|
@ -177,8 +189,12 @@ static void FillTrophyInfo(const TrophyState& state, const Trophies::Trophy& tro
|
|||
if (data != nullptr) {
|
||||
*data = {};
|
||||
data->trophy_id = trophy.id;
|
||||
data->unlocked = state.unlocked.contains(trophy.id);
|
||||
if (trophy.target) {
|
||||
data->unlocked = state.unlocks.unlocked.contains(trophy.id);
|
||||
if (const auto timestamp = state.unlocks.timestamps.find(trophy.id);
|
||||
timestamp != state.unlocks.timestamps.end()) {
|
||||
data->timestamp_tick = timestamp->second;
|
||||
}
|
||||
if (trophy.progressive && trophy.target) {
|
||||
data->progress.type = 1;
|
||||
data->progress.value = data->unlocked ? *trophy.target : 0;
|
||||
}
|
||||
|
|
@ -188,19 +204,13 @@ static void FillTrophyInfo(const TrophyState& state, const Trophies::Trophy& tro
|
|||
// Game and group structures share the same count fields.
|
||||
template <typename Details, typename Data>
|
||||
static void FillTrophyCounts(const TrophyState& state, int group, Details* details, Data* data) {
|
||||
std::array<uint32_t, 5> total {}, unlocked {};
|
||||
for (const auto& [id, trophy]: state.package->trophies) {
|
||||
if (group != -2 && trophy.group_id != group) {
|
||||
continue;
|
||||
}
|
||||
++total[trophy.grade];
|
||||
if (state.unlocked.contains(id)) {
|
||||
++unlocked[trophy.grade];
|
||||
}
|
||||
}
|
||||
const auto progress = Trophies::GetProgress(
|
||||
*state.package, state.unlocks, group == -2 ? std::nullopt : std::optional<int>(group));
|
||||
const auto& total = progress.total_grade;
|
||||
const auto& unlocked = progress.earned_grade;
|
||||
if (details != nullptr) {
|
||||
*details = {};
|
||||
details->num_trophies = total[1] + total[2] + total[3] + total[4];
|
||||
details->num_trophies = progress.total;
|
||||
details->num_platinum = total[1];
|
||||
details->num_gold = total[2];
|
||||
details->num_silver = total[3];
|
||||
|
|
@ -208,14 +218,12 @@ static void FillTrophyCounts(const TrophyState& state, int group, Details* detai
|
|||
}
|
||||
if (data != nullptr) {
|
||||
*data = {};
|
||||
data->unlocked_trophies = unlocked[1] + unlocked[2] + unlocked[3] + unlocked[4];
|
||||
data->unlocked_trophies = progress.earned;
|
||||
data->unlocked_platinum = unlocked[1];
|
||||
data->unlocked_gold = unlocked[2];
|
||||
data->unlocked_silver = unlocked[3];
|
||||
data->unlocked_bronze = unlocked[4];
|
||||
const auto points = total[2] * 6 + total[3] * 2 + total[4];
|
||||
const auto earned = unlocked[2] * 6 + unlocked[3] * 2 + unlocked[4];
|
||||
data->progress_percentage = points == 0 ? 0 : earned * 100 / points;
|
||||
data->progress_percentage = progress.Percentage();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -231,31 +239,45 @@ static void FillGroupInfo(const TrophyState& state, int group_id, const std::str
|
|||
}
|
||||
}
|
||||
|
||||
static void RecordTrophyUnlock(TrophyState& state, int trophy_id) {
|
||||
static void RecordTrophyUnlock(TrophyState& state, int trophy_id, bool from_stat = false) {
|
||||
const auto found = state.package->trophies.find(trophy_id);
|
||||
if (found == state.package->trophies.end() || found->second.grade == 1 ||
|
||||
found->second.target || !state.unlocked.insert(trophy_id).second) {
|
||||
if (found == state.package->trophies.end()) {
|
||||
LOGF("[Trophy] ignored unknown trophy ID %d\n", trophy_id);
|
||||
return;
|
||||
}
|
||||
if (found->second.grade == 1 || (!from_stat && found->second.progressive) ||
|
||||
!state.unlocks.unlocked.insert(trophy_id).second) {
|
||||
return;
|
||||
}
|
||||
const auto timestamp =
|
||||
Trophies::UnixEpochTick + std::chrono::duration_cast<std::chrono::microseconds>(
|
||||
std::chrono::system_clock::now().time_since_epoch())
|
||||
.count();
|
||||
state.unlocks.timestamps.emplace(trophy_id, timestamp);
|
||||
std::vector<int> earned {trophy_id};
|
||||
const auto platinum_id = found->second.platinum_id;
|
||||
if (platinum_id >= 0 && state.package->trophies.contains(platinum_id) &&
|
||||
std::all_of(state.package->trophies.begin(), state.package->trophies.end(),
|
||||
[&](const auto& entry) {
|
||||
return entry.second.platinum_id != platinum_id ||
|
||||
state.unlocked.contains(entry.first);
|
||||
state.unlocks.unlocked.contains(entry.first);
|
||||
}) &&
|
||||
state.unlocked.insert(platinum_id).second) {
|
||||
state.unlocks.unlocked.insert(platinum_id).second) {
|
||||
state.unlocks.timestamps.emplace(platinum_id, timestamp);
|
||||
earned.push_back(platinum_id);
|
||||
}
|
||||
if (!Trophies::SaveUnlocks(state.path, state.unlocked)) {
|
||||
if (!Trophies::SaveUnlockData(state.path, state.unlocks)) {
|
||||
LOGF("[Trophy] could not save unlocks to %s\n", state.path.string().c_str());
|
||||
} else {
|
||||
LOGF("[Trophy] recorded unlock %d: %s\n", trophy_id, found->second.name.c_str());
|
||||
}
|
||||
if (Config::TrophyEnabled()) {
|
||||
for (const auto id: earned) {
|
||||
const auto& trophy = state.package->trophies.at(id);
|
||||
Graphics::NotifyTrophyUnlocked(trophy.name, trophy.grade, trophy.icon_png);
|
||||
}
|
||||
} else {
|
||||
LOGF("[Trophy] notification disabled by configuration\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -541,11 +563,13 @@ struct NpUniversalDataSystemMemoryStat {
|
|||
};
|
||||
|
||||
struct NpUniversalDataSystemEventPropertyObject {
|
||||
std::optional<int32_t> trophy_id;
|
||||
std::map<std::string, Common::Trophies::UdsInteger> integers;
|
||||
|
||||
void SetTrophyId(const char* key, std::optional<int32_t> value) {
|
||||
if (std::strcmp(key, "_trophy_id") == 0) {
|
||||
trophy_id = value;
|
||||
void SetInteger(const char* key, std::optional<Common::Trophies::UdsInteger> value) {
|
||||
if (value) {
|
||||
integers.insert_or_assign(key, *value);
|
||||
} else {
|
||||
integers.erase(key);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
@ -647,6 +671,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemCreateEvent(
|
|||
}
|
||||
*new_event = new NpUniversalDataSystemEvent {
|
||||
event_name, prop != nullptr ? *prop : NpUniversalDataSystemEventPropertyObject {}};
|
||||
LOGF("[UDS] created event: %s\n", event_name);
|
||||
if (prop_ptr != nullptr) {
|
||||
*prop_ptr = &(*new_event)->properties;
|
||||
}
|
||||
|
|
@ -668,14 +693,26 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemPostEvent(int context, int handle,
|
|||
return static_cast<int>(0x80553120); // NOT_REGISTERED
|
||||
}
|
||||
const auto& uds_event = *static_cast<const NpUniversalDataSystemEvent*>(event);
|
||||
LOGF("[UDS] posted event: %s\n", uds_event.name.c_str());
|
||||
if (uds_event.name == "_UnlockTrophy") {
|
||||
const auto trophy_id = uds_event.properties.trophy_id;
|
||||
if (!trophy_id || *trophy_id < 0) {
|
||||
const auto property = uds_event.properties.integers.find("_trophy_id");
|
||||
const auto* trophy_id = property == uds_event.properties.integers.end()
|
||||
? nullptr
|
||||
: std::get_if<int32_t>(&property->second);
|
||||
if (trophy_id == nullptr || *trophy_id < 0) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
if (auto* state = LibNpTrophy2::LoadTrophyState(it->second.key); state != nullptr) {
|
||||
LibNpTrophy2::RecordTrophyUnlock(*state, *trophy_id);
|
||||
}
|
||||
} else if (!uds_event.properties.integers.empty()) {
|
||||
if (auto* state = LibNpTrophy2::LoadTrophyState(it->second.key); state != nullptr) {
|
||||
const auto ids = LibNpTrophy2::Trophies::FindUdsTrophies(
|
||||
*state->package, uds_event.name, uds_event.properties.integers);
|
||||
for (const auto trophy_id: ids) {
|
||||
LibNpTrophy2::RecordTrophyUnlock(*state, trophy_id, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -809,7 +846,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetString(
|
|||
if (object == nullptr || key == nullptr || value == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, std::nullopt);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -826,7 +863,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetInt32(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, value);
|
||||
object->SetInteger(key, value);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -838,7 +875,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetUInt32(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, value);
|
||||
|
||||
LOGF("\t object = 0x%016" PRIx64 "\n"
|
||||
"\t key = %s\n"
|
||||
|
|
@ -855,7 +892,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetInt64(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, std::nullopt);
|
||||
|
||||
LOGF("\t object = 0x%016" PRIx64 "\n"
|
||||
"\t key = %s\n"
|
||||
|
|
@ -872,7 +909,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetUInt64(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, value);
|
||||
|
||||
LOGF("\t object = 0x%016" PRIx64 "\n"
|
||||
"\t key = %s\n"
|
||||
|
|
@ -889,7 +926,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetFloat32(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, std::nullopt);
|
||||
|
||||
LOGF("\t object = 0x%016" PRIx64 "\n"
|
||||
"\t key = %s\n"
|
||||
|
|
@ -906,7 +943,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetFloat64(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, std::nullopt);
|
||||
|
||||
LOGF("\t object = 0x%016" PRIx64 "\n"
|
||||
"\t key = %s\n"
|
||||
|
|
@ -923,7 +960,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetBool(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, std::nullopt);
|
||||
|
||||
LOGF("\t object = 0x%016" PRIx64 "\n"
|
||||
"\t key = %s\n"
|
||||
|
|
@ -941,7 +978,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetBinary(
|
|||
if (object == nullptr || key == nullptr || (value == nullptr && value_size != 0)) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, std::nullopt);
|
||||
|
||||
LOGF("\t object = 0x%016" PRIx64 "\n"
|
||||
"\t key = %s\n"
|
||||
|
|
@ -962,7 +999,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetObject(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, std::nullopt);
|
||||
|
||||
if (value_ptr != nullptr) {
|
||||
*value_ptr =
|
||||
|
|
@ -996,7 +1033,7 @@ static int KYTY_SYSV_ABI NpUniversalDataSystemEventPropertyObjectSetArray(
|
|||
if (object == nullptr || key == nullptr) {
|
||||
return NP_UNIVERSAL_DATA_SYSTEM_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
object->SetTrophyId(key, std::nullopt);
|
||||
object->SetInteger(key, std::nullopt);
|
||||
|
||||
if (value_ptr != nullptr) {
|
||||
*value_ptr = (value != nullptr ? const_cast<NpUniversalDataSystemEventPropertyArray*>(value)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,261 @@
|
|||
#include "common/file.h"
|
||||
#include "common/trophies.h"
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <filesystem>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
namespace Trophies = Common::Trophies;
|
||||
|
||||
void Check(bool value, const char *text) {
|
||||
if (!value) {
|
||||
std::fprintf(stderr, "TrophySystemTests: failed: %s\n", text);
|
||||
std::abort();
|
||||
}
|
||||
}
|
||||
|
||||
class TempDirectory {
|
||||
public:
|
||||
TempDirectory() {
|
||||
const auto unique =
|
||||
std::chrono::steady_clock::now().time_since_epoch().count();
|
||||
m_path = std::filesystem::temp_directory_path() /
|
||||
("kyty_trophy_test_" + std::to_string(unique));
|
||||
Check(std::filesystem::create_directories(m_path),
|
||||
"create temporary directory");
|
||||
}
|
||||
~TempDirectory() {
|
||||
std::error_code error;
|
||||
std::filesystem::remove_all(m_path, error);
|
||||
}
|
||||
[[nodiscard]] const std::filesystem::path &Path() const { return m_path; }
|
||||
|
||||
private:
|
||||
std::filesystem::path m_path;
|
||||
};
|
||||
|
||||
void WriteBigEndian(std::vector<char> &bytes, size_t offset, uint64_t value,
|
||||
size_t length) {
|
||||
Check(offset <= bytes.size() && length <= bytes.size() - offset,
|
||||
"write within package");
|
||||
for (size_t i = 0; i < length; ++i) {
|
||||
bytes[offset + length - 1 - i] = static_cast<char>(value & 0xff);
|
||||
value >>= 8;
|
||||
}
|
||||
}
|
||||
|
||||
void WritePackage(const std::filesystem::path &path,
|
||||
const std::map<std::string, std::string> &files) {
|
||||
size_t offset = 0x40 + files.size() * 0x40;
|
||||
size_t size = offset;
|
||||
for (const auto &[name, contents] : files)
|
||||
size += contents.size();
|
||||
std::vector<char> bytes(size);
|
||||
WriteBigEndian(bytes, 0, 0xb228c60a, 4);
|
||||
WriteBigEndian(bytes, 4, 1, 4);
|
||||
WriteBigEndian(bytes, 8, bytes.size(), 8);
|
||||
WriteBigEndian(bytes, 0x10, files.size(), 4);
|
||||
WriteBigEndian(bytes, 0x14, 0x20, 4);
|
||||
size_t entry = 0x40;
|
||||
for (const auto &[name, contents] : files) {
|
||||
Check(name.size() < 0x20, "fixture file name fits");
|
||||
std::memcpy(bytes.data() + entry, name.data(), name.size());
|
||||
WriteBigEndian(bytes, entry + 0x20, offset, 8);
|
||||
WriteBigEndian(bytes, entry + 0x28, contents.size(), 8);
|
||||
std::memcpy(bytes.data() + offset, contents.data(), contents.size());
|
||||
offset += contents.size();
|
||||
entry += 0x40;
|
||||
}
|
||||
Common::File file;
|
||||
Check(file.Create(path), "create package fixture");
|
||||
uint32_t written = 0;
|
||||
file.Write(bytes.data(), static_cast<uint32_t>(bytes.size()), &written);
|
||||
Check(written == bytes.size(), "write package fixture");
|
||||
}
|
||||
|
||||
Trophies::Package MakePackage(const std::filesystem::path &directory) {
|
||||
const auto path = directory / "trophy00.ucp";
|
||||
WritePackage(
|
||||
path,
|
||||
{{"tropconf.json", R"({"defaultLanguage":"en-US","trophies":[
|
||||
{"id":"0","grade":"P"},
|
||||
{"id":"1","grade":"G","unlockCondition":{"udsStatId":"10","comparator":"ge","targetValue":"10","progressive":false}},
|
||||
{"id":"2","grade":"S","unlockCondition":{"udsStatId":"20","comparator":"gt","targetValue":"100","progressive":false}},
|
||||
{"id":"3","grade":"B","groupId":"1","unlockCondition":{"udsStatId":"30","comparator":"le","targetValue":"5","progressive":false}},
|
||||
{"id":"4","grade":"B","unlockCondition":{"udsStatId":"10","comparator":"lt","targetValue":"-1","progressive":false}}
|
||||
]})"},
|
||||
{"tropmeta_en-US.json",
|
||||
R"({"metadata":{"titleMetadata":{"name":"Test game"},"trophyMetadata":[
|
||||
{"id":"1","name":"Find All Coins","detail":"Find all coins in the level."}
|
||||
]}})"}});
|
||||
return Trophies::LoadPackage(path, 1);
|
||||
}
|
||||
|
||||
void TestEventExtraction(const std::filesystem::path &directory) {
|
||||
auto package = MakePackage(directory);
|
||||
Check(package.trophies.size() == 5,
|
||||
"unsupported signed target does not discard trophy metadata");
|
||||
Check(package.trophies.at(1).uds_stat_id == 10 &&
|
||||
package.trophies.at(1).target == 10 &&
|
||||
!package.trophies.at(1).progressive,
|
||||
"non-progressive trophy retains its stat target");
|
||||
Check(!package.trophies.at(4).target,
|
||||
"negative target is not converted to unsigned");
|
||||
Check(Trophies::FindUdsTrophies(package, "FIND_ALL_COINS",
|
||||
{{"counter", uint64_t{100}}})
|
||||
.empty(),
|
||||
"missing mapping never guesses from trophy text");
|
||||
const auto path = directory / "uds00.ucp";
|
||||
WritePackage(path, {{"stats_definition.json", R"({"statDefinitionArray":[
|
||||
{"statId":10,"dataType":"uint64","aggregation":"latest","minValue":"0"},
|
||||
{"statId":20,"dataType":"uint64","aggregation":"latest"},
|
||||
{"statId":30,"dataType":"uint32","aggregation":"latest"},
|
||||
{"statId":40,"dataType":"uint64","aggregation":"sum"},
|
||||
{"statId":50,"dataType":"uint64","aggregation":"count"},
|
||||
{"statId":60,"dataType":"uint64","aggregation":"max"},
|
||||
{"statId":70,"dataType":"uint64","aggregation":"latest","maxValue":"3"}
|
||||
]})"},
|
||||
{"stats_extraction.json", R"({"statsExtractionRuleArray":[
|
||||
{"condition":{"eventName":"COLLECT"},"action":{"input":"$.counter","output":{"statId":10}}},
|
||||
{"condition":{"eventName":"COLLECT"},"action":{"input":"$.counterBase","output":{"statId":20}}},
|
||||
{"condition":{"eventName":"TIME"},"action":{"input":"$.seconds","output":{"statId":30}}},
|
||||
{"condition":{"eventName":"FILTERED","property":{"path":"$.level","comparator":"==","value":1}},"action":{"input":"$.counter","output":{"statId":10}}},
|
||||
{"condition":{"eventName":"NESTED"},"action":{"input":"$.player.counter","output":{"statId":10}}},
|
||||
{"condition":{"eventName":"SUM"},"action":{"input":"$.counter","output":{"statId":40}}},
|
||||
{"condition":{"eventName":"COUNT"},"action":{"output":{"statId":50}}},
|
||||
{"condition":{"eventName":"MAX"},"action":{"input":"$.counter","output":{"statId":60}}},
|
||||
{"condition":{"eventName":"BOUNDED"},"action":{"input":"$.counter","output":{"statId":70}}},
|
||||
{"bad":1}
|
||||
]})"}});
|
||||
package.event_rules = Trophies::LoadUdsRules(path);
|
||||
Check(package.event_rules.size() == 2,
|
||||
"skip unsupported extraction and aggregation");
|
||||
Check(Trophies::FindUdsTrophies(
|
||||
package, "COLLECT",
|
||||
{{"counter", uint64_t{9}}, {"counterBase", uint64_t{100}}})
|
||||
.empty(),
|
||||
"do not add independent counters or treat gt as ge");
|
||||
Check(Trophies::FindUdsTrophies(
|
||||
package, "COLLECT",
|
||||
{{"counter", uint64_t{10}}, {"counterBase", uint64_t{100}}}) ==
|
||||
std::vector<int>{1},
|
||||
"each stat reads its configured property");
|
||||
Check(Trophies::FindUdsTrophies(
|
||||
package, "COLLECT",
|
||||
{{"counter", uint64_t{0}}, {"counterBase", uint64_t{101}}}) ==
|
||||
std::vector<int>{2},
|
||||
"strict comparison requires greater value");
|
||||
Check(Trophies::FindUdsTrophies(
|
||||
package, "COLLECT",
|
||||
{{"counter", uint64_t{10}}, {"counterBase", uint64_t{101}}}) ==
|
||||
std::vector<int>({1, 2}),
|
||||
"one event can unlock multiple mapped trophies");
|
||||
Check(Trophies::FindUdsTrophies(
|
||||
package, "TIME", {{"seconds", uint32_t{5}}}) == std::vector<int>{3},
|
||||
"less-equal condition accepts its boundary");
|
||||
Check(Trophies::FindUdsTrophies(package, "TIME", {{"seconds", uint32_t{6}}})
|
||||
.empty(),
|
||||
"less-equal condition rejects larger input");
|
||||
Check(Trophies::FindUdsTrophies(package, "TIME", {{"counter", uint64_t{0}}})
|
||||
.empty(),
|
||||
"missing property is not zero");
|
||||
package.trophies.at(3).comparison = Trophies::Comparison::Less;
|
||||
Check(Trophies::FindUdsTrophies(package, "TIME", {{"seconds", uint32_t{5}}})
|
||||
.empty(),
|
||||
"strict less rejects its boundary");
|
||||
Check(Trophies::FindUdsTrophies(
|
||||
package, "TIME", {{"seconds", uint32_t{4}}}) == std::vector<int>{3},
|
||||
"strict less accepts lower input");
|
||||
package.trophies.at(3).comparison = Trophies::Comparison::GreaterEqual;
|
||||
Check(Trophies::FindUdsTrophies(package, "TIME",
|
||||
{{"seconds", uint64_t{UINT32_MAX} + 1}})
|
||||
.empty(),
|
||||
"uint64 input cannot update a uint32 stat");
|
||||
Check(
|
||||
Trophies::FindUdsTrophies(package, "COLLECT", {{"counter", int32_t{100}}})
|
||||
.empty(),
|
||||
"signed inputs cannot update unsigned stats");
|
||||
Check(Trophies::FindUdsTrophies(package, "COLLECT",
|
||||
{{"counter", uint32_t{100}}})
|
||||
.empty(),
|
||||
"unsigned input width must match the stat");
|
||||
package.trophies.at(1).comparison = Trophies::Comparison::None;
|
||||
Check(Trophies::FindUdsTrophies(package, "COLLECT",
|
||||
{{"counter", uint64_t{100}}})
|
||||
.empty(),
|
||||
"unknown comparator cannot unlock");
|
||||
WritePackage(path, {{"stats_extraction.json", "{}"}});
|
||||
Check(Trophies::LoadUdsRules(path).empty(),
|
||||
"missing stat definitions cannot infer aggregation");
|
||||
Check(Trophies::LoadUdsRules(directory / "missing.ucp").empty(),
|
||||
"missing UDS package has no rules");
|
||||
}
|
||||
|
||||
void TestProgress(const std::filesystem::path &directory) {
|
||||
const auto package = MakePackage(directory);
|
||||
Trophies::UnlockData unlocks;
|
||||
unlocks.unlocked = {0, 1, 999};
|
||||
const auto progress = Trophies::GetProgress(package, unlocks);
|
||||
Check(progress.total == 5 && progress.earned == 2,
|
||||
"ignore unlock IDs absent from package");
|
||||
Check(progress.earned_grade[1] == 1 && progress.earned_grade[2] == 1 &&
|
||||
progress.Percentage() == 60,
|
||||
"percentage uses 6:2:1 grade points and excludes platinum");
|
||||
const auto group = Trophies::GetProgress(package, unlocks, 1);
|
||||
Check(group.total == 1 && group.earned == 0 && group.Percentage() == 0,
|
||||
"group counts filter trophies");
|
||||
Check(Trophies::GetProgress({}, {}).Percentage() == 0,
|
||||
"empty package progress is zero");
|
||||
}
|
||||
|
||||
void TestUnlockPersistence(const std::filesystem::path &directory) {
|
||||
const auto path = Trophies::UnlocksPath(directory, "PPSA00001", 1000, 0);
|
||||
Check(path == directory / "_Trophies/PPSA00001/trophies_1000_0.json",
|
||||
"store trophies outside save data");
|
||||
Check(Trophies::UnlocksPath(directory, "../bad", 1000, 0).empty(),
|
||||
"reject unsafe title IDs");
|
||||
Check(Trophies::LoadUnlockData(path).unlocked.empty(),
|
||||
"missing unlock file loads as empty");
|
||||
Trophies::UnlockData unlocks;
|
||||
unlocks.unlocked = {4, 42};
|
||||
const auto tick = Trophies::UnixEpochTick + 1791288000123456ULL;
|
||||
unlocks.timestamps.emplace(42, tick);
|
||||
Check(Trophies::SaveUnlockData(path, unlocks), "save timestamped unlocks");
|
||||
auto loaded = Trophies::LoadUnlockData(path);
|
||||
Check(loaded.unlocked == unlocks.unlocked &&
|
||||
loaded.timestamps == unlocks.timestamps,
|
||||
"persist full UTC microsecond timestamp");
|
||||
loaded.unlocked.insert(43);
|
||||
loaded.timestamps.emplace(43, tick + 1000000);
|
||||
Check(Trophies::SaveUnlockData(path, loaded), "replace existing unlock file");
|
||||
Check(Trophies::LoadUnlockData(path).timestamps.at(42) == tick,
|
||||
"retain original unlock time");
|
||||
|
||||
const auto blocked = directory / "blocked.json";
|
||||
std::filesystem::create_directory(blocked);
|
||||
Common::File sentinel;
|
||||
Check(sentinel.Create(blocked / "keep"),
|
||||
"create replacement failure fixture");
|
||||
sentinel.Close();
|
||||
Check(!Trophies::SaveUnlockData(blocked, loaded) &&
|
||||
std::filesystem::exists(blocked / "keep"),
|
||||
"failed replacement leaves destination intact");
|
||||
Check(!std::filesystem::exists(directory / "blocked.json.tmp"),
|
||||
"failed replacement removes temporary file");
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
TempDirectory directory;
|
||||
TestEventExtraction(directory.Path());
|
||||
TestProgress(directory.Path());
|
||||
TestUnlockPersistence(directory.Path());
|
||||
std::printf("TrophySystemTests: all cases passed\n");
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue