Merge pull request #3804 from Janrupf/feature/default-server

Add ability to select a server to join in the instance settings

api/logic/BaseInstance.h

@@ -34,6 +34,8 @@
 
 #include "multimc_logic_export.h"
 
+#include "minecraft/launch/MinecraftServerTarget.h"
+
 class QDir;
 class Task;
 class LaunchTask;
@@ -145,7 +147,8 @@ public:
     virtual shared_qobject_ptr<Task> createUpdateTask(Net::Mode mode) = 0;
 
     /// returns a valid launcher (task container)
-    virtual shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr account) = 0;
+    virtual shared_qobject_ptr<LaunchTask> createLaunchTask(
+            AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) = 0;
 
     /// returns the current launch task (if any)
     shared_qobject_ptr<LaunchTask> getLaunchTask();
@@ -221,9 +224,9 @@ public:
     bool reloadSettings();
 
     /**
-     * 'print' a verbose desription of the instance into a QStringList
+     * 'print' a verbose description of the instance into a QStringList
      */
-    virtual QStringList verboseDescription(AuthSessionPtr session) = 0;
+    virtual QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) = 0;
 
     Status currentStatus() const;
 

api/logic/CMakeLists.txt

@@ -124,6 +124,8 @@ set(NET_SOURCES
 
 # Game launch logic
 set(LAUNCH_SOURCES
+    launch/steps/LookupServerAddress.cpp
+    launch/steps/LookupServerAddress.h
     launch/steps/PostLaunchCommand.cpp
     launch/steps/PostLaunchCommand.h
     launch/steps/PreLaunchCommand.cpp
@@ -236,6 +238,8 @@ set(MINECRAFT_SOURCES
     minecraft/launch/ExtractNatives.h
     minecraft/launch/LauncherPartLaunch.cpp
     minecraft/launch/LauncherPartLaunch.h
+    minecraft/launch/MinecraftServerTarget.cpp
+    minecraft/launch/MinecraftServerTarget.h
     minecraft/launch/PrintInstanceInfo.cpp
     minecraft/launch/PrintInstanceInfo.h
     minecraft/launch/ReconstructAssets.cpp

api/logic/NullInstance.h

@@ -27,7 +27,7 @@ public:
     {
         return instanceRoot();
     };
-    shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr) override
+    shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr, MinecraftServerTargetPtr) override
     {
         return nullptr;
     }
@@ -67,7 +67,7 @@ public:
     {
         return false;
     }
-    QStringList verboseDescription(AuthSessionPtr session) override
+    QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) override
     {
         QStringList out;
         out << "Null instance - placeholder.";

api/logic/launch/steps/LookupServerAddress.cpp

@@ -0,0 +1,95 @@
+/* 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 "LookupServerAddress.h"
+
+#include <launch/LaunchTask.h>
+
+LookupServerAddress::LookupServerAddress(LaunchTask *parent) :
+    LaunchStep(parent), m_dnsLookup(new QDnsLookup(this))
+{
+    connect(m_dnsLookup, &QDnsLookup::finished, this, &LookupServerAddress::on_dnsLookupFinished);
+
+    m_dnsLookup->setType(QDnsLookup::SRV);
+}
+
+void LookupServerAddress::setLookupAddress(const QString &lookupAddress)
+{
+    m_lookupAddress = lookupAddress;
+    m_dnsLookup->setName(QString("_minecraft._tcp.%1").arg(lookupAddress));
+}
+
+void LookupServerAddress::setOutputAddressPtr(MinecraftServerTargetPtr output)
+{
+    m_output = std::move(output);
+}
+
+bool LookupServerAddress::abort()
+{
+    m_dnsLookup->abort();
+    emitFailed("Aborted");
+    return true;
+}
+
+void LookupServerAddress::executeTask()
+{
+    m_dnsLookup->lookup();
+}
+
+void LookupServerAddress::on_dnsLookupFinished()
+{
+    if (isFinished())
+    {
+        // Aborted
+        return;
+    }
+
+    if (m_dnsLookup->error() != QDnsLookup::NoError)
+    {
+        emit logLine(QString("Failed to resolve server address (this is NOT an error!) %1: %2\n")
+            .arg(m_dnsLookup->name(), m_dnsLookup->errorString()), MessageLevel::MultiMC);
+        resolve(m_lookupAddress, 25565); // Technically the task failed, however, we don't abort the launch
+                                                      // and leave it up to minecraft to fail (or maybe not) when connecting
+        return;
+    }
+
+    const auto records = m_dnsLookup->serviceRecords();
+    if (records.empty())
+    {
+        emit logLine(
+                QString("Failed to resolve server address %1: the DNS lookup succeeded, but no records were returned.\n")
+                .arg(m_dnsLookup->name()), MessageLevel::Warning);
+        resolve(m_lookupAddress, 25565); // Technically the task failed, however, we don't abort the launch
+                                                      // and leave it up to minecraft to fail (or maybe not) when connecting
+        return;
+    }
+
+    const auto &firstRecord = records.at(0);
+    quint16 port = firstRecord.port();
+
+    emit logLine(QString("Resolved server address %1 to %2 with port %3\n").arg(
+            m_dnsLookup->name(), firstRecord.target(), QString::number(port)),MessageLevel::MultiMC);
+    resolve(firstRecord.target(), port);
+}
+
+void LookupServerAddress::resolve(const QString &address, quint16 port)
+{
+    m_output->address = address;
+    m_output->port = port;
+
+    emitSucceeded();
+    m_dnsLookup->deleteLater();
+}

api/logic/launch/steps/LookupServerAddress.h

@@ -0,0 +1,49 @@
+/* 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 <QObjectPtr.h>
+#include <QDnsLookup>
+
+#include "minecraft/launch/MinecraftServerTarget.h"
+
+class LookupServerAddress: public LaunchStep {
+Q_OBJECT
+public:
+    explicit LookupServerAddress(LaunchTask *parent);
+    virtual ~LookupServerAddress() {};
+
+    virtual void executeTask();
+    virtual bool abort();
+    virtual bool canAbort() const
+    {
+        return true;
+    }
+
+    void setLookupAddress(const QString &lookupAddress);
+    void setOutputAddressPtr(MinecraftServerTargetPtr output);
+
+private slots:
+    void on_dnsLookupFinished();
+
+private:
+    void resolve(const QString &address, quint16 port);
+
+    QDnsLookup *m_dnsLookup;
+    QString m_lookupAddress;
+    MinecraftServerTargetPtr m_output;
+};

api/logic/minecraft/MinecraftInstance.cpp

@@ -12,6 +12,7 @@
 #include <java/JavaVersion.h>
 
 #include "launch/LaunchTask.h"
+#include "launch/steps/LookupServerAddress.h"
 #include "launch/steps/PostLaunchCommand.h"
 #include "launch/steps/Update.h"
 #include "launch/steps/PreLaunchCommand.h"
@@ -111,6 +112,10 @@ MinecraftInstance::MinecraftInstance(SettingsObjectPtr globalSettings, SettingsO
     m_settings->registerOverride(globalSettings->getSetting("ShowGameTime"), gameTimeOverride);
     m_settings->registerOverride(globalSettings->getSetting("RecordGameTime"), gameTimeOverride);
 
+    // Join server on launch, this does not have a global override
+    m_settings->registerSetting("JoinServerOnLaunch", false);
+    m_settings->registerSetting("JoinServerOnLaunchAddress", "");
+
     // DEPRECATED: Read what versions the user configuration thinks should be used
     m_settings->registerSetting({"IntendedVersion", "MinecraftVersion"}, "");
     m_settings->registerSetting("LWJGLVersion", "");
@@ -395,7 +400,8 @@ static QString replaceTokensIn(QString text, QMap<QString, QString> with)
     return result;
 }
 
-QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session) const
+QStringList MinecraftInstance::processMinecraftArgs(
+        AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) const
 {
     auto profile = m_components->getProfile();
     QString args_pattern = profile->getMinecraftArguments();
@@ -404,6 +410,12 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session) cons
         args_pattern += " --tweakClass " + tweaker;
     }
 
+    if (serverToJoin && !serverToJoin->address.isEmpty())
+    {
+        args_pattern += " --server " + serverToJoin->address;
+        args_pattern += " --port " + QString::number(serverToJoin->port);
+    }
+
     QMap<QString, QString> token_mapping;
     // yggdrasil!
     if(session)
@@ -440,7 +452,7 @@ QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session) cons
     return parts;
 }
 
-QString MinecraftInstance::createLaunchScript(AuthSessionPtr session)
+QString MinecraftInstance::createLaunchScript(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin)
 {
     QString launchScript;
 
@@ -461,8 +473,17 @@ QString MinecraftInstance::createLaunchScript(AuthSessionPtr session)
         launchScript += "appletClass " + appletClass + "\n";
     }
 
+    if (serverToJoin && !serverToJoin->address.isEmpty())
+    {
+        launchScript += "serverAddress " + serverToJoin->address + "\n";
+        launchScript += "serverPort " + QString::number(serverToJoin->port) + "\n";
+    }
+
     // generic minecraft params
-    for (auto param : processMinecraftArgs(session))
+    for (auto param : processMinecraftArgs(
+            session,
+            nullptr /* When using a launch script, the server parameters are handled by it*/
+    ))
     {
         launchScript += "param " + param + "\n";
     }
