Merge branch 'develop' of https://github.com/PrismLauncher/PrismLauncher into fix/component-version-resolusion

launcher/minecraft/MinecraftInstance.cpp

@@ -196,8 +196,9 @@ void MinecraftInstance::loadSpecificSettings()
     }
 
     // Join server on launch, this does not have a global override
-    m_settings->registerSetting("JoinServerOnLaunch", false);
+    m_settings->registerSetting({ "JoinServerOnLaunch", "JoinOnLaunch" }, false);
     m_settings->registerSetting("JoinServerOnLaunchAddress", "");
+    m_settings->registerSetting("JoinWorldOnLaunch", "");
 
     // Use account for instance, this does not have a global override
     m_settings->registerSetting("UseAccountForInstance", false);
@@ -523,8 +524,7 @@ QStringList MinecraftInstance::javaArguments()
 
     if (javaVersion.isModular() && shouldApplyOnlineFixes())
         // allow reflective access to java.net - required by the skin fix
-        args << "--add-opens"
-             << "java.base/java.net=ALL-UNNAMED";
+        args << "--add-opens" << "java.base/java.net=ALL-UNNAMED";
 
     return args;
 }
@@ -608,7 +608,7 @@ QProcessEnvironment MinecraftInstance::createLaunchEnvironment()
             // 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());
+            preloadList << mangoHudLibString;
         }
 
         env.insert("LD_PRELOAD", preloadList.join(QLatin1String(":")));
@@ -656,7 +656,7 @@ static QString replaceTokensIn(QString text, QMap<QString, QString> with)
     return result;
 }
 
-QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) const
+QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin) const
 {
     auto profile = m_components->getProfile();
     QString args_pattern = profile->getMinecraftArguments();
@@ -664,12 +664,16 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session, Mine
         args_pattern += " --tweakClass " + tweaker;
     }
 
-    if (serverToJoin && !serverToJoin->address.isEmpty()) {
-        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);
+    if (targetToJoin) {
+        if (!targetToJoin->address.isEmpty()) {
+            if (profile->hasTrait("feature:is_quick_play_multiplayer")) {
+                args_pattern += " --quickPlayMultiplayer " + targetToJoin->address + ':' + QString::number(targetToJoin->port);
+            } else {
+                args_pattern += " --server " + targetToJoin->address;
+                args_pattern += " --port " + QString::number(targetToJoin->port);
+            }
+        } else if (!targetToJoin->world.isEmpty() && profile->hasTrait("feature:is_quick_play_singleplayer")) {
+            args_pattern += " --quickPlaySingleplayer " + targetToJoin->world;
         }
     }
 
@@ -713,7 +717,7 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session, Mine
     return parts;
 }
 
-QString MinecraftInstance::createLaunchScript(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin)
+QString MinecraftInstance::createLaunchScript(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin)
 {
     QString launchScript;
 
@@ -732,9 +736,13 @@ QString MinecraftInstance::createLaunchScript(AuthSessionPtr session, MinecraftS
         launchScript += "appletClass " + appletClass + "\n";
     }
 
-    if (serverToJoin && !serverToJoin->address.isEmpty()) {
-        launchScript += "serverAddress " + serverToJoin->address + "\n";
-        launchScript += "serverPort " + QString::number(serverToJoin->port) + "\n";
+    if (targetToJoin) {
+        if (!targetToJoin->address.isEmpty()) {
+            launchScript += "serverAddress " + targetToJoin->address + "\n";
+            launchScript += "serverPort " + QString::number(targetToJoin->port) + "\n";
+        } else if (!targetToJoin->world.isEmpty()) {
+            launchScript += "worldName " + targetToJoin->world + "\n";
+        }
     }
 
     // generic minecraft params
@@ -787,16 +795,15 @@ QString MinecraftInstance::createLaunchScript(AuthSessionPtr session, MinecraftS
     return launchScript;
 }
 
-QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin)
+QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin)
 {
     QStringList out;
-    out << "Main Class:"
-        << "  " + getMainClass() << "";
-    out << "Native path:"
-        << "  " + getNativePath() << "";
+    out << "Main Class:" << "  " + getMainClass() << "";
+    out << "Native path:" << "  " + getNativePath() << "";
 
     auto profile = m_components->getProfile();
 
+    // traits
     auto alltraits = traits();
     if (alltraits.size()) {
         out << "Traits:";
@@ -806,6 +813,7 @@ QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, Minecr
         out << "";
     }
 
+    // native libraries
     auto settings = this->settings();
     bool nativeOpenAL = settings->get("UseNativeOpenAL").toBool();
     bool nativeGLFW = settings->get("UseNativeGLFW").toBool();
@@ -841,6 +849,7 @@ QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, Minecr
         out << "";
     }
 
