Merge remote-tracking branch 'upstream/develop' into resource-meta

Signed-off-by: TheKodeToad <TheKodeToad@proton.me>

launcher/minecraft/MinecraftInstance.cpp

@@ -173,11 +173,12 @@ void MinecraftInstance::loadSpecificSettings()
         m_settings->registerOverride(global_settings->getSetting("UseNativeGLFW"), nativeLibraryWorkaroundsOverride);
         m_settings->registerOverride(global_settings->getSetting("CustomGLFWPath"), nativeLibraryWorkaroundsOverride);
 
-        // Peformance related options
+        // Performance related options
         auto performanceOverride = m_settings->registerSetting("OverridePerformance", false);
         m_settings->registerOverride(global_settings->getSetting("EnableFeralGamemode"), performanceOverride);
         m_settings->registerOverride(global_settings->getSetting("EnableMangoHud"), performanceOverride);
         m_settings->registerOverride(global_settings->getSetting("UseDiscreteGpu"), performanceOverride);
+        m_settings->registerOverride(global_settings->getSetting("UseZink"), performanceOverride);
 
         // Miscellaneous
         auto miscellaneousOverride = m_settings->registerSetting("OverrideMiscellaneous", false);
@@ -292,10 +293,10 @@ QString MinecraftInstance::gameRoot() const
     QFileInfo mcDir(FS::PathCombine(instanceRoot(), "minecraft"));
     QFileInfo dotMCDir(FS::PathCombine(instanceRoot(), ".minecraft"));
 
-    if (mcDir.exists() && !dotMCDir.exists())
-        return mcDir.filePath();
-    else
+    if (dotMCDir.exists() && !mcDir.exists())
         return dotMCDir.filePath();
+    else
+        return mcDir.filePath();
 }
 
 QString MinecraftInstance::binRoot() const
@@ -594,9 +595,6 @@ QProcessEnvironment MinecraftInstance::createLaunchEnvironment()
         QStringList preloadList;
         if (auto value = env.value("LD_PRELOAD"); !value.isEmpty())
             preloadList = value.split(QLatin1String(":"));
-        QStringList libPaths;
-        if (auto value = env.value("LD_LIBRARY_PATH"); !value.isEmpty())
-            libPaths = value.split(QLatin1String(":"));
 
         auto mangoHudLibString = MangoHud::getLibraryString();
         if (!mangoHudLibString.isEmpty()) {
@@ -604,18 +602,16 @@ QProcessEnvironment MinecraftInstance::createLaunchEnvironment()
             QString libPath = mangoHudLib.absolutePath();
             auto appendLib = [libPath, &preloadList](QString fileName) {
                 if (QFileInfo(FS::PathCombine(libPath, fileName)).exists())
-                    preloadList << fileName;
+                    preloadList << FS::PathCombine(libPath, fileName);
             };
 
             // dlsym variant is only needed for OpenGL and not included in the vulkan layer
             appendLib("libMangoHud_dlsym.so");
             appendLib("libMangoHud_opengl.so");
             appendLib(mangoHudLib.fileName());
-            libPaths << libPath;
         }
 
         env.insert("LD_PRELOAD", preloadList.join(QLatin1String(":")));
-        env.insert("LD_LIBRARY_PATH", libPaths.join(QLatin1String(":")));
         env.insert("MANGOHUD", "1");
     }
 
@@ -627,6 +623,13 @@ QProcessEnvironment MinecraftInstance::createLaunchEnvironment()
         env.insert("__VK_LAYER_NV_optimus", "NVIDIA_only");
         env.insert("__GLX_VENDOR_LIBRARY_NAME", "nvidia");
     }
+
+    if (settings()->get("UseZink").toBool()) {
+        // taken from https://wiki.archlinux.org/title/OpenGL#OpenGL_over_Vulkan_(Zink)
+        env.insert("__GLX_VENDOR_LIBRARY_NAME", "mesa");
+        env.insert("MESA_LOADER_DRIVER_OVERRIDE", "zink");
+        env.insert("GALLIUM_DRIVER", "zink");
+    }
 #endif
     return env;
 }
