Merge branch 'develop' of https://github.com/PrismLauncher/PrismLauncher into clean_net

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

flake.lock

@@ -75,11 +75,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1720031269,
+        "lastModified": 1720768451,
-        "narHash": "sha256-rwz8NJZV+387rnWpTYcXaRNvzUSnnF9aHONoJIYmiUQ=",
+        "narHash": "sha256-EYekUHJE2gxeo2pM/zM9Wlqw1Uw2XTJXOSAO79ksc4Y=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "9f4128e00b0ae8ec65918efeba59db998750ead6",
+        "rev": "7e7c39ea35c5cdd002cd4588b03a3fb9ece6fad9",
         "type": "github"
       },
       "original": {
@@ -103,11 +103,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1719259945,
+        "lastModified": 1720524665,
-        "narHash": "sha256-F1h+XIsGKT9TkGO3omxDLEb/9jOOsI6NnzsXFsZhry4=",
+        "narHash": "sha256-ni/87oHPZm6Gv0ECYxr1f6uxB0UKBWJ6HvS7lwLU6oY=",
         "owner": "cachix",
         "repo": "pre-commit-hooks.nix",
-        "rev": "0ff4381bbb8f7a52ca4a851660fc7a437a4c6e07",
+        "rev": "8d6a17d0cdf411c55f12602624df6368ad86fac1",
         "type": "github"
       },
       "original": {

launcher/Application.cpp

@@ -559,6 +559,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
 
         m_settings->registerSetting("NumberOfConcurrentTasks", 10);
         m_settings->registerSetting("NumberOfConcurrentDownloads", 6);
+        m_settings->registerSetting("NumberOfManualRetries", 1);
         m_settings->registerSetting("RequestTimeout", 60);
 
         QString defaultMonospace;
@@ -817,7 +818,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         m_icons.reset(new IconList(instFolders, setting->get().toString()));
         connect(setting.get(), &Setting::SettingChanged,
                 [&](const Setting&, QVariant value) { m_icons->directoryChanged(value.toString()); });
-        qDebug() << "<> Instance icons intialized.";
+        qDebug() << "<> Instance icons initialized.";
     }
 
     // Themes

launcher/java/JavaUtils.cpp

@@ -394,7 +394,7 @@ QList<QString> JavaUtils::FindJavaPaths()
     return javas;
 }
 
-#elif defined(Q_OS_LINUX)
+#elif defined(Q_OS_LINUX) || defined(Q_OS_OPENBSD) || defined(Q_OS_FREEBSD)
 QList<QString> JavaUtils::FindJavaPaths()
 {
     QList<QString> javas;
@@ -419,6 +419,7 @@ QList<QString> JavaUtils::FindJavaPaths()
             scanJavaDir(snap + dirPath);
         }
     };
+#if defined(Q_OS_LINUX)
     // oracle RPMs
     scanJavaDirs("/usr/java");
     // general locations used by distro packaging
@@ -437,7 +438,10 @@ QList<QString> JavaUtils::FindJavaPaths()
     scanJavaDirs("/opt/ibm");  // IBM Semeru Certified Edition
     // flatpak
     scanJavaDirs("/app/jdk");
-
+#elif defined(Q_OS_OPENBSD) || defined(Q_OS_FREEBSD)
+    // ports install to /usr/local on OpenBSD & FreeBSD
+    scanJavaDirs("/usr/local");
+#endif
     auto home = qEnvironmentVariable("HOME");
 
     // javas downloaded by IntelliJ

launcher/meta/BaseEntity.cpp