@@ -512,7 +533,7 @@ QString MinecraftInstance::createLaunchScript(AuthSessionPtr session)
     return launchScript;
 }
 
-QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session)
+QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin)
 {
     QStringList out;
     out << "Main Class:" << "  " + getMainClass() << "";
@@ -627,7 +648,7 @@ QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session)
         out << "";
     }
 
-    auto params = processMinecraftArgs(nullptr);
+    auto params = processMinecraftArgs(nullptr, serverToJoin);
     out << "Params:";
     out << "  " + params.join(' ');
     out << "";
@@ -801,7 +822,7 @@ shared_qobject_ptr<Task> MinecraftInstance::createUpdateTask(Net::Mode mode)
     return nullptr;
 }
 
-shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPtr session)
+shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin)
 {
     // FIXME: get rid of shared_from_this ...
     auto process = LaunchTask::create(std::dynamic_pointer_cast<MinecraftInstance>(shared_from_this()));
@@ -833,6 +854,21 @@ shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPt
         process->appendStep(new CreateGameFolders(pptr));
     }
 
+    if (!serverToJoin && m_settings->get("JoinServerOnLaunch").toBool())
+    {
+        QString fullAddress = m_settings->get("JoinServerOnLaunchAddress").toString();
+        serverToJoin.reset(new MinecraftServerTarget(MinecraftServerTarget::parse(fullAddress)));
+    }
+
+    if(serverToJoin && serverToJoin->port == 25565)
+    {
+        // Resolve server address to join on launch
+        auto *step = new LookupServerAddress(pptr);
+        step->setLookupAddress(serverToJoin->address);
+        step->setOutputAddressPtr(serverToJoin);
+        process->appendStep(step);
+    }
+
     // run pre-launch command if that's needed
     if(getPreLaunchCommand().size())
     {
@@ -864,7 +900,7 @@ shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPt
 
     // print some instance info here...
     {
-        process->appendStep(new PrintInstanceInfo(pptr, session));
+        process->appendStep(new PrintInstanceInfo(pptr, session, serverToJoin));
     }
 
     // extract native jars if needed
@@ -885,6 +921,7 @@ shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPt
             auto step = new LauncherPartLaunch(pptr);
             step->setWorkingDirectory(gameRoot());
             step->setAuthSession(session);
+            step->setServerToJoin(serverToJoin);
             process->appendStep(step);
         }
         else if (method == "DirectJava")
