camerin
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add multi mod installs 

Signed-off-by: crueter <crueter@eden-emu.dev>
This commit is contained in:
crueter 2026-02-05 15:39:26 -05:00
parent c482a4c4d3
commit db14db2b73
No known key found for this signature in database
GPG Key ID: 425ACD2D4830EBC6
11 changed files with 322 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/frontend_common/mod_manager.cpp
View File

@ -13,11 +13,10 @@
namespace FrontendCommon {
// TODO: Handle cases where the folder appears to contain multiple mods.
std::optional<std::filesystem::path> GetModFolder(const std::string& root) {
std::filesystem::path path;
bool found;
std::vector<std::filesystem::path> GetModFolder(const std::string& root) {
std::vector<std::filesystem::path> paths;
auto callback = [&path, &found](const std::filesystem::directory_entry& entry) -> bool {
auto callback = [&paths](const std::filesystem::directory_entry& entry) -> bool {
const auto name = entry.path().filename().string();
static constexpr const std::array<std::string, 5> valid_names = {"exefs",
"romfs"
@ -25,8 +24,7 @@ std::optional<std::filesystem::path> GetModFolder(const std::string& root) {
"cheats", "romfslite"};
if (std::ranges::find(valid_names, name) != valid_names.end()) {
path = entry.path().parent_path();
found = true;
paths.emplace_back(entry.path().parent_path());
}
return true;
@ -34,10 +32,7 @@ std::optional<std::filesystem::path> GetModFolder(const std::string& root) {
Common::FS::IterateDirEntriesRecursively(root, callback, Common::FS::DirEntryFilter::Directory);
if (found)
return path;
return std::nullopt;
return paths;
}
ModInstallResult InstallMod(const std::filesystem::path& path, const u64 program_id, const bool copy) {

2
src/frontend_common/mod_manager.h
View File

@ -15,7 +15,7 @@ enum ModInstallResult {
Success,
};
std::optional<std::filesystem::path> GetModFolder(const std::string& root);
std::vector<std::filesystem::path> GetModFolder(const std::string& root);
ModInstallResult InstallMod(const std::filesystem::path &path, const u64 program_id, const bool copy = true);
}

184
src/qt_common/util/mod.cpp
View File

@ -3,107 +3,120 @@
#include <filesystem>
#include <JlCompress.h>
#include "frontend_common/mod_manager.h"
#include "mod.h"
#include "qt_common/abstract/frontend.h"
namespace QtCommon::Mod {
QString GetModFolder(const QString& root, const QString& fallbackName) {
QStringList GetModFolders(const QString& root, const QString& fallbackName) {
namespace fs = std::filesystem;
const auto std_root = root.toStdString();
auto std_path = FrontendCommon::GetModFolder(std_root);
QString default_name;
if (!fallbackName.isEmpty())
default_name = fallbackName;
else if (std_path)
default_name = QString::fromStdString(std_path->filename());
else
default_name = root.split(QLatin1Char('/')).last();
auto paths = FrontendCommon::GetModFolder(std_root);
QString name = QtCommon::Frontend::GetTextInput(
tr("Mod Name"), tr("What should this mod be called?"), default_name);
// if std_path is empty, frontend_common could not determine mod type and/or name.
// so we have to prompt the user and set up the structure ourselves
if (!std_path) {
// TODO: Carboxyl impl.
const QStringList choices = {
tr("RomFS"),
tr("ExeFS/Patch"),
tr("Cheat"),
};
int choice = QtCommon::Frontend::Choice(
tr("Mod Type"),
tr("Could not detect mod type automatically. Please manually "
"specify the type of mod you downloaded.\n\nMost mods are RomFS mods, but patches "
"(.pchtxt) are typically ExeFS mods."),
choices);
std::string to_make;
switch (choice) {
case 0:
to_make = "romfs";
break;
case 1:
to_make = "exefs";
break;
case 2:
to_make = "cheats";
break;
default:
return QString();
// multi mod zip
if (paths.size() > 1) {
// We just have to assume it's properly formed here.
// If not, you're out of luck.
QStringList qpaths;
for (const fs::path& path : paths) {
qpaths << QString::fromStdString(path.string());
}
// now make a temp directory...
const auto mod_dir = fs::temp_directory_path() / "eden" / "mod" / name.toStdString();
const auto tmp = mod_dir / to_make;
fs::remove_all(mod_dir);
if (!fs::create_directories(tmp)) {
LOG_ERROR(Frontend, "Failed to create temporary directory {}", tmp.string());
return QString();
}
std_path = mod_dir;
// ... and copy everything from the root to the temp dir
for (const auto& entry : fs::directory_iterator(root.toStdString())) {
const auto target = tmp / entry.path().filename();
fs::copy(entry.path(), target,
fs::copy_options::recursive | fs::copy_options::overwrite_existing);
}
} else {
// Rename the existing mod folder.
const auto new_path = std_path->parent_path() / name.toStdString();
fs::rename(std_path.value(), new_path);
std_path = new_path;
return qpaths;
}
// either frontend didn't detect any romfs/exefs, or is a single-mod zip
else {
fs::path std_path;
if (!paths.empty())
std_path = paths[0];
return QString::fromStdString(std_path->string());
QString default_name;
if (!fallbackName.isEmpty())
default_name = fallbackName;
else if (!paths.empty())
default_name = QString::fromStdString(std_path.filename());
else
default_name = root.split(QLatin1Char('/')).last();
QString name = QtCommon::Frontend::GetTextInput(
tr("Mod Name"), tr("What should this mod be called?"), default_name);
// if std_path is empty, frontend_common could not determine mod type and/or name.
// so we have to prompt the user and set up the structure ourselves
if (paths.empty()) {
// TODO: Carboxyl impl.
const QStringList choices = {
tr("RomFS"),
tr("ExeFS/Patch"),
tr("Cheat"),
};
int choice = QtCommon::Frontend::Choice(
tr("Mod Type"),
tr("Could not detect mod type automatically. Please manually "
"specify the type of mod you downloaded.\n\nMost mods are RomFS mods, but "
"patches "
"(.pchtxt) are typically ExeFS mods."),
choices);
std::string to_make;
switch (choice) {
case 0:
to_make = "romfs";
break;
case 1:
to_make = "exefs";
break;
case 2:
to_make = "cheats";
break;
default:
return {};
}
// now make a temp directory...
const auto mod_dir = fs::temp_directory_path() / "eden" / "mod" / name.toStdString();
const auto tmp = mod_dir / to_make;
fs::remove_all(mod_dir);
if (!fs::create_directories(tmp)) {
LOG_ERROR(Frontend, "Failed to create temporary directory {}", tmp.string());
return {};
}
std_path = mod_dir;
// ... and copy everything from the root to the temp dir
for (const auto& entry : fs::directory_iterator(root.toStdString())) {
const auto target = tmp / entry.path().filename();
fs::copy(entry.path(), target,
fs::copy_options::recursive | fs::copy_options::overwrite_existing);
}
} else {
// Rename the existing mod folder.
const auto new_path = std_path.parent_path() / name.toStdString();
fs::rename(std_path, new_path);
std_path = new_path;
}
return {QString::fromStdString(std_path.string())};
}
}
FrontendCommon::ModInstallResult InstallMod(const QString& path, const QString& fallbackName, const u64 program_id,
const bool copy) {
const auto target = GetModFolder(path, fallbackName);
if (target.isEmpty()) {
return FrontendCommon::Cancelled;
}
return FrontendCommon::InstallMod(target.toStdString(), program_id, copy);
}
FrontendCommon::ModInstallResult InstallModFromZip(const QString& path, const u64 program_id) {
// TODO(crueter): Make this a common extract_to_tmp func
const QString ExtractMod(const QString& path) {
namespace fs = std::filesystem;
fs::path tmp{fs::temp_directory_path() / "eden" / "unzip_mod"};
fs::remove_all(tmp);
if (!fs::create_directories(tmp)) {
LOG_ERROR(Frontend, "Failed to create temporary directory {}", tmp.string());
return FrontendCommon::Failed;
QtCommon::Frontend::Critical(tr("Mod Extract Failed"),
tr("Failed to create temporary directory %1")
.arg(QString::fromStdString(tmp.string())));
return QString();
}
QString qCacheDir = QString::fromStdString(tmp.string());
@ -113,13 +126,12 @@ FrontendCommon::ModInstallResult InstallModFromZip(const QString& path, const u6
// TODO(crueter): use QtCompress
QStringList result = JlCompress::extractDir(&zip, qCacheDir);
if (result.isEmpty()) {
LOG_ERROR(Frontend, "Zip file {} is empty", path.toStdString());
return FrontendCommon::Failed;
QtCommon::Frontend::Critical(tr("Mod Extract Failed"),
tr("Zip file %1 is empty").arg(path));
return QString();
}
const auto fallback = fs::path{path.toStdString()}.stem();
return InstallMod(qCacheDir, QString::fromStdString(fallback.string()), program_id, false);
return qCacheDir;
}
} // namespace QtCommon::Mod

7
src/qt_common/util/mod.h
View File

@ -9,11 +9,8 @@
namespace QtCommon::Mod {
QString GetModFolder(const QString &root, const QString &fallbackName);
QStringList GetModFolders(const QString &root, const QString &fallbackName);
FrontendCommon::ModInstallResult InstallMod(const QString& path, const QString& fallbackName,
const u64 program_id, const bool copy = true);
FrontendCommon::ModInstallResult InstallModFromZip(const QString &path, const u64 program_id);
const QString ExtractMod(const QString &path);
}

1
src/yuzu/CMakeLists.txt
View File

@ -238,6 +238,7 @@ add_executable(yuzu
configuration/system/new_user_dialog.h configuration/system/new_user_dialog.cpp configuration/system/new_user_dialog.ui
configuration/system/profile_avatar_dialog.h configuration/system/profile_avatar_dialog.cpp
configuration/addon/mod_select_dialog.h configuration/addon/mod_select_dialog.cpp configuration/addon/mod_select_dialog.ui
)
set_target_properties(yuzu PROPERTIES OUTPUT_NAME "eden")

46
src/yuzu/configuration/addon/mod_select_dialog.cpp Normal file
View File

@ -0,0 +1,46 @@
#include <filesystem>
#include <qnamespace.h>
#include "mod_select_dialog.h"
#include "ui_mod_select_dialog.h"
ModSelectDialog::ModSelectDialog(const QStringList& mods, QWidget* parent)
: QDialog(parent), ui(new Ui::ModSelectDialog) {
ui->setupUi(this);
item_model = new QStandardItemModel(ui->treeView);
ui->treeView->setModel(item_model);
// We must register all custom types with the Qt Automoc system so that we are able to use it
// with signals/slots. In this case, QList falls under the umbrella of custom types.
qRegisterMetaType<QList<QStandardItem*>>("QList<QStandardItem*>");
for (const auto& mod : mods) {
const auto basename = QString::fromStdString(std::filesystem::path(mod.toStdString()).filename());
auto* const first_item = new QStandardItem;
first_item->setText(basename);
first_item->setData(mod);
first_item->setCheckable(true);
first_item->setCheckState(Qt::Checked);
item_model->appendRow(first_item);
item_model->layoutChanged();
}
connect(this, &QDialog::accepted, this, [this]() {
QStringList selected_mods;
for (qsizetype i = 0; i < item_model->rowCount(); ++i) {
auto *const item = item_model->item(i);
if (item->checkState() == Qt::Checked)
selected_mods << item->data().toString();
}
emit modsSelected(selected_mods);
});
}
ModSelectDialog::~ModSelectDialog() {
delete ui;
}

23
src/yuzu/configuration/addon/mod_select_dialog.h Normal file
View File

@ -0,0 +1,23 @@
#pragma once
#include <QDialog>
#include <QStandardItemModel>
namespace Ui {
class ModSelectDialog;
}
class ModSelectDialog : public QDialog {
Q_OBJECT
public:
explicit ModSelectDialog(const QStringList &mods, QWidget* parent = nullptr);
~ModSelectDialog();
signals:
void modsSelected(const QStringList &mods);
private:
Ui::ModSelectDialog* ui;
QStandardItemModel* item_model;
};

99
src/yuzu/configuration/addon/mod_select_dialog.ui Normal file
View File

@ -0,0 +1,99 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>ModSelectDialog</class>
<widget class="QDialog" name="ModSelectDialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Dialog</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>The specified folder or archive contain the following mods. Select which ones to install.</string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QTreeView" name="treeView">
<property name="contextMenuPolicy">
<enum>Qt::ContextMenuPolicy::NoContextMenu</enum>
</property>
<property name="editTriggers">
<set>QAbstractItemView::EditTrigger::NoEditTriggers</set>
</property>
<property name="alternatingRowColors">
<bool>true</bool>
</property>
<property name="verticalScrollMode">
<enum>QAbstractItemView::ScrollMode::ScrollPerPixel</enum>
</property>
<property name="uniformRowHeights">
<bool>true</bool>
</property>
<property name="sortingEnabled">
<bool>true</bool>
</property>
<property name="headerHidden">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QDialogButtonBox" name="buttonBox">
<property name="orientation">
<enum>Qt::Orientation::Horizontal</enum>
</property>
<property name="standardButtons">
<set>QDialogButtonBox::StandardButton::Cancel|QDialogButtonBox::StandardButton::Ok</set>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections>
<connection>
<sender>buttonBox</sender>
<signal>accepted()</signal>
<receiver>ModSelectDialog</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>248</x>
<y>254</y>
</hint>
<hint type="destinationlabel">
<x>157</x>
<y>274</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonBox</sender>
<signal>rejected()</signal>
<receiver>ModSelectDialog</receiver>
<slot>reject()</slot>
<hints>
<hint type="sourcelabel">
<x>316</x>
<y>260</y>
</hint>
<hint type="destinationlabel">
<x>286</x>
<y>274</y>
</hint>
</hints>
</connection>
</connections>
</ui>

81
src/yuzu/configuration/configure_per_game_addons.cpp
View File

@ -18,6 +18,7 @@
#include "common/fs/fs.h"
#include "common/fs/path_util.h"
#include "configuration/addon/mod_select_dialog.h"
#include "core/core.h"
#include "core/file_sys/patch_manager.h"
#include "core/loader/loader.h"
@ -105,6 +106,44 @@ void ConfigurePerGameAddons::SetTitleId(u64 id) {
this->title_id = id;
}
void ConfigurePerGameAddons::InstallMods(const QStringList& mods) {
QStringList failed;
for (const auto& mod : mods) {
if (FrontendCommon::InstallMod(mod.toStdString(), title_id, true) ==
FrontendCommon::Failed) {
failed << QFileInfo(mod).baseName();
}
}
if (failed.empty()) {
QtCommon::Frontend::Information(tr("Mod Install Succeeded"),
tr("Successfully installed all mods."));
item_model->removeRows(0, item_model->rowCount());
list_items.clear();
LoadConfiguration();
UISettings::values.is_game_list_reload_pending.exchange(true);
} else {
QtCommon::Frontend::Critical(
tr("Mod Install Failed"),
tr("Failed to install the following mods:\n\t%1\nCheck the log for details.")
.arg(failed.join(QStringLiteral("\n\t"))));
}
}
void ConfigurePerGameAddons::InstallModPath(const QString& path) {
const auto mods = QtCommon::Mod::GetModFolders(path, {});
if (mods.size() > 1) {
ModSelectDialog* dialog = new ModSelectDialog(mods, this);
connect(dialog, &ModSelectDialog::modsSelected, this, &ConfigurePerGameAddons::InstallMods);
dialog->show();
} else {
InstallMods(mods);
}
}
void ConfigurePerGameAddons::InstallModFolder() {
const auto path = QtCommon::Frontend::GetExistingDirectory(
tr("Mod Folder"), QStandardPaths::writableLocation(QStandardPaths::DownloadLocation));
@ -112,25 +151,7 @@ void ConfigurePerGameAddons::InstallModFolder() {
return;
}
// TODO: Pending refresh game list
auto ret = QtCommon::Mod::InstallMod(path, {}, title_id);
switch (ret) {
case FrontendCommon::Success:
QtCommon::Frontend::Information(tr("Mod Installed"), tr("Mod was successfully installed."));
item_model->removeRows(0, item_model->rowCount());
list_items.clear();
emit RefreshGameList();
LoadConfiguration();
break;
case FrontendCommon::Failed:
QtCommon::Frontend::Critical(
tr("Mod Install Failed"),
tr("Mod install was unsuccessful. Check the log for details."));
break;
case FrontendCommon::Cancelled:
default:
break;
}
InstallModPath(path);
}
void ConfigurePerGameAddons::InstallModZip() {
@ -142,25 +163,9 @@ void ConfigurePerGameAddons::InstallModZip() {
return;
}
auto ret = QtCommon::Mod::InstallModFromZip(path, title_id);
switch (ret) {
case FrontendCommon::Success:
QtCommon::Frontend::Information(tr("Mod Installed"), tr("Mod was successfully installed."));
item_model->removeRows(0, item_model->rowCount());
list_items.clear();
emit RefreshGameList();
LoadConfiguration();
break;
case FrontendCommon::Failed:
QtCommon::Frontend::Critical(
tr("Mod Install Failed"),
tr("Mod install was unsuccessful. Check the log for details."));
break;
case FrontendCommon::Cancelled:
default:
break;
}
const QString extracted = QtCommon::Mod::ExtractMod(path);
if (!extracted.isEmpty())
InstallModPath(extracted);
}
void ConfigurePerGameAddons::changeEvent(QEvent* event) {

3
src/yuzu/configuration/configure_per_game_addons.h
View File

@ -43,6 +43,9 @@ public:
void SetTitleId(u64 id);
public slots:
void InstallMods(const QStringList &mods);
void InstallModPath(const QString& path);
void InstallModFolder();
void InstallModZip();

2
src/yuzu/main_window.cpp
View File

@ -3668,7 +3668,7 @@ void MainWindow::OpenPerGameConfiguration(u64 title_id, const std::string& file_
const auto reload = UISettings::values.is_game_list_reload_pending.exchange(false);
if (reload) {
game_list->PopulateAsync(UISettings::values.game_dirs);
OnGameListRefresh();
}
// Do not cause the global config to write local settings into the config file