NOISSUE Flatten gui and logic libraries into MultiMC

launcher/minecraft/launch/ClaimAccount.cpp

@@ -0,0 +1,24 @@
+#include "ClaimAccount.h"
+#include <launch/LaunchTask.h>
+
+ClaimAccount::ClaimAccount(LaunchTask* parent, AuthSessionPtr session): LaunchStep(parent)
+{
+    if(session->status == AuthSession::Status::PlayableOnline)
+    {
+        m_account = session->m_accountPtr;
+    }
+}
+
+void ClaimAccount::executeTask()
+{
+    if(m_account)
+    {
+        lock.reset(new UseLock(m_account));
+        emitSucceeded();
+    }
+}
+
+void ClaimAccount::finalize()
+{
+    lock.reset();
+}

launcher/minecraft/launch/ClaimAccount.h

@@ -0,0 +1,37 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <minecraft/auth/MojangAccount.h>
+
+class ClaimAccount: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit ClaimAccount(LaunchTask *parent, AuthSessionPtr session);
+    virtual ~ClaimAccount() {};
+
+    void executeTask() override;
+    void finalize() override;
+    bool canAbort() const override
+    {
+        return false;
+    }
+private:
+    std::unique_ptr<UseLock> lock;
+    MojangAccountPtr m_account;
+};

launcher/minecraft/launch/CreateGameFolders.cpp

@@ -0,0 +1,28 @@
+#include "CreateGameFolders.h"
+#include "minecraft/MinecraftInstance.h"
+#include "launch/LaunchTask.h"
+#include "FileSystem.h"
+
+CreateGameFolders::CreateGameFolders(LaunchTask* parent): LaunchStep(parent)
+{
+}
+
+void CreateGameFolders::executeTask()
+{
+    auto instance = m_parent->instance();
+    std::shared_ptr<MinecraftInstance> minecraftInstance = std::dynamic_pointer_cast<MinecraftInstance>(instance);
+
+    if(!FS::ensureFolderPathExists(minecraftInstance->gameRoot()))
+    {
+        emit logLine("Couldn't create the main game folder", MessageLevel::Error);
+        emitFailed(tr("Couldn't create the main game folder"));
+        return;
+    }
+
+    // HACK: this is a workaround for MCL-3732 - 'server-resource-packs' folder is created.
+    if(!FS::ensureFolderPathExists(FS::PathCombine(minecraftInstance->gameRoot(), "server-resource-packs")))
+    {
+        emit logLine("Couldn't create the 'server-resource-packs' folder", MessageLevel::Error);
+    }
+    emitSucceeded();
+}

launcher/minecraft/launch/CreateGameFolders.h

@@ -0,0 +1,37 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <LoggedProcess.h>
+#include <minecraft/auth/AuthSession.h>
+
+// Create the main .minecraft for the instance and any other necessary folders
+class CreateGameFolders: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit CreateGameFolders(LaunchTask *parent);
+    virtual ~CreateGameFolders() {};
+
+    virtual void executeTask();
+    virtual bool canAbort() const
+    {
+        return false;
+    }
+};
+
+

launcher/minecraft/launch/DirectJavaLaunch.cpp