+    // mods and core mods
     auto printModList = [&](const QString& label, ModFolderModel& model) {
         if (model.size()) {
             out << QString("%1:").arg(label);
@@ -869,6 +878,7 @@ QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, Minecr
     printModList("Mods", *(loaderModList().get()));
     printModList("Core Mods", *(coreModList().get()));
 
+    // jar mods
     auto& jarMods = profile->getJarMods();
     if (jarMods.size()) {
         out << "Jar Mods:";
@@ -884,11 +894,13 @@ QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, Minecr
         out << "";
     }
 
-    auto params = processMinecraftArgs(nullptr, serverToJoin);
+    // minecraft arguments
+    auto params = processMinecraftArgs(nullptr, targetToJoin);
     out << "Params:";
     out << "  " + params.join(' ');
     out << "";
 
+    // window size
     QString windowParams;
     if (settings->get("LaunchMaximized").toBool()) {
         out << "Window size: max (if available)";
@@ -1034,7 +1046,7 @@ Task::Ptr MinecraftInstance::createUpdateTask(Net::Mode mode)
     return nullptr;
 }
 
-shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin)
+shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin)
 {
     updateRuntimeContext();
     // FIXME: get rid of shared_from_this ...
@@ -1058,16 +1070,23 @@ shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPt
         process->appendStep(makeShared<CreateGameFolders>(pptr));
     }
 
-    if (!serverToJoin && settings()->get("JoinServerOnLaunch").toBool()) {
+    if (!targetToJoin && settings()->get("JoinOnLaunch").toBool()) {
         QString fullAddress = settings()->get("JoinServerOnLaunchAddress").toString();
-        serverToJoin.reset(new MinecraftServerTarget(MinecraftServerTarget::parse(fullAddress)));
+        if (!fullAddress.isEmpty()) {
+            targetToJoin.reset(new MinecraftTarget(MinecraftTarget::parse(fullAddress, false)));
+        } else {
+            QString world = settings()->get("JoinWorldOnLaunch").toString();
+            if (!world.isEmpty()) {
+                targetToJoin.reset(new MinecraftTarget(MinecraftTarget::parse(world, true)));
+            }
+        }
     }
 
-    if (serverToJoin && serverToJoin->port == 25565) {
+    if (targetToJoin && targetToJoin->port == 25565) {
         // Resolve server address to join on launch
         auto step = makeShared<LookupServerAddress>(pptr);
-        step->setLookupAddress(serverToJoin->address);
-        step->setOutputAddressPtr(serverToJoin);
+        step->setLookupAddress(targetToJoin->address);
+        step->setOutputAddressPtr(targetToJoin);
         process->appendStep(step);
     }
 
@@ -1100,7 +1119,7 @@ shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPt
 
     // print some instance info here...
     {
-        process->appendStep(makeShared<PrintInstanceInfo>(pptr, session, serverToJoin));
+        process->appendStep(makeShared<PrintInstanceInfo>(pptr, session, targetToJoin));
     }
 
     // extract native jars if needed
@@ -1123,7 +1142,7 @@ shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPt
         auto step = makeShared<LauncherPartLaunch>(pptr);
         step->setWorkingDirectory(gameRoot());
         step->setAuthSession(session);
-        step->setServerToJoin(serverToJoin);
+        step->setTargetToJoin(targetToJoin);
         process->appendStep(step);
     }
 

launcher/minecraft/MinecraftInstance.h

@@ -39,7 +39,7 @@
 #include <QDir>
 #include <QProcess>
 #include "BaseInstance.h"
-#include "minecraft/launch/MinecraftServerTarget.h"
+#include "minecraft/launch/MinecraftTarget.h"
 #include "minecraft/mod/Mod.h"
 
 class ModFolderModel;
@@ -56,7 +56,7 @@ class MinecraftInstance : public BaseInstance {
     Q_OBJECT
    public:
     MinecraftInstance(SettingsObjectPtr globalSettings, SettingsObjectPtr settings, const QString& rootDir);
-    virtual ~MinecraftInstance() {};
+    virtual ~MinecraftInstance() = default;
     virtual void saveNow() override;
 
     void loadSpecificSettings() override;
@@ -121,11 +121,11 @@ class MinecraftInstance : public BaseInstance {
 
     //////  Launch stuff //////
     Task::Ptr createUpdateTask(Net::Mode mode) override;
-    shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) override;
+    shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr account, MinecraftTarget::Ptr targetToJoin) override;
     QStringList extraArguments() override;
-    QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) override;
+    QStringList verboseDescription(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin) override;
     QList<Mod*> getJarMods() const;
