eden-emu
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Releases Wiki Activity
Browse Source

Add multi mod installs 

Signed-off-by: crueter <crueter@eden-emu.dev>
pull/3472/head
crueter 2 days ago
parent
c482a4c4d3
commit
db14db2b73
No known key found for this signature in database GPG Key ID: 425ACD2D4830EBC6
11 changed files with 321 additions and 140 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 15
      src/frontend_common/mod_manager.cpp
  2. 2
      src/frontend_common/mod_manager.h
  3. 184
      src/qt_common/util/mod.cpp
  4. 7
      src/qt_common/util/mod.h
  5. 1
      src/yuzu/CMakeLists.txt
  6. 46
      src/yuzu/configuration/addon/mod_select_dialog.cpp
  7. 23
      src/yuzu/configuration/addon/mod_select_dialog.h
  8. 99
      src/yuzu/configuration/addon/mod_select_dialog.ui
  9. 79
      src/yuzu/configuration/configure_per_game_addons.cpp
  10. 3
      src/yuzu/configuration/configure_per_game_addons.h
  11. 2
      src/yuzu/main_window.cpp

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();
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();
}
// 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;
auto paths = FrontendCommon::GetModFolder(std_root);
// ... 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);
// 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());
}
} 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 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 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];
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 FrontendCommon::InstallMod(target.toStdString(), program_id, copy);
return {QString::fromStdString(std_path.string())};
}
}
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
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
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
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>

79
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,34 +106,54 @@ void ConfigurePerGameAddons::SetTitleId(u64 id) {
this->title_id = id;
}
void ConfigurePerGameAddons::InstallModFolder() {
const auto path = QtCommon::Frontend::GetExistingDirectory(
tr("Mod Folder"), QStandardPaths::writableLocation(QStandardPaths::DownloadLocation));
if (path.isEmpty()) {
return;
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();
}
}
// 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."));
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();
emit RefreshGameList();
LoadConfiguration();
break;
case FrontendCommon::Failed:
UISettings::values.is_game_list_reload_pending.exchange(true);
} else {
QtCommon::Frontend::Critical(
tr("Mod Install Failed"),
tr("Mod install was unsuccessful. Check the log for details."));
break;
case FrontendCommon::Cancelled:
default:
break;
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));
if (path.isEmpty()) {
return;
}
InstallModPath(path);
}
void ConfigurePerGameAddons::InstallModZip() {
const auto path = QtCommon::Frontend::GetOpenFileName(
tr("Zipped Mod Location"),
@ -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

Write Preview
Loading…
Cancel
Save