@@ -0,0 +1,148 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "DirectJavaLaunch.h"
+#include <launch/LaunchTask.h>
+#include <minecraft/MinecraftInstance.h>
+#include <FileSystem.h>
+#include <Commandline.h>
+#include <QStandardPaths>
+
+DirectJavaLaunch::DirectJavaLaunch(LaunchTask *parent) : LaunchStep(parent)
+{
+    connect(&m_process, &LoggedProcess::log, this, &DirectJavaLaunch::logLines);
+    connect(&m_process, &LoggedProcess::stateChanged, this, &DirectJavaLaunch::on_state);
+}
+
+void DirectJavaLaunch::executeTask()
+{
+    auto instance = m_parent->instance();
+    std::shared_ptr<MinecraftInstance> minecraftInstance = std::dynamic_pointer_cast<MinecraftInstance>(instance);
+    QStringList args = minecraftInstance->javaArguments();
+
+    args.append("-Djava.library.path=" + minecraftInstance->getNativePath());
+
+    auto classPathEntries = minecraftInstance->getClassPath();
+    args.append("-cp");
+    QString classpath;
+#ifdef Q_OS_WIN32
+    classpath = classPathEntries.join(';');
+#else
+    classpath = classPathEntries.join(':');
+#endif
+    args.append(classpath);
+    args.append(minecraftInstance->getMainClass());
+
+    QString allArgs = args.join(", ");
+    emit logLine("Java Arguments:\n[" + m_parent->censorPrivateInfo(allArgs) + "]\n\n", MessageLevel::MultiMC);
+
+    auto javaPath = FS::ResolveExecutable(instance->settings()->get("JavaPath").toString());
+
+    m_process.setProcessEnvironment(instance->createEnvironment());
+
+    // make detachable - this will keep the process running even if the object is destroyed
+    m_process.setDetachable(true);
+
+    auto mcArgs = minecraftInstance->processMinecraftArgs(m_session, m_serverToJoin);
+    args.append(mcArgs);
+
+    QString wrapperCommandStr = instance->getWrapperCommand().trimmed();
+    if(!wrapperCommandStr.isEmpty())
+    {
+        auto wrapperArgs = Commandline::splitArgs(wrapperCommandStr);
+        auto wrapperCommand = wrapperArgs.takeFirst();
+        auto realWrapperCommand = QStandardPaths::findExecutable(wrapperCommand);
+        if (realWrapperCommand.isEmpty())
+        {
+            const char *reason = QT_TR_NOOP("The wrapper command \"%1\" couldn't be found.");
+            emit logLine(QString(reason).arg(wrapperCommand), MessageLevel::Fatal);
+            emitFailed(tr(reason).arg(wrapperCommand));
+            return;
+        }
+        emit logLine("Wrapper command is:\n" + wrapperCommandStr + "\n\n", MessageLevel::MultiMC);
+        args.prepend(javaPath);
+        m_process.start(wrapperCommand, wrapperArgs + args);
+    }
+    else
+    {
+        m_process.start(javaPath, args);
+    }
+}
+
+void DirectJavaLaunch::on_state(LoggedProcess::State state)
+{
+    switch(state)
+    {
+        case LoggedProcess::FailedToStart:
+        {
+            //: Error message displayed if instance can't start
+            const char *reason = QT_TR_NOOP("Could not launch minecraft!");
+            emit logLine(reason, MessageLevel::Fatal);
+            emitFailed(tr(reason));
+            return;
+        }
+        case LoggedProcess::Aborted:
+        case LoggedProcess::Crashed:
+        {
+            m_parent->setPid(-1);
+            emitFailed(tr("Game crashed."));
+            return;
+        }
+        case LoggedProcess::Finished:
+        {
+            m_parent->setPid(-1);
+            // if the exit code wasn't 0, report this as a crash
+            auto exitCode = m_process.exitCode();
+            if(exitCode != 0)
+            {
+                emitFailed(tr("Game crashed."));
+                return;
+            }
+            //FIXME: make this work again
+            // m_postlaunchprocess.processEnvironment().insert("INST_EXITCODE", QString(exitCode));
+            // run post-exit
+            emitSucceeded();
+            break;
+        }
+        case LoggedProcess::Running:
+            emit logLine(QString("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::MultiMC);
+            m_parent->setPid(m_process.processId());
+            m_parent->instance()->setLastLaunch();
+            break;
+        default:
+            break;
+    }
+}
+
+void DirectJavaLaunch::setWorkingDirectory(const QString &wd)
+{
+    m_process.setWorkingDirectory(wd);
+}
+
+void DirectJavaLaunch::proceed()
+{
+    // nil
+}
+
+bool DirectJavaLaunch::abort()
+{
+    auto state = m_process.state();
+    if (state == LoggedProcess::Running || state == LoggedProcess::Starting)
+    {
+        m_process.kill();
+    }
+    return true;
+}
+

launcher/minecraft/launch/DirectJavaLaunch.h

@@ -0,0 +1,58 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <LoggedProcess.h>
+#include <minecraft/auth/AuthSession.h>
+
+#include "MinecraftServerTarget.h"
+
+class DirectJavaLaunch: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit DirectJavaLaunch(LaunchTask *parent);
+    virtual ~DirectJavaLaunch() {};
+
+    virtual void executeTask();
+    virtual bool abort();
+    virtual void proceed();
+    virtual bool canAbort() const
+    {
+        return true;
+    }
+    void setWorkingDirectory(const QString &wd);
+    void setAuthSession(AuthSessionPtr session)
+    {
+        m_session = session;
+    }
+
+    void setServerToJoin(MinecraftServerTargetPtr serverToJoin)
+    {
+        m_serverToJoin = std::move(serverToJoin);
+    }
+
+private slots:
+    void on_state(LoggedProcess::State state);
+
+private:
+    LoggedProcess m_process;
+    QString m_command;
+    AuthSessionPtr m_session;
+    MinecraftServerTargetPtr m_serverToJoin;
+};
+

launcher/minecraft/launch/ExtractNatives.cpp

@@ -0,0 +1,111 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ExtractNatives.h"
+#include <minecraft/MinecraftInstance.h>
+#include <launch/LaunchTask.h>
+
+#include <quazip.h>
+#include <quazipdir.h>
+#include "MMCZip.h"
+#include "FileSystem.h"
+#include <QDir>
+
+static QString replaceSuffix (QString target, const QString &suffix, const QString &replacement)
+{
+    if (!target.endsWith(suffix))
+    {
+        return target;
+    }
+    target.resize(target.length() - suffix.length());
+    return target + replacement;
+}
+
+static bool unzipNatives(QString source, QString targetFolder, bool applyJnilibHack, bool nativeOpenAL, bool nativeGLFW)
+{
+    QuaZip zip(source);
+    if(!zip.open(QuaZip::mdUnzip))
+    {
+        return false;
+    }
+    QDir directory(targetFolder);
+    if (!zip.goToFirstFile())
+    {
+        return false;
+    }
+    do
+    {
+        QString name = zip.getCurrentFileName();
+        auto lowercase = name.toLower();
+        if (nativeGLFW && name.contains("glfw")) {
+            continue;
+        }
+        if (nativeOpenAL && name.contains("openal")) {
+            continue;
+        }
+        if(applyJnilibHack)
+        {
+            name = replaceSuffix(name, ".jnilib", ".dylib");
+        }
+        QString absFilePath = directory.absoluteFilePath(name);
+        if (!JlCompress::extractFile(&zip, "", absFilePath))
+        {
+            return false;
+        }
+    } while (zip.goToNextFile());
+    zip.close();
+    if(zip.getZipError()!=0)
+    {
+        return false;
+    }
+    return true;
+}
+
+void ExtractNatives::executeTask()
+{
+    auto instance = m_parent->instance();
+    std::shared_ptr<MinecraftInstance> minecraftInstance = std::dynamic_pointer_cast<MinecraftInstance>(instance);
+    auto toExtract = minecraftInstance->getNativeJars();
+    if(toExtract.isEmpty())
+    {
+        emitSucceeded();
+        return;
+    }
+    auto settings = minecraftInstance->settings();
+    bool nativeOpenAL = settings->get("UseNativeOpenAL").toBool();
+    bool nativeGLFW = settings->get("UseNativeGLFW").toBool();
+
+    auto outputPath  = minecraftInstance->getNativePath();
+    auto javaVersion = minecraftInstance->getJavaVersion();
+    bool jniHackEnabled = javaVersion.major() >= 8;
+    for(const auto &source: toExtract)
+    {
+        if(!unzipNatives(source, outputPath, jniHackEnabled, nativeOpenAL, nativeGLFW))
+        {
+            const char *reason = QT_TR_NOOP("Couldn't extract native jar '%1' to destination '%2'");
+            emit logLine(QString(reason).arg(source, outputPath), MessageLevel::Fatal);
+            emitFailed(tr(reason).arg(source, outputPath));
+        }
+    }
+    emitSucceeded();
+}
+
+void ExtractNatives::finalize()
+{
+    auto instance = m_parent->instance();
+    QString target_dir = FS::PathCombine(instance->instanceRoot(), "natives/");
+    QDir dir(target_dir);
+    dir.removeRecursively();
+}

launcher/minecraft/launch/ExtractNatives.h

@@ -0,0 +1,38 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <memory>
+#include "minecraft/auth/AuthSession.h"
+
+// FIXME: temporary wrapper for existing task.
+class ExtractNatives: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit ExtractNatives(LaunchTask *parent) : LaunchStep(parent){};
+    virtual ~ExtractNatives(){};
+
+    void executeTask() override;
+    bool canAbort() const override
+    {
+        return false;
+    }
+    void finalize() override;
+};
+
+