-    QString createLaunchScript(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin);
+    QString createLaunchScript(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin);
     /// get arguments passed to java
     QStringList javaArguments();
     QString getLauncher();
@@ -155,7 +155,7 @@ class MinecraftInstance : public BaseInstance {
     virtual QString getMainClass() const;
 
     // FIXME: remove
-    virtual QStringList processMinecraftArgs(AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) const;
+    virtual QStringList processMinecraftArgs(AuthSessionPtr account, MinecraftTarget::Ptr targetToJoin) const;
 
     virtual JavaVersion getJavaVersion();
 

launcher/minecraft/MinecraftUpdate.cpp

@@ -16,32 +16,22 @@
 #include "MinecraftUpdate.h"
 #include "MinecraftInstance.h"
 
-#include <QDataStream>
-#include <QFile>
-#include <QFileInfo>
-#include <QTextStream>
-
-#include <FileSystem.h>
-#include "BaseInstance.h"
-#include "minecraft/Library.h"
 #include "minecraft/PackProfile.h"
 
+#include "tasks/SequentialTask.h"
 #include "update/AssetUpdateTask.h"
 #include "update/FMLLibrariesTask.h"
 #include "update/FoldersTask.h"
 #include "update/LibrariesTask.h"
 
-#include <meta/Index.h>
-#include <meta/Version.h>
-
-MinecraftUpdate::MinecraftUpdate(MinecraftInstance* inst, QObject* parent) : Task(parent), m_inst(inst) {}
+MinecraftUpdate::MinecraftUpdate(MinecraftInstance* inst, QObject* parent) : SequentialTask(parent), m_inst(inst) {}
 
 void MinecraftUpdate::executeTask()
 {
-    m_tasks.clear();
+    m_queue.clear();
     // create folders
     {
-        m_tasks.append(makeShared<FoldersTask>(m_inst));
+        addTask(makeShared<FoldersTask>(m_inst));
     }
 
     // add metadata update task if necessary
@@ -50,121 +40,24 @@ void MinecraftUpdate::executeTask()
         components->reload(Net::Mode::Online);
         auto task = components->getCurrentTask();
         if (task) {
-            m_tasks.append(task);
+            addTask(task);
         }
     }
 
     // libraries download
     {
-        m_tasks.append(makeShared<LibrariesTask>(m_inst));
+        addTask(makeShared<LibrariesTask>(m_inst));
     }
 
     // FML libraries download and copy into the instance
     {
-        m_tasks.append(makeShared<FMLLibrariesTask>(m_inst));
+        addTask(makeShared<FMLLibrariesTask>(m_inst));
     }
 
     // assets update
     {
-        m_tasks.append(makeShared<AssetUpdateTask>(m_inst));
+        addTask(makeShared<AssetUpdateTask>(m_inst));
     }
 
-    if (!m_preFailure.isEmpty()) {
-        emitFailed(m_preFailure);
-        return;
-    }
-    next();
-}
-
-void MinecraftUpdate::next()
-{
-    if (m_abort) {
-        emitFailed(tr("Aborted by user."));
-        return;
-    }
-    if (m_failed_out_of_order) {
-        emitFailed(m_fail_reason);
-        return;
-    }
-    m_currentTask++;
-    if (m_currentTask > 0) {
-        auto task = m_tasks[m_currentTask - 1];
-        disconnect(task.get(), &Task::succeeded, this, &MinecraftUpdate::subtaskSucceeded);
-        disconnect(task.get(), &Task::failed, this, &MinecraftUpdate::subtaskFailed);
-        disconnect(task.get(), &Task::aborted, this, &Task::abort);
-        disconnect(task.get(), &Task::progress, this, &MinecraftUpdate::progress);
-        disconnect(task.get(), &Task::stepProgress, this, &MinecraftUpdate::propagateStepProgress);
-        disconnect(task.get(), &Task::status, this, &MinecraftUpdate::setStatus);
-        disconnect(task.get(), &Task::details, this, &MinecraftUpdate::setDetails);
-    }
-    if (m_currentTask == m_tasks.size()) {
-        emitSucceeded();
-        return;
-    }
-    auto task = m_tasks[m_currentTask];
-    // if the task is already finished by the time we look at it, skip it
-    if (task->isFinished()) {
-        qCritical() << "MinecraftUpdate: Skipping finished subtask" << m_currentTask << ":" << task.get();
-        next();
-    }
-    connect(task.get(), &Task::succeeded, this, &MinecraftUpdate::subtaskSucceeded);
-    connect(task.get(), &Task::failed, this, &MinecraftUpdate::subtaskFailed);
-    connect(task.get(), &Task::aborted, this, &Task::abort);
-    connect(task.get(), &Task::progress, this, &MinecraftUpdate::progress);
-    connect(task.get(), &Task::stepProgress, this, &MinecraftUpdate::propagateStepProgress);
-    connect(task.get(), &Task::status, this, &MinecraftUpdate::setStatus);
-    connect(task.get(), &Task::details, this, &MinecraftUpdate::setDetails);
-    // if the task is already running, do not start it again
-    if (!task->isRunning()) {
-        task->start();
-    }
-}
-
-void MinecraftUpdate::subtaskSucceeded()
-{
-    if (isFinished()) {
-        qCritical() << "MinecraftUpdate: Subtask" << sender() << "succeeded, but work was already done!";
-        return;
-    }
-    auto senderTask = QObject::sender();
-    auto currentTask = m_tasks[m_currentTask].get();
-    if (senderTask != currentTask) {
-        qDebug() << "MinecraftUpdate: Subtask" << sender() << "succeeded out of order.";
-        return;
-    }
-    next();
-}
-
-void MinecraftUpdate::subtaskFailed(QString error)
-{
-    if (isFinished()) {
-        qCritical() << "MinecraftUpdate: Subtask" << sender() << "failed, but work was already done!";
-        return;
-    }
-    auto senderTask = QObject::sender();
-    auto currentTask = m_tasks[m_currentTask].get();
-    if (senderTask != currentTask) {
-        qDebug() << "MinecraftUpdate: Subtask" << sender() << "failed out of order.";
-        m_failed_out_of_order = true;
-        m_fail_reason = error;
-        return;
-    }
-    emitFailed(error);
-}
-
-bool MinecraftUpdate::abort()
-{
-    if (!m_abort) {
-        m_abort = true;
-        auto task = m_tasks[m_currentTask];
-        if (task->canAbort()) {
-            return task->abort();
-        }
-    }
-    return true;
-}
-
-bool MinecraftUpdate::canAbort() const
-{
-    return true;
+    SequentialTask::executeTask();
 }