@@ -30,13 +30,21 @@ class ParsingValidator : public Net::Validator {
     virtual ~ParsingValidator() {};
 
    public: /* methods */
-    bool init(QNetworkRequest&) override { return true; }
+    bool init(QNetworkRequest&) override
+    {
+        m_data.clear();
+        return true;
+    }
     bool write(QByteArray& data) override
     {
         this->m_data.append(data);
         return true;
     }
-    bool abort() override { return true; }
+    bool abort() override
+    {
+        m_data.clear();
+        return true;
+    }
     bool validate(QNetworkReply&) override
     {
         auto fname = m_entity->localFilename();

launcher/minecraft/PackProfile.cpp

@@ -58,7 +58,6 @@
 #include "ComponentUpdateTask.h"
 #include "PackProfile.h"
 #include "PackProfile_p.h"
-#include "minecraft/mod/Mod.h"
 #include "modplatform/ModIndex.h"
 
 static const QMap<QString, ModPlatform::ModLoaderType> modloaderMapping{ { "net.neoforged", ModPlatform::NeoForge },
@@ -181,7 +180,7 @@ static bool loadPackProfile(PackProfile* parent,
     }
     if (!componentsFile.open(QFile::ReadOnly)) {
         qCritical() << "Couldn't open" << componentsFile.fileName() << " for reading:" << componentsFile.errorString();
-        qWarning() << "Ignoring overriden order";
+        qWarning() << "Ignoring overridden order";
         return false;
     }
 
@@ -190,7 +189,7 @@ static bool loadPackProfile(PackProfile* parent,
     QJsonDocument doc = QJsonDocument::fromJson(componentsFile.readAll(), &error);
     if (error.error != QJsonParseError::NoError) {
         qCritical() << "Couldn't parse" << componentsFile.fileName() << ":" << error.errorString();
-        qWarning() << "Ignoring overriden order";
+        qWarning() << "Ignoring overridden order";
         return false;
     }
 
@@ -1022,3 +1021,23 @@ std::optional<ModPlatform::ModLoaderTypes> PackProfile::getSupportedModLoaders()
         loaders |= ModPlatform::Forge;
     return loaders;
 }
+
+QList<ModPlatform::ModLoaderType> PackProfile::getModLoadersList()
+{
+    QList<ModPlatform::ModLoaderType> result;
+    for (auto c : d->components) {
+        if (c->isEnabled() && modloaderMapping.contains(c->getID())) {
+            result.append(modloaderMapping[c->getID()]);
+        }
+    }
+
+    // TODO: remove this or add version condition once Quilt drops official Fabric support
+    if (result.contains(ModPlatform::Quilt) && !result.contains(ModPlatform::Fabric)) {
+        result.append(ModPlatform::Fabric);
+    }
+    if (getComponentVersion("net.minecraft") == "1.20.1" && result.contains(ModPlatform::NeoForge) &&
+        !result.contains(ModPlatform::Forge)) {
+        result.append(ModPlatform::Forge);
+    }
+    return result;
+}

launcher/minecraft/PackProfile.h

@@ -146,6 +146,7 @@ class PackProfile : public QAbstractListModel {
     std::optional<ModPlatform::ModLoaderTypes> getModLoaders();
     // this returns aditional loaders(Quilt supports fabric and NeoForge supports Forge)
     std::optional<ModPlatform::ModLoaderTypes> getSupportedModLoaders();
+    QList<ModPlatform::ModLoaderType> getModLoadersList();
 
    private:
     void scheduleSave();

launcher/minecraft/ProfileUtils.cpp

@@ -57,7 +57,7 @@ bool readOverrideOrders(QString path, PatchOrder& order)
     }
     if (!orderFile.open(QFile::ReadOnly)) {
         qCritical() << "Couldn't open" << orderFile.fileName() << " for reading:" << orderFile.errorString();
-        qWarning() << "Ignoring overriden order";
+        qWarning() << "Ignoring overridden order";
         return false;
     }
 
@@ -66,7 +66,7 @@ bool readOverrideOrders(QString path, PatchOrder& order)
     QJsonDocument doc = QJsonDocument::fromJson(orderFile.readAll(), &error);
     if (error.error != QJsonParseError::NoError) {
         qCritical() << "Couldn't parse" << orderFile.fileName() << ":" << error.errorString();
-        qWarning() << "Ignoring overriden order";
+        qWarning() << "Ignoring overridden order";
         return false;
     }
 
@@ -84,7 +84,7 @@ bool readOverrideOrders(QString path, PatchOrder& order)
         }
     } catch ([[maybe_unused]] const JSONValidationError& err) {
         qCritical() << "Couldn't parse" << orderFile.fileName() << ": bad file format";
-        qWarning() << "Ignoring overriden order";
+        qWarning() << "Ignoring overridden order";
         order.clear();
         return false;
     }

launcher/minecraft/mod/tasks/GetModDependenciesTask.cpp

@@ -29,7 +29,6 @@
 #include "modplatform/ResourceAPI.h"
 #include "modplatform/flame/FlameAPI.h"
 #include "modplatform/modrinth/ModrinthAPI.h"
-#include "tasks/ConcurrentTask.h"
 #include "tasks/SequentialTask.h"
 #include "ui/pages/modplatform/ModModel.h"
 #include "ui/pages/modplatform/flame/FlameResourceModels.h"

launcher/modplatform/CheckUpdateTask.h

@@ -3,7 +3,6 @@
 #include "minecraft/mod/Mod.h"
 #include "minecraft/mod/tasks/GetModDependenciesTask.h"
 #include "modplatform/ModIndex.h"
-#include "modplatform/ResourceAPI.h"
 #include "tasks/Task.h"
 
 class ResourceDownloadTask;
@@ -15,9 +14,9 @@ class CheckUpdateTask : public Task {
    public:
     CheckUpdateTask(QList<Mod*>& mods,
                     std::list<Version>& mcVersions,
-                    std::optional<ModPlatform::ModLoaderTypes> loaders,
+                    QList<ModPlatform::ModLoaderType> loadersList,
                     std::shared_ptr<ModFolderModel> mods_folder)
-        : Task(nullptr), m_mods(mods), m_game_versions(mcVersions), m_loaders(loaders), m_mods_folder(mods_folder) {};
+        : Task(nullptr), m_mods(mods), m_game_versions(mcVersions), m_loaders_list(loadersList), m_mods_folder(mods_folder) {};
 
     struct UpdatableMod {
         QString name;
@@ -67,7 +66,7 @@ class CheckUpdateTask : public Task {
    protected:
     QList<Mod*>& m_mods;
     std::list<Version>& m_game_versions;
-    std::optional<ModPlatform::ModLoaderTypes> m_loaders;
+    QList<ModPlatform::ModLoaderType> m_loaders_list;
     std::shared_ptr<ModFolderModel> m_mods_folder;
 
     std::vector<UpdatableMod> m_updatable;

launcher/modplatform/ModIndex.h

@@ -25,7 +25,6 @@
 #include <QVariant>
 #include <QVector>
 #include <memory>
-#include <optional>
 
 class QIODevice;
 
@@ -44,7 +43,7 @@ namespace ProviderCapabilities {
 const char* name(ResourceProvider);
 QString readableName(ResourceProvider);
 QStringList hashType(ResourceProvider);
-};  // namespace ProviderCapabilities
+}  // namespace ProviderCapabilities
 
 struct ModpackAuthor {
     QString name;

launcher/modplatform/flame/FileResolvingTask.cpp

@@ -74,6 +74,7 @@ void Flame::FileResolvingTask::netJobFinished()
     setProgress(1, 3);
     // job to check modrinth for blocked projects
     m_checkJob.reset(new NetJob("Modrinth check", m_network));
+    m_checkJob->setAskRetry(false);
     blockedProjects = QMap<File*, std::shared_ptr<QByteArray>>();
 
     QJsonDocument doc;

launcher/modplatform/flame/FlameAPI.cpp

@@ -4,6 +4,7 @@
 
 #include "FlameAPI.h"
 #include <memory>
+#include <optional>
 #include "FlameModIndex.h"
 
 #include "Application.h"
@@ -12,7 +13,6 @@
 #include "net/ApiDownload.h"
 #include "net/ApiUpload.h"
 #include "net/NetJob.h"
-#include "net/Upload.h"
 
 Task::Ptr FlameAPI::matchFingerprints(const QList<uint>& fingerprints, std::shared_ptr<QByteArray> response)
 {
@@ -34,7 +34,7 @@ Task::Ptr FlameAPI::matchFingerprints(const QList<uint>& fingerprints, std::shar
     return netJob;
 }
 
-auto FlameAPI::getModFileChangelog(int modId, int fileId) -> QString
+QString FlameAPI::getModFileChangelog(int modId, int fileId)
 {
     QEventLoop lock;
     QString changelog;
@@ -69,7 +69,7 @@ auto FlameAPI::getModFileChangelog(int modId, int fileId) -> QString
     return changelog;
 }
 
-auto FlameAPI::getModDescription(int modId) -> QString
+QString FlameAPI::getModDescription(int modId)
 {
     QEventLoop lock;
     QString description;
@@ -102,7 +102,7 @@ auto FlameAPI::getModDescription(int modId) -> QString
     return description;
 }
 
-auto FlameAPI::getLatestVersion(VersionSearchArgs&& args) -> ModPlatform::IndexedVersion
+QList<ModPlatform::IndexedVersion> FlameAPI::getLatestVersions(VersionSearchArgs&& args)
 {
     auto versions_url_optional = getVersionsURL(args);
     if (!versions_url_optional.has_value())
@@ -114,7 +114,7 @@ auto FlameAPI::getLatestVersion(VersionSearchArgs&& args) -> ModPlatform::Indexe
 
     auto netJob = makeShared<NetJob>(QString("Flame::GetLatestVersion(%1)").arg(args.pack.name), APPLICATION->network());
     auto response = std::make_shared<QByteArray>();
-    ModPlatform::IndexedVersion ver;
+    QList<ModPlatform::IndexedVersion> ver;
 
     netJob->addNetAction(Net::ApiDownload::makeByteArray(versions_url, response));
 
@@ -134,9 +134,7 @@ auto FlameAPI::getLatestVersion(VersionSearchArgs&& args) -> ModPlatform::Indexe
 
             for (auto file : arr) {
                 auto file_obj = Json::requireObject(file);
-                auto file_tmp = FlameMod::loadIndexedPackVersion(file_obj);
+                ver.append(FlameMod::loadIndexedPackVersion(file_obj));
-                if (file_tmp.date > ver.date && (!args.loaders.has_value() || !file_tmp.loaders || args.loaders.value() & file_tmp.loaders))
-                    ver = file_tmp;
             }
 
         } catch (Json::JsonException& e) {
@@ -146,7 +144,7 @@ auto FlameAPI::getLatestVersion(VersionSearchArgs&& args) -> ModPlatform::Indexe
         }
     });
 
-    QObject::connect(netJob.get(), &NetJob::finished, [&loop] { loop.quit(); });
+    QObject::connect(netJob.get(), &NetJob::finished, &loop, &QEventLoop::quit);
 
     netJob->start();
 
@@ -260,4 +258,27 @@ QList<ModPlatform::Category> FlameAPI::loadModCategories(std::shared_ptr<QByteAr
         qDebug() << doc;
     }
     return categories;
-};
+};
+
+std::optional<ModPlatform::IndexedVersion> FlameAPI::getLatestVersion(QList<ModPlatform::IndexedVersion> versions,
+                                                                      QList<ModPlatform::ModLoaderType> instanceLoaders,
+                                                                      ModPlatform::ModLoaderTypes modLoaders)
+{
+    // edge case: mod has installed for forge but the instance is fabric => fabric version will be prioritizated on update
+    auto bestVersion = [&versions](ModPlatform::ModLoaderTypes loader) {
+        std::optional<ModPlatform::IndexedVersion> ver;
+        for (auto file_tmp : versions) {
+            if (file_tmp.loaders & loader && (!ver.has_value() || file_tmp.date > ver->date)) {
+                ver = file_tmp;
+            }
+        }
+        return ver;
+    };
+    for (auto l : instanceLoaders) {
+        auto ver = bestVersion(l);
+        if (ver.has_value()) {
+            return ver;
+        }
+    }
+    return bestVersion(modLoaders);
+}

launcher/modplatform/flame/FlameAPI.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <QList>
-#include <algorithm>
 #include <memory>
 #include "modplatform/ModIndex.h"
 #include "modplatform/ResourceAPI.h"
@@ -13,10 +12,13 @@
 
 class FlameAPI : public NetworkResourceAPI {
    public:
-    auto getModFileChangelog(int modId, int fileId) -> QString;
+    QString getModFileChangelog(int modId, int fileId);
-    auto getModDescription(int modId) -> QString;
+    QString getModDescription(int modId);
 
-    auto getLatestVersion(VersionSearchArgs&& args) -> ModPlatform::IndexedVersion;
+    QList<ModPlatform::IndexedVersion> getLatestVersions(VersionSearchArgs&& args);
+    std::optional<ModPlatform::IndexedVersion> getLatestVersion(QList<ModPlatform::IndexedVersion> versions,
+                                                                QList<ModPlatform::ModLoaderType> instanceLoaders,
+                                                                ModPlatform::ModLoaderTypes fallback);
 
     Task::Ptr getProjects(QStringList addonIds, std::shared_ptr<QByteArray> response) const override;
     Task::Ptr matchFingerprints(const QList<uint>& fingerprints, std::shared_ptr<QByteArray> response);
@@ -26,9 +28,9 @@ class FlameAPI : public NetworkResourceAPI {
     static Task::Ptr getModCategories(std::shared_ptr<QByteArray> response);
     static QList<ModPlatform::Category> loadModCategories(std::shared_ptr<QByteArray> response);
 
-    [[nodiscard]] auto getSortingMethods() const -> QList<ResourceAPI::SortingMethod> override;
+    [[nodiscard]] QList<ResourceAPI::SortingMethod> getSortingMethods() const override;
 
-    static inline auto validateModLoaders(ModPlatform::ModLoaderTypes loaders) -> bool
+    static inline bool validateModLoaders(ModPlatform::ModLoaderTypes loaders)
     {
         return loaders & (ModPlatform::NeoForge | ModPlatform::Forge | ModPlatform::Fabric | ModPlatform::Quilt);
     }
@@ -67,7 +69,7 @@ class FlameAPI : public NetworkResourceAPI {
         return 0;
     }
 
-    static auto getModLoaderStrings(const ModPlatform::ModLoaderTypes types) -> const QStringList
+    static const QStringList getModLoaderStrings(const ModPlatform::ModLoaderTypes types)
     {
         QStringList l;
         for (auto loader : { ModPlatform::NeoForge, ModPlatform::Forge, ModPlatform::Fabric, ModPlatform::Quilt }) {
@@ -78,10 +80,7 @@ class FlameAPI : public NetworkResourceAPI {
         return l;
     }
 
-    static auto getModLoaderFilters(ModPlatform::ModLoaderTypes types) -> const QString
+    static const QString getModLoaderFilters(ModPlatform::ModLoaderTypes types) { return "[" + getModLoaderStrings(types).join(',') + "]"; }
-    {
-        return "[" + getModLoaderStrings(types).join(',') + "]";
-    }
 
    private:
     [[nodiscard]] std::optional<QString> getSearchURL(SearchArgs const& args) const override

launcher/modplatform/flame/FlameCheckUpdate.cpp

@@ -1,4 +1,5 @@
 #include "FlameCheckUpdate.h"
+#include "Application.h"
 #include "FlameAPI.h"
 #include "FlameModIndex.h"
 
@@ -132,25 +133,26 @@ void FlameCheckUpdate::executeTask()
         setStatus(tr("Getting API response from CurseForge for '%1'...").arg(mod->name()));
         setProgress(i++, m_mods.size());
 
-        auto latest_ver = api.getLatestVersion({ { mod->metadata()->project_id.toString() }, m_game_versions, m_loaders });
+        auto latest_vers = api.getLatestVersions({ { mod->metadata()->project_id.toString() }, m_game_versions });
 
         // Check if we were aborted while getting the latest version
         if (m_was_aborted) {
             aborted();
             return;
         }
+        auto latest_ver = api.getLatestVersion(latest_vers, m_loaders_list, mod->loaders());
 
         setStatus(tr("Parsing the API response from CurseForge for '%1'...").arg(mod->name()));
 
-        if (!latest_ver.addonId.isValid()) {
+        if (!latest_ver.has_value() || !latest_ver->addonId.isValid()) {
             emit checkFailed(mod, tr("No valid version found for this mod. It's probably unavailable for the current game "
                                      "version / mod loader."));
             continue;
         }
 
-        if (latest_ver.downloadUrl.isEmpty() && latest_ver.fileId != mod->metadata()->file_id) {
+        if (latest_ver->downloadUrl.isEmpty() && latest_ver->fileId != mod->metadata()->file_id) {
-            auto pack = getProjectInfo(latest_ver);
+            auto pack = getProjectInfo(latest_ver.value());
-            auto recover_url = QString("%1/download/%2").arg(pack.websiteUrl, latest_ver.fileId.toString());
+            auto recover_url = QString("%1/download/%2").arg(pack.websiteUrl, latest_ver->fileId.toString());
             emit checkFailed(mod, tr("Mod has a new update available, but is not downloadable using CurseForge."), recover_url);
 
             continue;
@@ -166,19 +168,19 @@ void FlameCheckUpdate::executeTask()
             pack->authors.append({ author });
         pack->description = mod->description();
         pack->provider = ModPlatform::ResourceProvider::FLAME;
-        if (!latest_ver.hash.isEmpty() && (mod->metadata()->hash != latest_ver.hash || mod->status() == ModStatus::NotInstalled)) {
+        if (!latest_ver->hash.isEmpty() && (mod->metadata()->hash != latest_ver->hash || mod->status() == ModStatus::NotInstalled)) {
             auto old_version = mod->version();
             if (old_version.isEmpty() && mod->status() != ModStatus::NotInstalled) {
-                auto current_ver = getFileInfo(latest_ver.addonId.toInt(), mod->metadata()->file_id.toInt());
+                auto current_ver = getFileInfo(latest_ver->addonId.toInt(), mod->metadata()->file_id.toInt());
                 old_version = current_ver.version;
             }
 
-            auto download_task = makeShared<ResourceDownloadTask>(pack, latest_ver, m_mods_folder);
+            auto download_task = makeShared<ResourceDownloadTask>(pack, latest_ver.value(), m_mods_folder);
-            m_updatable.emplace_back(pack->name, mod->metadata()->hash, old_version, latest_ver.version, latest_ver.version_type,
+            m_updatable.emplace_back(pack->name, mod->metadata()->hash, old_version, latest_ver->version, latest_ver->version_type,
-                                     api.getModFileChangelog(latest_ver.addonId.toInt(), latest_ver.fileId.toInt()),
+                                     api.getModFileChangelog(latest_ver->addonId.toInt(), latest_ver->fileId.toInt()),
                                      ModPlatform::ResourceProvider::FLAME, download_task);
         }
-        m_deps.append(std::make_shared<GetModDependenciesTask::PackDependency>(pack, latest_ver));
+        m_deps.append(std::make_shared<GetModDependenciesTask::PackDependency>(pack, latest_ver.value()));
     }
 
     emitSucceeded();

launcher/modplatform/flame/FlameCheckUpdate.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "Application.h"
 #include "modplatform/CheckUpdateTask.h"
 #include "net/NetJob.h"
 
@@ -10,9 +9,9 @@ class FlameCheckUpdate : public CheckUpdateTask {
    public:
     FlameCheckUpdate(QList<Mod*>& mods,
                      std::list<Version>& mcVersions,
-                     std::optional<ModPlatform::ModLoaderTypes> loaders,
+                     QList<ModPlatform::ModLoaderType> loadersList,
                      std::shared_ptr<ModFolderModel> mods_folder)
-        : CheckUpdateTask(mods, mcVersions, loaders, mods_folder)
+        : CheckUpdateTask(mods, mcVersions, loadersList, mods_folder)
     {}
 
    public slots:

launcher/modplatform/modrinth/ModrinthCheckUpdate.cpp

@@ -1,23 +1,31 @@
 #include "ModrinthCheckUpdate.h"
+#include "Application.h"
 #include "ModrinthAPI.h"
 #include "ModrinthPackIndex.h"
 
 #include "Json.h"
 
+#include "QObjectPtr.h"
 #include "ResourceDownloadTask.h"
 
 #include "modplatform/helpers/HashUtils.h"
 
 #include "tasks/ConcurrentTask.h"
 
-#include "minecraft/mod/ModFolderModel.h"
-
 static ModrinthAPI api;
 
+ModrinthCheckUpdate::ModrinthCheckUpdate(QList<Mod*>& mods,
+                                         std::list<Version>& mcVersions,
+                                         QList<ModPlatform::ModLoaderType> loadersList,
+                                         std::shared_ptr<ModFolderModel> mods_folder)
+    : CheckUpdateTask(mods, mcVersions, loadersList, mods_folder)
+    , m_hash_type(ModPlatform::ProviderCapabilities::hashType(ModPlatform::ResourceProvider::MODRINTH).first())
+{}
+
 bool ModrinthCheckUpdate::abort()
 {
-    if (m_net_job)
+    if (m_job)
-        return m_net_job->abort();
+        return m_job->abort();
     return true;
 }
 
@@ -29,15 +37,10 @@ bool ModrinthCheckUpdate::abort()
 void ModrinthCheckUpdate::executeTask()
 {
     setStatus(tr("Preparing mods for Modrinth..."));
-    setProgress(0, 3);
+    setProgress(0, 9);
 
-    QHash<QString, Mod*> mappings;
+    auto hashing_task =
-
+        makeShared<ConcurrentTask>(this, "MakeModrinthHashesTask", APPLICATION->settings()->get("NumberOfConcurrentTasks").toInt());
-    // Create all hashes
-    QStringList hashes;
-    auto best_hash_type = ModPlatform::ProviderCapabilities::hashType(ModPlatform::ResourceProvider::MODRINTH).first();
-
-    ConcurrentTask hashing_task(this, "MakeModrinthHashesTask", APPLICATION->settings()->get("NumberOfConcurrentTasks").toInt());
     for (auto* mod : m_mods) {
         if (!mod->enabled()) {
             emit checkFailed(mod, tr("Disabled mods won't be updated, to prevent mod duplication issues!"));
@@ -49,132 +52,176 @@ void ModrinthCheckUpdate::executeTask()
         // Sadly the API can only handle one hash type per call, se we
         // need to generate a new hash if the current one is innadequate
         // (though it will rarely happen, if at all)
-        if (mod->metadata()->hash_format != best_hash_type) {
+        if (mod->metadata()->hash_format != m_hash_type) {
             auto hash_task = Hashing::createHasher(mod->fileinfo().absoluteFilePath(), ModPlatform::ResourceProvider::MODRINTH);
-            connect(hash_task.get(), &Hashing::Hasher::resultsReady, [&hashes, &mappings, mod](QString hash) {
+            connect(hash_task.get(), &Hashing::Hasher::resultsReady, [this, mod](QString hash) { m_mappings.insert(hash, mod); });
-                hashes.append(hash);
-                mappings.insert(hash, mod);
-            });
             connect(hash_task.get(), &Task::failed, [this] { failed("Failed to generate hash"); });
-            hashing_task.addTask(hash_task);
+            hashing_task->addTask(hash_task);
         } else {
-            hashes.append(hash);
+            m_mappings.insert(hash, mod);
-            mappings.insert(hash, mod);
         }
     }
 
-    QEventLoop loop;
+    connect(hashing_task.get(), &Task::finished, this, &ModrinthCheckUpdate::checkNextLoader);
-    connect(&hashing_task, &Task::finished, [&loop] { loop.quit(); });
+    m_job = hashing_task;
-    hashing_task.start();
+    hashing_task->start();
-    loop.exec();
+}
 
-    auto response = std::make_shared<QByteArray>();
+void ModrinthCheckUpdate::checkVersionsResponse(std::shared_ptr<QByteArray> response,
-    auto job = api.latestVersions(hashes, best_hash_type, m_game_versions, m_loaders, response);
+                                                ModPlatform::ModLoaderTypes loader,
+                                                bool forceModLoaderCheck)
+{
+    QJsonParseError parse_error{};
+    QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
+    if (parse_error.error != QJsonParseError::NoError) {
+        qWarning() << "Error while parsing JSON response from ModrinthCheckUpdate at " << parse_error.offset
+                   << " reason: " << parse_error.errorString();
+        qWarning() << *response;
 
-    connect(job.get(), &Task::succeeded, this, [this, response, mappings, best_hash_type, job] {
+        emitFailed(parse_error.errorString());
-        QJsonParseError parse_error{};
+        return;
-        QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
+    }
-        if (parse_error.error != QJsonParseError::NoError) {
-            qWarning() << "Error while parsing JSON response from ModrinthCheckUpdate at " << parse_error.offset
-                       << " reason: " << parse_error.errorString();
-            qWarning() << *response;
 
-            emitFailed(parse_error.errorString());
+    setStatus(tr("Parsing the API response from Modrinth..."));
-            return;
+    setProgress(m_next_loader_idx * 2, 9);
-        }
 
-        setStatus(tr("Parsing the API response from Modrinth..."));
+    try {
-        setProgress(2, 3);
+        for (auto hash : m_mappings.keys()) {
-
+            if (forceModLoaderCheck && !(m_mappings[hash]->loaders() & loader)) {
-        try {
+                continue;
-            for (auto hash : mappings.keys()) {
-                auto project_obj = doc[hash].toObject();
-
-                // If the returned project is empty, but we have Modrinth metadata,
-                // it means this specific version is not available
-                if (project_obj.isEmpty()) {
-                    qDebug() << "Mod " << mappings.find(hash).value()->name() << " got an empty response.";
-                    qDebug() << "Hash: " << hash;
-
-                    emit checkFailed(
-                        mappings.find(hash).value(),
-                        tr("No valid version found for this mod. It's probably unavailable for the current game version / mod loader."));
-
-                    continue;
-                }
-
-                // Sometimes a version may have multiple files, one with "forge" and one with "fabric",
-                // so we may want to filter it
-                QString loader_filter;
-                if (m_loaders.has_value()) {
-                    static auto flags = { ModPlatform::ModLoaderType::NeoForge, ModPlatform::ModLoaderType::Forge,
-                                          ModPlatform::ModLoaderType::Fabric, ModPlatform::ModLoaderType::Quilt };
-                    for (auto flag : flags) {
-                        if (m_loaders.value().testFlag(flag)) {
-                            loader_filter = ModPlatform::getModLoaderAsString(flag);
-                            break;
-                        }
-                    }
-                }
-
-                // Currently, we rely on a couple heuristics to determine whether an update is actually available or not:
-                // - The file needs to be preferred: It is either the primary file, or the one found via (explicit) usage of the
-                // loader_filter
-                // - The version reported by the JAR is different from the version reported by the indexed version (it's usually the case)
-                // Such is the pain of having arbitrary files for a given version .-.
-
-                auto project_ver = Modrinth::loadIndexedPackVersion(project_obj, best_hash_type, loader_filter);
-                if (project_ver.downloadUrl.isEmpty()) {
-                    qCritical() << "Modrinth mod without download url!";
-                    qCritical() << project_ver.fileName;
-
-                    emit checkFailed(mappings.find(hash).value(), tr("Mod has an empty download URL"));
-
-                    continue;
-                }
-
-                auto mod_iter = mappings.find(hash);
-                if (mod_iter == mappings.end()) {
-                    qCritical() << "Failed to remap mod from Modrinth!";
-                    continue;
-                }
-                auto mod = *mod_iter;
-
-                auto key = project_ver.hash;
-
-                // Fake pack with the necessary info to pass to the download task :)
-                auto pack = std::make_shared<ModPlatform::IndexedPack>();
-                pack->name = mod->name();
-                pack->slug = mod->metadata()->slug;
-                pack->addonId = mod->metadata()->project_id;
-                pack->websiteUrl = mod->homeurl();
-                for (auto& author : mod->authors())
-                    pack->authors.append({ author });
-                pack->description = mod->description();
-                pack->provider = ModPlatform::ResourceProvider::MODRINTH;
-                if ((key != hash && project_ver.is_preferred) || (mod->status() == ModStatus::NotInstalled)) {
-                    if (mod->version() == project_ver.version_number)
-                        continue;
-
-                    auto download_task = makeShared<ResourceDownloadTask>(pack, project_ver, m_mods_folder);
-
-                    m_updatable.emplace_back(pack->name, hash, mod->version(), project_ver.version_number, project_ver.version_type,
-                                             project_ver.changelog, ModPlatform::ResourceProvider::MODRINTH, download_task);
-                }
-                m_deps.append(std::make_shared<GetModDependenciesTask::PackDependency>(pack, project_ver));
             }
-        } catch (Json::JsonException& e) {
+            auto project_obj = doc[hash].toObject();
-            emitFailed(e.cause() + " : " + e.what());
-            return;
-        }
-        emitSucceeded();
-    });
 
-    connect(job.get(), &Task::failed, this, &ModrinthCheckUpdate::emitFailed);
+            // If the returned project is empty, but we have Modrinth metadata,
+            // it means this specific version is not available
+            if (project_obj.isEmpty()) {
+                qDebug() << "Mod " << m_mappings.find(hash).value()->name() << " got an empty response."
+                         << "Hash: " << hash;
+
+                continue;
+            }
+
+            // Sometimes a version may have multiple files, one with "forge" and one with "fabric",
+            // so we may want to filter it
+            QString loader_filter;
+            static auto flags = { ModPlatform::ModLoaderType::NeoForge, ModPlatform::ModLoaderType::Forge,
+                                  ModPlatform::ModLoaderType::Quilt, ModPlatform::ModLoaderType::Fabric };
+            for (auto flag : flags) {
+                if (loader.testFlag(flag)) {
+                    loader_filter = ModPlatform::getModLoaderAsString(flag);
+                    break;
+                }
+            }
+
+            // Currently, we rely on a couple heuristics to determine whether an update is actually available or not:
+            // - The file needs to be preferred: It is either the primary file, or the one found via (explicit) usage of the
+            // loader_filter
+            // - The version reported by the JAR is different from the version reported by the indexed version (it's usually the case)
+            // Such is the pain of having arbitrary files for a given version .-.
+
+            auto project_ver = Modrinth::loadIndexedPackVersion(project_obj, m_hash_type, loader_filter);
+            if (project_ver.downloadUrl.isEmpty()) {
+                qCritical() << "Modrinth mod without download url!" << project_ver.fileName;
+
+                continue;
+            }
+
+            auto mod_iter = m_mappings.find(hash);
+            if (mod_iter == m_mappings.end()) {
+                qCritical() << "Failed to remap mod from Modrinth!";
+                continue;
+            }
+            auto mod = *mod_iter;
+            m_mappings.remove(hash);
+
+            auto key = project_ver.hash;
+
+            // Fake pack with the necessary info to pass to the download task :)
+            auto pack = std::make_shared<ModPlatform::IndexedPack>();
+            pack->name = mod->name();
+            pack->slug = mod->metadata()->slug;
+            pack->addonId = mod->metadata()->project_id;
+            pack->websiteUrl = mod->homeurl();
+            for (auto& author : mod->authors())
+                pack->authors.append({ author });
+            pack->description = mod->description();
+            pack->provider = ModPlatform::ResourceProvider::MODRINTH;
+            if ((key != hash && project_ver.is_preferred) || (mod->status() == ModStatus::NotInstalled)) {
+                if (mod->version() == project_ver.version_number)
+                    continue;
+
+                auto download_task = makeShared<ResourceDownloadTask>(pack, project_ver, m_mods_folder);
+
+                m_updatable.emplace_back(pack->name, hash, mod->version(), project_ver.version_number, project_ver.version_type,
+                                         project_ver.changelog, ModPlatform::ResourceProvider::MODRINTH, download_task);
+            }
+            m_deps.append(std::make_shared<GetModDependenciesTask::PackDependency>(pack, project_ver));
+        }
+    } catch (Json::JsonException& e) {
+        emitFailed(e.cause() + " : " + e.what());
+        return;
+    }
+    checkNextLoader();
+}
+
+void ModrinthCheckUpdate::getUpdateModsForLoader(ModPlatform::ModLoaderTypes loader, bool forceModLoaderCheck)
+{
+    auto response = std::make_shared<QByteArray>();
+    QStringList hashes;
+    if (forceModLoaderCheck) {
+        for (auto hash : m_mappings.keys()) {
+            if (m_mappings[hash]->loaders() & loader) {
+                hashes.append(hash);
+            }
+        }
+    } else {
+        hashes = m_mappings.keys();
+    }
+    auto job = api.latestVersions(hashes, m_hash_type, m_game_versions, loader, response);
+
+    connect(job.get(), &Task::succeeded, this,
+            [this, response, loader, forceModLoaderCheck] { checkVersionsResponse(response, loader, forceModLoaderCheck); });
+
+    connect(job.get(), &Task::failed, this, &ModrinthCheckUpdate::checkNextLoader);
 
     setStatus(tr("Waiting for the API response from Modrinth..."));
-    setProgress(1, 3);
+    setProgress(m_next_loader_idx * 2 - 1, 9);
 
-    m_net_job = qSharedPointerObjectCast<NetJob, Task>(job);
+    m_job = job;
     job->start();
 }
+
+void ModrinthCheckUpdate::checkNextLoader()
+{
+    if (m_mappings.isEmpty()) {
+        emitSucceeded();
+        return;
+    }
+    if (m_next_loader_idx < m_loaders_list.size()) {
+        getUpdateModsForLoader(m_loaders_list.at(m_next_loader_idx));
+        m_next_loader_idx++;
+        return;
+    }
+    static auto flags = { ModPlatform::ModLoaderType::NeoForge, ModPlatform::ModLoaderType::Forge, ModPlatform::ModLoaderType::Quilt,
+                          ModPlatform::ModLoaderType::Fabric };
+    for (auto flag : flags) {
+        if (!m_loaders_list.contains(flag)) {
+            m_loaders_list.append(flag);
+            m_next_loader_idx++;
+            setProgress(m_next_loader_idx * 2 - 1, 9);
+            for (auto m : m_mappings) {
+                if (m->loaders() & flag) {
+                    getUpdateModsForLoader(flag, true);
+                    return;
+                }
+            }
+            setProgress(m_next_loader_idx * 2, 9);
+        }
+    }
+    for (auto m : m_mappings) {
+        emit checkFailed(m,
+                         tr("No valid version found for this mod. It's probably unavailable for the current game version / mod loader."));
+    }
+    emitSucceeded();
+    return;
+}

launcher/modplatform/modrinth/ModrinthCheckUpdate.h

@@ -1,8 +1,6 @@
 #pragma once
 
-#include "Application.h"
 #include "modplatform/CheckUpdateTask.h"
-#include "net/NetJob.h"
 
 class ModrinthCheckUpdate : public CheckUpdateTask {
     Q_OBJECT
@@ -10,17 +8,21 @@ class ModrinthCheckUpdate : public CheckUpdateTask {
    public:
     ModrinthCheckUpdate(QList<Mod*>& mods,
                         std::list<Version>& mcVersions,
-                        std::optional<ModPlatform::ModLoaderTypes> loaders,
+                        QList<ModPlatform::ModLoaderType> loadersList,
-                        std::shared_ptr<ModFolderModel> mods_folder)
+                        std::shared_ptr<ModFolderModel> mods_folder);
-        : CheckUpdateTask(mods, mcVersions, loaders, mods_folder)
-    {}
 
    public slots:
     bool abort() override;
 
    protected slots:
     void executeTask() override;
+    void getUpdateModsForLoader(ModPlatform::ModLoaderTypes loader, bool forceModLoaderCheck = false);
+    void checkVersionsResponse(std::shared_ptr<QByteArray> response, ModPlatform::ModLoaderTypes loader, bool forceModLoaderCheck = false);
+    void checkNextLoader();
 
    private:
-    NetJob::Ptr m_net_job = nullptr;
+    Task::Ptr m_job = nullptr;
+    QHash<QString, Mod*> m_mappings;
+    QString m_hash_type;
+    int m_next_loader_idx = 0;
 };

launcher/net/ChecksumValidator.h

@@ -60,7 +60,11 @@ class ChecksumValidator : public Validator {
         return true;
     }
 
-    auto abort() -> bool override { return true; }
+    auto abort() -> bool override
+    {
+        m_checksum.reset();
+        return true;
+    }
 
     auto validate(QNetworkReply&) -> bool override
     {

launcher/net/NetJob.cpp

@@ -36,6 +36,7 @@
  */
 
 #include "NetJob.h"
+#include <QNetworkReply>
 #include "net/NetRequest.h"
 #include "tasks/ConcurrentTask.h"
 #if defined(LAUNCHER_APPLICATION)
@@ -145,10 +146,23 @@ void NetJob::updateState()
                   .arg(QString::number(m_doing.count()), QString::number(m_done.count()), QString::number(totalSize())));
 }
 
+bool NetJob::isOnline()
+{
+    // check some errors that are ussually associated with the lack of internet
+    for (auto job : getFailedActions()) {
+        auto err = job->error();
+        if (err != QNetworkReply::HostNotFoundError && err != QNetworkReply::NetworkSessionFailedError) {
+            return true;
+        }
+    }
+    return false;
+};
+
 void NetJob::emitFailed(QString reason)
 {
 #if defined(LAUNCHER_APPLICATION)
-    if (m_ask_retry) {
+    if (m_ask_retry && m_manual_try < APPLICATION->settings()->get("NumberOfManualRetries").toInt() && isOnline()) {
+        m_manual_try++;
         auto response = CustomMessageBox::selectable(nullptr, "Confirm retry",
                                                      "The tasks failed.\n"
                                                      "Failed urls\n" +

launcher/net/NetJob.h

@@ -74,10 +74,12 @@ class NetJob : public ConcurrentTask {
 
    protected:
     void updateState() override;
+    bool isOnline();
 
    private:
     shared_qobject_ptr<QNetworkAccessManager> m_network;
 
     int m_try = 1;
     bool m_ask_retry = true;
+    int m_manual_try = 0;
 };

launcher/net/NetRequest.cpp

@@ -84,7 +84,7 @@ void NetRequest::executeTask()
             break;
         case State::Inactive:
         case State::Failed:
-            emit failed("Failed to initilize sink");
+            emit failed("Failed to initialize sink");
             emit finished();
             return;
         case State::AbortedByUser:

launcher/news/NewsChecker.cpp

@@ -58,6 +58,7 @@ void NewsChecker::reloadNews()
 
     NetJob::Ptr job{ new NetJob("News RSS Feed", m_network) };
     job->addNetAction(Net::Download::makeByteArray(m_feedUrl, newsData));
+    job->setAskRetry(false);
     QObject::connect(job.get(), &NetJob::succeeded, this, &NewsChecker::rssDownloadFinished);
     QObject::connect(job.get(), &NetJob::failed, this, &NewsChecker::rssDownloadFailed);
     m_newsNetJob.reset(job);

launcher/screenshots/ImgurAlbumCreation.cpp

@@ -69,13 +69,13 @@ QNetworkReply* ImgurAlbumCreation::getReply(QNetworkRequest& request)
     }
     const QByteArray data = "deletehashes=" + hashes.join(',').toUtf8() + "&title=Minecraft%20Screenshots&privacy=hidden";
     return m_network->post(request, data);
-};
+}
 
 auto ImgurAlbumCreation::Sink::init(QNetworkRequest& request) -> Task::State
 {
     m_output.clear();
     return Task::State::Running;
-};
+}
 
 auto ImgurAlbumCreation::Sink::write(QByteArray& data) -> Task::State
 {

launcher/screenshots/ImgurUpload.cpp

@@ -73,13 +73,13 @@ QNetworkReply* ImgurUpload::getReply(QNetworkRequest& request)
     multipart->append(namePart);
 
     return m_network->post(request, multipart);
-};
+}
 
 auto ImgurUpload::Sink::init(QNetworkRequest& request) -> Task::State
 {
     m_output.clear();
     return Task::State::Running;
-};
+}
 
 auto ImgurUpload::Sink::write(QByteArray& data) -> Task::State
 {

launcher/settings/OverrideSetting.h

@@ -29,7 +29,7 @@
 class OverrideSetting : public Setting {
     Q_OBJECT
    public:
-    explicit OverrideSetting(std::shared_ptr<Setting> overriden, std::shared_ptr<Setting> gate);
+    explicit OverrideSetting(std::shared_ptr<Setting> overridden, std::shared_ptr<Setting> gate);
 
     virtual QVariant defValue() const;
     virtual QVariant get() const;

launcher/settings/PassthroughSetting.h

@@ -28,7 +28,7 @@
 class PassthroughSetting : public Setting {
     Q_OBJECT
    public:
-    explicit PassthroughSetting(std::shared_ptr<Setting> overriden, std::shared_ptr<Setting> gate);
+    explicit PassthroughSetting(std::shared_ptr<Setting> overridden, std::shared_ptr<Setting> gate);
 
     virtual QVariant defValue() const;
     virtual QVariant get() const;

launcher/translations/TranslationsModel.cpp

@@ -553,6 +553,7 @@ void TranslationsModel::downloadIndex()
     auto task = Net::Download::makeCached(QUrl(BuildConfig.TRANSLATIONS_BASE_URL + "index_v2.json"), entry);
     d->m_index_task = task.get();
     d->m_index_job->addNetAction(task);
+    d->m_index_job->setAskRetry(false);
     connect(d->m_index_job.get(), &NetJob::failed, this, &TranslationsModel::indexFailed);
     connect(d->m_index_job.get(), &NetJob::succeeded, this, &TranslationsModel::indexReceived);
     d->m_index_job->start();

launcher/ui/dialogs/ModUpdateDialog.cpp

@@ -1,4 +1,5 @@
 #include "ModUpdateDialog.h"
+#include "Application.h"
 #include "ChooseProviderDialog.h"
 #include "CustomMessageBox.h"
 #include "ProgressDialog.h"
@@ -30,9 +31,9 @@ static std::list<Version> mcVersions(BaseInstance* inst)
     return { static_cast<MinecraftInstance*>(inst)->getPackProfile()->getComponent("net.minecraft")->getVersion() };
 }
 
-static std::optional<ModPlatform::ModLoaderTypes> mcLoaders(BaseInstance* inst)
+static QList<ModPlatform::ModLoaderType> mcLoadersList(BaseInstance* inst)
 {
-    return { static_cast<MinecraftInstance*>(inst)->getPackProfile()->getSupportedModLoaders() };
+    return static_cast<MinecraftInstance*>(inst)->getPackProfile()->getModLoadersList();
 }
 
 ModUpdateDialog::ModUpdateDialog(QWidget* parent,
@@ -86,19 +87,19 @@ void ModUpdateDialog::checkCandidates()
     }
 
     auto versions = mcVersions(m_instance);
-    auto loaders = mcLoaders(m_instance);
+    auto loadersList = mcLoadersList(m_instance);
 
     SequentialTask check_task(m_parent, tr("Checking for updates"));
 
     if (!m_modrinth_to_update.empty()) {
-        m_modrinth_check_task.reset(new ModrinthCheckUpdate(m_modrinth_to_update, versions, loaders, m_mod_model));
+        m_modrinth_check_task.reset(new ModrinthCheckUpdate(m_modrinth_to_update, versions, loadersList, m_mod_model));
         connect(m_modrinth_check_task.get(), &CheckUpdateTask::checkFailed, this,
                 [this](Mod* mod, QString reason, QUrl recover_url) { m_failed_check_update.append({ mod, reason, recover_url }); });
         check_task.addTask(m_modrinth_check_task);
     }
 
     if (!m_flame_to_update.empty()) {
-        m_flame_check_task.reset(new FlameCheckUpdate(m_flame_to_update, versions, loaders, m_mod_model));
+        m_flame_check_task.reset(new FlameCheckUpdate(m_flame_to_update, versions, loadersList, m_mod_model));
         connect(m_flame_check_task.get(), &CheckUpdateTask::checkFailed, this,
                 [this](Mod* mod, QString reason, QUrl recover_url) { m_failed_check_update.append({ mod, reason, recover_url }); });
         check_task.addTask(m_flame_check_task);

launcher/ui/pages/global/APIPage.ui

@@ -207,7 +207,7 @@
           <item row="0" column="0">
            <widget class="QLabel" name="label_8">
             <property name="text">
-             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Note: you only need to set this to access private data. Read the &lt;a href=&quot;https://docs.modrinth.com/api-spec/#section/Authentication&quot;&gt;documentation&lt;/a&gt; for more information.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Note: you only need to set this to access private data. Read the &lt;a href=&quot;https://docs.modrinth.com/#section/Authentication&quot;&gt;documentation&lt;/a&gt; for more information.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
             <property name="openExternalLinks">
              <bool>true</bool>

launcher/ui/pages/global/AccountListPage.h

@@ -66,7 +66,7 @@ class AccountListPage : public QMainWindow, public BasePage {
         return icon;
     }
     QString id() const override { return "accounts"; }
-    QString helpPage() const override { return "Getting-Started#adding-an-account"; }
+    QString helpPage() const override { return "/getting-started/adding-an-account"; }
     void retranslate() override;
 
    public slots:

launcher/ui/pages/global/LauncherPage.cpp

@@ -203,6 +203,7 @@ void LauncherPage::applySettings()
 
     s->set("NumberOfConcurrentTasks", ui->numberOfConcurrentTasksSpinBox->value());
     s->set("NumberOfConcurrentDownloads", ui->numberOfConcurrentDownloadsSpinBox->value());
+    s->set("NumberOfManualRetries", ui->numberOfManualRetriesSpinBox->value());
     s->set("RequestTimeout", ui->timeoutSecondsSpinBox->value());
 
     // Console settings
@@ -261,6 +262,7 @@ void LauncherPage::loadSettings()
 
     ui->numberOfConcurrentTasksSpinBox->setValue(s->get("NumberOfConcurrentTasks").toInt());
     ui->numberOfConcurrentDownloadsSpinBox->setValue(s->get("NumberOfConcurrentDownloads").toInt());
+    ui->numberOfManualRetriesSpinBox->setValue(s->get("NumberOfManualRetries").toInt());
     ui->timeoutSecondsSpinBox->setValue(s->get("RequestTimeout").toInt());
 
     // Console settings

launcher/ui/pages/global/LauncherPage.ui

@@ -291,6 +291,20 @@
            </widget>
           </item>
           <item row="2" column="0">
+           <widget class="QLabel" name="numberOfManualRetriesLabel">
+            <property name="text">
+             <string>Number of manual retries</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="1">
+           <widget class="QSpinBox" name="numberOfManualRetriesSpinBox">
+            <property name="minimum">
+             <number>0</number>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="0">
            <widget class="QLabel" name="timeoutSecondsLabel">
             <property name="toolTip">
              <string>Seconds to wait until the requests are terminated</string>
@@ -300,7 +314,7 @@
             </property>
            </widget>
           </item>
-          <item row="2" column="1">
+          <item row="3" column="1">
            <widget class="QSpinBox" name="timeoutSecondsSpinBox">
             <property name="suffix">
              <string>s</string>

launcher/ui/pages/instance/ManagedPackPage.h

@@ -119,6 +119,7 @@ class ModrinthManagedPackPage final : public ManagedPackPage {
 
     void parseManagedPack() override;
     [[nodiscard]] QString url() const override;
+    [[nodiscard]] QString helpPage() const override { return "modrinth-managed-pack"; }
 
    public slots:
     void suggestVersion() override;
@@ -142,6 +143,7 @@ class FlameManagedPackPage final : public ManagedPackPage {
 
     void parseManagedPack() override;
     [[nodiscard]] QString url() const override;
+    [[nodiscard]] QString helpPage() const override { return "curseforge-managed-pack"; }
 
    public slots:
     void suggestVersion() override;

launcher/ui/pages/instance/OtherLogsPage.h

@@ -57,7 +57,7 @@ class OtherLogsPage : public QWidget, public BasePage {
     QString id() const override { return "logs"; }
     QString displayName() const override { return tr("Other logs"); }
     QIcon icon() const override { return APPLICATION->getThemedIcon("log"); }
-    QString helpPage() const override { return "Minecraft-Logs"; }
+    QString helpPage() const override { return "other-Logs"; }
     void retranslate() override;
 
     void openedImpl() override;

launcher/ui/pages/instance/ShaderPackPage.h

@@ -48,7 +48,7 @@ class ShaderPackPage : public ExternalResourcesPage {
     QString displayName() const override { return tr("Shader packs"); }
     QIcon icon() const override { return APPLICATION->getThemedIcon("shaderpacks"); }
     QString id() const override { return "shaderpacks"; }
-    QString helpPage() const override { return "Resource-packs"; }
+    QString helpPage() const override { return "shader-packs"; }
 
     bool shouldDisplay() const override { return true; }
 

launcher/ui/pages/modplatform/ResourceModel.cpp

@@ -317,8 +317,10 @@ std::optional<QIcon> ResourceModel::getIcon(QModelIndex& index, const QUrl& url)
     if (QPixmapCache::find(url.toString(), &pixmap))
         return { pixmap };
 
-    if (!m_current_icon_job)
+    if (!m_current_icon_job) {
         m_current_icon_job.reset(new NetJob("IconJob", APPLICATION->network()));
+        m_current_icon_job->setAskRetry(false);
+    }
 
     if (m_currently_running_icon_actions.contains(url))
         return {};

launcher/ui/pages/modplatform/ResourcePackPage.h

@@ -40,6 +40,8 @@ class ResourcePackResourcePage : public ResourcePage {
 
     [[nodiscard]] QMap<QString, QString> urlHandlers() const override;
 
+    [[nodiscard]] inline auto helpPage() const -> QString override { return "resourcepack-platform"; }
+
    protected:
     ResourcePackResourcePage(ResourceDownloadDialog* dialog, BaseInstance& instance);
 

launcher/ui/pages/modplatform/ShaderPackPage.h

@@ -42,6 +42,8 @@ class ShaderPackResourcePage : public ResourcePage {
 
     [[nodiscard]] QMap<QString, QString> urlHandlers() const override;
 
+    [[nodiscard]] inline auto helpPage() const -> QString override { return "shaderpack-platform"; }
+
    protected:
     ShaderPackResourcePage(ShaderPackDownloadDialog* dialog, BaseInstance& instance);
 

launcher/ui/pages/modplatform/atlauncher/AtlListModel.cpp

@@ -195,6 +195,7 @@ void ListModel::requestLogo(QString file, QString url)
 
     MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("ATLauncherPacks", QString("logos/%1").arg(file));
     auto job = new NetJob(QString("ATLauncher Icon Download %1").arg(file), APPLICATION->network());
+    job->setAskRetry(false);
     job->addNetAction(Net::ApiDownload::makeCached(QUrl(url), entry));
 
     auto fullPath = entry->getFullPath();

launcher/ui/pages/modplatform/flame/FlameModel.cpp

@@ -110,6 +110,7 @@ void ListModel::requestLogo(QString logo, QString url)
 
     MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("FlamePacks", QString("logos/%1").arg(logo));
     auto job = new NetJob(QString("Flame Icon Download %1").arg(logo), APPLICATION->network());
+    job->setAskRetry(false);
     job->addNetAction(Net::ApiDownload::makeCached(QUrl(url), entry));
 
     auto fullPath = entry->getFullPath();
@@ -172,7 +173,7 @@ void ListModel::performPaginatedSearch()
             callbacks.on_succeed = [this](auto& doc, auto& pack) { searchRequestForOneSucceeded(doc); };
             callbacks.on_abort = [this] {
                 qCritical() << "Search task aborted by an unknown reason!";
-                searchRequestFailed("Abborted");
+                searchRequestFailed("Aborted");
             };
             static const FlameAPI api;
             if (auto job = api.getProjectInfo({ projectId }, std::move(callbacks)); job) {

launcher/ui/pages/modplatform/import_ftb/ImportFTBPage.h

@@ -44,7 +44,7 @@ class ImportFTBPage : public QWidget, public BasePage {
     QString displayName() const override { return tr("FTB App Import"); }
     QIcon icon() const override { return APPLICATION->getThemedIcon("ftb_logo"); }
     QString id() const override { return "import_ftb"; }
-    QString helpPage() const override { return "FTB-platform"; }
+    QString helpPage() const override { return "FTB-import"; }
     bool shouldDisplay() const override { return true; }
     void openedImpl() override;
     void retranslate() override;

launcher/ui/pages/modplatform/legacy_ftb/ListModel.cpp

@@ -264,6 +264,7 @@ void ListModel::requestLogo(QString file)
 
     MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("FTBPacks", QString("logos/%1").arg(file));
     NetJob* job = new NetJob(QString("FTB Icon Download for %1").arg(file), APPLICATION->network());
+    job->setAskRetry(false);
     job->addNetAction(Net::ApiDownload::makeCached(QUrl(QString(BuildConfig.LEGACY_FTB_CDN_BASE_URL + "static/%1").arg(file)), entry));
 
     auto fullPath = entry->getFullPath();

launcher/ui/pages/modplatform/legacy_ftb/Page.h

@@ -66,7 +66,7 @@ class Page : public QWidget, public BasePage {
     QString displayName() const override { return "FTB Legacy"; }
     QIcon icon() const override { return APPLICATION->getThemedIcon("ftb_logo"); }
     QString id() const override { return "legacy_ftb"; }
-    QString helpPage() const override { return "FTB-platform"; }
+    QString helpPage() const override { return "FTB-legacy"; }
     bool shouldDisplay() const override;
     void openedImpl() override;
     void retranslate() override;

launcher/ui/pages/modplatform/modrinth/ModrinthModel.cpp

@@ -254,6 +254,7 @@ void ModpackListModel::requestLogo(QString logo, QString url)
 
     MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry(m_parent->metaEntryBase(), QString("logos/%1").arg(logo));
     auto job = new NetJob(QString("%1 Icon Download %2").arg(m_parent->debugName()).arg(logo), APPLICATION->network());
+    job->setAskRetry(false);
     job->addNetAction(Net::ApiDownload::makeCached(QUrl(url), entry));
 
     auto fullPath = entry->getFullPath();

launcher/ui/pages/modplatform/technic/TechnicModel.cpp

@@ -292,6 +292,7 @@ void Technic::ListModel::requestLogo(QString logo, QString url)
 
     MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("TechnicPacks", QString("logos/%1").arg(logo));
     auto job = new NetJob(QString("Technic Icon Download %1").arg(logo), APPLICATION->network());
+    job->setAskRetry(false);
     job->addNetAction(Net::ApiDownload::makeCached(QUrl(url), entry));
 
     auto fullPath = entry->getFullPath();

launcher/ui/widgets/VariableSizedImageObject.cpp

@@ -80,7 +80,7 @@ void VariableSizedImageObject::drawObject(QPainter* painter,
 {
     if (!format.hasProperty(ImageData)) {
         QUrl image_url{ qvariant_cast<QString>(format.property(QTextFormat::ImageName)) };
-        if (m_fetching_images.contains(image_url))
+        if (m_fetching_images.contains(image_url) || image_url.isEmpty())
             return;
 
         auto meta = std::make_shared<ImageMetadata>();
@@ -140,6 +140,7 @@ void VariableSizedImageObject::loadImage(QTextDocument* doc, std::shared_ptr<Ima
         QString("images/%1").arg(QString(QCryptographicHash::hash(meta->url.toEncoded(), QCryptographicHash::Algorithm::Sha1).toHex())));
 
     auto job = new NetJob(QString("Load Image: %1").arg(meta->url.fileName()), APPLICATION->network());
+    job->setAskRetry(false);
     job->addNetAction(Net::ApiDownload::makeCached(meta->url, entry));
 
     auto full_entry_path = entry->getFullPath();