Added curseforge export

Signed-off-by: Trial97 <alexandru.tripon97@gmail.com>

launcher/CMakeLists.txt

@@ -517,6 +517,8 @@ set(FLAME_SOURCES
     modplatform/flame/FlameCheckUpdate.h
     modplatform/flame/FlameInstanceCreationTask.h
     modplatform/flame/FlameInstanceCreationTask.cpp
+    modplatform/flame/FlamePackExportTask.h
+    modplatform/flame/FlamePackExportTask.cpp
 )
 
 set(MODRINTH_SOURCES

launcher/modplatform/flame/FlamePackExportTask.cpp

@@ -0,0 +1,223 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "FlamePackExportTask.h"
+#include <QJsonArray>
+#include <QJsonObject>
+
+#include <QCryptographicHash>
+#include <QFileInfo>
+#include <QMessageBox>
+#include <QtConcurrentRun>
+#include "Json.h"
+#include "MMCZip.h"
+#include "minecraft/PackProfile.h"
+#include "minecraft/mod/ModFolderModel.h"
+#include "modplatform/helpers/ExportModsToStringTask.h"
+
+const QStringList FlamePackExportTask::PREFIXES({ "mods/", "coremods/", "resourcepacks/", "texturepacks/", "shaderpacks/" });
+const QStringList FlamePackExportTask::FILE_EXTENSIONS({ "jar", "litemod", "zip" });
+const QString FlamePackExportTask::TEMPLATE = "<li><a href={url}>{name}({authors})</a></li>";
+
+FlamePackExportTask::FlamePackExportTask(const QString& name,
+                                         const QString& version,
+                                         const QVariant& projectID,
+                                         InstancePtr instance,
+                                         const QString& output,
+                                         MMCZip::FilterFunction filter)
+    : name(name)
+    , version(version)
+    , projectID(projectID)
+    , instance(instance)
+    , mcInstance(dynamic_cast<MinecraftInstance*>(instance.get()))
+    , gameRoot(instance->gameRoot())
+    , output(output)
+    , filter(filter)
+{}
+
+void FlamePackExportTask::executeTask()
+{
+    setStatus(tr("Searching for files..."));
+    setProgress(0, 0);
+    collectFiles();
+}
+
+bool FlamePackExportTask::abort()
+{
+    if (task != nullptr) {
+        task->abort();
+        task = nullptr;
+        emitAborted();
+        return true;
+    }
+
+    if (buildZipFuture.isRunning()) {
+        buildZipFuture.cancel();
+        // NOTE: Here we don't do `emitAborted()` because it will be done when `buildZipFuture` actually cancels, which may not occur
+        // immediately.
+        return true;
+    }
+
+    return false;
+}
+
+void FlamePackExportTask::collectFiles()
+{
+    setAbortable(false);
+    QCoreApplication::processEvents();
+
+    files.clear();
+    if (!MMCZip::collectFileListRecursively(instance->gameRoot(), nullptr, &files, filter)) {
+        emitFailed(tr("Could not search for files"));
+        return;
+    }
+
+    resolvedFiles.clear();
+
+    mcInstance->loaderModList()->update();
+    connect(mcInstance->loaderModList().get(), &ModFolderModel::updateFinished, this, [this]() {
+        mods = mcInstance->loaderModList()->allMods();
+        buildZip();
+    });
+}
+
+void FlamePackExportTask::buildZip()
+{
+    setStatus(tr("Adding files..."));
+
+    buildZipFuture = QtConcurrent::run(QThreadPool::globalInstance(), [this]() {
+        QuaZip zip(output);
+        if (!zip.open(QuaZip::mdCreate)) {
+            QFile::remove(output);
+            return BuildZipResult(tr("Could not create file"));
+        }
+
+        if (buildZipFuture.isCanceled())
+            return BuildZipResult();
+
+        QuaZipFile indexFile(&zip);
+        if (!indexFile.open(QIODevice::WriteOnly, QuaZipNewInfo("manifest.json"))) {
+            QFile::remove(output);
+            return BuildZipResult(tr("Could not create index"));
+        }
+        indexFile.write(generateIndex());
+
+        QuaZipFile modlist(&zip);
+        if (!modlist.open(QIODevice::WriteOnly, QuaZipNewInfo("modlist.html"))) {
+            QFile::remove(output);
+            return BuildZipResult(tr("Could not create index"));
+        }
+        QString content = ExportToString::ExportModsToStringTask(mods, TEMPLATE);
+        content = "<ul>" + content + "</ul>";
+        modlist.write(content.toUtf8());
+
+        size_t progress = 0;
+        for (const QFileInfo& file : files) {
+            if (buildZipFuture.isCanceled()) {
+                QFile::remove(output);
+                return BuildZipResult();
+            }
+
+            setProgress(progress, files.length());
+            const QString relative = gameRoot.relativeFilePath(file.absoluteFilePath());
+            if (!resolvedFiles.contains(relative) && !JlCompress::compressFile(&zip, file.absoluteFilePath(), "overrides/" + relative)) {
+                QFile::remove(output);
+                return BuildZipResult(tr("Could not read and compress %1").arg(relative));
+            }
+            progress++;
+        }
+
+        zip.close();
+
+        if (zip.getZipError() != 0) {
+            QFile::remove(output);
+            return BuildZipResult(tr("A zip error occurred"));
+        }
+
+        return BuildZipResult();
+    });
+    connect(&buildZipWatcher, &QFutureWatcher<BuildZipResult>::finished, this, &FlamePackExportTask::finish);
+    buildZipWatcher.setFuture(buildZipFuture);
+}
+
+void FlamePackExportTask::finish()
+{
+    if (buildZipFuture.isCanceled())
+        emitAborted();
+    else {
+        const BuildZipResult result = buildZipFuture.result();
+        if (result.has_value())
+            emitFailed(result.value());
+        else
+            emitSucceeded();
+    }
+}
+
+QByteArray FlamePackExportTask::generateIndex()
+{
+    QJsonObject obj;
+    obj["manifestType"] = "minecraftModpack";
+    obj["manifestVersion"] = 1;
+    obj["name"] = name;
+    obj["version"] = version;
+    obj["author"] = author;
+    obj["projectID"] = projectID.toInt();
+    obj["overrides"] = "overrides";
+    if (mcInstance) {
+        QJsonObject version;
+        auto profile = mcInstance->getPackProfile();
+        // collect all supported components
+        const ComponentPtr minecraft = profile->getComponent("net.minecraft");
+        const ComponentPtr quilt = profile->getComponent("org.quiltmc.quilt-loader");
+        const ComponentPtr fabric = profile->getComponent("net.fabricmc.fabric-loader");
+        const ComponentPtr forge = profile->getComponent("net.minecraftforge");
+
+        // convert all available components to mrpack dependencies
+        if (minecraft != nullptr)
+            version["version"] = minecraft->m_version;
+
+        QJsonObject loader;
+        if (quilt != nullptr)
+            loader["id"] = quilt->getName();
+        else if (fabric != nullptr)
+            loader["id"] = fabric->getName();
+        else if (forge != nullptr)
+            loader["id"] = forge->getName();
+        loader["primary"] = true;
+
+        version["modLoaders"] = QJsonArray({ loader });
+        obj["minecraft"] = version;
+    }
+
+    QJsonArray files;
+    QMapIterator<QString, ResolvedFile> iterator(resolvedFiles);
+    while (iterator.hasNext()) {
+        iterator.next();
+
+        const ResolvedFile& value = iterator.value();
+
+        QJsonObject file;
+        file["projectID"] = value.projectID.toInt();
+        file["fileID"] = value.fileID.toInt();
+        file["required"] = value.required;
+        files << file;
+    }
+    obj["files"] = files;
+
+    return QJsonDocument(obj).toJson(QJsonDocument::Compact);
+}

launcher/modplatform/flame/FlamePackExportTask.h

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2023 Trial97 <alexandru.tripon97@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QFuture>
+#include <QFutureWatcher>
+#include "BaseInstance.h"
+#include "MMCZip.h"
+#include "minecraft/MinecraftInstance.h"
+#include "tasks/Task.h"
+
+class FlamePackExportTask : public Task {
+   public:
+    FlamePackExportTask(const QString& name,
+                        const QString& version,
+                        const QVariant& projectID,
+                        InstancePtr instance,
+                        const QString& output,
+                        MMCZip::FilterFunction filter);
+
+   protected:
+    void executeTask() override;
+    bool abort() override;
+
+   private:
+    struct ResolvedFile {
+        QVariant projectID, fileID;
+        bool required;
+    };
+
+    static const QStringList PREFIXES;
+    static const QStringList FILE_EXTENSIONS;
+    static const QString TEMPLATE;
+
+    // inputs
+    const QString name, version, author;
+    const QVariant projectID;
+    const InstancePtr instance;
+    MinecraftInstance* mcInstance;
+    const QDir gameRoot;
+    const QString output;
+    const MMCZip::FilterFunction filter;
+
+    typedef std::optional<QString> BuildZipResult;
+
+    QFileInfoList files;
+    QMap<QString, ResolvedFile> resolvedFiles;
+    Task::Ptr task;
+    QFuture<BuildZipResult> buildZipFuture;
+    QFutureWatcher<BuildZipResult> buildZipWatcher;
+    QList<Mod*> mods;
+
+    void collectFiles();
+    void buildZip();
+    void finish();
+
+    QByteArray generateIndex();
+};

launcher/ui/MainWindow.cpp

@@ -205,6 +205,7 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWi
         auto exportInstanceMenu = new QMenu(this);
         exportInstanceMenu->addAction(ui->actionExportInstanceZip);
         exportInstanceMenu->addAction(ui->actionExportInstanceMrPack);
+        exportInstanceMenu->addAction(ui->actionExportInstanceFlamePack);
         ui->actionExportInstance->setMenu(exportInstanceMenu);
     }
 