launcher/minecraft/launch/LauncherPartLaunch.cpp

@@ -0,0 +1,218 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LauncherPartLaunch.h"
+#include <QCoreApplication>
+#include <launch/LaunchTask.h>
+#include <minecraft/MinecraftInstance.h>
+#include <FileSystem.h>
+#include <Commandline.h>
+#include <QStandardPaths>
+#include "Env.h"
+
+LauncherPartLaunch::LauncherPartLaunch(LaunchTask *parent) : LaunchStep(parent)
+{
+    connect(&m_process, &LoggedProcess::log, this, &LauncherPartLaunch::logLines);
+    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()
+{
+    auto instance = m_parent->instance();
+    std::shared_ptr<MinecraftInstance> minecraftInstance = std::dynamic_pointer_cast<MinecraftInstance>(instance);
+
+    m_launchScript = minecraftInstance->createLaunchScript(m_session, m_serverToJoin);
+    QStringList args = minecraftInstance->javaArguments();
+    QString allArgs = args.join(", ");
+    emit logLine("Java Arguments:\n[" + m_parent->censorPrivateInfo(allArgs) + "]\n\n", MessageLevel::MultiMC);
+
+    auto javaPath = FS::ResolveExecutable(instance->settings()->get("JavaPath").toString());
+
+    m_process.setProcessEnvironment(instance->createEnvironment());
+
+    // make detachable - this will keep the process running even if the object is destroyed
+    m_process.setDetachable(true);
+
+    auto classPath = minecraftInstance->getClassPath();
+    classPath.prepend(FS::PathCombine(ENV.getJarsPath(), "NewLaunch.jar"));
+
+    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;
+#endif
+
+    args << "-cp";
+#ifdef Q_OS_WIN
+    QStringList processed;
+    for(auto & item: classPath)
+    {
+        if (!fitsInLocal8bit(item))
+        {
+            processed << shortPathName(item);
+        }
+        else
+        {
+            processed << item;
+        }
+    }
+    args << processed.join(';');
+#else
+    args << classPath.join(':');
+#endif
+    args << "org.multimc.EntryPoint";
+
+    qDebug() << args.join(' ');
+
+    QString wrapperCommandStr = instance->getWrapperCommand().trimmed();
+    if(!wrapperCommandStr.isEmpty())
+    {
+        auto wrapperArgs = Commandline::splitArgs(wrapperCommandStr);
+        auto wrapperCommand = wrapperArgs.takeFirst();
+        auto realWrapperCommand = QStandardPaths::findExecutable(wrapperCommand);
+        if (realWrapperCommand.isEmpty())
+        {
+            const char *reason = QT_TR_NOOP("The wrapper command \"%1\" couldn't be found.");
+            emit logLine(QString(reason).arg(wrapperCommand), MessageLevel::Fatal);
+            emitFailed(tr(reason).arg(wrapperCommand));
+            return;
+        }
+        emit logLine("Wrapper command is:\n" + wrapperCommandStr + "\n\n", MessageLevel::MultiMC);
+        args.prepend(javaPath);
+        m_process.start(wrapperCommand, wrapperArgs + args);
+    }
+    else
+    {
+        m_process.start(javaPath, args);
+    }
+}
+
+void LauncherPartLaunch::on_state(LoggedProcess::State state)
+{
+    switch(state)
+    {
+        case LoggedProcess::FailedToStart:
+        {
+            //: Error message displayed if instace can't start
+            const char *reason = QT_TR_NOOP("Could not launch minecraft!");
+            emit logLine(reason, MessageLevel::Fatal);
+            emitFailed(tr(reason));
+            return;
+        }
+        case LoggedProcess::Aborted:
+        case LoggedProcess::Crashed:
+        {
+            m_parent->setPid(-1);
+            emitFailed(tr("Game crashed."));
+            return;
+        }
+        case LoggedProcess::Finished:
+        {
+            m_parent->setPid(-1);
+            // if the exit code wasn't 0, report this as a crash
+            auto exitCode = m_process.exitCode();
+            if(exitCode != 0)
+            {
+                emitFailed(tr("Game crashed."));
+                return;
+            }
+            //FIXME: make this work again
+            // m_postlaunchprocess.processEnvironment().insert("INST_EXITCODE", QString(exitCode));
+            // run post-exit
+            emitSucceeded();
+            break;
+        }
+        case LoggedProcess::Running:
+            emit logLine(QString("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::MultiMC);
+            m_parent->setPid(m_process.processId());
+            m_parent->instance()->setLastLaunch();
+            // send the launch script to the launcher part
+            m_process.write(m_launchScript.toUtf8());
+
+            mayProceed = true;
+            emit readyForLaunch();
+            break;
+        default:
+            break;
+    }
+}
+
+void LauncherPartLaunch::setWorkingDirectory(const QString &wd)
+{
+    m_process.setWorkingDirectory(wd);
+}
+
+void LauncherPartLaunch::proceed()
+{
+    if(mayProceed)
+    {
+        QString launchString("launch\n");
+        m_process.write(launchString.toUtf8());
+        mayProceed = false;
+    }
+}
+
+bool LauncherPartLaunch::abort()
+{
+    if(mayProceed)
+    {
+        mayProceed = false;
+        QString launchString("abort\n");
+        m_process.write(launchString.toUtf8());
+    }
+    else
+    {
+        auto state = m_process.state();
+        if (state == LoggedProcess::Running || state == LoggedProcess::Starting)
+        {
+            m_process.kill();
+        }
+    }
+    return true;
+}

launcher/minecraft/launch/LauncherPartLaunch.h

@@ -0,0 +1,60 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <LoggedProcess.h>
+#include <minecraft/auth/AuthSession.h>
+
+#include "MinecraftServerTarget.h"
+
+class LauncherPartLaunch: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit LauncherPartLaunch(LaunchTask *parent);
+    virtual ~LauncherPartLaunch() {};
+
+    virtual void executeTask();
+    virtual bool abort();
+    virtual void proceed();
+    virtual bool canAbort() const
+    {
+        return true;
+    }
+    void setWorkingDirectory(const QString &wd);
+    void setAuthSession(AuthSessionPtr session)
+    {
+        m_session = session;
+    }
+
+    void setServerToJoin(MinecraftServerTargetPtr serverToJoin)
+    {
+        m_serverToJoin = std::move(serverToJoin);
+    }
+
+private slots:
+    void on_state(LoggedProcess::State state);
+
+private:
+    LoggedProcess m_process;
+    QString m_command;
+    AuthSessionPtr m_session;
+    QString m_launchScript;
+    MinecraftServerTargetPtr m_serverToJoin;
+
+    bool mayProceed = false;
+};

launcher/minecraft/launch/MinecraftServerTarget.cpp

@@ -0,0 +1,66 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MinecraftServerTarget.h"
+
+#include <QStringList>
+
+MinecraftServerTarget MinecraftServerTarget::parse(const QString &fullAddress) {
+    QStringList split = fullAddress.split(":");
+
+    // The logic below replicates the exact logic minecraft uses for parsing server addresses.
+    // While the conversion is not lossless and eats errors, it ensures the same behavior
+    // within Minecraft and MultiMC when entering server addresses.
+    if (fullAddress.startsWith("["))
+    {
+        int bracket = fullAddress.indexOf("]");
+        if (bracket > 0)
+        {
+            QString ipv6 = fullAddress.mid(1, bracket - 1);
+            QString port = fullAddress.mid(bracket + 1).trimmed();
+
+            if (port.startsWith(":") && !ipv6.isEmpty())
+            {
+                port = port.mid(1);
+                split = QStringList({ ipv6, port });
+            }
+            else
+            {
+                split = QStringList({ipv6});
+            }
+        }
+    }
+
+    if (split.size() > 2)
+    {
+        split = QStringList({fullAddress});
+    }
+
+    QString realAddress = split[0];
+
+    quint16 realPort = 25565;
+    if (split.size() > 1)
+    {
+        bool ok;
+        realPort = split[1].toUInt(&ok);
+
+        if (!ok)
+        {
+            realPort = 25565;
+        }
+    }
+
+    return MinecraftServerTarget { realAddress, realPort };
+}

launcher/minecraft/launch/MinecraftServerTarget.h

@@ -0,0 +1,29 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include <QString>
+
+struct MinecraftServerTarget {
+    QString address;
+    quint16 port;
+
+    static MinecraftServerTarget parse(const QString &fullAddress);
+};
+
+typedef std::shared_ptr<MinecraftServerTarget> MinecraftServerTargetPtr;

launcher/minecraft/launch/ModMinecraftJar.cpp

@@ -0,0 +1,82 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ModMinecraftJar.h"
+#include "launch/LaunchTask.h"
+#include "MMCZip.h"
+#include "minecraft/OpSys.h"
+#include "FileSystem.h"
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/PackProfile.h"
+
+void ModMinecraftJar::executeTask()
+{
+    auto m_inst = std::dynamic_pointer_cast<MinecraftInstance>(m_parent->instance());
+
+    if(!m_inst->getJarMods().size())
+    {
+        emitSucceeded();
+        return;
+    }
+    // nuke obsolete stripped jar(s) if needed
+    if(!FS::ensureFolderPathExists(m_inst->binRoot()))
+    {
+        emitFailed(tr("Couldn't create the bin folder for Minecraft.jar"));
+    }
+
+    auto finalJarPath = QDir(m_inst->binRoot()).absoluteFilePath("minecraft.jar");
+    if(!removeJar())
+    {
+        emitFailed(tr("Couldn't remove stale jar file: %1").arg(finalJarPath));
+    }
+
+    // create temporary modded jar, if needed
+    auto components = m_inst->getPackProfile();
+    auto profile = components->getProfile();
+    auto jarMods = m_inst->getJarMods();
+    if(jarMods.size())
+    {
+        auto mainJar = profile->getMainJar();
+        QStringList jars, temp1, temp2, temp3, temp4;
+        mainJar->getApplicableFiles(currentSystem, jars, temp1, temp2, temp3, m_inst->getLocalLibraryPath());
+        auto sourceJarPath = jars[0];
+        if(!MMCZip::createModdedJar(sourceJarPath, finalJarPath, jarMods))
+        {
+            emitFailed(tr("Failed to create the custom Minecraft jar file."));
+            return;
+        }
+    }
+    emitSucceeded();
+}
+
+void ModMinecraftJar::finalize()
+{
+    removeJar();
+}
+
+bool ModMinecraftJar::removeJar()
+{
+    auto m_inst = std::dynamic_pointer_cast<MinecraftInstance>(m_parent->instance());
+    auto finalJarPath = QDir(m_inst->binRoot()).absoluteFilePath("minecraft.jar");
+    QFile finalJar(finalJarPath);
+    if(finalJar.exists())
+    {
+        if(!finalJar.remove())
+        {
+            return false;
+        }
+    }
+    return true;
+}

launcher/minecraft/launch/ModMinecraftJar.h

@@ -0,0 +1,36 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <memory>
+
+class ModMinecraftJar: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit ModMinecraftJar(LaunchTask *parent) : LaunchStep(parent) {};
+    virtual ~ModMinecraftJar(){};
+
+    virtual void executeTask() override;
+    virtual bool canAbort() const override
+    {
+        return false;
+    }
+    void finalize() override;
+private:
+    bool removeJar();
+};

launcher/minecraft/launch/PrintInstanceInfo.cpp

@@ -0,0 +1,106 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <fstream>
+#include <string>
+
+#include "PrintInstanceInfo.h"
+#include <launch/LaunchTask.h>
+
+#ifdef Q_OS_LINUX
+namespace {
+void probeProcCpuinfo(QStringList &log)
+{
+    std::ifstream cpuin("/proc/cpuinfo");
+    for (std::string line; std::getline(cpuin, line);)
+    {
+        if (strncmp(line.c_str(), "model name", 10) == 0)
+        {
+            log << QString::fromStdString(line.substr(13, std::string::npos));
+            break;
+        }
+    }
+}
+
+void runLspci(QStringList &log)
+{
+    // FIXME: fixed size buffers...
+    char buff[512];
+    int gpuline = -1;
+    int cline = 0;
+    FILE * lspci = popen("lspci -k", "r");
+
+    if (!lspci)
+        return;
+
+    while (fgets(buff, 512, lspci) != NULL)
+    {
+        std::string str(buff);
+        if (str.length() < 9)
+            continue;
+        if (str.substr(8, 3) == "VGA")
+        {
+            gpuline = cline;
+            log << QString::fromStdString(str.substr(35, std::string::npos));
+        }
+        if (gpuline > -1 && gpuline != cline)
+        {
+            if (cline - gpuline < 3)
+            {
+                log << QString::fromStdString(str.substr(1, std::string::npos));
+            }
+        }
+        cline++;
+    }
+    pclose(lspci);
+}
+
+void runGlxinfo(QStringList & log)
+{
+    // FIXME: fixed size buffers...
+    char buff[512];
+    FILE *glxinfo = popen("glxinfo", "r");
+    if (!glxinfo)
+        return;
+
+    while (fgets(buff, 512, glxinfo) != NULL)
+    {
+        if (strncmp(buff, "OpenGL version string:", 22) == 0)
+        {
+            log << QString::fromUtf8(buff);
+            break;
+        }
+    }
+    pclose(glxinfo);
+}
+
+}
+#endif
+
+void PrintInstanceInfo::executeTask()
+{
+    auto instance = m_parent->instance();
+    QStringList log;
+
+#ifdef Q_OS_LINUX
+    ::probeProcCpuinfo(log);
+    ::runLspci(log);
+    ::runGlxinfo(log);
+#endif
+
+    logLines(log, MessageLevel::MultiMC);
+    logLines(instance->verboseDescription(m_session, m_serverToJoin), MessageLevel::MultiMC);
+    emitSucceeded();
+}

launcher/minecraft/launch/PrintInstanceInfo.h

@@ -0,0 +1,41 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <memory>
+#include "minecraft/auth/AuthSession.h"
+#include "minecraft/launch/MinecraftServerTarget.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(){};
+
+    virtual void executeTask();
+    virtual bool canAbort() const
+    {
+        return false;
+    }
+private:
+    AuthSessionPtr m_session;
+    MinecraftServerTargetPtr m_serverToJoin;
+};
+