@@ -892,6 +929,7 @@ shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPt
             auto step = new DirectJavaLaunch(pptr);
             step->setWorkingDirectory(gameRoot());
             step->setAuthSession(session);
+            step->setServerToJoin(serverToJoin);
             process->appendStep(step);
         }
     }

api/logic/minecraft/MinecraftInstance.h

@@ -5,6 +5,7 @@
 #include <QProcess>
 #include <QDir>
 #include "multimc_logic_export.h"
+#include "minecraft/launch/MinecraftServerTarget.h"
 
 class ModFolderModel;
 class WorldList;
@@ -76,11 +77,11 @@ public:
 
     //////  Launch stuff //////
     shared_qobject_ptr<Task> createUpdateTask(Net::Mode mode) override;
-    shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr account) override;
+    shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) override;
     QStringList extraArguments() const override;
-    QStringList verboseDescription(AuthSessionPtr session) override;
+    QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) override;
     QList<Mod> getJarMods() const;
-    QString createLaunchScript(AuthSessionPtr session);
+    QString createLaunchScript(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin);
     /// get arguments passed to java
     QStringList javaArguments() const;
 
@@ -107,7 +108,7 @@ public:
     virtual QString getMainClass() const;
 
     // FIXME: remove
-    virtual QStringList processMinecraftArgs(AuthSessionPtr account) const;
+    virtual QStringList processMinecraftArgs(AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) const;
 
     virtual JavaVersion getJavaVersion() const;
 

api/logic/minecraft/launch/DirectJavaLaunch.cpp

@@ -55,7 +55,7 @@ void DirectJavaLaunch::executeTask()
     // make detachable - this will keep the process running even if the object is destroyed
     m_process.setDetachable(true);
 