launcher/minecraft/MinecraftUpdate.h

@@ -15,43 +15,19 @@
 
 #pragma once
 
-#include <QList>
-#include <QObject>
-#include <QUrl>
+#include "tasks/SequentialTask.h"
 
-#include <quazip/quazip.h>
-#include "minecraft/VersionFilterData.h"
-#include "net/NetJob.h"
-#include "tasks/Task.h"
-
-class MinecraftVersion;
 class MinecraftInstance;
 
-// FIXME: This looks very similar to a SequentialTask. Maybe we can reduce code duplications? :^)
-
-class MinecraftUpdate : public Task {
+// this needs to be a task because components->reload does stuff that may block
+class MinecraftUpdate : public SequentialTask {
     Q_OBJECT
    public:
     explicit MinecraftUpdate(MinecraftInstance* inst, QObject* parent = 0);
-    virtual ~MinecraftUpdate() {};
+    virtual ~MinecraftUpdate() = default;
 
     void executeTask() override;
-    bool canAbort() const override;
-
-   private slots:
-    bool abort() override;
-    void subtaskSucceeded();
-    void subtaskFailed(QString error);
-
-   private:
-    void next();
 
    private:
     MinecraftInstance* m_inst = nullptr;
-    QList<Task::Ptr> m_tasks;
-    QString m_preFailure;
-    int m_currentTask = -1;
-    bool m_abort = false;
-    bool m_failed_out_of_order = false;
-    QString m_fail_reason;
 };

launcher/minecraft/auth/steps/EntitlementsStep.cpp

@@ -11,7 +11,7 @@
 #include "minecraft/auth/Parsers.h"
 #include "net/Download.h"
 #include "net/NetJob.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 #include "tasks/Task.h"
 
 EntitlementsStep::EntitlementsStep(AccountData* data) : AuthStep(data) {}
@@ -33,7 +33,7 @@ void EntitlementsStep::perform()
 
     m_response.reset(new QByteArray());
     m_request = Net::Download::makeByteArray(url, m_response);
-    m_request->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+    m_request->addHeaderProxy(new Net::RawHeaderProxy(headers));
 
     m_task.reset(new NetJob("EntitlementsStep", APPLICATION->network()));
     m_task->setAskRetry(false);

launcher/minecraft/auth/steps/LauncherLoginStep.cpp

@@ -7,7 +7,7 @@
 #include "Logging.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 #include "net/Upload.h"
 
 LauncherLoginStep::LauncherLoginStep(AccountData* data) : AuthStep(data) {}
@@ -38,7 +38,7 @@ void LauncherLoginStep::perform()
 
     m_response.reset(new QByteArray());
     m_request = Net::Upload::makeByteArray(url, m_response, requestBody.toUtf8());
-    m_request->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+    m_request->addHeaderProxy(new Net::RawHeaderProxy(headers));
 
     m_task.reset(new NetJob("LauncherLoginStep", APPLICATION->network()));
     m_task->setAskRetry(false);

launcher/minecraft/auth/steps/MSADeviceCodeStep.cpp

@@ -40,7 +40,7 @@
 
 #include "Application.h"
 #include "Json.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 
 // https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-device-code
 MSADeviceCodeStep::MSADeviceCodeStep(AccountData* data) : AuthStep(data)
@@ -68,7 +68,7 @@ void MSADeviceCodeStep::perform()
     };
     m_response.reset(new QByteArray());
     m_request = Net::Upload::makeByteArray(url, m_response, payload);