launcher/minecraft/launch/ReconstructAssets.cpp

@@ -0,0 +1,36 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReconstructAssets.h"
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/PackProfile.h"
+#include "minecraft/AssetsUtils.h"
+#include "launch/LaunchTask.h"
+
+void ReconstructAssets::executeTask()
+{
+    auto instance = m_parent->instance();
+    std::shared_ptr<MinecraftInstance> minecraftInstance = std::dynamic_pointer_cast<MinecraftInstance>(instance);
+    auto components = minecraftInstance->getPackProfile();
+    auto profile = components->getProfile();
+    auto assets = profile->getMinecraftAssets();
+
+    if(!AssetsUtils::reconstructAssets(assets->id, minecraftInstance->resourcesDir()))
+    {
+        emit logLine("Failed to reconstruct Minecraft assets.", MessageLevel::Error);
+    }
+
+    emitSucceeded();
+}

launcher/minecraft/launch/ReconstructAssets.h

@@ -0,0 +1,33 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <memory>
+
+class ReconstructAssets: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit ReconstructAssets(LaunchTask *parent) : LaunchStep(parent){};
+    virtual ~ReconstructAssets(){};
+
+    void executeTask() override;
+    bool canAbort() const override
+    {
+        return false;
+    }
+};

launcher/minecraft/launch/ScanModFolders.cpp

