diff options
Diffstat (limited to 'archived/projt-launcher/launcher/minecraft/MinecraftInstance.cpp')
| -rw-r--r-- | archived/projt-launcher/launcher/minecraft/MinecraftInstance.cpp | 1430 |
1 files changed, 1430 insertions, 0 deletions
diff --git a/archived/projt-launcher/launcher/minecraft/MinecraftInstance.cpp b/archived/projt-launcher/launcher/minecraft/MinecraftInstance.cpp new file mode 100644 index 0000000000..29e44954ad --- /dev/null +++ b/archived/projt-launcher/launcher/minecraft/MinecraftInstance.cpp @@ -0,0 +1,1430 @@ +// SPDX-License-Identifier: GPL-3.0-only +// SPDX-FileCopyrightText: 2026 Project Tick +// SPDX-FileContributor: Project Tick Team +/* + * ProjT Launcher - Minecraft Launcher + * Copyright (C) 2026 Project Tick + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * === Upstream License Block (Do Not Modify) ============================== + * + * + * + * Prism Launcher - Minecraft Launcher + * Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net> + * Copyright (C) 2022 Jamie Mansfield <jmansfield@cadixdev.org> + * Copyright (C) 2023 TheKodeToad <TheKodeToad@proton.me> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * This file incorporates work covered by the following copyright and + * permission notice: + * + * 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 "MinecraftInstance.h" +#include "LaunchMode.h" +#include "Application.h" +#include "BuildConfig.h" +#include "Commandline.h" +#include "Json.h" +#include "MinecraftInstanceLaunchMenu.h" +#include "QObjectPtr.h" +#include "minecraft/launch/AutoInstallJava.hpp" +#include "minecraft/launch/CreateGameFolders.hpp" +#include "minecraft/launch/ExtractNatives.hpp" +#include "minecraft/launch/PrintInstanceInfo.hpp" +#include "minecraft/update/AssetUpdateTask.h" +#include "minecraft/update/FMLLibrariesTask.h" +#include "minecraft/update/LibrariesTask.h" +#include "settings/Setting.h" +#include "settings/SettingsObject.h" + +#include "FileSystem.h" +#include "MMCTime.h" +#include "java/core/RuntimeVersion.hpp" + +#include "launch/LaunchPipeline.hpp" +#include "launch/TaskBridgeStage.hpp" +#include "launch/steps/RuntimeProbeStep.hpp" +#include "launch/steps/ServerJoinResolveStep.hpp" +#include "launch/steps/LaunchCommandStep.hpp" +#include "launch/steps/QuitAfterGameStep.hpp" +#include "launch/steps/LogMessageStep.hpp" + +#include "minecraft/launch/ClaimAccount.hpp" +#include "minecraft/launch/LauncherPartLaunch.hpp" +#include "minecraft/launch/ModMinecraftJar.hpp" +#include "minecraft/launch/ReconstructAssets.hpp" +#include "minecraft/launch/ScanModFolders.hpp" +#include "minecraft/launch/VerifyJavaInstall.hpp" + +#include "java/services/RuntimeEnvironment.hpp" + +#include "icons/IconList.hpp" + +#include "mod/ModFolderModel.hpp" +#include "mod/ResourcePackFolderModel.hpp" +#include "mod/ShaderPackFolderModel.hpp" +#include "mod/TexturePackFolderModel.hpp" + +#include "WorldList.h" + +#include "AssetsUtils.h" +#include "MinecraftLoadAndCheck.h" +#include "PackProfile.h" +#include "minecraft/update/FoldersTask.h" + +#include "tools/BaseProfiler.h" + +#include <QActionGroup> +#include <QMainWindow> +#include <QScreen> +#include <QWindow> + +#ifdef Q_OS_LINUX +#include "MangoHud.h" +#endif + +#ifdef WITH_QTDBUS +#include <QtDBus/QtDBus> +#endif + +#define IBUS "@im=ibus" + +[[maybe_unused]] static bool switcherooSetupGPU(QProcessEnvironment& env) +{ +#ifdef WITH_QTDBUS + if (!QDBusConnection::systemBus().isConnected()) + return false; + + QDBusInterface switcheroo("net.hadess.SwitcherooControl", + "/net/hadess/SwitcherooControl", + "org.freedesktop.DBus.Properties", + QDBusConnection::systemBus()); + + if (!switcheroo.isValid()) + return false; + + QDBusReply<QDBusVariant> reply = + switcheroo.call(QStringLiteral("Get"), QStringLiteral("net.hadess.SwitcherooControl"), QStringLiteral("GPUs")); + if (!reply.isValid()) + return false; + + QDBusArgument arg = qvariant_cast<QDBusArgument>(reply.value().variant()); + QList<QVariantMap> gpus; + arg >> gpus; + + for (const auto& gpu : gpus) + { + QString name = qvariant_cast<QString>(gpu[QStringLiteral("Name")]); + bool defaultGpu = qvariant_cast<bool>(gpu[QStringLiteral("Default")]); + if (!defaultGpu) + { + QStringList envList = qvariant_cast<QStringList>(gpu[QStringLiteral("Environment")]); + for (int i = 0; i + 1 < envList.size(); i += 2) + { + env.insert(envList[i], envList[i + 1]); + } + return true; + } + } +#endif + return false; +} + +// all of this because keeping things compatible with deprecated old settings +// if either of the settings {a, b} is true, this also resolves to true +class OrSetting : public Setting +{ + Q_OBJECT + public: + OrSetting(QString id, std::shared_ptr<Setting> a, std::shared_ptr<Setting> b) + : Setting({ id }, false), + m_a(a), + m_b(b) + {} + virtual QVariant get() const + { + bool a = m_a->get().toBool(); + bool b = m_b->get().toBool(); + return a || b; + } + virtual void reset() + {} + virtual void set(QVariant value) + {} + + private: + std::shared_ptr<Setting> m_a; + std::shared_ptr<Setting> m_b; +}; + +MinecraftInstance::MinecraftInstance(SettingsObjectPtr globalSettings, + SettingsObjectPtr settings, + const QString& rootDir) + : BaseInstance(globalSettings, settings, rootDir) +{ + m_components.reset(new PackProfile(this)); +} + +void MinecraftInstance::saveNow() +{ + m_components->saveNow(); +} + +void MinecraftInstance::loadSpecificSettings() +{ + if (isSpecificSettingsLoaded()) + return; + + // Java Settings + auto locationOverride = m_settings->registerSetting("OverrideJavaLocation", false); + auto argsOverride = m_settings->registerSetting("OverrideJavaArgs", false); + m_settings->registerSetting("AutomaticJava", false); + + if (auto global_settings = globalSettings()) + { + m_settings->registerOverride(global_settings->getSetting("JavaPath"), locationOverride); + m_settings->registerOverride(global_settings->getSetting("JvmArgs"), argsOverride); + m_settings->registerOverride(global_settings->getSetting("IgnoreJavaCompatibility"), locationOverride); + + // special! + m_settings->registerPassthrough(global_settings->getSetting("JavaSignature"), locationOverride); + m_settings->registerPassthrough(global_settings->getSetting("JavaArchitecture"), locationOverride); + m_settings->registerPassthrough(global_settings->getSetting("JavaRealArchitecture"), locationOverride); + m_settings->registerPassthrough(global_settings->getSetting("JavaVersion"), locationOverride); + m_settings->registerPassthrough(global_settings->getSetting("JavaVendor"), locationOverride); + + // Window Size + auto windowSetting = m_settings->registerSetting("OverrideWindow", false); + m_settings->registerOverride(global_settings->getSetting("LaunchMaximized"), windowSetting); + m_settings->registerOverride(global_settings->getSetting("MinecraftWinWidth"), windowSetting); + m_settings->registerOverride(global_settings->getSetting("MinecraftWinHeight"), windowSetting); + + // Memory + auto memorySetting = m_settings->registerSetting("OverrideMemory", false); + m_settings->registerOverride(global_settings->getSetting("MinMemAlloc"), memorySetting); + m_settings->registerOverride(global_settings->getSetting("MaxMemAlloc"), memorySetting); + m_settings->registerOverride(global_settings->getSetting("PermGen"), memorySetting); + + // Native library workarounds + auto nativeLibraryWorkaroundsOverride = m_settings->registerSetting("OverrideNativeWorkarounds", false); + m_settings->registerOverride(global_settings->getSetting("UseNativeOpenAL"), nativeLibraryWorkaroundsOverride); + m_settings->registerOverride(global_settings->getSetting("CustomOpenALPath"), nativeLibraryWorkaroundsOverride); + m_settings->registerOverride(global_settings->getSetting("UseNativeGLFW"), nativeLibraryWorkaroundsOverride); + m_settings->registerOverride(global_settings->getSetting("CustomGLFWPath"), nativeLibraryWorkaroundsOverride); + + // Performance related options + auto performanceOverride = m_settings->registerSetting("OverridePerformance", false); + m_settings->registerOverride(global_settings->getSetting("EnableFeralGamemode"), performanceOverride); + m_settings->registerOverride(global_settings->getSetting("EnableMangoHud"), performanceOverride); + m_settings->registerOverride(global_settings->getSetting("UseDiscreteGpu"), performanceOverride); + m_settings->registerOverride(global_settings->getSetting("UseZink"), performanceOverride); + + // Miscellaneous + auto miscellaneousOverride = m_settings->registerSetting("OverrideMiscellaneous", false); + m_settings->registerOverride(global_settings->getSetting("CloseAfterLaunch"), miscellaneousOverride); + m_settings->registerOverride(global_settings->getSetting("QuitAfterGameStop"), miscellaneousOverride); + + // Legacy-related options + auto legacySettings = m_settings->registerSetting("OverrideLegacySettings", false); + m_settings->registerOverride(global_settings->getSetting("OnlineFixes"), legacySettings); + + auto envSetting = m_settings->registerSetting("OverrideEnv", false); + m_settings->registerOverride(global_settings->getSetting("Env"), envSetting); + + m_settings->set("InstanceType", "OneSix"); + } + + // Join server on launch, this does not have a global override + m_settings->registerSetting("JoinServerOnLaunch", 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); + m_settings->registerSetting("InstanceAccountId", ""); + + m_settings->registerSetting("ExportName", ""); + m_settings->registerSetting("ExportVersion", "1.0.0"); + m_settings->registerSetting("ExportSummary", ""); + m_settings->registerSetting("ExportAuthor", ""); + m_settings->registerSetting("ExportOptionalFiles", true); + m_settings->registerSetting("ExportRecommendedRAM"); + + auto dataPacksEnabled = m_settings->registerSetting("GlobalDataPacksEnabled", false); + auto dataPacksPath = m_settings->registerSetting("GlobalDataPacksPath", ""); + + connect(dataPacksEnabled.get(), &Setting::SettingChanged, this, [this] { m_data_pack_list.reset(); }); + connect(dataPacksPath.get(), &Setting::SettingChanged, this, [this] { m_data_pack_list.reset(); }); + + // Join server on launch, this does not have a global override + m_settings->registerSetting("OverrideModDownloadLoaders", false); + m_settings->registerSetting("ModDownloadLoaders", "[]"); + + qDebug() << "Instance-type specific settings were loaded!"; + + setSpecificSettingsLoaded(true); + + updateRuntimeContext(); +} + +void MinecraftInstance::updateRuntimeContext() +{ + m_runtimeContext.updateFromInstanceSettings(m_settings); + m_components->invalidateLaunchProfile(); +} + +QString MinecraftInstance::typeName() const +{ + return "Minecraft"; +} + +std::shared_ptr<PackProfile> MinecraftInstance::getPackProfile() const +{ + return m_components; +} + +QSet<QString> MinecraftInstance::traits() const +{ + auto components = getPackProfile(); + if (!components) + { + return { "version-incomplete" }; + } + auto profile = components->getProfile(); + if (!profile) + { + return { "version-incomplete" }; + } + return profile->getTraits(); +} + +QString MinecraftInstance::gameRoot() const +{ + QFileInfo mcDir(FS::PathCombine(instanceRoot(), "minecraft")); + QFileInfo dotMCDir(FS::PathCombine(instanceRoot(), ".minecraft")); + + if (dotMCDir.exists() && !mcDir.exists()) + return dotMCDir.filePath(); + else + return mcDir.filePath(); +} + +QString MinecraftInstance::binRoot() const +{ + return FS::PathCombine(gameRoot(), "bin"); +} + +QString MinecraftInstance::getNativePath() const +{ + QDir natives_dir(FS::PathCombine(instanceRoot(), "natives/")); + return natives_dir.absolutePath(); +} + +QString MinecraftInstance::getLocalLibraryPath() const +{ + QDir libraries_dir(FS::PathCombine(instanceRoot(), "libraries/")); + return libraries_dir.absolutePath(); +} + +bool MinecraftInstance::supportsDemo() const +{ + Version instance_ver{ getPackProfile()->getComponentVersion("net.minecraft") }; + // Demo mode was introduced in 1.3.1: https://minecraft.wiki/w/Demo_mode#History + // Note: This check may not work correctly for non-release versions due to version string formatting. Demo support + // is based on release versions. + return instance_ver >= Version("1.3.1"); +} + +QString MinecraftInstance::jarModsDir() const +{ + QDir jarmods_dir(FS::PathCombine(instanceRoot(), "jarmods/")); + return jarmods_dir.absolutePath(); +} + +QString MinecraftInstance::modsRoot() const +{ + return FS::PathCombine(gameRoot(), "mods"); +} + +QString MinecraftInstance::modsCacheLocation() const +{ + return FS::PathCombine(instanceRoot(), "mods.cache"); +} + +QString MinecraftInstance::coreModsDir() const +{ + return FS::PathCombine(gameRoot(), "coremods"); +} + +QString MinecraftInstance::nilModsDir() const +{ + return FS::PathCombine(gameRoot(), "nilmods"); +} + +QString MinecraftInstance::dataPacksDir() +{ + QString relativePath = settings()->get("GlobalDataPacksPath").toString(); + + if (relativePath.isEmpty()) + relativePath = "datapacks"; + + return QDir(gameRoot()).filePath(relativePath); +} + +QString MinecraftInstance::resourcePacksDir() const +{ + return FS::PathCombine(gameRoot(), "resourcepacks"); +} + +QString MinecraftInstance::texturePacksDir() const +{ + return FS::PathCombine(gameRoot(), "texturepacks"); +} + +QString MinecraftInstance::shaderPacksDir() const +{ + return FS::PathCombine(gameRoot(), "shaderpacks"); +} + +QString MinecraftInstance::instanceConfigFolder() const +{ + return FS::PathCombine(gameRoot(), "config"); +} + +QString MinecraftInstance::libDir() const +{ + return FS::PathCombine(gameRoot(), "lib"); +} + +QString MinecraftInstance::worldDir() const +{ + return FS::PathCombine(gameRoot(), "saves"); +} + +QString MinecraftInstance::resourcesDir() const +{ + return FS::PathCombine(gameRoot(), "resources"); +} + +QDir MinecraftInstance::librariesPath() const +{ + return QDir::current().absoluteFilePath("libraries"); +} + +QDir MinecraftInstance::jarmodsPath() const +{ + return QDir(jarModsDir()); +} + +QDir MinecraftInstance::versionsPath() const +{ + return QDir::current().absoluteFilePath("versions"); +} + +QStringList MinecraftInstance::getClassPath() +{ + QStringList jars, nativeJars; + auto profile = m_components->getProfile(); + profile->getLibraryFiles(runtimeContext(), jars, nativeJars, getLocalLibraryPath(), binRoot()); + return jars; +} + +QString MinecraftInstance::getMainClass() const +{ + auto profile = m_components->getProfile(); + return profile->getMainClass(); +} + +QStringList MinecraftInstance::getNativeJars() +{ + QStringList jars, nativeJars; + auto profile = m_components->getProfile(); + profile->getLibraryFiles(runtimeContext(), jars, nativeJars, getLocalLibraryPath(), binRoot()); + return nativeJars; +} + +QStringList MinecraftInstance::extraArguments() +{ + auto list = Commandline::splitArgs(settings()->get("JvmArgs").toString()); + auto version = getPackProfile(); + if (!version) + return list; + auto jarMods = getJarMods(); + if (!jarMods.isEmpty()) + { + list.append({ "-Dfml.ignoreInvalidMinecraftCertificates=true", "-Dfml.ignorePatchDiscrepancies=true" }); + } + auto addn = m_components->getProfile()->getAddnJvmArguments(); + if (!addn.isEmpty()) + { + list.append(addn); + } + auto agents = m_components->getProfile()->getAgents(); + for (auto agent : agents) + { + QStringList jar, temp1, temp2, temp3; + agent->library()->getApplicableFiles(runtimeContext(), jar, temp1, temp2, temp3, getLocalLibraryPath()); + list.append("-javaagent:" + jar[0] + (agent->argument().isEmpty() ? "" : "=" + agent->argument())); + } + + { + QString openALPath; + QString glfwPath; + + if (settings()->get("UseNativeOpenAL").toBool()) + { + openALPath = APPLICATION->m_detectedOpenALPath; + auto customPath = settings()->get("CustomOpenALPath").toString(); + if (!customPath.isEmpty()) + openALPath = customPath; + } + if (settings()->get("UseNativeGLFW").toBool()) + { + glfwPath = APPLICATION->m_detectedGLFWPath; + auto customPath = settings()->get("CustomGLFWPath").toString(); + if (!customPath.isEmpty()) + glfwPath = customPath; + } + + QFileInfo openALInfo(openALPath); + QFileInfo glfwInfo(glfwPath); + + if (!openALPath.isEmpty() && openALInfo.exists()) + list.append("-Dorg.lwjgl.openal.libname=" + openALInfo.absoluteFilePath()); + if (!glfwPath.isEmpty() && glfwInfo.exists()) + list.append("-Dorg.lwjgl.glfw.libname=" + glfwInfo.absoluteFilePath()); + } + + return list; +} + +QStringList MinecraftInstance::javaArguments() +{ + QStringList args; + + // custom args go first. we want to override them if we have our own here. + args.append(extraArguments()); + + // OSX dock icon and name +#ifdef Q_OS_MAC + args << "-Xdock:icon=icon.png"; + args << QString("-Xdock:name=\"%1\"").arg(windowTitle()); +#endif + auto traits_ = traits(); + // HACK: fix issues on macOS with 1.13 snapshots + // NOTE: Oracle Java option. if there are alternate jvm implementations, this would be the place to customize this + // for them +#ifdef Q_OS_MAC + if (traits_.contains("FirstThreadOnMacOS")) + { + args << QString("-XstartOnFirstThread"); + } +#endif + + // HACK: Stupid hack for Intel drivers. See: https://mojang.atlassian.net/browse/MCL-767 +#ifdef Q_OS_WIN32 + args << QString("-XX:HeapDumpPath=MojangTricksIntelDriversForPerformance_javaw.exe_" + "minecraft.exe.heapdump"); +#endif + + int min = settings()->get("MinMemAlloc").toInt(); + int max = settings()->get("MaxMemAlloc").toInt(); + if (min < max) + { + args << QString("-Xms%1m").arg(min); + args << QString("-Xmx%1m").arg(max); + } + else + { + args << QString("-Xms%1m").arg(max); + args << QString("-Xmx%1m").arg(min); + } + + // No PermGen in newer java. + projt::java::RuntimeVersion javaVersion = getRuntimeVersion(); + if (javaVersion.needsPermGen()) + { + auto permgen = settings()->get("PermGen").toInt(); + if (permgen != 64) + { + args << QString("-XX:PermSize=%1m").arg(permgen); + } + } + + args << "-Duser.language=en"; + + if (javaVersion.supportsModules() && shouldApplyOnlineFixes()) + // allow reflective access to java.net - required by the skin fix + args << "--add-opens" + << "java.base/java.net=ALL-UNNAMED"; + + return args; +} + +QString MinecraftInstance::getLauncher() +{ + // use legacy launcher if the traits are set + if (isLegacy()) + return "legacy"; + + return "standard"; +} + +bool MinecraftInstance::shouldApplyOnlineFixes() +{ + return traits().contains("legacyServices") && settings()->get("OnlineFixes").toBool(); +} + +QMap<QString, QString> MinecraftInstance::getVariables() +{ + QMap<QString, QString> out; + out.insert("INST_NAME", name()); + out.insert("INST_ID", id()); + out.insert("INST_DIR", QDir::toNativeSeparators(QDir(instanceRoot()).absolutePath())); + out.insert("INST_MC_DIR", QDir::toNativeSeparators(QDir(gameRoot()).absolutePath())); + out.insert("INST_JAVA", QDir::toNativeSeparators(QDir(settings()->get("JavaPath").toString()).absolutePath())); + out.insert("INST_JAVA_ARGS", javaArguments().join(' ')); + out.insert("NO_COLOR", "1"); +#ifdef Q_OS_MACOS + // get library for Steam overlay support + QString steamDyldInsertLibraries = qEnvironmentVariable("STEAM_DYLD_INSERT_LIBRARIES"); + if (!steamDyldInsertLibraries.isEmpty()) + { + out.insert("DYLD_INSERT_LIBRARIES", steamDyldInsertLibraries); + } +#endif + return out; +} + +QProcessEnvironment MinecraftInstance::createEnvironment() +{ + // prepare the process environment + QProcessEnvironment env = projt::java::buildCleanEnvironment(); + + // export some infos + auto variables = getVariables(); + for (auto it = variables.begin(); it != variables.end(); ++it) + { + env.insert(it.key(), it.value()); + } + // custom env + + auto insertEnv = [&env](QString value) + { + auto envMap = Json::toMap(value); + if (envMap.isEmpty()) + return; + + for (auto iter = envMap.begin(); iter != envMap.end(); iter++) + env.insert(iter.key(), iter.value().toString()); + }; + + bool overrideEnv = settings()->get("OverrideEnv").toBool(); + + if (!overrideEnv) + insertEnv(APPLICATION->settings()->get("Env").toString()); + else + insertEnv(settings()->get("Env").toString()); + return env; +} + +QProcessEnvironment MinecraftInstance::createLaunchEnvironment() +{ + // prepare the process environment + QProcessEnvironment env = createEnvironment(); + +#ifdef Q_OS_LINUX + if (settings()->get("EnableMangoHud").toBool() && APPLICATION->capabilities() & Application::SupportsMangoHud) + { + QStringList preloadList; + if (auto value = env.value("LD_PRELOAD"); !value.isEmpty()) + preloadList = value.split(QLatin1String(":")); + + auto mangoHudLibString = MangoHud::getLibraryString(); + if (!mangoHudLibString.isEmpty()) + { + QFileInfo mangoHudLib(mangoHudLibString); + QString libPath = mangoHudLib.absolutePath(); + auto appendLib = [libPath, &preloadList](QString fileName) + { + if (QFileInfo(FS::PathCombine(libPath, fileName)).exists()) + preloadList << FS::PathCombine(libPath, fileName); + }; + + // dlsym variant is only needed for OpenGL and not included in the vulkan layer + appendLib("libMangoHud_dlsym.so"); + appendLib("libMangoHud_opengl.so"); + appendLib("libMangoHud_shim.so"); + preloadList << mangoHudLibString; + } + + env.insert("LD_PRELOAD", preloadList.join(QLatin1String(":"))); + env.insert("MANGOHUD", "1"); + } + + if (settings()->get("UseDiscreteGpu").toBool()) + { + if (!switcherooSetupGPU(env)) + { + // Open Source Drivers + env.insert("DRI_PRIME", "1"); + // Proprietary Nvidia Drivers + env.insert("__NV_PRIME_RENDER_OFFLOAD", "1"); + env.insert("__VK_LAYER_NV_optimus", "NVIDIA_only"); + env.insert("__GLX_VENDOR_LIBRARY_NAME", "nvidia"); + } + } + + if (settings()->get("UseZink").toBool()) + { + // taken from https://wiki.archlinux.org/title/OpenGL#OpenGL_over_Vulkan_(Zink) + env.insert("__GLX_VENDOR_LIBRARY_NAME", "mesa"); + env.insert("MESA_LOADER_DRIVER_OVERRIDE", "zink"); + env.insert("GALLIUM_DRIVER", "zink"); + } +#endif + return env; +} + +static QString replaceTokensIn(QString text, QMap<QString, QString> with) +{ + // Replace tokens in the format ${key} with values from the map. + QString result; + static const QRegularExpression s_token_regexp("\\$\\{(.+)\\}", QRegularExpression::InvertedGreedinessOption); + QStringList list; + QRegularExpressionMatchIterator i = s_token_regexp.globalMatch(text); + int lastCapturedEnd = 0; + while (i.hasNext()) + { + QRegularExpressionMatch match = i.next(); + result.append(text.mid(lastCapturedEnd, match.capturedStart())); + QString key = match.captured(1); + auto iter = with.find(key); + if (iter != with.end()) + { + result.append(*iter); + } + lastCapturedEnd = match.capturedEnd(); + } + result.append(text.mid(lastCapturedEnd)); + return result; +} + +QStringList MinecraftInstance::processMinecraftArgs(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin) const +{ + auto profile = m_components->getProfile(); + QString args_pattern = profile->getMinecraftArguments(); + for (auto tweaker : profile->getTweakers()) + { + args_pattern += " --tweakClass " + tweaker; + } + + 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; + } + } + + QMap<QString, QString> token_mapping; + // yggdrasil! + if (session) + { + // token_mapping["auth_username"] = session->username; + token_mapping["auth_session"] = session->session; + token_mapping["auth_access_token"] = session->access_token; + token_mapping["auth_player_name"] = session->player_name; + token_mapping["auth_uuid"] = session->uuid; + token_mapping["user_properties"] = session->serializeUserProperties(); + token_mapping["user_type"] = session->user_type; + if (session->launchMode == LaunchMode::Demo) + { + args_pattern += " --demo"; + } + } + + token_mapping["profile_name"] = name(); + token_mapping["version_name"] = profile->getMinecraftVersion(); + token_mapping["version_type"] = profile->getMinecraftVersionType(); + + QString absRootDir = QDir(gameRoot()).absolutePath(); + token_mapping["game_directory"] = absRootDir; + QString absAssetsDir = QDir("assets/").absolutePath(); + auto assets = profile->getMinecraftAssets(); + token_mapping["game_assets"] = AssetsUtils::getAssetsDir(assets->id, resourcesDir()).absolutePath(); + + // 1.7.3+ assets tokens + token_mapping["assets_root"] = absAssetsDir; + token_mapping["assets_index_name"] = assets->id; + + QStringList parts = args_pattern.split(' ', Qt::SkipEmptyParts); + for (int i = 0; i < parts.length(); i++) + { + parts[i] = replaceTokensIn(parts[i], token_mapping); + } + return parts; +} + +QString MinecraftInstance::createLaunchScript(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin) +{ + QString launchScript; + + if (!m_components) + return QString(); + auto profile = m_components->getProfile(); + if (!profile) + return QString(); + + auto mainClass = getMainClass(); + if (!mainClass.isEmpty()) + { + launchScript += "mainClass " + mainClass + "\n"; + } + auto appletClass = profile->getAppletClass(); + if (!appletClass.isEmpty()) + { + launchScript += "appletClass " + appletClass + "\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 + for (auto param : processMinecraftArgs(session, nullptr /* When using a launch script, the server parameters are + handled by it*/ + )) + { + launchScript += "param " + param + "\n"; + } + + // window size, title and state, legacy + { + QString windowParams; + if (settings()->get("LaunchMaximized").toBool()) + { + // Note: Fullscreen/maximization support is limited. UI enhancements for fullscreen mode are needed. + if (!isLegacy()) + { + auto screen = QGuiApplication::primaryScreen(); + auto screenGeometry = screen->availableSize(); + + // small hack to get the widow decorations + for (auto w : QApplication::topLevelWidgets()) + { + auto mainWindow = qobject_cast<QMainWindow*>(w); + if (mainWindow) + { + auto m = mainWindow->windowHandle()->frameMargins(); + screenGeometry = screenGeometry.shrunkBy(m); + break; + } + } + + windowParams = QString("%1x%2").arg(screenGeometry.width()).arg(screenGeometry.height()); + } + else + { + windowParams = "maximized"; + } + } + else + { + windowParams = QString("%1x%2") + .arg(settings()->get("MinecraftWinWidth").toInt()) + .arg(settings()->get("MinecraftWinHeight").toInt()); + } + launchScript += "windowTitle " + windowTitle() + "\n"; + launchScript += "windowParams " + windowParams + "\n"; + } + + // launcher info + { + launchScript += "launcherBrand " + BuildConfig.LAUNCHER_NAME + "\n"; + launchScript += "launcherVersion " + BuildConfig.printableVersionString() + "\n"; + } + + // instance info + { + launchScript += "instanceName " + name() + "\n"; + launchScript += "instanceIconKey " + name() + "\n"; + launchScript += "instanceIconPath icon.png\n"; // we already save a copy here + } + + // legacy auth + if (session) + { + launchScript += "userName " + session->player_name + "\n"; + launchScript += "sessionId " + session->session + "\n"; + } + + for (auto trait : profile->getTraits()) + { + launchScript += "traits " + trait + "\n"; + } + + if (shouldApplyOnlineFixes()) + launchScript += "onlineFixes true\n"; + + launchScript += "launcher " + getLauncher() + "\n"; + + // qDebug() << "Generated launch script:" << launchScript; + return launchScript; +} + +QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, MinecraftTarget::Ptr targetToJoin) +{ + QStringList out; + out << "Main Class:" + << " " + getMainClass() << ""; + out << "Native path:" + << " " + getNativePath() << ""; + + auto profile = m_components->getProfile(); + + // traits + auto alltraits = traits(); + if (alltraits.size()) + { + out << "Traits:"; + for (auto trait : alltraits) + { + out << "traits " + trait; + } + out << ""; + } + + // native libraries + auto settings = this->settings(); + bool nativeOpenAL = settings->get("UseNativeOpenAL").toBool(); + bool nativeGLFW = settings->get("UseNativeGLFW").toBool(); + if (nativeOpenAL || nativeGLFW) + { + if (nativeOpenAL) + out << "Using system OpenAL."; + if (nativeGLFW) + out << "Using system GLFW."; + out << ""; + } + + // libraries and class path. + { + out << "Libraries:"; + QStringList jars, nativeJars; + profile->getLibraryFiles(runtimeContext(), jars, nativeJars, getLocalLibraryPath(), binRoot()); + auto printLibFile = [&out](const QString& path) + { + QFileInfo info(path); + if (info.exists()) + { + out << " " + path; + } + else + { + out << " " + path + " (missing)"; + } + }; + for (auto file : jars) + { + printLibFile(file); + } + out << ""; + out << "Native libraries:"; + for (auto file : nativeJars) + { + printLibFile(file); + } + out << ""; + } + + // mods and core mods + auto printModList = [&out](const QString& label, ModFolderModel& model) + { + if (model.size()) + { + out << QString("%1:").arg(label); + auto modList = model.allMods(); + std::sort(modList.begin(), + modList.end(), + [](auto a, auto b) + { + auto aName = a->fileinfo().completeBaseName(); + auto bName = b->fileinfo().completeBaseName(); + return aName.localeAwareCompare(bName) < 0; + }); + for (auto mod : modList) + { + if (mod->type() == ResourceType::FOLDER) + { + out << u8" [🖿] " + mod->fileinfo().completeBaseName() + " (folder)"; + continue; + } + + if (mod->enabled()) + { + out << u8" [✔] " + mod->fileinfo().completeBaseName(); + } + else + { + out << u8" [✘] " + mod->fileinfo().completeBaseName() + " (disabled)"; + } + } + out << ""; + } + }; + + printModList("Mods", *(loaderModList().get())); + printModList("Core Mods", *(coreModList().get())); + + // jar mods + auto& jarMods = profile->getJarMods(); + if (jarMods.size()) + { + out << "Jar Mods:"; + for (auto& jarmod : jarMods) + { + auto displayname = jarmod->displayName(runtimeContext()); + auto realname = jarmod->filename(runtimeContext()); + if (displayname != realname) + { + out << " " + displayname + " (" + realname + ")"; + } + else + { + out << " " + realname; + } + } + out << ""; + } + + // 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)"; + } + else + { + auto width = settings->get("MinecraftWinWidth").toInt(); + auto height = settings->get("MinecraftWinHeight").toInt(); + out << "Window size: " + QString::number(width) + " x " + QString::number(height); + } + out << ""; + out << "Launcher: " + getLauncher(); + out << ""; + return out; +} + +QMap<QString, QString> MinecraftInstance::createCensorFilterFromSession(AuthSessionPtr session) +{ + if (!session) + { + return QMap<QString, QString>(); + } + auto& sessionRef = *session.get(); + QMap<QString, QString> filter; + auto addToFilter = [&filter](QString key, QString value) + { + if (key.trimmed().size()) + { + filter[key] = value; + } + }; + if (sessionRef.session != "-") + { + addToFilter(sessionRef.session, tr("<SESSION ID>")); + } + if (sessionRef.access_token != "0") + { + addToFilter(sessionRef.access_token, tr("<ACCESS TOKEN>")); + } + addToFilter(sessionRef.uuid, tr("<PROFILE ID>")); + + return filter; +} + +QStringList MinecraftInstance::getLogFileSearchPaths() +{ + return { FS::PathCombine(gameRoot(), "crash-reports"), FS::PathCombine(gameRoot(), "logs"), gameRoot() }; +} + +QString MinecraftInstance::getStatusbarDescription() +{ + QStringList traits; + if (hasVersionBroken()) + { + traits.append(tr("broken")); + } + + QString mcVersion = m_components->getComponentVersion("net.minecraft"); + if (mcVersion.isEmpty()) + { + // Load component info if needed - use Online mode to fetch metadata if not cached + m_components->reload(Net::Mode::Online); + mcVersion = m_components->getComponentVersion("net.minecraft"); + } + + QString description; + description.append(tr("Minecraft %1").arg(mcVersion)); + if (m_settings->get("ShowGameTime").toBool()) + { + if (lastTimePlayed() > 0 && lastLaunch() > 0) + { + QDateTime lastLaunchTime = QDateTime::fromMSecsSinceEpoch(lastLaunch()); + description.append( + tr(", last played on %1 for %2") + .arg(QLocale().toString(lastLaunchTime, QLocale::ShortFormat)) + .arg(Time::prettifyDuration(lastTimePlayed(), + APPLICATION->settings()->get("ShowGameTimeWithoutDays").toBool()))); + } + + if (totalTimePlayed() > 0) + { + description.append( + tr(", total played for %1") + .arg(Time::prettifyDuration(totalTimePlayed(), + APPLICATION->settings()->get("ShowGameTimeWithoutDays").toBool()))); + } + } + if (hasCrashed()) + { + description.append(tr(", has crashed.")); + } + return description; +} + +QList<Task::Ptr> MinecraftInstance::createUpdateTask() +{ + return { + // create folders + makeShared<FoldersTask>(this), + // libraries download + makeShared<LibrariesTask>(this), + // FML libraries download and copy into the instance + makeShared<FMLLibrariesTask>(this), + // assets update + makeShared<AssetUpdateTask>(this), + }; +} + +shared_qobject_ptr<projt::launch::LaunchPipeline> MinecraftInstance::createLaunchPipeline( + AuthSessionPtr session, + MinecraftTarget::Ptr targetToJoin) +{ + updateRuntimeContext(); + // Using static_pointer_cast since 'this' is guaranteed to be a MinecraftInstance + auto process = + projt::launch::LaunchPipeline::create(std::dynamic_pointer_cast<MinecraftInstance>(shared_from_this())); + auto pptr = process.get(); + + APPLICATION->icons()->saveIcon(iconKey(), FS::PathCombine(gameRoot(), "icon.png"), "PNG"); + + // print a header + { + process->appendStage( + makeShared<projt::launch::steps::LogMessageStep>(pptr, + "Minecraft folder is:\n" + gameRoot() + "\n\n", + MessageLevel::Launcher)); + } + + // create the .minecraft folder and server-resource-packs (workaround for Minecraft bug MCL-3732) + { + process->appendStage(makeShared<CreateGameFolders>(pptr)); + } + + if (!targetToJoin && settings()->get("JoinServerOnLaunch").toBool()) + { + QString fullAddress = settings()->get("JoinServerOnLaunchAddress").toString(); + 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 (targetToJoin && targetToJoin->port == 25565) + { + // Resolve server address to join on launch + auto step = makeShared<projt::launch::steps::ServerJoinResolveStep>(pptr); + step->setLookupAddress(targetToJoin->address); + step->setOutputTarget(targetToJoin); + process->appendStage(step); + } + + // load meta + { + auto mode = session->launchMode != LaunchMode::Offline ? Net::Mode::Online : Net::Mode::Offline; + process->appendStage( + makeShared<projt::launch::TaskBridgeStage>(pptr, makeShared<MinecraftLoadAndCheck>(this, mode))); + } + + // check java + { + process->appendStage(makeShared<AutoInstallJava>(pptr)); + process->appendStage(makeShared<projt::launch::steps::RuntimeProbeStep>(pptr)); + } + + // run pre-launch command if that's needed + if (getPreLaunchCommand().size()) + { + auto step = makeShared<projt::launch::steps::LaunchCommandStep>( + pptr, + projt::launch::steps::LaunchCommandStep::Hook::PreLaunch, + getPreLaunchCommand()); + step->setWorkingDirectory(gameRoot()); + process->appendStage(step); + } + + // if we aren't in offline mode + if (session->launchMode != LaunchMode::Offline) + { + process->appendStage(makeShared<ClaimAccount>(pptr, session)); + for (auto t : createUpdateTask()) + { + process->appendStage(makeShared<projt::launch::TaskBridgeStage>(pptr, t)); + } + } + + // if there are any jar mods + { + process->appendStage(makeShared<ModMinecraftJar>(pptr)); + } + + // Scan mods folders for mods + { + process->appendStage(makeShared<ScanModFolders>(pptr)); + } + + // print some instance info here... + { + process->appendStage(makeShared<PrintInstanceInfo>(pptr, session, targetToJoin)); + } + + // extract native jars if needed + { + process->appendStage(makeShared<ExtractNatives>(pptr)); + } + + // reconstruct assets if needed + { + process->appendStage(makeShared<ReconstructAssets>(pptr)); + } + + // verify that minimum Java requirements are met + { + process->appendStage(makeShared<VerifyJavaInstall>(pptr)); + } + + { + // actually launch the game + auto step = makeShared<LauncherPartLaunch>(pptr); + step->setWorkingDirectory(gameRoot()); + step->setAuthSession(session); + step->setTargetToJoin(targetToJoin); + process->appendStage(step); + } + + // run post-exit command if that's needed + if (getPostExitCommand().size()) + { + auto step = + makeShared<projt::launch::steps::LaunchCommandStep>(pptr, + projt::launch::steps::LaunchCommandStep::Hook::PostExit, + getPostExitCommand()); + step->setWorkingDirectory(gameRoot()); + process->appendStage(step); + } + if (session) + { + process->setCensorFilter(createCensorFilterFromSession(session)); + } + if (m_settings->get("QuitAfterGameStop").toBool()) + { + process->appendStage(makeShared<projt::launch::steps::QuitAfterGameStep>(pptr)); + } + m_launchProcess = process; + emit launchPipelineChanged(m_launchProcess); + return m_launchProcess; +} + +projt::java::RuntimeVersion MinecraftInstance::getRuntimeVersion() +{ + return projt::java::RuntimeVersion(settings()->get("JavaVersion").toString()); +} + +std::shared_ptr<ModFolderModel> MinecraftInstance::loaderModList() +{ + if (!m_loader_mod_list) + { + bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool(); + m_loader_mod_list.reset(new ModFolderModel(modsRoot(), this, is_indexed, true)); + } + return m_loader_mod_list; +} + +std::shared_ptr<ModFolderModel> MinecraftInstance::coreModList() +{ + if (!m_core_mod_list) + { + bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool(); + m_core_mod_list.reset(new ModFolderModel(coreModsDir(), this, is_indexed, true)); + } + return m_core_mod_list; +} + +std::shared_ptr<ModFolderModel> MinecraftInstance::nilModList() +{ + if (!m_nil_mod_list) + { + bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool(); + m_nil_mod_list.reset(new ModFolderModel(nilModsDir(), this, is_indexed, false)); + } + return m_nil_mod_list; +} + +std::shared_ptr<ResourcePackFolderModel> MinecraftInstance::resourcePackList() +{ + if (!m_resource_pack_list) + { + bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool(); + m_resource_pack_list.reset(new ResourcePackFolderModel(resourcePacksDir(), this, is_indexed, true)); + } + return m_resource_pack_list; +} + +std::shared_ptr<TexturePackFolderModel> MinecraftInstance::texturePackList() +{ + if (!m_texture_pack_list) + { + bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool(); + m_texture_pack_list.reset(new TexturePackFolderModel(texturePacksDir(), this, is_indexed, true)); + } + return m_texture_pack_list; +} + +std::shared_ptr<ShaderPackFolderModel> MinecraftInstance::shaderPackList() +{ + if (!m_shader_pack_list) + { + bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool(); + m_shader_pack_list.reset(new ShaderPackFolderModel(shaderPacksDir(), this, is_indexed, true)); + } + return m_shader_pack_list; +} + +std::shared_ptr<DataPackFolderModel> MinecraftInstance::dataPackList() +{ + if (!m_data_pack_list && settings()->get("GlobalDataPacksEnabled").toBool()) + { + bool isIndexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool(); + m_data_pack_list.reset(new DataPackFolderModel(dataPacksDir(), this, isIndexed, true)); + } + return m_data_pack_list; +} + +QList<std::shared_ptr<ResourceFolderModel>> MinecraftInstance::resourceLists() +{ + return { loaderModList(), coreModList(), nilModList(), resourcePackList(), + texturePackList(), shaderPackList(), dataPackList() }; +} + +std::shared_ptr<WorldList> MinecraftInstance::worldList() +{ + if (!m_world_list) + { + m_world_list.reset(new WorldList(worldDir(), this)); + } + return m_world_list; +} + +QList<Mod*> MinecraftInstance::getJarMods() const +{ + auto profile = m_components->getProfile(); + QList<Mod*> mods; + for (auto jarmod : profile->getJarMods()) + { + QStringList jar, temp1, temp2, temp3; + jarmod->getApplicableFiles(runtimeContext(), jar, temp1, temp2, temp3, jarmodsPath().absolutePath()); + // QString filePath = jarmodsPath().absoluteFilePath(jarmod->filename(currentSystem)); + mods.push_back(new Mod(QFileInfo(jar[0]))); + } + return mods; +} + +#include "MinecraftInstance.moc" |