-    m_request->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+    m_request->addHeaderProxy(new Net::RawHeaderProxy(headers));
 
     m_task.reset(new NetJob("MSADeviceCodeStep", APPLICATION->network()));
     m_task->setAskRetry(false);
@@ -183,7 +183,7 @@ void MSADeviceCodeStep::authenticateUser()
     };
     m_response.reset(new QByteArray());
     m_request = Net::Upload::makeByteArray(url, m_response, payload);
-    m_request->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+    m_request->addHeaderProxy(new Net::RawHeaderProxy(headers));
 
     connect(m_request.get(), &Task::finished, this, &MSADeviceCodeStep::authenticationFinished);
 

launcher/minecraft/auth/steps/MinecraftProfileStep.cpp

@@ -5,7 +5,7 @@
 #include "Application.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 
 MinecraftProfileStep::MinecraftProfileStep(AccountData* data) : AuthStep(data) {}
 
@@ -23,7 +23,7 @@ void MinecraftProfileStep::perform()
 
     m_response.reset(new QByteArray());
     m_request = Net::Download::makeByteArray(url, m_response);
-    m_request->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+    m_request->addHeaderProxy(new Net::RawHeaderProxy(headers));
 
     m_task.reset(new NetJob("MinecraftProfileStep", APPLICATION->network()));
     m_task->setAskRetry(false);

launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp

@@ -8,7 +8,7 @@
 #include "Logging.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 #include "net/Upload.h"
 
 XboxAuthorizationStep::XboxAuthorizationStep(AccountData* data, Token* token, QString relyingParty, QString authorizationKind)
@@ -43,7 +43,7 @@ void XboxAuthorizationStep::perform()
     };
     m_response.reset(new QByteArray());
     m_request = Net::Upload::makeByteArray(url, m_response, xbox_auth_data.toUtf8());
-    m_request->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+    m_request->addHeaderProxy(new Net::RawHeaderProxy(headers));
 
     m_task.reset(new NetJob("XboxAuthorizationStep", APPLICATION->network()));
     m_task->setAskRetry(false);

launcher/minecraft/auth/steps/XboxProfileStep.cpp

@@ -6,7 +6,7 @@
 #include "Application.h"
 #include "Logging.h"
 #include "net/NetUtils.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 
 XboxProfileStep::XboxProfileStep(AccountData* data) : AuthStep(data) {}
 
@@ -35,7 +35,7 @@ void XboxProfileStep::perform()
 
     m_response.reset(new QByteArray());
     m_request = Net::Download::makeByteArray(url, m_response);
-    m_request->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+    m_request->addHeaderProxy(new Net::RawHeaderProxy(headers));
 
     m_task.reset(new NetJob("XboxProfileStep", APPLICATION->network()));
     m_task->setAskRetry(false);

launcher/minecraft/auth/steps/XboxUserStep.cpp

@@ -5,7 +5,7 @@
 #include "Application.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 
 XboxUserStep::XboxUserStep(AccountData* data) : AuthStep(data) {}
 
@@ -39,7 +39,7 @@ void XboxUserStep::perform()
     };
     m_response.reset(new QByteArray());
     m_request = Net::Upload::makeByteArray(url, m_response, xbox_auth_data.toUtf8());