@@ -0,0 +1,59 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ScanModFolders.h"
+#include "launch/LaunchTask.h"
+#include "MMCZip.h"
+#include "minecraft/OpSys.h"
+#include "FileSystem.h"
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/mod/ModFolderModel.h"
+
+void ScanModFolders::executeTask()
+{
+    auto m_inst = std::dynamic_pointer_cast<MinecraftInstance>(m_parent->instance());
+
+    auto loaders = m_inst->loaderModList();
+    connect(loaders.get(), &ModFolderModel::updateFinished, this, &ScanModFolders::modsDone);
+    if(!loaders->update()) {
+        m_modsDone = true;
+    }
+
+    auto cores = m_inst->coreModList();
+    connect(cores.get(), &ModFolderModel::updateFinished, this, &ScanModFolders::coreModsDone);
+    if(!cores->update()) {
+        m_coreModsDone = true;
+    }
+    checkDone();
+}
+
+void ScanModFolders::modsDone()
+{
+    m_modsDone = true;
+    checkDone();
+}
+
+void ScanModFolders::coreModsDone()
+{
+    m_coreModsDone = true;
+    checkDone();
+}
+
+void ScanModFolders::checkDone()
+{
+    if(m_modsDone && m_coreModsDone) {
+        emitSucceeded();
+    }
+}

