ad3laid3/skate3recomp-multiplayer
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions
skate3recomp-multiplayer/src/skate3_title_update_installer.cpp
mchughalex 97df13cb01 add Skate 3 Title Update 3 support
2026-06-10 05:56:35 +01:00

879 lines
30 KiB
C++
Raw Blame History

#include "skate3_title_update_installer.h"
#include <algorithm>
#include <array>
#include <atomic>
#include <cctype>
#include <chrono>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <memory>
#include <string>
#include <string_view>
#include <thread>
#include <vector>
#include <rex/cvar.h>
#include <rex/logging.h>
#include <rex/ui/overlay/acquire_wizard_overlay.h>
#include <rex/ui/windowed_app_context.h>
#include "third_party/rexglue-sdk/thirdparty/crypto/sha256.h"
#if defined(_WIN32)
#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <commdlg.h>
#include <windows.h>
#include <winhttp.h>
#include <rex/ui/window_win.h>
#elif defined(__APPLE__)
#else
#include <gtk/gtk.h>
#endif
REXCVAR_DEFINE_STRING(skate3_title_update_url,
"https://xboxunity.net/Resources/Lib/TitleUpdate.php?tuid=21774",
"Skate 3",
"Download URL for the Skate 3 Title Update 3 package (TU3)");
namespace skate3 {
#if defined(__APPLE__)
std::filesystem::path PickTitleUpdateFileMacOS();
#endif
namespace {
// The recompilation is generated against exactly these payloads
// (Skate 3 title 454108E6, base 3.0.0.0 -> 3.0.3.0, media ID 5C087C2C).
struct TitleUpdatePayload {
std::string_view container_path; // path inside the TU STFS package
std::string_view staged_path; // path relative to the game root
uint64_t size;
std::string_view sha256; // lowercase hex
};
constexpr std::array<TitleUpdatePayload, 2> kPayloads = {{
{"default.xexp", "default.xexp", 1701888,
"eb9ef9109dfa6d940df2e156e7eaeda4603d2b2319ca6451f324b1c27f2b1f4c"},
{"data/webkit/EAWebkit.xexp", "data/webkit/EAWebkit.xexp", 4096,
"5d4a308d2a6c768fc27c8b62ccb6661171dc504f8c0011a3e116cf0074e09438"},
}};
// Size of the known TU3 STFS container; used as the progress estimate when the
// HTTP response carries no Content-Length, and as a sanity cap for downloads.
constexpr uint64_t kContainerSize = 1773568;
constexpr uint64_t kMaxPackageSize = 256ull * 1024 * 1024;
std::string ToLowerCopy(std::string value) {
std::transform(value.begin(), value.end(), value.begin(),
[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
return value;
}
std::string Sha256OfData(const uint8_t* data, size_t size) {
sha256::SHA256 hasher;
return hasher(data, size);
}
bool ReadWholeFile(const std::filesystem::path& path, std::vector<uint8_t>& out,
std::string& error) {
std::error_code ec;
const auto size = std::filesystem::file_size(path, ec);
if (ec) {
error = "Unable to read " + path.string() + ".";
return false;
}
if (size > kMaxPackageSize) {
error = "The selected file is too large to be a Skate 3 title update.";
return false;
}
std::ifstream file(path, std::ios::binary);
if (!file) {
error = "Unable to open " + path.string() + ".";
return false;
}
out.resize(static_cast<size_t>(size));
file.read(reinterpret_cast<char*>(out.data()), static_cast<std::streamsize>(out.size()));
if (!file) {
error = "Failed to read " + path.string() + ".";
return false;
}
return true;
}
const TitleUpdatePayload* MatchPayload(const std::vector<uint8_t>& data) {
for (const auto& payload : kPayloads) {
if (data.size() == payload.size && Sha256OfData(data.data(), data.size()) == payload.sha256) {
return &payload;
}
}
return nullptr;
}
bool StagePayload(const TitleUpdatePayload& payload, const std::vector<uint8_t>& data,
const std::filesystem::path& game_root, std::string& error) {
const auto target = game_root / std::filesystem::path(std::string(payload.staged_path));
std::error_code ec;
std::filesystem::create_directories(target.parent_path(), ec);
if (ec) {
error = "Unable to create " + target.parent_path().string() + ".";
return false;
}
std::ofstream out(target, std::ios::binary | std::ios::trunc);
if (!out) {
error = "Unable to create " + target.string() + ".";
return false;
}
out.write(reinterpret_cast<const char*>(data.data()), static_cast<std::streamsize>(data.size()));
if (!out) {
error = "Failed to write " + target.string() + ".";
return false;
}
REXLOG_INFO("Staged Skate 3 title update payload {}", target.string());
return true;
}
// ----------------------------------------------------------------------------
// Minimal read-only STFS (CON/LIVE/PIRS) package reader, enough to pull the
// xexp payloads out of a title update package.
// ----------------------------------------------------------------------------
uint16_t Be16(const uint8_t* p) {
return static_cast<uint16_t>((p[0] << 8) | p[1]);
}
uint32_t Be32(const uint8_t* p) {
return (static_cast<uint32_t>(p[0]) << 24) | (static_cast<uint32_t>(p[1]) << 16) |
(static_cast<uint32_t>(p[2]) << 8) | static_cast<uint32_t>(p[3]);
}
uint16_t Le16(const uint8_t* p) {
return static_cast<uint16_t>(p[0] | (p[1] << 8));
}
uint32_t U24Le(const uint8_t* p) {
return static_cast<uint32_t>(p[0]) | (static_cast<uint32_t>(p[1]) << 8) |
(static_cast<uint32_t>(p[2]) << 16);
}
class StfsPackageReader {
public:
static constexpr uint32_t kBlockSize = 0x1000;
static constexpr uint32_t kEndOfChain = 0xFFFFFF;
struct Entry {
std::string path;
bool is_dir = false;
uint32_t start_block = 0;
uint32_t length = 0;
};
static bool LooksLikeStfs(const std::vector<uint8_t>& data) {
if (data.size() < 4) {
return false;
}
const std::string_view magic(reinterpret_cast<const char*>(data.data()), 4);
return magic == "CON " || magic == "LIVE" || magic == "PIRS";
}
bool Open(std::vector<uint8_t> data, std::string& error) {
data_ = std::move(data);
if (data_.size() < 0x400 || !LooksLikeStfs(data_)) {
error = "The file is not an Xbox 360 content package.";
return false;
}
header_size_ = Be32(at(0x340, 4));
metadata_offset_ = 0x344;
volume_descriptor_offset_ = metadata_offset_ + 0x35;
const uint32_t volume_type = Be32(at(metadata_offset_ + 0x65, 4));
if (volume_type != 0) {
error = "The content package is not an STFS volume.";
return false;
}
const uint8_t flags = *at(volume_descriptor_offset_ + 2, 1);
blocks_per_hash_table_ = (flags & 1) ? 1 : 2;
return true;
}
bool ListEntries(std::vector<Entry>& entries, std::string& error) {
entries.clear();
const uint8_t* descriptor = at(volume_descriptor_offset_, 8);
if (!descriptor) {
error = "The content package header is truncated.";
return false;
}
uint16_t table_block_count = Le16(descriptor + 3);
uint32_t table_block = U24Le(descriptor + 5);
for (uint32_t table = 0; table < table_block_count; ++table) {
const uint64_t table_offset = BlockToOffset(table_block);
for (uint32_t index = 0; index < 0x40; ++index) {
const uint8_t* entry = at(table_offset + index * 0x40, 0x40);
if (!entry) {
error = "The content package file table is truncated.";
return false;
}
if (entry[0] == 0) {
break;
}
const uint8_t flags = entry[40];
const uint32_t name_length = flags & 0x3F;
if (name_length == 0 || name_length > 40) {
error = "The content package contains an invalid file name.";
return false;
}
Entry parsed;
std::string name(reinterpret_cast<const char*>(entry), name_length);
parsed.is_dir = (flags & 0x80) != 0;
parsed.start_block = U24Le(entry + 47);
const uint16_t parent_index = Be16(entry + 50);
parsed.length = Be32(entry + 52);
std::string parent_path;
if (parent_index != 0xFFFF) {
if (parent_index >= entries.size()) {
error = "The content package directory tree is invalid.";
return false;
}
parent_path = entries[parent_index].path;
}
parsed.path = parent_path.empty() ? name : parent_path + "/" + name;
entries.push_back(std::move(parsed));
}
const uint32_t next = NextBlock(table_block);
if (next == kEndOfChain) {
break;
}
table_block = next;
}
return true;
}
bool ReadFile(const Entry& entry, std::vector<uint8_t>& out, std::string& error) {
out.clear();
out.reserve(entry.length);
uint32_t block_index = entry.start_block;
uint64_t remaining = entry.length;
while (remaining > 0 && block_index != kEndOfChain) {
const uint64_t chunk = std::min<uint64_t>(kBlockSize, remaining);
const uint8_t* block = at(BlockToOffset(block_index), chunk);
if (!block) {
error = "The content package data is truncated.";
return false;
}
out.insert(out.end(), block, block + chunk);
remaining -= chunk;
block_index = NextBlock(block_index);
}
if (remaining > 0) {
error = "The content package block chain ended unexpectedly.";
return false;
}
return true;
}
private:
const uint8_t* at(uint64_t offset, uint64_t size) const {
if (offset + size > data_.size()) {
return nullptr;
}
return data_.data() + offset;
}
uint64_t RoundUp(uint64_t value, uint64_t alignment) const {
return (value + alignment - 1) & ~(alignment - 1);
}
uint64_t BlockToOffset(uint32_t block_index) const {
uint64_t block = block_index;
uint64_t base = 170;
for (int i = 0; i < 3; ++i) {
block += ((block_index + base) / base) * blocks_per_hash_table_;
if (block_index < base) {
break;
}
base *= 170;
}
return RoundUp(header_size_, kBlockSize) + (block << 12);
}
uint32_t HashBlockNumber(uint32_t block_index, int hash_level) const {
const uint32_t block_step0 = 170 + blocks_per_hash_table_;
const uint32_t block_step1 = 28900 + (170 + 1) * blocks_per_hash_table_;
if (hash_level == 0) {
if (block_index < 170) {
return 0;
}
uint32_t block = (block_index / 170) * block_step0;
block += ((block_index / 28900) + 1) * blocks_per_hash_table_;
if (block_index < 28900) {
return block;
}
return block + blocks_per_hash_table_;
}
if (hash_level == 1) {
if (block_index < 28900) {
return block_step0;
}
const uint32_t block = (block_index / 28900) * block_step1;
return block + blocks_per_hash_table_;
}
return block_step1;
}
uint64_t HashOffset(uint32_t block_index, int hash_level) const {
return RoundUp(header_size_, kBlockSize) +
(static_cast<uint64_t>(HashBlockNumber(block_index, hash_level)) << 12);
}
uint32_t NextBlock(uint32_t block_index) const {
const uint64_t hash_offset = HashOffset(block_index, 0);
const uint8_t* hash_entry = at(hash_offset + (block_index % 170) * 0x18, 0x18);
if (!hash_entry) {
return kEndOfChain;
}
return Be32(hash_entry + 0x14) & 0xFFFFFF;
}
std::vector<uint8_t> data_;
uint32_t header_size_ = 0;
uint32_t metadata_offset_ = 0;
uint32_t volume_descriptor_offset_ = 0;
uint32_t blocks_per_hash_table_ = 2;
};
// ----------------------------------------------------------------------------
// Download
// ----------------------------------------------------------------------------
#if defined(_WIN32)
std::wstring Widen(const std::string& value) {
if (value.empty()) {
return {};
}
const int length =
MultiByteToWideChar(CP_UTF8, 0, value.data(), static_cast<int>(value.size()), nullptr, 0);
std::wstring wide(static_cast<size_t>(length), L'\0');
MultiByteToWideChar(CP_UTF8, 0, value.data(), static_cast<int>(value.size()), wide.data(),
length);
return wide;
}
bool DownloadToFile(const std::string& url, const std::filesystem::path& destination,
std::atomic<uint64_t>& copied_bytes, std::atomic<uint64_t>& total_bytes,
std::string& error) {
std::wstring wide_url = Widen(url);
URL_COMPONENTS components{};
components.dwStructSize = sizeof(components);
components.dwSchemeLength = static_cast<DWORD>(-1);
components.dwHostNameLength = static_cast<DWORD>(-1);
components.dwUrlPathLength = static_cast<DWORD>(-1);
components.dwExtraInfoLength = static_cast<DWORD>(-1);
if (!WinHttpCrackUrl(wide_url.c_str(), 0, 0, &components)) {
error = "The configured title update URL is invalid.";
return false;
}
const std::wstring host(components.lpszHostName, components.dwHostNameLength);
std::wstring path(components.lpszUrlPath, components.dwUrlPathLength);
if (components.lpszExtraInfo && components.dwExtraInfoLength) {
path.append(components.lpszExtraInfo, components.dwExtraInfoLength);
}
const bool secure = components.nScheme == INTERNET_SCHEME_HTTPS;
HINTERNET session = WinHttpOpen(L"skate3-recomp/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
if (!session) {
error = "Unable to initialize the download (WinHttpOpen failed).";
return false;
}
// Many hosts (xboxunity.net included) publish both A and AAAA records. Unlike
// browsers, WinHTTP connects to addresses sequentially, so on a machine with
// broken IPv6 routing it stalls on the dead IPv6 connect for ~15s before
// falling back to IPv4. Enable "fast fallback" (Happy Eyeballs, RFC 6555) so
// WinHTTP races both families in parallel and uses whichever connects first.
#ifndef WINHTTP_OPTION_IPV6_FAST_FALLBACK
#define WINHTTP_OPTION_IPV6_FAST_FALLBACK 140
#endif
BOOL fast_fallback = TRUE;
WinHttpSetOption(session, WINHTTP_OPTION_IPV6_FAST_FALLBACK, &fast_fallback,
sizeof(fast_fallback));
// Backstop for OS versions without fast fallback: bound the connect attempt so
// a dead address family cannot hang the installer indefinitely.
WinHttpSetTimeouts(session, /*resolve=*/10000, /*connect=*/10000, /*send=*/30000,
/*receive=*/60000);
auto fail = [&](const char* what) {
error = std::string("Download failed (") + what + ", error " +
std::to_string(GetLastError()) + "). Check your internet connection.";
return false;
};
bool ok = false;
HINTERNET connection = nullptr;
HINTERNET request = nullptr;
std::ofstream out;
do {
connection = WinHttpConnect(session, host.c_str(), components.nPort, 0);
if (!connection) {
fail("connect");
break;
}
request = WinHttpOpenRequest(connection, L"GET", path.c_str(), nullptr, WINHTTP_NO_REFERER,
WINHTTP_DEFAULT_ACCEPT_TYPES, secure ? WINHTTP_FLAG_SECURE : 0);
if (!request) {
fail("open request");
break;
}
if (!WinHttpSendRequest(request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0,
0, 0) ||
!WinHttpReceiveResponse(request, nullptr)) {
fail("request");
break;
}
DWORD status_code = 0;
DWORD status_size = sizeof(status_code);
WinHttpQueryHeaders(request, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
WINHTTP_HEADER_NAME_BY_INDEX, &status_code, &status_size,
WINHTTP_NO_HEADER_INDEX);
if (status_code != 200) {
error = "The download server returned HTTP " + std::to_string(status_code) + ".";
break;
}
DWORD content_length = 0;
DWORD length_size = sizeof(content_length);
if (WinHttpQueryHeaders(request, WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER,
WINHTTP_HEADER_NAME_BY_INDEX, &content_length, &length_size,
WINHTTP_NO_HEADER_INDEX) &&
content_length > 0) {
total_bytes.store(content_length, std::memory_order_relaxed);
}
out.open(destination, std::ios::binary | std::ios::trunc);
if (!out) {
error = "Unable to create the download file at " + destination.string() + ".";
break;
}
std::vector<char> buffer(64 * 1024);
uint64_t received = 0;
bool read_failed = false;
for (;;) {
DWORD available = 0;
if (!WinHttpQueryDataAvailable(request, &available)) {
fail("read");
read_failed = true;
break;
}
if (available == 0) {
break;
}
while (available > 0) {
const DWORD chunk = std::min<DWORD>(available, static_cast<DWORD>(buffer.size()));
DWORD read = 0;
if (!WinHttpReadData(request, buffer.data(), chunk, &read) || read == 0) {
fail("read");
read_failed = true;
break;
}
out.write(buffer.data(), static_cast<std::streamsize>(read));
received += read;
available -= read;
copied_bytes.fetch_add(read, std::memory_order_relaxed);
if (received > kMaxPackageSize) {
error = "The download is unexpectedly large; aborting.";
read_failed = true;
break;
}
}
if (read_failed) {
break;
}
}
if (read_failed) {
break;
}
out.flush();
if (!out) {
error = "Failed to write the downloaded file.";
break;
}
ok = received > 0;
if (!ok) {
error = "The download was empty.";
}
} while (false);
if (request) {
WinHttpCloseHandle(request);
}
if (connection) {
WinHttpCloseHandle(connection);
}
WinHttpCloseHandle(session);
return ok;
}
#else
bool DownloadToFile(const std::string& url, const std::filesystem::path& destination,
std::atomic<uint64_t>& copied_bytes, std::atomic<uint64_t>& total_bytes,
std::string& error) {
if (url.find('\'') != std::string::npos || url.find('\\') != std::string::npos) {
error = "The configured title update URL is invalid.";
return false;
}
const std::string destination_str = destination.string();
if (destination_str.find('\'') != std::string::npos) {
error = "The temporary download path is not usable.";
return false;
}
const std::string command = "curl -fsSL --connect-timeout 30 --max-time 600 -o '" +
destination_str + "' '" + url + "'";
REXLOG_INFO("Downloading Skate 3 title update via curl");
const int status = std::system(command.c_str());
if (status != 0) {
error = "The download failed (curl exit status " + std::to_string(status) +
"). Check your internet connection, or select the title update file manually.";
return false;
}
std::error_code ec;
const auto size = std::filesystem::file_size(destination, ec);
if (ec || size == 0) {
error = "The download produced no data.";
return false;
}
total_bytes.store(size, std::memory_order_relaxed);
copied_bytes.store(size, std::memory_order_relaxed);
return true;
}
#endif // defined(_WIN32)
// ----------------------------------------------------------------------------
// File picker
// ----------------------------------------------------------------------------
#if defined(_WIN32)
std::filesystem::path PickTitleUpdateFile() {
wchar_t filename[MAX_PATH] = {};
OPENFILENAMEW ofn{};
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = GetActiveWindow();
ofn.lpstrFile = filename;
ofn.nMaxFile = static_cast<DWORD>(std::size(filename));
ofn.lpstrFilter = L"Title update package (*.*)\0*.*\0";
ofn.lpstrTitle = L"Select the Skate 3 Title Update 3 package";
ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_NOCHANGEDIR |
OFN_DONTADDTORECENT;
if (!GetOpenFileNameW(&ofn)) {
return {};
}
return filename;
}
#elif defined(__APPLE__)
std::filesystem::path PickTitleUpdateFile() {
return skate3::PickTitleUpdateFileMacOS();
}
#else
std::filesystem::path PickTitleUpdateFile() {
GtkWidget* dialog = gtk_file_chooser_dialog_new(
"Select the Skate 3 Title Update 3 package", nullptr, GTK_FILE_CHOOSER_ACTION_OPEN,
"_Cancel", GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, nullptr);
if (!dialog) {
return {};
}
GtkFileFilter* all_filter = gtk_file_filter_new();
gtk_file_filter_set_name(all_filter, "All files");
gtk_file_filter_add_pattern(all_filter, "*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), all_filter);
std::filesystem::path result;
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if (filename) {
result = filename;
g_free(filename);
}
}
gtk_widget_destroy(dialog);
while (gtk_events_pending()) {
gtk_main_iteration_do(FALSE);
}
return result;
}
#endif
bool DownloadAndStageTitleUpdate(const std::filesystem::path& game_root,
std::atomic<uint64_t>& copied_bytes,
std::atomic<uint64_t>& total_bytes, std::string& error) {
total_bytes.store(kContainerSize, std::memory_order_relaxed);
std::error_code ec;
auto temp_dir = std::filesystem::temp_directory_path(ec);
if (ec) {
temp_dir = game_root;
}
const auto temp_file = temp_dir / "skate3_title_update_download.tmp";
const std::string url = REXCVAR_GET(skate3_title_update_url);
REXLOG_INFO("Downloading Skate 3 title update from {}", url);
const bool downloaded = DownloadToFile(url, temp_file, copied_bytes, total_bytes, error);
bool staged = false;
if (downloaded) {
staged = StageTitleUpdateFromFile(temp_file, game_root, error);
}
std::filesystem::remove(temp_file, ec);
return downloaded && staged;
}
} // namespace
bool IsTitleUpdateInstalled(const std::filesystem::path& game_root) {
for (const auto& payload : kPayloads) {
const auto staged = game_root / std::filesystem::path(std::string(payload.staged_path));
std::error_code ec;
if (!std::filesystem::is_regular_file(staged, ec) ||
std::filesystem::file_size(staged, ec) != payload.size || ec) {
return false;
}
std::vector<uint8_t> data;
std::string error;
if (!ReadWholeFile(staged, data, error) ||
Sha256OfData(data.data(), data.size()) != payload.sha256) {
return false;
}
}
return true;
}
bool StageTitleUpdateFromFile(const std::filesystem::path& source,
const std::filesystem::path& game_root, std::string& error) {
std::vector<uint8_t> data;
if (!ReadWholeFile(source, data, error)) {
return false;
}
if (StfsPackageReader::LooksLikeStfs(data)) {
StfsPackageReader package;
if (!package.Open(std::move(data), error)) {
return false;
}
std::vector<StfsPackageReader::Entry> entries;
if (!package.ListEntries(entries, error)) {
return false;
}
size_t staged_count = 0;
for (const auto& payload : kPayloads) {
const auto wanted = ToLowerCopy(std::string(payload.container_path));
const auto it = std::find_if(entries.begin(), entries.end(), [&](const auto& entry) {
return !entry.is_dir && ToLowerCopy(entry.path) == wanted;
});
if (it == entries.end()) {
error = "The package does not contain " + std::string(payload.container_path) +
"; it is not the Skate 3 title update.";
return false;
}
std::vector<uint8_t> file_data;
if (!package.ReadFile(*it, file_data, error)) {
return false;
}
if (file_data.size() != payload.size ||
Sha256OfData(file_data.data(), file_data.size()) != payload.sha256) {
error = "The package contains a different version of " +
std::string(payload.container_path) +
"; this build requires Title Update 3 (3.0.3.0).";
return false;
}
if (!StagePayload(payload, file_data, game_root, error)) {
return false;
}
++staged_count;
}
return staged_count == kPayloads.size();
}
// Not an STFS container; accept a raw xexp payload that matches one of the
// expected files exactly.
if (const auto* payload = MatchPayload(data)) {
if (!StagePayload(*payload, data, game_root, error)) {
return false;
}
if (!IsTitleUpdateInstalled(game_root)) {
error = std::string(payload->staged_path) +
" was installed, but the other title update file is still missing. Provide the "
"full title update package.";
return false;
}
return true;
}
error =
"The selected file is neither the Skate 3 title update package nor one of its "
"xexp payloads.";
return false;
}
void ShowTitleUpdateInstallWizard(rex::ui::ImGuiDrawer* drawer, rex::PathConfig runtime_paths,
std::function<void(rex::PathConfig)> complete) {
const auto game_root = runtime_paths.game_data_root;
rex::ui::AcquireWizardDialog::Options options;
options.title = "Skate 3 Title Update";
options.intro =
"This build of Skate 3 requires Title Update 3, a free update originally published on "
"Xbox Live. It is not part of the game disc.";
options.target_directory = game_root.string();
options.initial_status =
"Download it automatically, or select a title update package you already have.";
options.fetch_button_label = "Download (1.7 MB)";
options.pick_button_label = "Select file...";
options.fetch_connecting_status =
"Connecting to the download server... (this can take a moment)";
options.fetch_working_status = "Downloading Title Update 3...";
options.install_working_status = "Installing the title update...";
options.done_status = "Title Update 3 installed.";
options.done_button_label = "Start Game";
auto fetch = [game_root](std::atomic<uint64_t>& copied_bytes, std::atomic<uint64_t>& total_bytes,
std::string& error) {
if (!DownloadAndStageTitleUpdate(game_root, copied_bytes, total_bytes, error)) {
return false;
}
if (!IsTitleUpdateInstalled(game_root)) {
error = "The title update could not be verified after installation.";
return false;
}
return true;
};
auto install = [game_root](const std::filesystem::path& source,
std::atomic<uint64_t>& copied_bytes,
std::atomic<uint64_t>& total_bytes, std::string& error) {
(void)copied_bytes;
(void)total_bytes;
if (!StageTitleUpdateFromFile(source, game_root, error)) {
return false;
}
if (!IsTitleUpdateInstalled(game_root)) {
error = "The title update could not be verified after installation.";
return false;
}
return true;
};
new rex::ui::AcquireWizardDialog(
drawer, std::move(options), std::move(fetch), []() { return PickTitleUpdateFile(); },
std::move(install),
[runtime_paths = std::move(runtime_paths), complete = std::move(complete)]() mutable {
if (complete) {
complete(std::move(runtime_paths));
}
});
}
bool RunTitleUpdateInstallWizardBlocking(rex::ui::WindowedAppContext& app_context,
rex::ui::Window* window,
rex::ui::ImGuiDrawer* drawer,
rex::PathConfig runtime_paths,
rex::PathConfig& installed_paths) {
if (const char* automated_tu = std::getenv("SKATE3_INSTALL_TU");
automated_tu != nullptr && *automated_tu != '\0') {
std::string error;
bool ok = false;
REXLOG_INFO("Installing Skate 3 title update from SKATE3_INSTALL_TU={}", automated_tu);
if (std::string_view(automated_tu) == "download") {
std::atomic<uint64_t> copied_bytes{0};
std::atomic<uint64_t> total_bytes{0};
ok = DownloadAndStageTitleUpdate(runtime_paths.game_data_root, copied_bytes, total_bytes,
error);
} else {
ok = StageTitleUpdateFromFile(automated_tu, runtime_paths.game_data_root, error);
}
if (!ok || !IsTitleUpdateInstalled(runtime_paths.game_data_root)) {
REXLOG_ERROR("Automated title update installation failed: {}", error);
return false;
}
installed_paths = std::move(runtime_paths);
REXLOG_INFO("Automated title update installation completed successfully");
return true;
}
struct InstallResult {
bool done = false;
bool ok = false;
rex::PathConfig paths;
};
auto result = std::make_shared<InstallResult>();
ShowTitleUpdateInstallWizard(drawer, runtime_paths,
[result](rex::PathConfig runtime_paths) mutable {
result->paths = std::move(runtime_paths);
result->ok = true;
result->done = true;
});
#if defined(_WIN32)
HWND hwnd = nullptr;
if (auto* win32_window = dynamic_cast<rex::ui::Win32Window*>(window)) {
hwnd = win32_window->hwnd();
}
#endif
REXLOG_INFO("Entering Skate 3 title update installer pump");
while (!result->done && !app_context.HasQuitFromUIThread()) {
app_context.ExecutePendingFunctionsFromUIThread();
#if defined(_WIN32)
MSG message;
while (PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE)) {
if (message.message == WM_QUIT) {
app_context.QuitFromUIThread();
break;
}
TranslateMessage(&message);
DispatchMessageW(&message);
}
if (app_context.HasQuitFromUIThread()) {
break;
}
if (window) {
window->RequestPaint();
}
if (hwnd) {
RedrawWindow(hwnd, nullptr, nullptr, RDW_INVALIDATE | RDW_UPDATENOW | RDW_NOERASE);
}
#else
if (window) {
window->RequestPaint();
}
#if !defined(__APPLE__)
while (gtk_events_pending()) {
gtk_main_iteration_do(FALSE);
}
#endif
#endif
std::this_thread::sleep_for(std::chrono::milliseconds(16));
}
if (!result->ok) {
REXLOG_INFO("Leaving title update installer pump without installation");
return false;
}
installed_paths = std::move(result->paths);
REXLOG_INFO("Leaving title update installer pump after successful installation");
return true;
}
} // namespace skate3
Reference in a new issue View git blame Copy permalink