-    m_request->addHeaderProxy(new Net::StaticHeaderProxy(headers));
+    m_request->addHeaderProxy(new Net::RawHeaderProxy(headers));
 
     m_task.reset(new NetJob("XboxUserStep", APPLICATION->network()));
     m_task->setAskRetry(false);

launcher/minecraft/launch/LauncherPartLaunch.cpp

@@ -90,7 +90,7 @@ void LauncherPartLaunch::executeTask()
         }
     }
 
-    m_launchScript = minecraftInstance->createLaunchScript(m_session, m_serverToJoin);
+    m_launchScript = minecraftInstance->createLaunchScript(m_session, m_targetToJoin);
     QStringList args = minecraftInstance->javaArguments();
     QString allArgs = args.join(", ");
     emit logLine("Java Arguments:\n[" + m_parent->censorPrivateInfo(allArgs) + "]\n\n", MessageLevel::Launcher);

launcher/minecraft/launch/LauncherPartLaunch.h

@@ -19,13 +19,13 @@
 #include <launch/LaunchStep.h>
 #include <minecraft/auth/AuthSession.h>
 
-#include "MinecraftServerTarget.h"
+#include "MinecraftTarget.h"
 
 class LauncherPartLaunch : public LaunchStep {
     Q_OBJECT
    public:
     explicit LauncherPartLaunch(LaunchTask* parent);
-    virtual ~LauncherPartLaunch() {};
+    virtual ~LauncherPartLaunch() = default;
 
     virtual void executeTask();
     virtual bool abort();
@@ -34,7 +34,7 @@ class LauncherPartLaunch : public LaunchStep {
     void setWorkingDirectory(const QString& wd);
     void setAuthSession(AuthSessionPtr session) { m_session = session; }
 
-    void setServerToJoin(MinecraftServerTargetPtr serverToJoin) { m_serverToJoin = std::move(serverToJoin); }
+    void setTargetToJoin(MinecraftTarget::Ptr targetToJoin) { m_targetToJoin = std::move(targetToJoin); }
 
    private slots:
     void on_state(LoggedProcess::State state);
@@ -44,7 +44,7 @@ class LauncherPartLaunch : public LaunchStep {
     QString m_command;
     AuthSessionPtr m_session;
     QString m_launchScript;
-    MinecraftServerTargetPtr m_serverToJoin;
+    MinecraftTarget::Ptr m_targetToJoin;
 
     bool mayProceed = false;
 };

launcher/minecraft/launch/MinecraftTarget.cpp

@@ -13,13 +13,18 @@
  * limitations under the License.
  */
 
-#include "MinecraftServerTarget.h"
+#include "MinecraftTarget.h"
 
 #include <QStringList>
 
 // FIXME: the way this is written, it can't ever do any sort of validation and can accept total junk
-MinecraftServerTarget MinecraftServerTarget::parse(const QString& fullAddress)
+MinecraftTarget MinecraftTarget::parse(const QString& fullAddress, bool useWorld)
 {
+    if (useWorld) {
+        MinecraftTarget target;
+        target.world = fullAddress;
+        return target;
+    }
     QStringList split = fullAddress.split(":");
 
     // The logic below replicates the exact logic minecraft uses for parsing server addresses.
@@ -56,5 +61,5 @@ MinecraftServerTarget MinecraftServerTarget::parse(const QString& fullAddress)
         }
     }
 
-    return MinecraftServerTarget{ realAddress, realPort };
+    return MinecraftTarget{ realAddress, realPort };
 }

launcher/minecraft/launch/MinecraftTarget.h

@@ -19,11 +19,11 @@
 
 #include <QString>
 
-struct MinecraftServerTarget {
+struct MinecraftTarget {
     QString address;
     quint16 port;
 
-    static MinecraftServerTarget parse(const QString& fullAddress);
+    QString world;
+    static MinecraftTarget parse(const QString& fullAddress, bool useWorld);
+    using Ptr = std::shared_ptr<MinecraftTarget>;
 };
-
-using MinecraftServerTargetPtr = std::shared_ptr<MinecraftServerTarget>;

launcher/minecraft/launch/PrintInstanceInfo.cpp

@@ -129,6 +129,6 @@ void PrintInstanceInfo::executeTask()
 #endif
 
     logLines(log, MessageLevel::Launcher);
-    logLines(instance->verboseDescription(m_session, m_serverToJoin), MessageLevel::Launcher);
+    logLines(instance->verboseDescription(m_session, m_targetToJoin), MessageLevel::Launcher);
     emitSucceeded();
 }

launcher/minecraft/launch/PrintInstanceInfo.h

@@ -16,22 +16,21 @@
 #pragma once
 
 #include <launch/LaunchStep.h>
