Skip to content

Commit

Permalink
[Kernel] Support for loading achievement data
Browse files Browse the repository at this point in the history
  • Loading branch information
@Gliniak @gibbed
Gliniak authored and gibbed committed Dec 28, 2022
1 parent da9c908 commit 859bb89
Show file tree
Hide file tree
Showing 6 changed files with 175 additions and 84 deletions.
41 changes: 24 additions & 17 deletions src/xenia/emulator.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,6 +55,8 @@
#include "xenia/cpu/backend/x64/x64_backend.h"
#endif // XE_ARCH

DECLARE_int32(user_language);

DEFINE_double(time_scalar, 1.0,
"Scalar used to speed or slow time (1x, 2x, 1/2x, etc).",
"General");
Expand Down Expand Up @@ -795,23 +797,28 @@ X_STATUS Emulator::CompleteLaunch(const std::filesystem::path& path,
}
game_config_load_callback_loop_next_index_ = SIZE_MAX;

uint32_t resource_data = 0;
uint32_t resource_size = 0;
if (XSUCCEEDED(module->GetSection(title_id.c_str(), &resource_data,
&resource_size))) {
kernel::util::XdbfGameData db(
module->memory()->TranslateVirtual(resource_data), resource_size);
if (db.is_valid()) {
// TODO(gibbed): get title respective to user locale.
title_name_ = db.title(XLanguage::kEnglish);
if (title_name_.empty()) {
// If English title is unavailable, get the title in default locale.
title_name_ = db.title();
}
auto icon_block = db.icon();
if (icon_block) {
display_window_->SetIcon(icon_block.buffer, icon_block.size);
}
const kernel::util::XdbfGameData db = kernel_state_->module_xdbf(module);
if (db.is_valid()) {
XLanguage language =
db.GetExistingLanguage(static_cast<XLanguage>(cvars::user_language));
title_name_ = db.title(language);

XELOGI("-------------------- ACHIEVEMENTS --------------------");
const std::vector<kernel::util::XdbfAchievementTableEntry>
achievement_list = db.GetAchievements();
for (const kernel::util::XdbfAchievementTableEntry& entry :
achievement_list) {
std::string label = db.GetStringTableEntry(language, entry.label_id);
std::string desc =
db.GetStringTableEntry(language, entry.description_id);

XELOGI("{} - {} - {} - {}", entry.id, label, desc, entry.gamerscore);
}
XELOGI("----------------- END OF ACHIEVEMENTS ----------------");

auto icon_block = db.icon();
if (icon_block) {
display_window_->SetIcon(icon_block.buffer, icon_block.size);
}
}
}
Expand Down
20 changes: 20 additions & 0 deletions src/xenia/kernel/kernel_state.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -104,6 +104,26 @@ uint32_t KernelState::title_id() const {
return 0;
}

util::XdbfGameData KernelState::title_xdbf() const {
return module_xdbf(executable_module_);
}

util::XdbfGameData KernelState::module_xdbf(
object_ref<UserModule> exec_module) const {
assert_not_null(exec_module);

uint32_t resource_data = 0;
uint32_t resource_size = 0;
if (XSUCCEEDED(exec_module->GetSection(
fmt::format("{:08X}", exec_module->title_id()).c_str(),
&resource_data, &resource_size))) {
util::XdbfGameData db(memory()->TranslateVirtual(resource_data),
resource_size);
return db;
}
return util::XdbfGameData(nullptr, resource_size);
}

uint32_t KernelState::process_type() const {
auto pib =
memory_->TranslateVirtual<ProcessInfoBlock*>(process_info_block_address_);
Expand Down
3 changes: 3 additions & 0 deletions src/xenia/kernel/kernel_state.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,7 @@
#include "xenia/cpu/export_resolver.h"
#include "xenia/kernel/util/native_list.h"
#include "xenia/kernel/util/object_table.h"
#include "xenia/kernel/util/xdbf_utils.h"
#include "xenia/kernel/xam/app_manager.h"
#include "xenia/kernel/xam/content_manager.h"
#include "xenia/kernel/xam/user_profile.h"
Expand Down Expand Up @@ -99,6 +100,8 @@ class KernelState {
vfs::VirtualFileSystem* file_system() const { return file_system_; }

uint32_t title_id() const;
util::XdbfGameData title_xdbf() const;
util::XdbfGameData module_xdbf(object_ref<UserModule> exec_module) const;

xam::AppManager* app_manager() const { return app_manager_.get(); }
xam::ContentManager* content_manager() const {
Expand Down
42 changes: 37 additions & 5 deletions src/xenia/kernel/util/xdbf_utils.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,11 @@ namespace util {
constexpr fourcc_t kXdbfSignatureXdbf = make_fourcc("XDBF");
constexpr fourcc_t kXdbfSignatureXstc = make_fourcc("XSTC");
constexpr fourcc_t kXdbfSignatureXstr = make_fourcc("XSTR");
constexpr fourcc_t kXdbfSignatureXach = make_fourcc("XACH");

constexpr uint64_t kXdbfIdTitle = 0x8000;
constexpr uint64_t kXdbfIdXstc = 0x58535443;
constexpr uint64_t kXdbfIdXach = 0x58414348;

XdbfWrapper::XdbfWrapper(const uint8_t* data, size_t data_size)
: data_(data), data_size_(data_size) {
Expand Down Expand Up @@ -64,12 +69,12 @@ std::string XdbfWrapper::GetStringTableEntry(XLanguage language,
}

auto xstr_head =
reinterpret_cast<const XdbfXstrHeader*>(language_block.buffer);
reinterpret_cast<const XdbfSectionHeader*>(language_block.buffer);
assert_true(xstr_head->magic == kXdbfSignatureXstr);
assert_true(xstr_head->version == 1);

const uint8_t* ptr = language_block.buffer + sizeof(XdbfXstrHeader);
for (uint16_t i = 0; i < xstr_head->string_count; ++i) {
const uint8_t* ptr = language_block.buffer + sizeof(XdbfSectionHeader);
for (uint16_t i = 0; i < xstr_head->count; ++i) {
auto entry = reinterpret_cast<const XdbfStringTableEntry*>(ptr);
ptr += sizeof(XdbfStringTableEntry);
if (entry->id == string_id) {
Expand All @@ -81,8 +86,35 @@ std::string XdbfWrapper::GetStringTableEntry(XLanguage language,
return "";
}

constexpr uint64_t kXdbfIdTitle = 0x8000;
constexpr uint64_t kXdbfIdXstc = 0x58535443;
std::vector<XdbfAchievementTableEntry> XdbfWrapper::GetAchievements() const {
std::vector<XdbfAchievementTableEntry> achievements;

auto achievement_table = GetEntry(XdbfSection::kMetadata, kXdbfIdXach);
if (!achievement_table) {
return achievements;
}

auto xach_head =
reinterpret_cast<const XdbfSectionHeader*>(achievement_table.buffer);
assert_true(xach_head->magic == kXdbfSignatureXach);
assert_true(xach_head->version == 1);

const uint8_t* ptr = achievement_table.buffer + sizeof(XdbfSectionHeader);
for (uint16_t i = 0; i < xach_head->count; ++i) {
auto entry = reinterpret_cast<const XdbfAchievementTableEntry*>(ptr);
ptr += sizeof(XdbfAchievementTableEntry);
achievements.push_back(*entry);
}
return achievements;

}

XLanguage XdbfGameData::GetExistingLanguage(XLanguage language_to_check) const {
// A bit of a hack. Check if title in specific language exist.
// If it doesn't then for sure language is not supported.
return title(language_to_check).empty() ? default_language()
: language_to_check;
}

XdbfBlock XdbfGameData::icon() const {
return GetEntry(XdbfSection::kImage, kXdbfIdTitle);
Expand Down
117 changes: 68 additions & 49 deletions src/xenia/kernel/util/xdbf_utils.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,6 +29,70 @@ enum class XdbfSection : uint16_t {
kStringTable = 0x0003,
};

#pragma pack(push, 1)
struct XbdfHeader {
xe::be<uint32_t> magic;
xe::be<uint32_t> version;
xe::be<uint32_t> entry_count;
xe::be<uint32_t> entry_used;
xe::be<uint32_t> free_count;
xe::be<uint32_t> free_used;
};
static_assert_size(XbdfHeader, 24);

struct XbdfEntry {
xe::be<uint16_t> section;
xe::be<uint64_t> id;
xe::be<uint32_t> offset;
xe::be<uint32_t> size;
};
static_assert_size(XbdfEntry, 18);

struct XbdfFileLoc {
xe::be<uint32_t> offset;
xe::be<uint32_t> size;
};
static_assert_size(XbdfFileLoc, 8);

struct XdbfXstc {
xe::be<uint32_t> magic;
xe::be<uint32_t> version;
xe::be<uint32_t> size;
xe::be<uint32_t> default_language;
};
static_assert_size(XdbfXstc, 16);

struct XdbfSectionHeader {
xe::be<uint32_t> magic;
xe::be<uint32_t> version;
xe::be<uint32_t> size;
xe::be<uint16_t> count;
};
static_assert_size(XdbfSectionHeader, 14);

struct XdbfStringTableEntry {
xe::be<uint16_t> id;
xe::be<uint16_t> string_length;
};
static_assert_size(XdbfStringTableEntry, 4);

struct XdbfAchievementTableEntry {
xe::be<uint16_t> id;
xe::be<uint16_t> label_id;
xe::be<uint16_t> description_id;
xe::be<uint16_t> unachieved_id;
xe::be<uint32_t> image_id;
xe::be<uint16_t> gamerscore;
xe::be<uint16_t> unkE;
xe::be<uint32_t> flags;
xe::be<uint32_t> unk14;
xe::be<uint32_t> unk18;
xe::be<uint32_t> unk1C;
xe::be<uint32_t> unk20;
};
static_assert_size(XdbfAchievementTableEntry, 0x24);
#pragma pack(pop)

struct XdbfBlock {
const uint8_t* buffer;
size_t size;
Expand All @@ -52,55 +116,7 @@ class XdbfWrapper {
// Gets a string from the string table in the given language.
// Returns the empty string if the entry is not found.
std::string GetStringTableEntry(XLanguage language, uint16_t string_id) const;

protected:
#pragma pack(push, 1)
struct XbdfHeader {
xe::be<uint32_t> magic;
xe::be<uint32_t> version;
xe::be<uint32_t> entry_count;
xe::be<uint32_t> entry_used;
xe::be<uint32_t> free_count;
xe::be<uint32_t> free_used;
};
static_assert_size(XbdfHeader, 24);

struct XbdfEntry {
xe::be<uint16_t> section;
xe::be<uint64_t> id;
xe::be<uint32_t> offset;
xe::be<uint32_t> size;
};
static_assert_size(XbdfEntry, 18);

struct XbdfFileLoc {
xe::be<uint32_t> offset;
xe::be<uint32_t> size;
};
static_assert_size(XbdfFileLoc, 8);

struct XdbfXstc {
xe::be<uint32_t> magic;
xe::be<uint32_t> version;
xe::be<uint32_t> size;
xe::be<uint32_t> default_language;
};
static_assert_size(XdbfXstc, 16);

struct XdbfXstrHeader {
xe::be<uint32_t> magic;
xe::be<uint32_t> version;
xe::be<uint32_t> size;
xe::be<uint16_t> string_count;
};
static_assert_size(XdbfXstrHeader, 14);

struct XdbfStringTableEntry {
xe::be<uint16_t> id;
xe::be<uint16_t> string_length;
};
static_assert_size(XdbfStringTableEntry, 4);
#pragma pack(pop)
std::vector<XdbfAchievementTableEntry> GetAchievements() const;

private:
const uint8_t* data_ = nullptr;
Expand All @@ -117,6 +133,9 @@ class XdbfGameData : public XdbfWrapper {
XdbfGameData(const uint8_t* data, size_t data_size)
: XdbfWrapper(data, data_size) {}

// Checks if provided language exist, if not returns default title language.
XLanguage GetExistingLanguage(XLanguage language_to_check) const;

// The game icon image, if found.
XdbfBlock icon() const;

Expand Down
36 changes: 23 additions & 13 deletions src/xenia/kernel/xam/xam_user.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,8 @@
#include "xenia/kernel/xthread.h"
#include "xenia/xbox.h"

DECLARE_int32(user_language);

namespace xe {
namespace kernel {
namespace xam {
Expand Down Expand Up @@ -672,19 +674,27 @@ dword_result_t XamUserCreateAchievementEnumerator_entry(
return result;
}

uint32_t dummy_count = std::min(100u, uint32_t(count));
for (uint32_t i = 1; i <= dummy_count; ++i) {
auto item = XStaticAchievementEnumerator::AchievementDetails{
i, // dummy achievement id
fmt::format(u"Dummy {}", i),
u"Dummy description",
u"Dummy unachieved",
i, // dummy image id
0,
{0, 0},
8}; // flags=8 makes dummy achievements show up in 4D5307DC
// achievements list.
e->AppendItem(item);
const util::XdbfGameData db = kernel_state()->title_xdbf();

if (db.is_valid()) {
const XLanguage language =
db.GetExistingLanguage(static_cast<XLanguage>(cvars::user_language));
const std::vector<util::XdbfAchievementTableEntry> achievement_list =
db.GetAchievements();

for (const util::XdbfAchievementTableEntry& entry : achievement_list) {
auto item = XStaticAchievementEnumerator::AchievementDetails{
entry.id,
xe::to_utf16(db.GetStringTableEntry(language, entry.label_id)),
xe::to_utf16(db.GetStringTableEntry(language, entry.description_id)),
xe::to_utf16(db.GetStringTableEntry(language, entry.unachieved_id)),
entry.image_id,
entry.gamerscore,
{0, 0},
entry.flags};

e->AppendItem(item);
}
}

*handle_ptr = e->handle();
Expand Down

0 comments on commit 859bb89

Please sign in to comment.