@@ -662,8 +665,12 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session, Mine
     }
 
     if (serverToJoin && !serverToJoin->address.isEmpty()) {
-        args_pattern += " --server " + serverToJoin->address;
-        args_pattern += " --port " + QString::number(serverToJoin->port);
+        if (profile->hasTrait("feature:is_quick_play_multiplayer")) {
+            args_pattern += " --quickPlayMultiplayer " + serverToJoin->address + ':' + QString::number(serverToJoin->port);
+        } else {
+            args_pattern += " --server " + serverToJoin->address;
+            args_pattern += " --port " + QString::number(serverToJoin->port);
+        }
     }
 
     QMap<QString, QString> token_mapping;

launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp

@@ -126,7 +126,35 @@ bool XboxAuthorizationStep::processSTSError(QNetworkReply::NetworkError error, Q
                 emit finished(
                     AccountTaskState::STATE_FAILED_SOFT,
                     tr("This Microsoft account is underaged and is not linked to a family.\n\nPlease set up your account according to %1.")
-                        .arg("<a href=\"https://help.minecraft.net/hc/en-us/articles/4403181904525\">help.minecraft.net</a>"));
+                        .arg("<a href=\"https://help.minecraft.net/hc/en-us/articles/4408968616077\">help.minecraft.net</a>"));
+                return true;
+            }
+            // the following codes where copied from: https://github.com/PrismarineJS/prismarine-auth/pull/44
+            case 2148916236: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("This Microsoft account requires proof of age to play. Please login to %1 to provide proof of age.")
+                                  .arg("<a href=\"https://login.live.com/login.srf\">login.live.com</a>"));
+                return true;
+            }
+            case 2148916237:
+                emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("This Microsoft account has reached its limit for playtime. This "
+                                                                      "Microsoft account has been blocked from logging in."));
+                return true;
+            case 2148916227: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("This Microsoft account was banned by Xbox for violating one or more "
+                                                                      "Community Standards for Xbox and is unable to be used."));
+                return true;
+            }
+            case 2148916229: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("This Microsoft account is currently restricted and your guardian has not given you permission to play "
+                                 "online. Login to %1 and have your guardian change your permissions.")
+                                  .arg("<a href=\"https://account.microsoft.com/family/\">account.microsoft.com</a>"));
+                return true;
+            }
+            case 2148916234: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("This Microsoft account has not accepted Xbox's Terms of Service. Please login and accept them."));
                 return true;
             }
             default: {

launcher/minecraft/launch/ExtractNatives.cpp

@@ -79,6 +79,7 @@ void ExtractNatives::executeTask()
     auto settings = minecraftInstance->settings();
 
     auto outputPath = minecraftInstance->getNativePath();
+    FS::ensureFolderPathExists(outputPath);
     auto javaVersion = minecraftInstance->getJavaVersion();
     bool jniHackEnabled = javaVersion.major() >= 8;
     for (const auto& source : toExtract) {

launcher/minecraft/launch/ExtractNatives.h

@@ -16,8 +16,6 @@
 #pragma once
 
 #include <launch/LaunchStep.h>
-#include <memory>
-#include "minecraft/auth/AuthSession.h"
 
 // FIXME: temporary wrapper for existing task.
 class ExtractNatives : public LaunchStep {

launcher/minecraft/launch/LauncherPartLaunch.cpp

@@ -66,32 +66,6 @@ LauncherPartLaunch::LauncherPartLaunch(LaunchTask* parent) : LaunchStep(parent)
     connect(&m_process, &LoggedProcess::stateChanged, this, &LauncherPartLaunch::on_state);
 }
 
-#ifdef Q_OS_WIN
-// returns 8.3 file format from long path
-#include <windows.h>
-QString shortPathName(const QString& file)
-{
-    auto input = file.toStdWString();
-    std::wstring output;
-    long length = GetShortPathNameW(input.c_str(), NULL, 0);
-    // NOTE: this resizing might seem weird...
-    // when GetShortPathNameW fails, it returns length including null character
-    // when it succeeds, it returns length excluding null character
-    // See: https://msdn.microsoft.com/en-us/library/windows/desktop/aa364989(v=vs.85).aspx
-    output.resize(length);
-    GetShortPathNameW(input.c_str(), (LPWSTR)output.c_str(), length);
-    output.resize(length - 1);
-    QString ret = QString::fromStdWString(output);
-    return ret;
-}
-#endif
-
-// if the string survives roundtrip through local 8bit encoding...
-bool fitsInLocal8bit(const QString& string)
-{
-    return string == QString::fromLocal8Bit(string.toLocal8Bit());
-}
-
 void LauncherPartLaunch::executeTask()
 {
     QString jarPath = APPLICATION->getJarPath("NewLaunch.jar");
@@ -136,24 +110,15 @@ void LauncherPartLaunch::executeTask()
 
     auto natPath = minecraftInstance->getNativePath();
 #ifdef Q_OS_WIN
-    if (!fitsInLocal8bit(natPath)) {
-        args << "-Djava.library.path=" + shortPathName(natPath);
-    } else {
-        args << "-Djava.library.path=" + natPath;
-    }
-#else
-    args << "-Djava.library.path=" + natPath;
+    natPath = FS::getPathNameInLocal8bit(natPath);
 #endif
+    args << "-Djava.library.path=" + natPath;
 
     args << "-cp";
 #ifdef Q_OS_WIN
     QStringList processed;
     for (auto& item : classPath) {
-        if (!fitsInLocal8bit(item)) {
-            processed << shortPathName(item);
-        } else {
-            processed << item;
-        }
+        processed << FS::getPathNameInLocal8bit(item);
     }
     args << processed.join(';');
 #else

launcher/minecraft/mod/tasks/GetModDependenciesTask.cpp

@@ -57,9 +57,11 @@ GetModDependenciesTask::GetModDependenciesTask(QObject* parent,
     , m_version(mcVersion(instance))
     , m_loaderType(mcLoaders(instance))
 {
-    for (auto mod : folder->allMods())
+    for (auto mod : folder->allMods()) {
+        m_mods_file_names << mod->fileinfo().fileName();
         if (auto meta = mod->metadata(); meta)
             m_mods.append(meta);
+    }
     prepare();
 }
 
@@ -231,8 +233,13 @@ Task::Ptr GetModDependenciesTask::prepareDependencyTask(const ModPlatform::Depen
             if (dep_.addonId != pDep->version.addonId) {
                 removePack(pDep->version.addonId);
                 addTask(prepareDependencyTask(dep_, provider.name, level));
-            } else
+            } else {
                 addTask(getProjectInfoTask(pDep));
+            }
+        }
+        if (isLocalyInstalled(pDep)) {
+            removePack(pDep->version.addonId);
+            return;
         }
         for (auto dep_ : getDependenciesForVersion(pDep->version, provider.name)) {
             addTask(prepareDependencyTask(dep_, provider.name, level - 1));
@@ -258,9 +265,9 @@ void GetModDependenciesTask::removePack(const QVariant& addonId)
 #endif
 }
 
-QHash<QString, QStringList> GetModDependenciesTask::getRequiredBy()
+auto GetModDependenciesTask::getExtraInfo() -> QHash<QString, PackDependencyExtraInfo>
 {
-    QHash<QString, QStringList> rby;
+    QHash<QString, PackDependencyExtraInfo> rby;
     auto fullList = m_selected + m_pack_dependencies;
     for (auto& mod : fullList) {
         auto addonId = mod->pack->addonId;
@@ -282,7 +289,61 @@ QHash<QString, QStringList> GetModDependenciesTask::getRequiredBy()
                 req.append(smod->pack->name);
             }
         }
-        rby[addonId.toString()] = req;
+        rby[addonId.toString()] = { maybeInstalled(mod), req };
     }
     return rby;
 }
+
+// super lax compare (but not fuzzy)
+// convert to lowercase
+// convert all speratores to whitespace
+// simplify sequence of internal whitespace to a single space
+// efectivly compare two strings ignoring all separators and case
+auto laxCompare = [](QString fsfilename, QString metadataFilename, bool excludeDigits = false) {
+    // allowed character seperators
+    QList<QChar> allowedSeperators = { '-', '+', '.', '_' };
+    if (excludeDigits)
+        allowedSeperators.append({ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' });
+
+    // copy in lowercase
+    auto fsName = fsfilename.toLower();
+    auto metaName = metadataFilename.toLower();
+
+    // replace all potential allowed seperatores with whitespace
+    for (auto sep : allowedSeperators) {
+        fsName = fsName.replace(sep, ' ');
+        metaName = metaName.replace(sep, ' ');
+    }
+
+    // remove extraneous whitespace
+    fsName = fsName.simplified();
+    metaName = metaName.simplified();
+
+    return fsName.compare(metaName) == 0;
+};
+
+bool GetModDependenciesTask::isLocalyInstalled(std::shared_ptr<PackDependency> pDep)
+{
+    return pDep->version.fileName.isEmpty() ||
+
+           std::find_if(m_selected.begin(), m_selected.end(),
+                        [pDep](std::shared_ptr<PackDependency> i) {
+                            return !i->version.fileName.isEmpty() && laxCompare(i->version.fileName, pDep->version.fileName);
+                        }) != m_selected.end() ||  // check the selected versions
+
+           std::find_if(m_mods_file_names.begin(), m_mods_file_names.end(),
+                        [pDep](QString i) { return !i.isEmpty() && laxCompare(i, pDep->version.fileName); }) !=
+               m_mods_file_names.end() ||  // check the existing mods
+
+           std::find_if(m_pack_dependencies.begin(), m_pack_dependencies.end(), [pDep](std::shared_ptr<PackDependency> i) {
+               return pDep->pack->addonId != i->pack->addonId && !i->version.fileName.isEmpty() &&
+                      laxCompare(pDep->version.fileName, i->version.fileName);
+           }) != m_pack_dependencies.end();  // check loaded dependencies
+}
+
+bool GetModDependenciesTask::maybeInstalled(std::shared_ptr<PackDependency> pDep)
+{
+    return std::find_if(m_mods_file_names.begin(), m_mods_file_names.end(), [pDep](QString i) {
+               return !i.isEmpty() && laxCompare(i, pDep->version.fileName, true);
+           }) != m_mods_file_names.end();  // check the existing mods
+}

launcher/minecraft/mod/tasks/GetModDependenciesTask.h

@@ -50,6 +50,11 @@ class GetModDependenciesTask : public SequentialTask {
         }
     };
 
+    struct PackDependencyExtraInfo {
+        bool maybe_installed;
+        QStringList required_by;
+    };
+
     struct Provider {
         ModPlatform::ResourceProvider name;
         std::shared_ptr<ResourceDownload::ModModel> mod;
@@ -62,7 +67,7 @@ class GetModDependenciesTask : public SequentialTask {
                                     QList<std::shared_ptr<PackDependency>> selected);
 
     auto getDependecies() const -> QList<std::shared_ptr<PackDependency>> { return m_pack_dependencies; }
-    QHash<QString, QStringList> getRequiredBy();
+    QHash<QString, PackDependencyExtraInfo> getExtraInfo();
 
    protected slots:
     Task::Ptr prepareDependencyTask(const ModPlatform::Dependency&, ModPlatform::ResourceProvider, int);
@@ -73,10 +78,14 @@ class GetModDependenciesTask : public SequentialTask {
     ModPlatform::Dependency getOverride(const ModPlatform::Dependency&, ModPlatform::ResourceProvider providerName);
     void removePack(const QVariant& addonId);
 
+    bool isLocalyInstalled(std::shared_ptr<PackDependency> pDep);
+    bool maybeInstalled(std::shared_ptr<PackDependency> pDep);
+
    private:
     QList<std::shared_ptr<PackDependency>> m_pack_dependencies;
     QList<std::shared_ptr<Metadata::ModStruct>> m_mods;
     QList<std::shared_ptr<PackDependency>> m_selected;
+    QStringList m_mods_file_names;
     Provider m_flame_provider;
     Provider m_modrinth_provider;
 

launcher/minecraft/mod/tasks/LocalModParseTask.cpp

@@ -469,7 +469,7 @@ bool processZIP(Mod& mod, [[maybe_unused]] ProcessingLevel level)
 
     QuaZipFile file(&zip);
 
-    if (zip.setCurrentFile("META-INF/mods.toml")) {
+    if (zip.setCurrentFile("META-INF/mods.toml") || zip.setCurrentFile("META-INF/neoforge.mods.toml")) {
         if (!file.open(QIODevice::ReadOnly)) {
             zip.close();
             return false;