-    auto mcArgs = minecraftInstance->processMinecraftArgs(m_session);
+    auto mcArgs = minecraftInstance->processMinecraftArgs(m_session, m_serverToJoin);
     args.append(mcArgs);
 
     QString wrapperCommandStr = instance->getWrapperCommand().trimmed();

api/logic/minecraft/launch/DirectJavaLaunch.h

@@ -19,6 +19,8 @@
 #include <LoggedProcess.h>
 #include <minecraft/auth/AuthSession.h>
 
+#include "MinecraftServerTarget.h"
+
 class DirectJavaLaunch: public LaunchStep
 {
     Q_OBJECT
@@ -38,6 +40,12 @@ public:
     {
         m_session = session;
     }
+
+    void setServerToJoin(MinecraftServerTargetPtr serverToJoin)
+    {
+        m_serverToJoin = std::move(serverToJoin);
+    }
+
 private slots:
     void on_state(LoggedProcess::State state);
 
@@ -45,5 +53,6 @@ private:
     LoggedProcess m_process;
     QString m_command;
     AuthSessionPtr m_session;
+    MinecraftServerTargetPtr m_serverToJoin;
 };
 

api/logic/minecraft/launch/LauncherPartLaunch.cpp

@@ -59,7 +59,7 @@ 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_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);

api/logic/minecraft/launch/LauncherPartLaunch.h

@@ -19,6 +19,8 @@
 #include <LoggedProcess.h>
 #include <minecraft/auth/AuthSession.h>
 
+#include "MinecraftServerTarget.h"
+
 class LauncherPartLaunch: public LaunchStep
 {
     Q_OBJECT
@@ -39,6 +41,11 @@ public:
         m_session = session;
     }
 
+    void setServerToJoin(MinecraftServerTargetPtr serverToJoin)
+    {
+        m_serverToJoin = std::move(serverToJoin);
+    }
+
 private slots:
     void on_state(LoggedProcess::State state);
 
@@ -47,5 +54,7 @@ private:
     QString m_command;
     AuthSessionPtr m_session;
     QString m_launchScript;
+    MinecraftServerTargetPtr m_serverToJoin;
+
     bool mayProceed = false;
 };

api/logic/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 };
+}

api/logic/minecraft/launch/MinecraftServerTarget.h

@@ -0,0 +1,30 @@
+/* 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>
+#include <multimc_logic_export.h>
+
+struct MinecraftServerTarget {
+    QString address;
+    quint16 port;
+
+    static MULTIMC_LOGIC_EXPORT MinecraftServerTarget parse(const QString &fullAddress);
+};
+
+typedef std::shared_ptr<MinecraftServerTarget> MinecraftServerTargetPtr;

api/logic/minecraft/launch/PrintInstanceInfo.cpp

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

api/logic/minecraft/launch/PrintInstanceInfo.h

@@ -18,13 +18,15 @@
 #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) : LaunchStep(parent), m_session(session) {};
+    explicit PrintInstanceInfo(LaunchTask *parent, AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) :
+        LaunchStep(parent), m_session(session), m_serverToJoin(serverToJoin) {};
     virtual ~PrintInstanceInfo(){};
 
     virtual void executeTask();
@@ -34,5 +36,6 @@ public:
     }
 private:
     AuthSessionPtr m_session;
+    MinecraftServerTargetPtr m_serverToJoin;
 };
 

api/logic/minecraft/legacy/LegacyInstance.cpp

@@ -225,7 +225,7 @@ QString LegacyInstance::getStatusbarDescription()
     return tr("Instance from previous versions.");
 }
 
-QStringList LegacyInstance::verboseDescription(AuthSessionPtr session)
+QStringList LegacyInstance::verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin)
 {
     QStringList out;
 

api/logic/minecraft/legacy/LegacyInstance.h

@@ -111,7 +111,8 @@ public:
     {
         return false;
     }
-    shared_qobject_ptr<LaunchTask> createLaunchTask(AuthSessionPtr account) override
+    shared_qobject_ptr<LaunchTask> createLaunchTask(
+            AuthSessionPtr account, MinecraftServerTargetPtr serverToJoin) override
     {
         return nullptr;
     }
@@ -125,7 +126,7 @@ public:
     }
 
     QString getStatusbarDescription() override;
-    QStringList verboseDescription(AuthSessionPtr session) override;
+    QStringList verboseDescription(AuthSessionPtr session, MinecraftServerTargetPtr serverToJoin) override;
 
     QProcessEnvironment createEnvironment() override
     {