@@ -1416,6 +1417,14 @@ void MainWindow::on_actionExportInstanceMrPack_triggered()
     }
 }
 
+void MainWindow::on_actionExportInstanceFlamePack_triggered()
+{
+    if (m_selectedInstance) {
+        ExportMrPackDialog dlg(m_selectedInstance, this, ModPlatform::ResourceProvider::FLAME);
+        dlg.exec();
+    }
+}
+
 void MainWindow::on_actionRenameInstance_triggered()
 {
     if (m_selectedInstance)

launcher/ui/MainWindow.h

@@ -157,6 +157,7 @@ private slots:
     inline void on_actionExportInstance_triggered() { on_actionExportInstanceZip_triggered(); }
     void on_actionExportInstanceZip_triggered();
     void on_actionExportInstanceMrPack_triggered();
+    void on_actionExportInstanceFlamePack_triggered();
 
     void on_actionRenameInstance_triggered();
 

launcher/ui/MainWindow.ui

@@ -479,6 +479,14 @@
     <string>Modrinth (mrpack)</string>
    </property>
   </action>
+  <action name="actionExportInstanceFlamePack">
+   <property name="icon">
+    <iconset theme="flame"/>
+   </property>
+   <property name="text">
+    <string>Curseforge (zip)</string>
+   </property>
+  </action>
   <action name="actionCreateInstanceShortcut">
    <property name="icon">
     <iconset theme="shortcut">

launcher/ui/dialogs/ExportMrPackDialog.cpp

@@ -18,6 +18,8 @@
 
 #include "ExportMrPackDialog.h"
 #include "minecraft/mod/ModFolderModel.h"
+#include "modplatform/ModIndex.h"
+#include "modplatform/flame/FlamePackExportTask.h"
 #include "ui/dialogs/CustomMessageBox.h"
 #include "ui/dialogs/ProgressDialog.h"
 #include "ui_ExportMrPackDialog.h"
@@ -32,12 +34,15 @@
 #include "MMCZip.h"
 #include "modplatform/modrinth/ModrinthPackExportTask.h"
 
-ExportMrPackDialog::ExportMrPackDialog(InstancePtr instance, QWidget* parent)
+ExportMrPackDialog::ExportMrPackDialog(InstancePtr instance, QWidget* parent, ModPlatform::ResourceProvider provider)
-    : QDialog(parent), instance(instance), ui(new Ui::ExportMrPackDialog)
+    : QDialog(parent), instance(instance), ui(new Ui::ExportMrPackDialog), m_provider(provider)
 {
     ui->setupUi(this);
     ui->name->setText(instance->name());
-    ui->summary->setText(instance->notes().split(QRegularExpression("\\r?\\n"))[0]);
+    if (m_provider == ModPlatform::ResourceProvider::MODRINTH)
+        ui->summary->setText(instance->notes().split(QRegularExpression("\\r?\\n"))[0]);
+    else
+        ui->summaryLabel->setText("ProjectID");
 
     // ensure a valid pack is generated
     // the name and version fields mustn't be empty
@@ -97,20 +102,25 @@ void ExportMrPackDialog::done(int result)
 
         if (output.isEmpty())
             return;
+        Task* task;
+        if (m_provider == ModPlatform::ResourceProvider::MODRINTH)
+            task = new ModrinthPackExportTask(ui->name->text(), ui->version->text(), ui->summary->text(), instance, output,
+                                              [this](const QString& path) { return proxy->blockedPaths().covers(path); });
+        else
+            task = new FlamePackExportTask(ui->name->text(), ui->version->text(), ui->summary->text(), instance, output,
+                                           [this](const QString& path) { return proxy->blockedPaths().covers(path); });
 
-        ModrinthPackExportTask task(ui->name->text(), ui->version->text(), ui->summary->text(), instance, output,
+        connect(task, &Task::failed,
-                                    [this](const QString& path) { return proxy->blockedPaths().covers(path); });
-
-        connect(&task, &Task::failed,
                 [this](const QString reason) { CustomMessageBox::selectable(this, tr("Error"), reason, QMessageBox::Critical)->show(); });
-        connect(&task, &Task::aborted, [this] {
+        connect(task, &Task::aborted, [this] {
             CustomMessageBox::selectable(this, tr("Task aborted"), tr("The task has been aborted by the user."), QMessageBox::Information)
                 ->show();
         });
+        connect(task, &Task::finished, [task] { task->deleteLater(); });
 
         ProgressDialog progress(this);
         progress.setSkipButton(true, tr("Abort"));
-        if (progress.execWithTask(&task) != QDialog::Accepted)
+        if (progress.execWithTask(task) != QDialog::Accepted)
             return;
     }
 

launcher/ui/dialogs/ExportMrPackDialog.h

@@ -22,6 +22,7 @@
 #include "BaseInstance.h"
 #include "FastFileIconProvider.h"
 #include "FileIgnoreProxy.h"
+#include "modplatform/ModIndex.h"
 
 namespace Ui {
 class ExportMrPackDialog;
@@ -31,7 +32,9 @@ class ExportMrPackDialog : public QDialog {
     Q_OBJECT
 
    public:
-    explicit ExportMrPackDialog(InstancePtr instance, QWidget* parent = nullptr);
+    explicit ExportMrPackDialog(InstancePtr instance,
+                                QWidget* parent = nullptr,
+                                ModPlatform::ResourceProvider provider = ModPlatform::ResourceProvider::MODRINTH);
     ~ExportMrPackDialog();
 
     void done(int result) override;
@@ -42,4 +45,5 @@ class ExportMrPackDialog : public QDialog {
     Ui::ExportMrPackDialog* ui;
     FileIgnoreProxy* proxy;
     FastFileIconProvider icons;
+    const ModPlatform::ResourceProvider m_provider;
 };