launcher/minecraft/launch/ScanModFolders.h

@@ -0,0 +1,42 @@
+/* Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <launch/LaunchStep.h>
+#include <memory>
+
+class ScanModFolders: public LaunchStep
+{
+    Q_OBJECT
+public:
+    explicit ScanModFolders(LaunchTask *parent) : LaunchStep(parent) {};
+    virtual ~ScanModFolders(){};
+
+    virtual void executeTask() override;
+    virtual bool canAbort() const override
+    {
+        return false;
+    }
+private slots:
+    void coreModsDone();
+    void modsDone();
+private:
+    void checkDone();
+
+private: // DATA
+    bool m_modsDone = false;
+    bool m_coreModsDone = false;
+};

launcher/minecraft/launch/VerifyJavaInstall.cpp

@@ -0,0 +1,34 @@
+#include "VerifyJavaInstall.h"
+
+#include <launch/LaunchTask.h>
+#include <minecraft/MinecraftInstance.h>
+#include <minecraft/PackProfile.h>
+#include <minecraft/VersionFilterData.h>
+
+void VerifyJavaInstall::executeTask() {
+    auto m_inst = std::dynamic_pointer_cast<MinecraftInstance>(m_parent->instance());
+
+    auto javaVersion = m_inst->getJavaVersion();
+    auto minecraftComponent = m_inst->getPackProfile()->getComponent("net.minecraft");
+
+    // Java 16 requirement
+    if (minecraftComponent->getReleaseDateTime() >= g_VersionFilterData.java16BeginsDate) {
+        if (javaVersion.major() < 16) {
+            emit logLine("Minecraft 21w19a and above require the use of Java 16",
+                         MessageLevel::Fatal);
+            emitFailed(tr("Minecraft 21w19a and above require the use of Java 16"));
+            return;
+        }
+    }
+    // Java 8 requirement
+    else if (minecraftComponent->getReleaseDateTime() >= g_VersionFilterData.java8BeginsDate) {
+        if (javaVersion.major() < 8) {
+            emit logLine("Minecraft 17w13a and above require the use of Java 8",
+                         MessageLevel::Fatal);
+            emitFailed(tr("Minecraft 17w13a and above require the use of Java 8"));
+            return;
+        }
+    }
+
+    emitSucceeded();
+}

launcher/minecraft/launch/VerifyJavaInstall.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <launch/LaunchStep.h>
+
+class VerifyJavaInstall : public LaunchStep {
+    Q_OBJECT
+
+public:
+    explicit VerifyJavaInstall(LaunchTask *parent) : LaunchStep(parent) {
+    };
+    ~VerifyJavaInstall() override = default;
+
+    void executeTask() override;
+    bool canAbort() const override {
+        return false;
+    }
+};