-#include <memory>
 #include "minecraft/auth/AuthSession.h"
-#include "minecraft/launch/MinecraftServerTarget.h"
+#include "minecraft/launch/MinecraftTarget.h"
 
 // FIXME: temporary wrapper for existing task.
 class PrintInstanceInfo : public LaunchStep {
     Q_OBJECT
    public:
-    explicit PrintInstanceInfo(LaunchTask* parent, AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin)
-        : LaunchStep(parent), m_session(session), m_serverToJoin(serverToJoin) {};
-    virtual ~PrintInstanceInfo() {};
+    explicit PrintInstanceInfo(LaunchTask* parent, AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin)
+        : LaunchStep(parent), m_session(session), m_targetToJoin(targetToJoin) {};
+    virtual ~PrintInstanceInfo() = default;
 
     virtual void executeTask();
     virtual bool canAbort() const { return false; }
 
    private:
     AuthSessionPtr m_session;
-    MinecraftServerTargetPtr m_serverToJoin;
+    MinecraftTarget::Ptr m_targetToJoin;
 };

launcher/minecraft/mod/ModFolderModel.cpp

@@ -251,7 +251,7 @@ Task* ModFolderModel::createParseTask(Resource& resource)
 bool ModFolderModel::uninstallMod(const QString& filename, bool preserve_metadata)
 {
     for (auto mod : allMods()) {
-        if (mod->fileinfo().fileName() == filename) {
+        if (mod->getOriginalFileName() == filename) {
             auto index_dir = indexDir();
             mod->destroy(index_dir, preserve_metadata, false);
 

launcher/minecraft/mod/Resource.cpp

@@ -197,3 +197,11 @@ bool Resource::isMoreThanOneHardLink() const
 {
     return FS::hardLinkCount(m_file_info.absoluteFilePath()) > 1;
 }
+
+auto Resource::getOriginalFileName() const -> QString
+{
+    auto fileName = m_file_info.fileName();
+    if (!m_enabled)
+        fileName.chop(9);
+    return fileName;
+}

launcher/minecraft/mod/Resource.h

@@ -80,6 +80,7 @@ class Resource : public QObject {
     [[nodiscard]] auto internal_id() const -> QString { return m_internal_id; }
     [[nodiscard]] auto type() const -> ResourceType { return m_type; }
     [[nodiscard]] bool enabled() const { return m_enabled; }
+    [[nodiscard]] auto getOriginalFileName() const -> QString;
     [[nodiscard]] QString sizeStr() const { return m_size_str; }
     [[nodiscard]] qint64 sizeInfo() const { return m_size_info; }
 

launcher/minecraft/skins/CapeChange.cpp

@@ -39,9 +39,9 @@
 #include <memory>
 
 #include "net/ByteArraySink.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 
-CapeChange::CapeChange(QString token, QString cape) : NetRequest(), m_capeId(cape), m_token(token)
+CapeChange::CapeChange(QString cape) : NetRequest(), m_capeId(cape)
 {
     logCat = taskMCSkinsLogC;
 }
@@ -57,18 +57,14 @@ QNetworkReply* CapeChange::getReply(QNetworkRequest& request)
     }
 }
 
-void CapeChange::init()
-{
-    addHeaderProxy(new Net::StaticHeaderProxy(QList<Net::HeaderPair>{
-        { "Authorization", QString("Bearer %1").arg(m_token).toLocal8Bit() },
-    }));
-}
-
 CapeChange::Ptr CapeChange::make(QString token, QString capeId)
 {
-    auto up = makeShared<CapeChange>(token, capeId);
+    auto up = makeShared<CapeChange>(capeId);
     up->m_url = QUrl("https://api.minecraftservices.com/minecraft/profile/capes/active");
     up->setObjectName(QString("BYTES:") + up->m_url.toString());
     up->m_sink.reset(new Net::ByteArraySink(std::make_shared<QByteArray>()));
+    up->addHeaderProxy(new Net::RawHeaderProxy(QList<Net::HeaderPair>{
+        { "Authorization", QString("Bearer %1").arg(token).toLocal8Bit() },
+    }));
     return up;
 }

launcher/minecraft/skins/CapeChange.h

@@ -24,16 +24,14 @@ class CapeChange : public Net::NetRequest {
     Q_OBJECT
    public:
     using Ptr = shared_qobject_ptr<CapeChange>;
-    CapeChange(QString token, QString capeId);
+    CapeChange(QString capeId);
     virtual ~CapeChange() = default;
 
     static CapeChange::Ptr make(QString token, QString capeId);
-    void init() override;
 
    protected:
     virtual QNetworkReply* getReply(QNetworkRequest&) override;
 
    private:
     QString m_capeId;
-    QString m_token;
 };

launcher/minecraft/skins/SkinDelete.cpp

@@ -37,9 +37,9 @@
 #include "SkinDelete.h"
 
 #include "net/ByteArraySink.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 
-SkinDelete::SkinDelete(QString token) : NetRequest(), m_token(token)
+SkinDelete::SkinDelete() : NetRequest()
 {
     logCat = taskMCSkinsLogC;
 }
@@ -50,17 +50,13 @@ QNetworkReply* SkinDelete::getReply(QNetworkRequest& request)
     return m_network->deleteResource(request);
 }
 
-void SkinDelete::init()
-{
-    addHeaderProxy(new Net::StaticHeaderProxy(QList<Net::HeaderPair>{
-        { "Authorization", QString("Bearer %1").arg(m_token).toLocal8Bit() },
-    }));
-}
-
 SkinDelete::Ptr SkinDelete::make(QString token)
 {
-    auto up = makeShared<SkinDelete>(token);
+    auto up = makeShared<SkinDelete>();
     up->m_url = QUrl("https://api.minecraftservices.com/minecraft/profile/skins/active");
     up->m_sink.reset(new Net::ByteArraySink(std::make_shared<QByteArray>()));
+    up->addHeaderProxy(new Net::RawHeaderProxy(QList<Net::HeaderPair>{
+        { "Authorization", QString("Bearer %1").arg(token).toLocal8Bit() },
+    }));
     return up;
 }

launcher/minecraft/skins/SkinDelete.h

@@ -24,15 +24,11 @@ class SkinDelete : public Net::NetRequest {
     Q_OBJECT
    public:
     using Ptr = shared_qobject_ptr<SkinDelete>;
-    SkinDelete(QString token);
+    SkinDelete();
     virtual ~SkinDelete() = default;
 
     static SkinDelete::Ptr make(QString token);
-    void init() override;
 
    protected:
     virtual QNetworkReply* getReply(QNetworkRequest&) override;
-
-   private:
-    QString m_token;
 };

launcher/minecraft/skins/SkinUpload.cpp

@@ -40,9 +40,9 @@
 
 #include "FileSystem.h"
 #include "net/ByteArraySink.h"
-#include "net/StaticHeaderProxy.h"
+#include "net/RawHeaderProxy.h"
 
-SkinUpload::SkinUpload(QString token, QString path, QString variant) : NetRequest(), m_token(token), m_path(path), m_variant(variant)
+SkinUpload::SkinUpload(QString path, QString variant) : NetRequest(), m_path(path), m_variant(variant)
 {
     logCat = taskMCSkinsLogC;
 }
@@ -67,18 +67,14 @@ QNetworkReply* SkinUpload::getReply(QNetworkRequest& request)
     return m_network->post(request, multiPart);
 }
 
-void SkinUpload::init()
-{
-    addHeaderProxy(new Net::StaticHeaderProxy(QList<Net::HeaderPair>{
-        { "Authorization", QString("Bearer %1").arg(m_token).toLocal8Bit() },
-    }));
-}
-
 SkinUpload::Ptr SkinUpload::make(QString token, QString path, QString variant)
 {
-    auto up = makeShared<SkinUpload>(token, path, variant);
+    auto up = makeShared<SkinUpload>(path, variant);
     up->m_url = QUrl("https://api.minecraftservices.com/minecraft/profile/skins");
     up->setObjectName(QString("BYTES:") + up->m_url.toString());
     up->m_sink.reset(new Net::ByteArraySink(std::make_shared<QByteArray>()));
+    up->addHeaderProxy(new Net::RawHeaderProxy(QList<Net::HeaderPair>{
+        { "Authorization", QString("Bearer %1").arg(token).toLocal8Bit() },
+    }));
     return up;
 }

launcher/minecraft/skins/SkinUpload.h

@@ -26,17 +26,15 @@ class SkinUpload : public Net::NetRequest {
     using Ptr = shared_qobject_ptr<SkinUpload>;
 
     // Note this class takes ownership of the file.
-    SkinUpload(QString token, QString path, QString variant);
+    SkinUpload(QString path, QString variant);
     virtual ~SkinUpload() = default;
 
     static SkinUpload::Ptr make(QString token, QString path, QString variant);
-    void init() override;
 
    protected:
     virtual QNetworkReply* getReply(QNetworkRequest&) override;
 
    private:
-    QString m_token;
     QString m_path;
     QString m_variant;
 };