.clang-tidy

@@ -1,32 +1,32 @@
 FormatStyle: file
 
 Checks:
-    "bugprone-*,clang-analyzer-*,cppcoreguidelines-*,hicpp-*,misc-*,modernize-*,performance-*,portability-*,readability-*,
+  'bugprone-*,clang-analyzer-*,cppcoreguidelines-*,hicpp-*,misc-*,modernize-*,performance-*,portability-*,readability-*,
-    -*-magic-numbers,
+  -*-magic-numbers,
-    -*-non-private-member-variables-in-classes,
+  -*-non-private-member-variables-in-classes,
-    -*-special-member-functions,
+  -*-special-member-functions,
-    -bugprone-easily-swappable-parameters,
+  -bugprone-easily-swappable-parameters,
-    -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-owning-memory,
-    -cppcoreguidelines-pro-type-static-cast-downcast,
+  -cppcoreguidelines-pro-type-static-cast-downcast,
-    -modernize-use-nodiscard,
+  -modernize-use-nodiscard,
-    -modernize-use-trailing-return-type,
+  -modernize-use-trailing-return-type,
-    -portability-avoid-pragma-once,
+  -portability-avoid-pragma-once,
-    -readability-avoid-unconditional-preprocessor-if,
+  -readability-avoid-unconditional-preprocessor-if,
-    -readability-function-cognitive-complexity,
+  -readability-function-cognitive-complexity,
-    -readability-identifier-length,
+  -readability-identifier-length,
-    -readability-redundant-access-specifiers"
+  -readability-redundant-access-specifiers'
 
 CheckOptions:
-    misc-include-cleaner.MissingIncludes: false
+  - { key: misc-include-cleaner.MissingIncludes,                        value: false }
-    readability-identifier-naming.DefaultCase: "camelBack"
+  - { key: readability-identifier-naming.DefaultCase,                   value: camelBack }
-    readability-identifier-naming.NamespaceCase: "CamelCase"
+  - { key: readability-identifier-naming.NamespaceCase,                 value: CamelCase }
-    readability-identifier-naming.ClassCase: "CamelCase"
+  - { key: readability-identifier-naming.ClassCase,                     value: CamelCase }
-    readability-identifier-naming.ClassConstantCase: "CamelCase"
+  - { key: readability-identifier-naming.ClassConstantCase,             value: CamelCase }
-    readability-identifier-naming.EnumCase: "CamelCase"
+  - { key: readability-identifier-naming.EnumCase,                      value: CamelCase }
-    readability-identifier-naming.EnumConstantCase: "CamelCase"
+  - { key: readability-identifier-naming.EnumConstantCase,              value: CamelCase }
-    readability-identifier-naming.MacroDefinitionCase: "UPPER_CASE"
+  - { key: readability-identifier-naming.MacroDefinitionCase,           value: UPPER_CASE }
-    readability-identifier-naming.ClassMemberPrefix: "m_"
+  - { key: readability-identifier-naming.ClassMemberPrefix,             value: m_ }
-    readability-identifier-naming.StaticConstantPrefix: "s_"
+  - { key: readability-identifier-naming.StaticConstantPrefix,          value: s_ }
-    readability-identifier-naming.StaticVariablePrefix: "s_"
+  - { key: readability-identifier-naming.StaticVariablePrefix,          value: s_ }
-    readability-identifier-naming.GlobalConstantPrefix: "g_"
+  - { key: readability-identifier-naming.GlobalConstantPrefix,          value: g_ }
-    readability-implicit-bool-conversion.AllowPointerConditions: true
+  - { key: readability-implicit-bool-conversion.AllowPointerConditions, value: true }

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -23,14 +23,14 @@ body:
     - macOS
     - Linux
     - Other
-- type: input
+- type: textarea
   attributes:
     label: Version of Prism Launcher
     description: The version of Prism Launcher used in the bug report.
     placeholder: Prism Launcher 5.0
   validations:
     required: true
-- type: input
+- type: textarea
   attributes:
     label: Version of Qt
     description: The version of Qt used in the bug report. You can find it in Help -> About Prism Launcher -> About Qt.

.github/actions/package/linux/action.yml

@@ -91,9 +91,9 @@ runs:
         find "$INSTALL_APPIMAGE_DIR" -name '*gamemode*' -exec rm {} +
 
         #disable OpenGL and Vulkan launcher features until https://github.com/VHSgunzo/sharun/issues/35
-        echo "PRISMLAUNCHER_DISABLE_GLVULKAN=1" >> "$INSTALL_APPIMAGE_DIR"/.env
+        echo "LAUNCHER_DISABLE_GLVULKAN=1" > "$INSTALL_APPIMAGE_DIR"/.env
         #makes the launcher use portals for file picking
-        echo "QT_QPA_PLATFORMTHEME=xdgdesktopportal" >> "$INSTALL_APPIMAGE_DIR"/.env
+        echo "QT_QPA_PLATFORMTHEME=xdgdesktopportal" > "$INSTALL_APPIMAGE_DIR"/.env
         ln -s org.prismlauncher.PrismLauncher.metainfo.xml "$INSTALL_APPIMAGE_DIR"/share/metainfo/org.prismlauncher.PrismLauncher.appdata.xml
         ln -s share/applications/org.prismlauncher.PrismLauncher.desktop "$INSTALL_APPIMAGE_DIR"
         ln -s share/icons/hicolor/256x256/apps/org.prismlauncher.PrismLauncher.png "$INSTALL_APPIMAGE_DIR"

.github/actions/package/windows/action.yml

@@ -69,7 +69,7 @@ runs:
 
     - name: Sign executables
       if: ${{ env.CI_HAS_ACCESS_TO_AZURE != '' && inputs.azure-client-id != '' }}
-      uses: azure/artifact-signing-action@v2
+      uses: azure/artifact-signing-action@v1
       with:
         endpoint: https://eus.codesigning.azure.net/
         trusted-signing-account-name: PrismLauncher
@@ -142,7 +142,7 @@ runs:
 
     - name: Sign installer
       if: ${{ env.CI_HAS_ACCESS_TO_AZURE != '' && inputs.azure-client-id != '' }}
-      uses: azure/artifact-signing-action@v2
+      uses: azure/artifact-signing-action@v1
       with:
         endpoint: https://eus.codesigning.azure.net/
         trusted-signing-account-name: PrismLauncher

.github/actions/setup-dependencies/action.yml

@@ -55,7 +55,7 @@ runs:
     # TODO(@getchoo): Get this working on MSYS2!
     - name: Setup ccache
       if: ${{ (runner.os != 'Windows' || inputs.msystem == '') && inputs.build-type == 'Debug' }}
-      uses: hendrikmuhs/ccache-action@v1.2.23
+      uses: hendrikmuhs/ccache-action@v1.2.21
       with:
         variant: sccache
         create-symlink: ${{ runner.os != 'Windows' }}

.github/actions/setup-dependencies/linux/action.yml

@@ -13,7 +13,7 @@ runs:
           dpkg-dev \
           ninja-build extra-cmake-modules pkg-config scdoc \
           cmark gamemode-dev libarchive-dev libcmark-dev libqrencode-dev zlib1g-dev \
-          libxcb-cursor-dev libtomlplusplus-dev
+          libxcb-cursor-dev libtomlplusplus-dev libvulkan-dev
 
     - name: Setup AppImage tooling
       shell: bash

.github/actions/setup-dependencies/windows/action.yml

@@ -91,7 +91,7 @@ runs:
 
     - name: Retrieve ccache cache (MinGW)
       if: ${{ inputs.msystem != '' && inputs.build-type == 'Debug' }}
-      uses: actions/cache@v5.0.5
+      uses: actions/cache@v5.0.4
       with:
         path: '${{ github.workspace }}\.ccache'
         key: ${{ runner.os }}-mingw-w64-ccache-${{ github.run_id }}

.github/workflows/backport.yml

@@ -24,7 +24,7 @@ jobs:
         with:
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Create backport PRs
-        uses: korthout/backport-action@v4.5
+        uses: korthout/backport-action@v4.2.0
         with:
           # Config README: https://github.com/korthout/backport-action#backport-action
           pull_description: |-

.github/workflows/clang-tidy.yml

@@ -28,14 +28,19 @@ jobs:
           fetch-depth: 0 # Required for diffing later on
           submodules: "true"
 
+      - name: Setup sccache
+        uses: hendrikmuhs/ccache-action@v1.2.21
+        with:
+          variant: sccache
+
       - name: Install Nix
         uses: cachix/install-nix-action@v31
 
-      - name: Run source generators
+      - name: Run build
         # TODO(@getchoo): Figure out how to make this work with PCH
         run: |
           nix develop --command bash -c '
-            cmake -B build -D Launcher_USE_PCH=OFF && cmake --build build --target autogen autorcc
+            cmake -B build -D Launcher_USE_PCH=OFF -D CMAKE_CXX_COMPILER_LAUNCHER=sccache && cmake --build build
           '
 
       # TODO: Use SARIF after https://github.com/psastras/sarif-rs/issues/638 is fixed
@@ -44,5 +49,5 @@ jobs:
           BASE_REF: ${{ github.event.pull_request.base.sha || github.event.merge_group.base_sha }}
         run: |
           nix develop --command bash -c '
-            clang-tidy -verify-config && git diff -U0 --no-color "$BASE_REF" | clang-tidy-diff.py -p1 -quiet -only-check-in-db
+            git diff -U0 --no-color "$BASE_REF" | clang-tidy-diff.py -p1
           '

.github/workflows/container.yml

@@ -33,7 +33,7 @@ jobs:
           - arch: arm64
             os: ubuntu-24.04-arm
           - arch: amd64
-            os: ubuntu-24.04
+            os: ubuntu-24.04-arm
 
     runs-on: ${{ matrix.os }}
 

.github/workflows/nix.yml

@@ -88,7 +88,7 @@ jobs:
           - os: ubuntu-22.04-arm
             system: aarch64-linux
 
-          - os: macos-26
+          - os: macos-14
             system: aarch64-darwin
 
     runs-on: ${{ matrix.os }}
@@ -103,7 +103,7 @@ jobs:
         # For PRs
       - name: Setup Nix Magic Cache
         if: ${{ github.event_name == 'pull_request' }}
-        uses: DeterminateSystems/magic-nix-cache-action@v14
+        uses: DeterminateSystems/magic-nix-cache-action@v13
         with:
           diagnostic-endpoint: ""
           use-flakehub: false

.github/workflows/release.yml

@@ -94,7 +94,7 @@ jobs:
 
       - name: Create release
         id: create_release
-        uses: softprops/action-gh-release@v3
+        uses: softprops/action-gh-release@v2
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           tag_name: ${{ github.ref }}

.github/workflows/update-flake.yml

@@ -20,16 +20,14 @@ jobs:
 
     steps:
       - uses: actions/checkout@v6
-      - uses: cachix/install-nix-action@8aa03977d8d733052d78f4e008a241fd1dbf36b3 # v31
+      - uses: cachix/install-nix-action@1ca7d21a94afc7c957383a2d217460d980de4934 # v31
 
       - uses: DeterminateSystems/update-flake-lock@v28
         with:
           commit-msg: "chore(nix): update lockfile"
           pr-title: "chore(nix): update lockfile"
           pr-labels: |
-            platform: Linux
+            Linux
-            area: packaging
+            packaging
-            complexity: low
+            simple change
-            priority: low
-            type: robot
             changelog:omit

CMakeLists.txt

@@ -13,10 +13,6 @@ endif()
 ##################################### Set CMake options #####################################
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
-set(CMAKE_AUTOUIC ON)
-set(CMAKE_AUTOGEN_ORIGIN_DEPENDS OFF)
-set(CMAKE_GLOBAL_AUTOGEN_TARGET ON)
-set(CMAKE_GLOBAL_AUTORCC_TARGET ON)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
@@ -183,7 +179,7 @@ set(Launcher_LOGIN_CALLBACK_URL "https://prismlauncher.org/successful-login" CAC
 set(Launcher_LEGACY_FMLLIBS_BASE_URL "https://files.prismlauncher.org/fmllibs/" CACHE STRING "URL for legacy (<=1.5.2) FML Libraries.")
 
 ######## Set version numbers ########
-set(Launcher_VERSION_MAJOR 12)
+set(Launcher_VERSION_MAJOR 11)
 set(Launcher_VERSION_MINOR 0)
 set(Launcher_VERSION_PATCH 0)
 

buildconfig/BuildConfig.cpp.in

@@ -50,7 +50,6 @@ Config::Config()
     LAUNCHER_GIT = "@Launcher_Git@";
     LAUNCHER_APPID = "@Launcher_AppID@";
     LAUNCHER_SVGFILENAME = "@Launcher_SVGFileName@";
-    LAUNCHER_ENVNAME = "@Launcher_ENVName@";
 
     USER_AGENT = "@Launcher_UserAgent@";
 

buildconfig/BuildConfig.h

@@ -54,7 +54,6 @@ class Config {
     QString LAUNCHER_GIT;
     QString LAUNCHER_APPID;
     QString LAUNCHER_SVGFILENAME;
-    QString LAUNCHER_ENVNAME;
 
     /// The major version number.
     int VERSION_MAJOR;
@@ -194,10 +193,8 @@ class Config {
     QString MODRINTH_STAGING_URL = "https://staging-api.modrinth.com/v2";
     QString MODRINTH_PROD_URL = "https://api.modrinth.com/v2";
     QStringList MODRINTH_MRPACK_HOSTS{ "cdn.modrinth.com", "github.com", "raw.githubusercontent.com", "gitlab.com" };
-    QString MODRINTH_DOWNLOAD_HOST = "cdn.modrinth.com";
 
     QString FLAME_BASE_URL = "https://api.curseforge.com/v1";
-    QString FLAME_DOWNLOAD_HOST = "edge.forgecdn.net";
 
     QString versionString() const;
     /**

flake.lock

@@ -18,15 +18,15 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1778443072,
+        "lastModified": 1773964973,
-        "narHash": "sha256-rNDJzV2JTV5SUTwv1cgKZYMdyoUYU9/YfegSaUf3QfY=",
+        "narHash": "sha256-d2Q5VNbc91GloTZNByC4u3JS8Tj5BjfuOF19/vuJ/iM=",
-        "rev": "da5ad661ba4e5ef59ba743f0d112cbc30e474f32",
+        "rev": "812b3986fd1568f7a858f97fcf425ad996ba7d25",
         "type": "tarball",
-        "url": "https://releases.nixos.org/nixos/unstable/nixos-26.05pre995699.da5ad661ba4e/nixexprs.tar.xz"
+        "url": "https://releases.nixos.org/nixos/25.11/nixos-25.11.7849.812b3986fd15/nixexprs.tar.xz"
       },
       "original": {
         "type": "tarball",
-        "url": "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz"
+        "url": "https://channels.nixos.org/nixos-25.11/nixexprs.tar.xz"
       }
     },
     "root": {

flake.nix

@@ -9,7 +9,7 @@
   };
 
   inputs = {
-    nixpkgs.url = "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz";
+    nixpkgs.url = "https://channels.nixos.org/nixos-25.11/nixexprs.tar.xz";
 
     libnbtplusplus = {
       url = "github:PrismLauncher/libnbtplusplus";
@@ -42,7 +42,7 @@
 
         let
           pkgs = nixpkgsFor.${system};
-          llvm = pkgs.llvmPackages_22;
+          llvm = pkgs.llvmPackages_19;
         in
 
         {
@@ -85,7 +85,7 @@
 
         let
           pkgs = nixpkgsFor.${system};
-          llvm = pkgs.llvmPackages_22;
+          llvm = pkgs.llvmPackages_19;
           python = pkgs.python3;
           mkShell = pkgs.mkShell.override { inherit (llvm) stdenv; };
 
@@ -189,7 +189,7 @@
         final: prev:
 
         let
-          llvm = final.llvmPackages_22 or prev.llvmPackages_22;
+          llvm = final.llvmPackages_19 or prev.llvmPackages_19;
         in
 
         {

launcher/Application.cpp

@@ -514,13 +514,12 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         logFile = std::unique_ptr<QFile>(new QFile(logBase.arg(0)));
         if (!logFile->open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) {
             showFatalErrorMessage("The launcher data folder is not writable!",
-                                  QString("The launcher couldn't create a log file - %1.\n"
+                                  QString("The launcher couldn't create a log file - the data folder is not writable.\n"
                                           "\n"
                                           "Make sure you have write permissions to the data folder.\n"
-                                          "(%2)\n"
+                                          "(%1)\n"
                                           "\n"
                                           "The launcher cannot continue until you fix this problem.")
-                                      .arg(logFile->errorString())
                                       .arg(dataPath));
             return;
         }
@@ -578,14 +577,16 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
     }
 
     {
-        auto migrated = handleDataMigration(
+        bool migrated = false;
-            dataPath, FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../PolyMC"), "PolyMC",
+
-            "polymc.cfg");
+        if (!migrated)
-        if (!migrated) {
+            migrated = handleDataMigration(
-            handleDataMigration(dataPath,
+                dataPath, FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../PolyMC"), "PolyMC",
-                                FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../multimc"),
+                "polymc.cfg");
-                                "MultiMC", "multimc.cfg");
+        if (!migrated)
-        }
+            migrated = handleDataMigration(
+                dataPath, FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../multimc"), "MultiMC",
+                "multimc.cfg");
     }
 
     {
@@ -625,11 +626,11 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
             if (check.write(payload) == payload.size()) {
                 check.close();
             } else {
-                qWarning() << "Could not write into" << liveCheckFile << "error:" << check.errorString();
+                qWarning() << "Could not write into" << liveCheckFile << "!";
                 check.remove();  // also closes file!
             }
         } else {
-            qWarning() << "Could not open" << liveCheckFile << "for writing:" << check.errorString();
+            qWarning() << "Could not open" << liveCheckFile << "for writing!";
         }
     }
 
@@ -733,7 +734,6 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         m_settings->registerSetting({ "MinMemAlloc", "MinMemoryAlloc" }, 512);
         m_settings->registerSetting({ "MaxMemAlloc", "MaxMemoryAlloc" }, SysInfo::defaultMaxJvmMem());
         m_settings->registerSetting("PermGen", 128);
-        m_settings->registerSetting("LowMemWarning", true);
 
         // Java Settings
         m_settings->registerSetting("JavaPath", "");
@@ -777,7 +777,6 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         m_settings->registerSetting("ModDependenciesDisabled", false);
         m_settings->registerSetting("SkipModpackUpdatePrompt", false);
         m_settings->registerSetting("ShowModIncompat", false);
-        m_settings->registerSetting("DownloadGameFilesDuringInstanceCreation", true);
 
         // Minecraft offline player name
         m_settings->registerSetting("LastOfflinePlayerName", "");
@@ -870,7 +869,6 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
             resetIfInvalid(m_settings->registerSetting("LegacyFMLLibsURLOverride", "").get());
         }
 
-        m_settings->registerSetting("MetaRefreshOnLaunch", true);
         m_settings->registerSetting("CloseAfterLaunch", false);
         m_settings->registerSetting("QuitAfterGameStop", false);
 
@@ -935,6 +933,15 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         qInfo() << "<> Network done.";
     }
 
+    // load translations
+    {
+        m_translations.reset(new TranslationsModel("translations"));
+        auto bcp47Name = m_settings->get("Language").toString();
+        m_translations->selectLanguage(bcp47Name);
+        qInfo() << "Your language is" << bcp47Name;
+        qInfo() << "<> Translations loaded.";
+    }
+
     // Instance icons
     {
         auto setting = APPLICATION->settings()->getSetting("IconsDir");
@@ -1013,13 +1020,8 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
         qInfo() << "<> Cache initialized.";
     }
 
-    // load translations
+    // now we have network, download translation updates
-    {
+    m_translations->downloadIndex();
-        m_translations.reset(new TranslationsModel("translations"));
-        m_translations->downloadIndex();
-        qInfo() << "Your language is" << m_translations->selectedLanguage();
-        qInfo() << "<> Translations loaded.";
-    }
 
     // FIXME: what to do with these?
     m_profilers.insert("jprofiler", std::shared_ptr<BaseProfilerFactory>(new JProfilerFactory()));
@@ -1953,7 +1955,7 @@ bool Application::handleDataMigration(const QString& currentData,
     auto setDoNotMigrate = [&nomigratePath] {
         QFile file(nomigratePath);
         if (!file.open(QIODevice::WriteOnly)) {
-            qWarning() << "setDoNotMigrate failed; Failed to open file" << file.fileName() << "for writing:" << file.errorString();
+            qWarning() << "setDoNotMigrate failed; Failed to open file '" << file.fileName() << "' for writing!";
         }
     };
 

launcher/BaseVersionList.h

@@ -63,7 +63,7 @@ class BaseVersionList : public QAbstractListModel {
      * The task returned by this function should reset the model when it's done.
      * \return A pointer to a task that reloads the version list.
      */
-    virtual Task::Ptr getLoadTask(bool forceReload = false) = 0;
+    virtual Task::Ptr getLoadTask() = 0;
 
     //! Checks whether or not the list is loaded. If this returns false, the list should be
     // loaded.

launcher/CMakeLists.txt

@@ -260,8 +260,6 @@ set(MINECRAFT_SOURCES
     minecraft/launch/ClaimAccount.h
     minecraft/launch/CreateGameFolders.cpp
     minecraft/launch/CreateGameFolders.h
-    minecraft/launch/EnsureAvailableMemory.cpp
-    minecraft/launch/EnsureAvailableMemory.h
     minecraft/launch/EnsureOfflineLibraries.cpp
     minecraft/launch/EnsureOfflineLibraries.h
     minecraft/launch/ModMinecraftJar.cpp
@@ -1067,8 +1065,6 @@ SET(LAUNCHER_SOURCES
     ui/dialogs/ImportResourceDialog.h
     ui/dialogs/MSALoginDialog.cpp
     ui/dialogs/MSALoginDialog.h
-    ui/dialogs/NetworkJobFailedDialog.cpp
-    ui/dialogs/NetworkJobFailedDialog.h
     ui/dialogs/NewComponentDialog.cpp
     ui/dialogs/NewComponentDialog.h
     ui/dialogs/NewInstanceDialog.cpp
@@ -1206,6 +1202,77 @@ if(WIN32)
     )
 endif()
 
+qt_wrap_ui(LAUNCHER_UI
+    ui/MainWindow.ui
+    ui/setupwizard/PasteWizardPage.ui
+    ui/setupwizard/AutoJavaWizardPage.ui
+    ui/setupwizard/LoginWizardPage.ui
+    ui/pages/global/AccountListPage.ui
+    ui/pages/global/JavaPage.ui
+    ui/pages/global/LauncherPage.ui
+    ui/pages/global/APIPage.ui
+    ui/pages/global/ProxyPage.ui
+    ui/pages/global/ExternalToolsPage.ui
+    ui/pages/instance/ExternalResourcesPage.ui
+    ui/pages/instance/NotesPage.ui
+    ui/pages/instance/LogPage.ui
+    ui/pages/instance/ServersPage.ui
+    ui/pages/instance/OtherLogsPage.ui
+    ui/pages/instance/VersionPage.ui
+    ui/pages/instance/ManagedPackPage.ui
+    ui/pages/instance/WorldListPage.ui
+    ui/pages/instance/ScreenshotsPage.ui
+    ui/pages/modplatform/atlauncher/AtlOptionalModDialog.ui
+    ui/pages/modplatform/atlauncher/AtlPage.ui
+    ui/pages/modplatform/CustomPage.ui
+    ui/pages/modplatform/ResourcePage.ui
+    ui/pages/modplatform/flame/FlamePage.ui
+    ui/pages/modplatform/legacy_ftb/Page.ui
+    ui/pages/modplatform/import_ftb/ImportFTBPage.ui
+    ui/pages/modplatform/ImportPage.ui
+    ui/pages/modplatform/OptionalModDialog.ui
+    ui/pages/modplatform/ftb/FtbPage.ui
+    ui/pages/modplatform/modrinth/ModrinthPage.ui
+    ui/pages/modplatform/technic/TechnicPage.ui
+    ui/widgets/CustomCommands.ui
+    ui/widgets/EnvironmentVariables.ui
+    ui/widgets/InfoFrame.ui
+    ui/widgets/ModFilterWidget.ui
+    ui/widgets/SubTaskProgressBar.ui
+    ui/widgets/AppearanceWidget.ui
+    ui/widgets/MinecraftSettingsWidget.ui
+    ui/widgets/JavaSettingsWidget.ui
+    ui/dialogs/CopyInstanceDialog.ui
+    ui/dialogs/CreateShortcutDialog.ui
+    ui/dialogs/ProfileSetupDialog.ui
+    ui/dialogs/ProgressDialog.ui
+    ui/dialogs/NewInstanceDialog.ui
+    ui/dialogs/NewComponentDialog.ui
+    ui/dialogs/NewsDialog.ui
+    ui/dialogs/ProfileSelectDialog.ui
+    ui/dialogs/ExportInstanceDialog.ui
+    ui/dialogs/ExportPackDialog.ui
+    ui/dialogs/ExportToModListDialog.ui
+    ui/dialogs/IconPickerDialog.ui
+    ui/dialogs/ImportResourceDialog.ui
+    ui/dialogs/MSALoginDialog.ui
+    ui/dialogs/AboutDialog.ui
+    ui/dialogs/ReviewMessageBox.ui
+    ui/dialogs/ScrollMessageBox.ui
+    ui/dialogs/BlockedModsDialog.ui
+    ui/dialogs/ChooseProviderDialog.ui
+    ui/dialogs/skins/SkinManageDialog.ui
+    ui/dialogs/ChooseOfflineNameDialog.ui
+)
+
+qt_wrap_ui(PRISM_UPDATE_UI
+    ui/dialogs/UpdateAvailableDialog.ui
+)
+
+if (NOT Apple)
+    set (LAUNCHER_UI ${LAUNCHER_UI} ${PRISM_UPDATE_UI})
+endif()
+
 qt_add_resources(LAUNCHER_RESOURCES
     resources/backgrounds/backgrounds.qrc
     resources/multimc/multimc.qrc
@@ -1224,6 +1291,12 @@ qt_add_resources(LAUNCHER_RESOURCES
     "${CMAKE_CURRENT_BINARY_DIR}/../${Launcher_Branding_LogoQRC}"
 )
 
+qt_wrap_ui(PRISMUPDATER_UI
+    updater/prismupdater/SelectReleaseDialog.ui
+    ui/widgets/SubTaskProgressBar.ui
+    ui/dialogs/ProgressDialog.ui
+)
+
 ######## Windows resource files ########
 if(WIN32)
     set(LAUNCHER_RCS ${CMAKE_CURRENT_BINARY_DIR}/../${Launcher_Branding_WindowsRC})
@@ -1243,7 +1316,7 @@ endif()
 ####### Targets ########
 
 # Add executable
-add_library(Launcher_logic STATIC ${LOGIC_SOURCES} ${LAUNCHER_SOURCES} ${LAUNCHER_RESOURCES})
+add_library(Launcher_logic STATIC ${LOGIC_SOURCES} ${LAUNCHER_SOURCES} ${LAUNCHER_UI} ${LAUNCHER_RESOURCES})
 target_include_directories(Launcher_logic PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 target_compile_definitions(Launcher_logic PUBLIC LAUNCHER_APPLICATION)
 
@@ -1363,7 +1436,7 @@ endif()
 
 if(Launcher_BUILD_UPDATER)
     # Updater
-    add_library(prism_updater_logic STATIC ${PRISMUPDATER_SOURCES} ${TASKS_SOURCES})
+    add_library(prism_updater_logic STATIC ${PRISMUPDATER_SOURCES} ${TASKS_SOURCES} ${PRISMUPDATER_UI})
     target_include_directories(prism_updater_logic PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 
     if(${Launcher_USE_PCH})
@@ -1491,10 +1564,8 @@ if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
     target_compile_options(Launcher_logic PRIVATE /wd4100) # C4100 - unused parameter
     target_compile_options(${Launcher_Name} PRIVATE /wd4100) # C4100 - unused parameter
 else()
-    # sfinae-incomplete is a new GCC warning and triggers in Qt headers
+    target_compile_options(Launcher_logic PRIVATE -Wno-unused-parameter -Wno-missing-field-initializers)
-    # no-unknown-warning-option so that compilers that don't have sfinae-incomplete don't error
+    target_compile_options(${Launcher_Name} PRIVATE -Wno-unused-parameter -Wno-missing-field-initializers)
-    target_compile_options(Launcher_logic PRIVATE -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unknown-warning-option -Wno-sfinae-incomplete)
-    target_compile_options(${Launcher_Name} PRIVATE -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unknown-warning-option -Wno-sfinae-incomplete)
 endif()
 
 #### The bundle mess! ####

launcher/FileSystem.cpp

@@ -36,7 +36,6 @@
  */
 
 #include "FileSystem.h"
-#include <qcontainerfwd.h>
 #include <QPair>
 
 #include "BuildConfig.h"
@@ -684,32 +683,6 @@ bool deletePath(QString path)
     return err.value() == 0;
 }
 
-bool deleteContents(const QString& path)
-{
-    const QFileInfo info(path);
-    if (!info.exists()) {
-        return true;
-    }
-    if (!info.isDir()) {
-        qWarning() << "Attempted to delete contents of non-directory path:" << path;
-        return false;
-    }
-
-    bool ret = true;
-
-    for (const auto& entry : fs::directory_iterator(StringUtils::toStdString(path))) {
-        std::error_code err;
-
-        fs::remove_all(entry.path(), err);
-        if (err.value() != 0) {
-            qWarning().nospace() << "Could not delete directory entry " << entry.path() << ": " << QString::fromStdString(err.message());
-            ret = false;
-        }
-    }
-
-    return ret;
-}
-
 bool trash(QString path, QString* pathInTrash)
 {
     // FIXME: Figure out trash in Flatpak. Qt seemingly doesn't use the Trash portal
@@ -823,33 +796,68 @@ QString NormalizePath(QString path)
     }
 }
 
-namespace {
+static const QString BAD_WIN_CHARS = "<>:\"|?*\r\n";
-const QString g_badChars = "<>:\"|?*\r\n!";
+static const QString BAD_NTFS_CHARS = "<>:\"|?*";
-QString removeChars(QString source, QChar replace, const QString& extraChars = "")
+static const QString BAD_HFS_CHARS = ":";
-{
-    auto badChars = g_badChars;
-    if (!extraChars.isEmpty()) {
-        badChars += extraChars;
-    }
 
-    for (auto& c : source) {
+static const QString BAD_FILENAME_CHARS = BAD_WIN_CHARS + "\\/";
-        if (c.unicode() < 0x20 || !c.isPrint() || badChars.contains(c)) {
-            c = replace;
-        }
-    }
-
-    return source;
-}
-}  // namespace
 
 QString RemoveInvalidFilenameChars(QString string, QChar replaceWith)
 {
-    return removeChars(std::move(string), replaceWith, "\\/");
+    for (int i = 0; i < string.length(); i++)
+        if (string.at(i) < ' ' || BAD_FILENAME_CHARS.contains(string.at(i)))
+            string[i] = replaceWith;
+    return string;
 }
 
-QString RemoveInvalidPathChars(QString string, QChar replaceWith)
+QString RemoveInvalidPathChars(QString path, QChar replaceWith)
 {
-    return removeChars(std::move(string), replaceWith);
+    QString invalidChars;
+#ifdef Q_OS_WIN
+    invalidChars = BAD_WIN_CHARS;
+#endif
+
+    // the null character is ignored in this check as it was not a problem until now
+    switch (statFS(path).fsType) {
+        case FilesystemType::FAT:  // similar to NTFS
+        /* fallthrough */
+        case FilesystemType::NTFS:
+        /* fallthrough */
+        case FilesystemType::REFS:  // similar to NTFS(should be available only on windows)
+            invalidChars += BAD_NTFS_CHARS;
+            break;
+        // case FilesystemType::EXT:
+        // case FilesystemType::EXT_2_OLD:
+        // case FilesystemType::EXT_2_3_4:
+        // case FilesystemType::XFS:
+        // case FilesystemType::BTRFS:
+        // case FilesystemType::NFS:
+        // case FilesystemType::ZFS:
+        case FilesystemType::APFS:
+        /* fallthrough */
+        case FilesystemType::HFS:
+        /* fallthrough */
+        case FilesystemType::HFSPLUS:
+        /* fallthrough */
+        case FilesystemType::HFSX:
+            invalidChars += BAD_HFS_CHARS;
+            break;
+        // case FilesystemType::FUSEBLK:
+        // case FilesystemType::F2FS:
+        // case FilesystemType::UNKNOWN:
+        default:
+            break;
+    }
+
+    if (invalidChars.size() != 0) {
+        for (int i = 0; i < path.length(); i++) {
+            if (path.at(i) < ' ' || invalidChars.contains(path.at(i))) {
+                path[i] = replaceWith;
+            }
+        }
+    }
+
+    return path;
 }
 
 QString DirNameFromString(QString string, QString inDir)
@@ -946,7 +954,7 @@ QString createShortcut(QString destination, QString target, QStringList args, QS
         return QString();
     }
     if (!info.open(QIODevice::WriteOnly | QIODevice::Text)) {
-        qWarning() << "Failed to open file" << info.fileName() << "for writing:" << info.errorString();
+        qWarning() << "Failed to open file" << info.fileName() << "for writing!";
         return QString();
     }
 
@@ -957,7 +965,7 @@ QString createShortcut(QString destination, QString target, QStringList args, QS
 
     QFile f(exec);
     if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
-        qWarning() << "Failed to open file" << f.fileName() << "for writing:" << f.errorString();
+        qWarning() << "Failed to open file" << f.fileName() << "for writing!";
         return QString();
     }
     QTextStream stream(&f);
@@ -1002,7 +1010,7 @@ QString createShortcut(QString destination, QString target, QStringList args, QS
         destination += ".desktop";
     QFile f(destination);
     if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
-        qWarning() << "Failed to open file" << f.fileName() << "for writing:" << f.errorString();
+        qWarning() << "Failed to open file '" << f.fileName() << "' for writing!";
         return QString();
     }
     QTextStream stream(&f);

launcher/FileSystem.h

@@ -291,13 +291,6 @@ bool move(const QString& source, const QString& dest);
  */
 bool deletePath(QString path);
 
-/**
- * Delete a folder's contents recursively but not the folder itself.
- * @param path The path to the folder.
- * @return Whether the deletion was completely successful.
- */
-bool deleteContents(const QString& path);
-
 bool removeFiles(QStringList listFile);
 
 /**

launcher/HardwareInfo.cpp

@@ -18,45 +18,79 @@
 
 #include "HardwareInfo.h"
 
-#include <QDebug>
+#include <QCoreApplication>
-#include <QStringList>
+#include <QOffscreenSurface>
+#include <QOpenGLFunctions>
+#include <QProcessEnvironment>
+
+#ifndef Q_OS_MACOS
+#include <QVulkanInstance>
+#include <QVulkanWindow>
+#endif
 
-#if defined(Q_OS_MACOS) || defined(Q_OS_LINUX)
 namespace {
-QString afterColon(QString str)
+bool vulkanInfo(QStringList& out)
 {
-    return str.remove(0, str.indexOf(':') + 2).trimmed();
+    if (!QProcessEnvironment::systemEnvironment().value(QStringLiteral("LAUNCHER_DISABLE_GLVULKAN")).isEmpty()) {
+        return false;
+    }
+#ifndef Q_OS_MACOS
+    QVulkanInstance inst;
+    if (!inst.create()) {
+        qWarning() << "Vulkan instance creation failed, VkResult:" << inst.errorCode();
+        out << "Couldn't get Vulkan device information";
+        return false;
+    }
+
+    QVulkanWindow window;
+    window.setVulkanInstance(&inst);
+
+    for (auto device : window.availablePhysicalDevices()) {
+        const auto supportedVulkanVersion = QVersionNumber(VK_API_VERSION_MAJOR(device.apiVersion), VK_API_VERSION_MINOR(device.apiVersion),
+                                                           VK_API_VERSION_PATCH(device.apiVersion));
+        out << QString("Found Vulkan device: %1 (API version %2)").arg(device.deviceName).arg(supportedVulkanVersion.toString());
+    }
+#endif
+
+    return true;
 }
 
-template <typename F>
+bool openGlInfo(QStringList& out)
-bool readFromOutput(const char* command, F function)
 {
-    FILE* file = popen(command, "r");  // NOLINT(*-command-processor)
+    if (!QProcessEnvironment::systemEnvironment().value(QStringLiteral("LAUNCHER_DISABLE_GLVULKAN")).isEmpty()) {
-    if (!file) {
+        return false;
-        qWarning().nospace() << "Could not execute command '" << command << "': " << strerror(errno);
+    }
+    QOpenGLContext ctx;
+    if (!ctx.create()) {
+        qWarning() << "OpenGL context creation failed";
+        out << "Couldn't get OpenGL device information";
         return false;
     }
 
-    constexpr size_t bufferSize = 512;
+    QOffscreenSurface surface;
-    std::array<char, bufferSize> buffer{};
+    surface.create();
-    while (fgets(buffer.data(), bufferSize, file) != nullptr) {
+    ctx.makeCurrent(&surface);
-        function(buffer.data());
-    }
 
-    const int exitCode = pclose(file);
+    auto* f = ctx.functions();
-    if (exitCode != 0) {
+    f->initializeOpenGLFunctions();
-        if (exitCode == -1) {
-            qWarning().nospace() << "Could not close stream for command '" << command << "': " << strerror(errno);
-        } else {
-            qWarning().nospace() << "Command '" << command << "' exited with code " << exitCode;
-        }
 
-        return false;
+    auto toQString = [](const GLubyte* str) { return QString(reinterpret_cast<const char*>(str)); };
-    }
+    out << "OpenGL driver vendor: " + toQString(f->glGetString(GL_VENDOR));
+    out << "OpenGL renderer: " + toQString(f->glGetString(GL_RENDERER));
+    out << "OpenGL driver version: " + toQString(f->glGetString(GL_VERSION));
 
     return true;
 }
 }  // namespace
+
+#ifndef Q_OS_LINUX
+QStringList HardwareInfo::gpuInfo()
+{
+    QStringList info;
+    vulkanInfo(info);
+    openGlInfo(info);
+    return info;
+}
 #endif
 
 #ifdef Q_OS_WINDOWS
@@ -65,11 +99,7 @@ bool readFromOutput(const char* command, F function)
 #endif
 #include <QSettings>
 
-#include <dxgi1_6.h>
+#include "windows.h"
-#include <windows.h>
-
-#include <wrl/client.h>
-using Microsoft::WRL::ComPtr;
 
 QString HardwareInfo::cpuInfo()
 {
@@ -105,42 +135,16 @@ uint64_t HardwareInfo::availableRamMiB()
     return 0;
 }
 
-QStringList HardwareInfo::gpuInfo()
-{
-    ComPtr<IDXGIFactory6> factory;
-    HRESULT hr = CreateDXGIFactory1(IID_PPV_ARGS(&factory));
-    if (FAILED(hr)) {
-        qWarning() << "Could not create DXGI factory:" << Qt::hex << hr;
-        return { "GPU discovery failed: could not create DXGI factory" };
-    }
-
-    UINT i = 0;
-    ComPtr<IDXGIAdapter> adapter;
-    QStringList out;
-    while (factory->EnumAdapterByGpuPreference(i, DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE, IID_PPV_ARGS(&adapter)) != DXGI_ERROR_NOT_FOUND) {
-        DXGI_ADAPTER_DESC desc;
-        hr = adapter->GetDesc(&desc);
-        if (SUCCEEDED(hr)) {
-            out << "GPU: " + QString::fromWCharArray(desc.Description);  // NOLINT(*-pro-bounds-array-to-pointer-decay, *-no-array-decay)
-        } else {
-            qWarning() << "Could not get DXGI adapter description:" << Qt::hex << hr;
-        }
-
-        ++i;
-    }
-
-    return out;
-}
-
 #elif defined(Q_OS_MACOS)
+#include "mach/mach.h"
 #include "sys/sysctl.h"
 
 QString HardwareInfo::cpuInfo()
 {
-    std::array<char, 512> buffer{};
+    std::array<char, 512> buffer;
     size_t bufferSize = buffer.size();
     if (sysctlbyname("machdep.cpu.brand_string", &buffer, &bufferSize, nullptr, 0) == 0) {
-        return { buffer.data() };
+        return QString(buffer.data());
     }
 
     qWarning() << "Could not get CPU model: sysctlbyname";
@@ -149,7 +153,7 @@ QString HardwareInfo::cpuInfo()
 
 uint64_t HardwareInfo::totalRamMiB()
 {
-    uint64_t memsize = 0;
+    uint64_t memsize;
     size_t memsizeSize = sizeof memsize;
     if (sysctlbyname("hw.memsize", &memsize, &memsizeSize, nullptr, 0) == 0) {
         // transforming bytes -> mib
@@ -162,62 +166,36 @@ uint64_t HardwareInfo::totalRamMiB()
 
 uint64_t HardwareInfo::availableRamMiB()
 {
+    mach_port_t host_port = mach_host_self();
+    mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
+
+    vm_statistics64_data_t vm_stats;
+
+    if (host_statistics64(host_port, HOST_VM_INFO64, reinterpret_cast<host_info64_t>(&vm_stats), &count) == KERN_SUCCESS) {
+        // transforming bytes -> mib
+        return (vm_stats.free_count + vm_stats.inactive_count) * vm_page_size / 1024 / 1024;
+    }
+
+    qWarning() << "Could not get available RAM: host_statistics64";
     return 0;
 }
 
-MacOSHardwareInfo::MemoryPressureLevel MacOSHardwareInfo::memoryPressureLevel()
-{
-    uint32_t level = 0;
-    size_t levelSize = sizeof level;
-    if (sysctlbyname("kern.memorystatus_vm_pressure_level", &level, &levelSize, nullptr, 0) == 0) {
-        return static_cast<MemoryPressureLevel>(level);
-    }
-
-    qWarning() << "Could not get memory pressure level: sysctlbyname";
-    return MemoryPressureLevel::Normal;
-}
-
-QString MacOSHardwareInfo::memoryPressureLevelName()
-{
-    // The names are internal, users refer to levels by their graph colors in Activity Monitor
-    switch (memoryPressureLevel()) {
-        case MemoryPressureLevel::Normal:
-            return "Green";
-        case MemoryPressureLevel::Warning:
-            return "Yellow";
-        case MemoryPressureLevel::Critical:
-            return "Red";
-        default:
-            Q_ASSERT(false);
-            return "";
-    }
-}
-
-QStringList HardwareInfo::gpuInfo()
-{
-    QStringList out;
-    const bool success = readFromOutput("system_profiler SPDisplaysDataType", [&](const QString& str) {
-        // Chipset Model: Intel HD Graphics 620
-        if (str.contains("Chipset Model")) {
-            out << "GPU: " + afterColon(str);
-        }
-    });
-    if (!success) {
-        return { "GPU discovery failed: could not read from system_profiler" };
-    }
-
-    return out;
-}
-
 #elif defined(Q_OS_LINUX)
 #include <fstream>
 
+namespace {
+QString afterColon(QString& str)
+{
+    return str.remove(0, str.indexOf(':') + 2).trimmed();
+}
+}  // namespace
+
 QString HardwareInfo::cpuInfo()
 {
     std::ifstream cpuin("/proc/cpuinfo");
     for (std::string line; std::getline(cpuin, line);) {
         // model name      : AMD Ryzen 7 5800X 8-Core Processor
-        if (const QString str = QString::fromStdString(line); str.startsWith("model name")) {
+        if (QString str = QString::fromStdString(line); str.startsWith("model name")) {
             return afterColon(str);
         }
     }
@@ -226,13 +204,12 @@ QString HardwareInfo::cpuInfo()
     return "unknown";
 }
 
-namespace {
+uint64_t readMemInfo(QString searchTarget)
-uint64_t readMemInfo(const QString& searchTarget)
 {
     std::ifstream memin("/proc/meminfo");
     for (std::string line; std::getline(memin, line);) {
         // MemTotal:       16287480 kB
-        if (const QString str = QString::fromStdString(line); str.startsWith(searchTarget)) {
+        if (QString str = QString::fromStdString(line); str.startsWith(searchTarget)) {
             bool ok = false;
             const uint total = str.simplified().section(' ', 1, 1).toUInt(&ok);
             if (!ok) {
@@ -248,7 +225,6 @@ uint64_t readMemInfo(const QString& searchTarget)
     qWarning() << "Could not read /proc/meminfo: search target not found:" << searchTarget;
     return 0;
 }
-}  // namespace
 
 uint64_t HardwareInfo::totalRamMiB()
 {
@@ -262,50 +238,52 @@ uint64_t HardwareInfo::availableRamMiB()
 
 QStringList HardwareInfo::gpuInfo()
 {
-    bool readingGpuInfo = false;
+    QStringList list;
-    QString gpu;
+    const bool vulkanSuccess = vulkanInfo(list);
-    QString driverInUse = "NONE";
+    const bool openGlSuccess = openGlInfo(list);
-    QString driversAvailable = "NONE";
+    if (vulkanSuccess || openGlSuccess) {
-    QStringList out;
+        return list;
+    }
 
-    const bool success = readFromOutput("lspci -k", [&](const QString& str) {
+    std::array<char, 512> buffer;
+    FILE* lspci = popen("lspci -k", "r");
+
+    if (!lspci) {
+        return { "Could not detect GPUs: lspci is not present" };
+    }
+
+    bool readingGpuInfo = false;
+    QString currentModel = "";
+    while (fgets(buffer.data(), 512, lspci) != nullptr) {
+        QString str(buffer.data());
         // clang-format off
         // 04:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Ellesmere [Radeon RX 470/480/570/570X/580/580X/590] (rev e7)
         // Subsystem: Sapphire Technology Limited Radeon RX 580 Pulse 4GB
         // Kernel driver in use: amdgpu
         // Kernel modules: amdgpu
         // clang-format on
-        if (str.contains("VGA compatible controller") || str.contains("3D controller")) {
+        if (str.contains("VGA compatible controller")) {
             readingGpuInfo = true;
         } else if (!str.startsWith('\t')) {
-            if (readingGpuInfo) {
-                out << QString("GPU: %1 (driver in use: %2; drivers available: %3)").arg(gpu, driverInUse, driversAvailable);
-                driverInUse = "NONE";
-                driversAvailable = "NONE";
-            }
             readingGpuInfo = false;
         }
-
         if (!readingGpuInfo) {
-            return;
+            continue;
         }
 
-        const QString value = afterColon(str);
         if (str.contains("Subsystem")) {
-            gpu = value;
+            currentModel = "Found GPU: " + afterColon(str);
         }
         if (str.contains("Kernel driver in use")) {
-            driverInUse = value;
+            currentModel += " (using driver " + afterColon(str);
         }
         if (str.contains("Kernel modules")) {
-            driversAvailable = value;
+            currentModel += ", available drivers: " + afterColon(str) + ")";
+            list.append(currentModel);
         }
-    });
-    if (!success) {
-        return { "GPU discovery failed: could not read from lspci" };
     }
-
+    pclose(lspci);
-    return out;
+    return list;
 }
 
 #else
@@ -320,20 +298,19 @@ QString HardwareInfo::cpuInfo()
 
 uint64_t HardwareInfo::totalRamMiB()
 {
-    uint64_t out = 0;
+    char buff[512];
+    FILE* fp = popen("sysctl hw.physmem", "r");
+    if (fp != nullptr) {
+        if (fgets(buff, 512, fp) != nullptr) {
+            std::string str(buff);
+            uint64_t mem = std::stoull(str.substr(12, std::string::npos));
 
-    const bool success = readFromOutput("sysctl hw.physmem", [&](const QString& str) {
+            // transforming kib -> mib
-        const uint64_t mem = str.mid(12).toULong();
+            return mem / 1024;
-
+        }
-        // transforming kib -> mib
-        out = mem / 1024;
-    });
-    if (!success) {
-        qWarning() << "Could not get total RAM: could not read from sysctl";
-        return 0;
     }
 
-    return out;
+    return 0;
 }
 
 #else
@@ -348,8 +325,4 @@ uint64_t HardwareInfo::availableRamMiB()
     return 0;
 }
 
-QStringList HardwareInfo::gpuInfo()
-{
-    return { "GPU discovery failed: not implemented for this OS" };
-}
 #endif

launcher/HardwareInfo.h

@@ -27,16 +27,3 @@ uint64_t totalRamMiB();
 uint64_t availableRamMiB();
 QStringList gpuInfo();
 }  // namespace HardwareInfo
-
-#ifdef Q_OS_MACOS
-namespace MacOSHardwareInfo {
-enum class MemoryPressureLevel : uint8_t {
-    Normal = 1,
-    Warning = 2,
-    Critical = 4,
-};
-
-MemoryPressureLevel memoryPressureLevel();
-QString memoryPressureLevelName();
-}  // namespace MacOSHardwareInfo
-#endif

launcher/InstanceCreationTask.cpp

@@ -3,7 +3,6 @@
 #include <QDebug>
 #include <QFile>
 
-#include "Application.h"
 #include "InstanceTask.h"
 #include "minecraft/MinecraftLoadAndCheck.h"
 #include "tasks/SequentialTask.h"
@@ -19,7 +18,7 @@ bool InstanceCreationTask::abort()
         return m_gameFilesTask->abort();
     }
 
-    return InstanceTask::abort();
+    return true;
 }
 
 void InstanceCreationTask::executeTask()
@@ -39,9 +38,8 @@ void InstanceCreationTask::executeTask()
 
     m_instance = createInstance();
     if (!m_instance) {
-        if (m_abort) {
+        if (m_abort)
             return;
-        }
 
         qWarning() << "Instance creation failed!";
         if (!m_error_message.isEmpty()) {
@@ -65,9 +63,8 @@ void InstanceCreationTask::executeTask()
         qDebug() << "Removing old files";
 
         for (const QString& path : m_filesToRemove) {
-            if (!QFile::exists(path)) {
+            if (!QFile::exists(path))
                 continue;
-            }
 
             qDebug() << "Removing" << path;
 
@@ -84,10 +81,6 @@ void InstanceCreationTask::executeTask()
     }
 
     if (!m_abort) {
-        if (!APPLICATION->settings()->get("DownloadGameFilesDuringInstanceCreation").toBool()) {
-            emitSucceeded();
-            return;
-        }
         setAbortable(true);
         setAbortButtonText(tr("Skip"));
         qDebug() << "Downloading game files";
@@ -117,7 +110,7 @@ void InstanceCreationTask::executeTask()
     }
 }
 
-void InstanceCreationTask::scheduleToDelete(QWidget* parent, const QDir& dir, const QString& path, bool checkDisabled)
+void InstanceCreationTask::scheduleToDelete(QWidget* parent, QDir dir, QString path, bool checkDisabled)
 {
     if (path.isEmpty()) {
         return;

launcher/InstanceCreationTask.h

@@ -38,7 +38,7 @@ class InstanceCreationTask : public InstanceTask {
 
    protected:
     void setError(const QString& message) { m_error_message = message; };
-    void scheduleToDelete(QWidget* parent, const QDir& dir, const QString& path, bool checkDisabled = false);
+    void scheduleToDelete(QWidget* parent, QDir dir, QString path, bool checkDisabled = false);
 
    protected:
     bool m_abort = false;

launcher/InstanceList.cpp

@@ -924,23 +924,23 @@ class InstanceStaging : public Task {
         connect(child, &Task::progress, this, &InstanceStaging::setProgress);
         connect(child, &Task::stepProgress, this, &InstanceStaging::propagateStepProgress);
         connect(&m_backoffTimer, &QTimer::timeout, this, &InstanceStaging::childSucceeded);
+        m_backoffTimer.setSingleShot(true);
     }
 
-    ~InstanceStaging() override = default;
+    virtual ~InstanceStaging() {}
 
     // FIXME/TODO: add ability to abort during instance commit retries
     bool abort() override
     {
-        if (!canAbort()) {
+        if (!canAbort())
             return false;
-        }
 
         return m_child->abort();
     }
     bool canAbort() const override { return (m_child && m_child->canAbort()); }
 
    protected:
-    void executeTask() override
+    virtual void executeTask() override
     {
         if (m_stagingPath.isNull()) {
             emitFailed(tr("Could not create staging folder"));
@@ -954,8 +954,10 @@ class InstanceStaging : public Task {
    private slots:
     void childSucceeded()
     {
+        if (!isRunning())
+            return;
         unsigned sleepTime = backoff();
-        if (m_parent->commitStagedInstance(m_stagingPath, *m_child, m_child->group(), *m_child)) {
+        if (m_parent->commitStagedInstance(m_stagingPath, *m_child.get(), m_child->group(), *m_child.get())) {
             m_backoffTimer.stop();
             emitSucceeded();
             return;

launcher/LaunchController.cpp

@@ -40,7 +40,6 @@
 #include "minecraft/auth/AccountData.h"
 #include "minecraft/auth/AccountList.h"
 
-#include "net/NetUtils.h"
 #include "ui/InstanceWindow.h"
 #include "ui/dialogs/CustomMessageBox.h"
 #include "ui/dialogs/MSALoginDialog.h"
@@ -51,7 +50,7 @@
 #include <QInputDialog>
 #include <QList>
 #include <QPushButton>
-#include <utility>
+#include <QRegularExpression>
 
 #include "BuildConfig.h"
 #include "JavaCommon.h"
@@ -83,9 +82,9 @@ void LaunchController::decideAccount()
     }
 
     // Select the account to use. If the instance has a specific account set, that will be used. Otherwise, the default account will be used
-    auto* accounts = APPLICATION->accounts();
+    auto accounts = APPLICATION->accounts();
-    const auto instanceAccountId = m_instance->settings()->get("InstanceAccountId").toString();
+    auto instanceAccountId = m_instance->settings()->get("InstanceAccountId").toString();
-    const auto instanceAccountIndex = accounts->findAccountByProfileId(instanceAccountId);
+    auto instanceAccountIndex = accounts->findAccountByProfileId(instanceAccountId);
     if (instanceAccountIndex == -1 || instanceAccountId.isEmpty()) {
         m_accountToUse = accounts->defaultAccount();
     } else {
@@ -110,7 +109,7 @@ void LaunchController::decideAccount()
         }
     }
 
-    if (!m_accountToUse && accounts->anyAccountIsValid()) {
+    if (!m_accountToUse) {
         // If no default account is set, ask the user which one to use.
         ProfileSelectDialog selectDialog(tr("Which account would you like to use?"), ProfileSelectDialog::GlobalDefaultCheckbox,
                                          m_parentWidget);
@@ -134,7 +133,15 @@ LaunchDecision LaunchController::decideLaunchMode()
         return LaunchDecision::Continue;
     }
 
-    const auto* accounts = APPLICATION->accounts();
+    if (m_wantedLaunchMode == LaunchMode::Normal) {
+        if (m_accountToUse->shouldRefresh() || m_accountToUse->accountState() == AccountState::Offline) {
+            // Force account refresh on the account used to launch the instance updating the AccountState
+            // only on first try and if it is not meant to be offline
+            m_accountToUse->refresh();
+        }
+    }
+
+    const auto accounts = APPLICATION->accounts();
     MinecraftAccountPtr accountToCheck = nullptr;
 
     if (m_accountToUse->accountType() != AccountType::Offline) {
@@ -156,9 +163,7 @@ LaunchDecision LaunchController::decideLaunchMode()
     }
 
     auto state = accountToCheck->accountState();
-    const bool needsRefresh =
+    if (state == AccountState::Unchecked || state == AccountState::Errored) {
-        m_wantedLaunchMode == LaunchMode::Normal && (state == AccountState::Offline || accountToCheck->shouldRefresh());
-    if (state == AccountState::Unchecked || state == AccountState::Errored || needsRefresh) {
         accountToCheck->refresh();
         state = AccountState::Working;
     }
@@ -208,7 +213,7 @@ LaunchDecision LaunchController::decideLaunchMode()
     return LaunchDecision::Abort;
 }
 
-bool LaunchController::askPlayDemo() const
+bool LaunchController::askPlayDemo()
 {
     QMessageBox box(m_parentWidget);
     box.setWindowTitle(tr("Play demo?"));
@@ -218,22 +223,21 @@ bool LaunchController::askPlayDemo() const
     text += tr("\n\nDo you want to play the demo?");
     box.setText(text);
     box.setIcon(QMessageBox::Warning);
-    const auto* demoButton = box.addButton(tr("Play Demo"), QMessageBox::ButtonRole::YesRole);
+    auto demoButton = box.addButton(tr("Play Demo"), QMessageBox::ButtonRole::YesRole);
-    auto* cancelButton = box.addButton(tr("Cancel"), QMessageBox::ButtonRole::NoRole);
+    auto cancelButton = box.addButton(tr("Cancel"), QMessageBox::ButtonRole::NoRole);
     box.setDefaultButton(cancelButton);
 
     box.exec();
     return box.clickedButton() == demoButton;
 }
 
-QString LaunchController::askOfflineName(const QString& playerName, bool* ok)
+QString LaunchController::askOfflineName(QString playerName, bool* ok)
 {
     if (ok != nullptr) {
         *ok = false;
     }
 
-    QString title, message;
+    QString message;
-    title = tr("Player name");
     switch (m_actualLaunchMode) {
         case LaunchMode::Normal:
             Q_ASSERT(false);
@@ -243,24 +247,17 @@ QString LaunchController::askOfflineName(const QString& playerName, bool* ok)
             break;
         case LaunchMode::Offline:
             if (m_wantedLaunchMode == LaunchMode::Normal) {
-                auto netErr = m_accountToUse->accountData()->networkError;
+                message = tr("You are not connected to the Internet, launching in offline mode\n\n");
-                if (Net::isServerError(netErr)) {
-                    title = tr("Auth servers offline");
-                    message = tr("The Minecraft authentication servers are currently unavailable, launching in offline mode.\n\n");
-                } else {
-                    title = tr("No internet connection");
-                    message = tr("You are not connected to the Internet, launching in offline mode.\n\n");
-                }
             }
             message += tr("Choose your offline mode player name");
             break;
     }
 
-    const QString lastOfflinePlayerName = APPLICATION->settings()->get("LastOfflinePlayerName").toString();
+    QString lastOfflinePlayerName = APPLICATION->settings()->get("LastOfflinePlayerName").toString();
     QString usedname = lastOfflinePlayerName.isEmpty() ? playerName : lastOfflinePlayerName;
 
     ChooseOfflineNameDialog dialog(message, m_parentWidget);
-    dialog.setWindowTitle(title);
+    dialog.setWindowTitle(tr("Player name"));
     dialog.setUsername(usedname);
     if (dialog.exec() != QDialog::Accepted) {
         return {};
@@ -334,24 +331,23 @@ void LaunchController::login()
     launchInstance();
 }
 
-bool LaunchController::reauthenticateAccount(const MinecraftAccountPtr& account, const QString& reason)
+bool LaunchController::reauthenticateAccount(MinecraftAccountPtr account, QString reason)
 {
     auto button = QMessageBox::warning(
         m_parentWidget, tr("Account refresh failed"), tr("%1. Do you want to reauthenticate this account?").arg(reason),
         QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No, QMessageBox::StandardButton::Yes);
     if (button == QMessageBox::StandardButton::Yes) {
-        auto* accounts = APPLICATION->accounts();
+        auto accounts = APPLICATION->accounts();
-        const bool isDefault = accounts->defaultAccount() == account;
+        bool isDefault = accounts->defaultAccount() == account;
+        accounts->removeAccount(accounts->index(accounts->findAccountByProfileId(account->profileId())));
         if (account->accountType() == AccountType::MSA) {
             auto newAccount = MSALoginDialog::newAccount(m_parentWidget);
 
             if (newAccount != nullptr) {
-                accounts->removeAccount(accounts->index(accounts->findAccountByProfileId(account->profileId())));
                 accounts->addAccount(newAccount);
 
-                if (isDefault) {
+                if (isDefault)
                     accounts->setDefaultAccount(newAccount);
-                }
 
                 if (m_accountToUse == account) {
                     m_accountToUse = nullptr;
@@ -362,13 +358,14 @@ bool LaunchController::reauthenticateAccount(const MinecraftAccountPtr& account,
         }
     }
 
+    emitFailed(reason);
     return false;
 }
 
 void LaunchController::launchInstance()
 {
-    Q_ASSERT(m_instance != nullptr);
+    Q_ASSERT_X(m_instance != NULL, "launchInstance", "instance is NULL");
-    Q_ASSERT(m_session.get() != nullptr);
+    Q_ASSERT_X(m_session.get() != nullptr, "launchInstance", "session is NULL");
 
     if (!m_instance->reloadSettings()) {
         QMessageBox::critical(m_parentWidget, tr("Error!"), tr("Couldn't load the instance profile."));
@@ -382,8 +379,8 @@ void LaunchController::launchInstance()
         return;
     }
 
-    const auto* console = qobject_cast<InstanceWindow*>(m_parentWidget);
+    auto console = qobject_cast<InstanceWindow*>(m_parentWidget);
-    const auto showConsole = m_instance->settings()->get("ShowConsole").toBool();
+    auto showConsole = m_instance->settings()->get("ShowConsole").toBool();
     if (!console && showConsole) {
         APPLICATION->showInstanceWindow(m_instance);
     }
@@ -398,7 +395,7 @@ void LaunchController::launchInstance()
         online_mode = "online";
 
         // Prepend Server Status
-        const QStringList servers = { "login.microsoftonline.com", "session.minecraft.net", "textures.minecraft.net", "api.mojang.com" };
+        QStringList servers = { "login.microsoftonline.com", "session.minecraft.net", "textures.minecraft.net", "api.mojang.com" };
 
         m_launcher->prependStep(makeShared<PrintServers>(m_launcher, servers));
     } else {
@@ -468,10 +465,10 @@ void LaunchController::onFailed(QString reason)
     if (m_instance->settings()->get("ShowConsoleOnError").toBool()) {
         APPLICATION->showInstanceWindow(m_instance, "console");
     }
-    emitFailed(std::move(reason));
+    emitFailed(reason);
 }
 
-void LaunchController::onProgressRequested(Task* task) const
+void LaunchController::onProgressRequested(Task* task)
 {
     ProgressDialog progDialog(m_parentWidget);
     progDialog.setSkipButton(true, tr("Abort"));

launcher/LaunchController.h

@@ -50,11 +50,11 @@ class LaunchController : public Task {
     void executeTask() override;
 
     LaunchController();
-    ~LaunchController() override = default;
+    virtual ~LaunchController() = default;
 
     void setInstance(BaseInstance* instance) { m_instance = instance; }
 
-    BaseInstance* instance() const { return m_instance; }
+    BaseInstance* instance() { return m_instance; }
 
     void setLaunchMode(const LaunchMode mode) { m_wantedLaunchMode = mode; }
 
@@ -68,7 +68,7 @@ class LaunchController : public Task {
 
     void setAccountToUse(MinecraftAccountPtr accountToUse) { m_accountToUse = std::move(accountToUse); }
 
-    QString id() const { return m_instance->id(); }
+    QString id() { return m_instance->id(); }
 
     bool abort() override;
 
@@ -77,27 +77,27 @@ class LaunchController : public Task {
     void launchInstance();
     void decideAccount();
     LaunchDecision decideLaunchMode();
-    bool askPlayDemo() const;
+    bool askPlayDemo();
-    QString askOfflineName(const QString& playerName, bool* ok = nullptr);
+    QString askOfflineName(QString playerName, bool* ok = nullptr);
-    bool reauthenticateAccount(const MinecraftAccountPtr& account, const QString& reason);
+    bool reauthenticateAccount(MinecraftAccountPtr account, QString reason);
 
    private slots:
     void readyForLaunch();
 
     void onSucceeded();
     void onFailed(QString reason);
-    void onProgressRequested(Task* task) const;
+    void onProgressRequested(Task* task);
 
    private:
     LaunchMode m_wantedLaunchMode = LaunchMode::Normal;
     LaunchMode m_actualLaunchMode = LaunchMode::Normal;
     BaseProfilerFactory* m_profiler = nullptr;
     QString m_offlineName;
-    BaseInstance* m_instance = nullptr;
+    BaseInstance* m_instance;
     QWidget* m_parentWidget = nullptr;
     InstanceWindow* m_console = nullptr;
     MinecraftAccountPtr m_accountToUse = nullptr;
-    AuthSessionPtr m_session = nullptr;
+    AuthSessionPtr m_session;
-    LaunchTask* m_launcher = nullptr;
+    LaunchTask* m_launcher;
-    MinecraftTarget::Ptr m_targetToJoin = nullptr;
+    MinecraftTarget::Ptr m_targetToJoin;
 };

launcher/Launcher.in

@@ -15,7 +15,6 @@ fi
 
 
 LAUNCHER_NAME=@Launcher_APP_BINARY_NAME@
-LAUNCHER_ENVNAME=@Launcher_ENVName@
 LAUNCHER_DIR="$(dirname "$(readlink -f "$0")")"
 echo "Launcher Dir: ${LAUNCHER_DIR}"
 
@@ -24,7 +23,7 @@ export QT_QPA_PLATFORMTHEME=xdgdesktopportal
 
 # disable OpenGL and Vulkan launcher features on sharun until https://github.com/VHSgunzo/sharun/issues/35
 if [[ -f "${LAUNCHER_DIR}/sharun" ]]; then
-    export ${LAUNCHER_ENVNAME}_DISABLE_GLVULKAN=1
+    export LAUNCHER_DISABLE_GLVULKAN=1
 fi
 
 # Just to be sure...

launcher/LoggedProcess.cpp

@@ -114,7 +114,7 @@ void LoggedProcess::on_error(QProcess::ProcessError error)
 {
     switch (error) {
         case QProcess::FailedToStart: {
-            emit log({ tr("The process failed to start: %1").arg(errorString()) }, MessageLevel::Fatal);
+            emit log({ tr("The process failed to start.") }, MessageLevel::Fatal);
             changeState(LoggedProcess::FailedToStart);
             break;
         }

launcher/MTPixmapCache.h

@@ -14,26 +14,26 @@
     else                                                                    \
         type = Qt::DirectConnection;
 
-#define DEFINE_FUNC_NO_PARAM(NAME, RET_TYPE, RET_DEF)                                        \
+#define DEFINE_FUNC_NO_PARAM(NAME, RET_TYPE)                                                 \
     static RET_TYPE NAME()                                                                   \
     {                                                                                        \
-        RET_TYPE ret = RET_DEF;                                                              \
+        RET_TYPE ret;                                                                        \
         GET_TYPE()                                                                           \
         QMetaObject::invokeMethod(s_instance, "_" #NAME, type, Q_RETURN_ARG(RET_TYPE, ret)); \
         return ret;                                                                          \
     }
-#define DEFINE_FUNC_ONE_PARAM(NAME, RET_TYPE, RET_DEF, PARAM_1_TYPE)                                                  \
+#define DEFINE_FUNC_ONE_PARAM(NAME, RET_TYPE, PARAM_1_TYPE)                                                           \
     static RET_TYPE NAME(PARAM_1_TYPE p1)                                                                             \
     {                                                                                                                 \
-        RET_TYPE ret = RET_DEF;                                                                                       \
+        RET_TYPE ret;                                                                                                 \
         GET_TYPE()                                                                                                    \
         QMetaObject::invokeMethod(s_instance, "_" #NAME, type, Q_RETURN_ARG(RET_TYPE, ret), Q_ARG(PARAM_1_TYPE, p1)); \
         return ret;                                                                                                   \
     }
-#define DEFINE_FUNC_TWO_PARAM(NAME, RET_TYPE, RET_DEF, PARAM_1_TYPE, PARAM_2_TYPE)                                   \
+#define DEFINE_FUNC_TWO_PARAM(NAME, RET_TYPE, PARAM_1_TYPE, PARAM_2_TYPE)                                            \
     static RET_TYPE NAME(PARAM_1_TYPE p1, PARAM_2_TYPE p2)                                                           \
     {                                                                                                                \
-        RET_TYPE ret = RET_DEF;                                                                                      \
+        RET_TYPE ret;                                                                                                \
         GET_TYPE()                                                                                                   \
         QMetaObject::invokeMethod(s_instance, "_" #NAME, type, Q_RETURN_ARG(RET_TYPE, ret), Q_ARG(PARAM_1_TYPE, p1), \
                                   Q_ARG(PARAM_2_TYPE, p2));                                                          \
@@ -53,18 +53,18 @@ class PixmapCache final : public QObject {
     static void setInstance(PixmapCache* i) { s_instance = i; }
 
    public:
-    DEFINE_FUNC_NO_PARAM(cacheLimit, int, -1)
+    DEFINE_FUNC_NO_PARAM(cacheLimit, int)
-    DEFINE_FUNC_NO_PARAM(clear, bool, false)
+    DEFINE_FUNC_NO_PARAM(clear, bool)
-    DEFINE_FUNC_TWO_PARAM(find, bool, false, const QString&, QPixmap*)
+    DEFINE_FUNC_TWO_PARAM(find, bool, const QString&, QPixmap*)
-    DEFINE_FUNC_TWO_PARAM(find, bool, false, const QPixmapCache::Key&, QPixmap*)
+    DEFINE_FUNC_TWO_PARAM(find, bool, const QPixmapCache::Key&, QPixmap*)
-    DEFINE_FUNC_TWO_PARAM(insert, bool, false, const QString&, const QPixmap&)
+    DEFINE_FUNC_TWO_PARAM(insert, bool, const QString&, const QPixmap&)
-    DEFINE_FUNC_ONE_PARAM(insert, QPixmapCache::Key, {}, const QPixmap&)
+    DEFINE_FUNC_ONE_PARAM(insert, QPixmapCache::Key, const QPixmap&)
-    DEFINE_FUNC_ONE_PARAM(remove, bool, false, const QString&)
+    DEFINE_FUNC_ONE_PARAM(remove, bool, const QString&)
-    DEFINE_FUNC_ONE_PARAM(remove, bool, false, const QPixmapCache::Key&)
+    DEFINE_FUNC_ONE_PARAM(remove, bool, const QPixmapCache::Key&)
-    DEFINE_FUNC_TWO_PARAM(replace, bool, false, const QPixmapCache::Key&, const QPixmap&)
+    DEFINE_FUNC_TWO_PARAM(replace, bool, const QPixmapCache::Key&, const QPixmap&)
-    DEFINE_FUNC_ONE_PARAM(setCacheLimit, bool, false, int)
+    DEFINE_FUNC_ONE_PARAM(setCacheLimit, bool, int)
-    DEFINE_FUNC_NO_PARAM(markCacheMissByEviciton, bool, false)
+    DEFINE_FUNC_NO_PARAM(markCacheMissByEviciton, bool)
-    DEFINE_FUNC_ONE_PARAM(setFastEvictionThreshold, bool, false, int)
+    DEFINE_FUNC_ONE_PARAM(setFastEvictionThreshold, bool, int)
 
     // NOTE: Every function returns something non-void to simplify the macros.
    private slots:

launcher/ResourceDownloadTask.cpp

@@ -19,52 +19,23 @@
 
 #include "ResourceDownloadTask.h"
 
-#include <utility>
-
 #include "Application.h"
 
 #include "FileSystem.h"
-#include "minecraft/MinecraftInstance.h"
-#include "minecraft/PackProfile.h"
 #include "minecraft/mod/ResourceFolderModel.h"
 
 #include "minecraft/mod/ShaderPackFolderModel.h"
-#include "modplatform/ModIndex.h"
 #include "modplatform/helpers/HashUtils.h"
 #include "net/ApiDownload.h"
 #include "net/ChecksumValidator.h"
 
-namespace {
-Net::ModrinthDownloadMeta createModrinthMeta(BaseInstance* instance, QString reason)
-{
-    auto* mcInstance = dynamic_cast<MinecraftInstance*>(instance);
-    if (!mcInstance) {
-        return {};
-    }
-
-    auto* profile = mcInstance->getPackProfile();
-    if (!profile) {
-        return {};
-    }
-
-    auto loaders = profile->getModLoadersList();
-
-    return {
-        .reason = std::move(reason),
-        .gameVersion = profile->getComponentVersion("net.minecraft"),
-        .loader = !loaders.isEmpty() ? ModPlatform::getModLoaderAsString(loaders.first()) : "",
-    };
-}
-}  // namespace
-
 ResourceDownloadTask::ResourceDownloadTask(ModPlatform::IndexedPack::Ptr pack,
                                            ModPlatform::IndexedVersion version,
                                            ResourceFolderModel* packs,
-                                           bool isIndexed,
+                                           bool is_indexed)
-                                           QString downloadReason)
     : m_pack(std::move(pack)), m_pack_version(std::move(version)), m_pack_model(packs)
 {
-    if (isIndexed) {
+    if (is_indexed) {
         m_update_task.reset(new LocalResourceUpdateTask(m_pack_model->indexDir(), *m_pack, m_pack_version));
         connect(m_update_task.get(), &LocalResourceUpdateTask::hasOldResource, this, &ResourceDownloadTask::hasOldResource);
 
@@ -74,9 +45,7 @@ ResourceDownloadTask::ResourceDownloadTask(ModPlatform::IndexedPack::Ptr pack,
     m_filesNetJob.reset(new NetJob(tr("Resource download"), APPLICATION->network()));
     m_filesNetJob->setStatus(tr("Downloading resource:\n%1").arg(m_pack_version.downloadUrl));
 
-    auto action = Net::ApiDownload::makeFile(m_pack_version.downloadUrl, m_pack_model->dir().absoluteFilePath(getFilename()),
+    auto action = Net::ApiDownload::makeFile(m_pack_version.downloadUrl, m_pack_model->dir().absoluteFilePath(getFilename()));
-                                             Net::Download::Option::NoOptions,
-                                             createModrinthMeta(m_pack_model->instance(), std::move(downloadReason)));
     if (!m_pack_version.hash_type.isEmpty() && !m_pack_version.hash.isEmpty()) {
         switch (Hashing::algorithmFromString(m_pack_version.hash_type)) {
             case Hashing::Algorithm::Md4:
@@ -113,9 +82,8 @@ void ResourceDownloadTask::downloadSucceeded()
     auto oldName = std::get<0>(to_delete);
     auto oldFilename = std::get<1>(to_delete);
 
-    if (oldName.isEmpty() || oldFilename == m_pack_version.fileName) {
+    if (oldName.isEmpty() || oldFilename == m_pack_version.fileName)
         return;
-    }
 
     m_pack_model->uninstallResource(oldFilename, true);
 
@@ -127,9 +95,8 @@ void ResourceDownloadTask::downloadSucceeded()
         if (oldConfig.exists() && !newConfig.exists()) {
             bool success = FS::move(oldConfig.filePath(), newConfig.filePath());
 
-            if (!success) {
+            if (!success)
                 emit logWarning(tr("Failed to rename shader config from '%1' to '%2'").arg(oldConfig.fileName(), newConfig.fileName()));
-            }
         }
     }
 }
@@ -137,7 +104,7 @@ void ResourceDownloadTask::downloadSucceeded()
 void ResourceDownloadTask::downloadFailed(QString reason)
 {
     m_filesNetJob.reset();
-    emitFailed(std::move(reason));
+    emitFailed(reason);
 }
 
 void ResourceDownloadTask::downloadProgressChanged(qint64 current, qint64 total)
@@ -147,7 +114,7 @@ void ResourceDownloadTask::downloadProgressChanged(qint64 current, qint64 total)
 
 // This indirection is done so that we don't delete a mod before being sure it was
 // downloaded successfully!
-void ResourceDownloadTask::hasOldResource(const QString& name, const QString& filename)
+void ResourceDownloadTask::hasOldResource(QString name, QString filename)
 {
     to_delete = { name, filename };
 }

launcher/ResourceDownloadTask.h

@@ -33,8 +33,7 @@ class ResourceDownloadTask : public SequentialTask {
     explicit ResourceDownloadTask(ModPlatform::IndexedPack::Ptr pack,
                                   ModPlatform::IndexedVersion version,
                                   ResourceFolderModel* packs,
-                                  bool isIndexed = true,
+                                  bool is_indexed = true);
-                                  QString downloadReason = "standalone");
     const QString& getFilename() const { return m_pack_version.fileName; }
     const QVariant& getVersionID() const { return m_pack_version.fileId; }
     const ModPlatform::IndexedVersion& getVersion() const { return m_pack_version; }
@@ -57,5 +56,5 @@ class ResourceDownloadTask : public SequentialTask {
     std::tuple<QString, QString> to_delete{ "", "" };
 
    private slots:
-    void hasOldResource(const QString& name, const QString& filename);
+    void hasOldResource(QString name, QString filename);
 };

launcher/Version.cpp

@@ -1,42 +1,124 @@
-// SPDX-License-Identifier: GPL-3.0-only
-/*
- *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2023 flowln <flowlnlnln@gmail.com>
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
- *  Copyright (c) 2026 Trial97 <alexandru.tripon97@gmail.com>
- *
- *  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, see <https://www.gnu.org/licenses/>.
- */
 #include "Version.h"
 
 #include <QDebug>
 #include <QRegularExpressionMatch>
 #include <QUrl>
-#include <compare>
+
+Version::Version(QString str) : m_string(std::move(str))
+{
+    parse();
+}
+
+#define VERSION_OPERATOR(return_on_different)                                               \
+    bool exclude_our_sections = false;                                                      \
+    bool exclude_their_sections = false;                                                    \
+                                                                                            \
+    const auto size = qMax(m_sections.size(), other.m_sections.size());                     \
+    for (int i = 0; i < size; ++i) {                                                        \
+        Section sec1 = (i >= m_sections.size()) ? Section() : m_sections.at(i);             \
+        Section sec2 = (i >= other.m_sections.size()) ? Section() : other.m_sections.at(i); \
+                                                                                            \
+        { /* Don't include appendixes in the comparison */                                  \
+            if (sec1.isAppendix())                                                          \
+                exclude_our_sections = true;                                                \
+            if (sec2.isAppendix())                                                          \
+                exclude_their_sections = true;                                              \
+                                                                                            \
+            if (exclude_our_sections) {                                                     \
+                sec1 = Section();                                                           \
+                if (sec2.m_isNull)                                                          \
+                    break;                                                                  \
+            }                                                                               \
+                                                                                            \
+            if (exclude_their_sections) {                                                   \
+                sec2 = Section();                                                           \
+                if (sec1.m_isNull)                                                          \
+                    break;                                                                  \
+            }                                                                               \
+        }                                                                                   \
+                                                                                            \
+        if (sec1 != sec2)                                                                   \
+            return return_on_different;                                                     \
+    }
+
+bool Version::operator<(const Version& other) const
+{
+    VERSION_OPERATOR(sec1 < sec2)
+
+    return false;
+}
+bool Version::operator==(const Version& other) const
+{
+    VERSION_OPERATOR(false)
+
+    return true;
+}
+bool Version::operator!=(const Version& other) const
+{
+    return !operator==(other);
+}
+bool Version::operator<=(const Version& other) const
+{
+    return *this < other || *this == other;
+}
+bool Version::operator>(const Version& other) const
+{
+    return !(*this <= other);
+}
+bool Version::operator>=(const Version& other) const
+{
+    return !(*this < other);
+}
+
+void Version::parse()
+{
+    m_sections.clear();
+    QString currentSection;
+
+    if (m_string.isEmpty())
+        return;
+
+    auto classChange = [&currentSection](QChar lastChar, QChar currentChar) {
+        if (lastChar.isNull())
+            return false;
+        if (lastChar.isDigit() != currentChar.isDigit())
+            return true;
+
+        const QList<QChar> s_separators{ '.', '-', '+' };
+        if (s_separators.contains(currentChar) && currentSection.at(0) != currentChar)
+            return true;
+
+        return false;
+    };
+
+    currentSection += m_string.at(0);
+    for (int i = 1; i < m_string.size(); ++i) {
+        const auto& current_char = m_string.at(i);
+        if (classChange(m_string.at(i - 1), current_char)) {
+            if (!currentSection.isEmpty())
+                m_sections.append(Section(currentSection));
+            currentSection = "";
+        }
+
+        currentSection += current_char;
+    }
+
+    if (!currentSection.isEmpty())
+        m_sections.append(Section(currentSection));
+}
 
 /// qDebug print support for the Version class
 QDebug operator<<(QDebug debug, const Version& v)
 {
-    const QDebugStateSaver saver(debug);
+    QDebugStateSaver saver(debug);
 
     debug.nospace() << "Version{ string: " << v.toString() << ", sections: [ ";
 
     bool first = true;
-    for (const auto& s : v.m_sections) {
+    for (auto s : v.m_sections) {
-        if (!first) {
+        if (!first)
             debug.nospace() << ", ";
-        }
+        debug.nospace() << s.m_fullString;
-        debug.nospace() << s.value;
         first = false;
     }
 
@@ -44,114 +126,3 @@ QDebug operator<<(QDebug debug, const Version& v)
 
     return debug;
 }
-
-std::strong_ordering Version::Section::operator<=>(const Section& other) const
-{
-    // If both components are numeric, compare numerically (codepoint-wise)
-    if (this->t == Type::Numeric && other.t == Type::Numeric) {
-        auto aLen = this->value.size();
-        if (aLen != other.value.size()) {
-            // Lengths differ; compare by length
-            return aLen <=> other.value.size();
-        }
-        // Compare by digits
-        auto cmp = QString::compare(this->value, other.value);
-        if (cmp < 0) {
-            return std::strong_ordering::less;
-        }
-        if (cmp > 0) {
-            return std::strong_ordering::greater;
-        }
-        return std::strong_ordering::equal;
-    }
-    // One or both are null
-    if (this->t == Type::Null) {
-        if (other.t == Type::PreRelease) {
-            return std::strong_ordering::greater;
-        }
-        return std::strong_ordering::less;
-    }
-    if (other.t == Type::Null) {
-        if (this->t == Type::PreRelease) {
-            return std::strong_ordering::less;
-        }
-        return std::strong_ordering::greater;
-    }
-    // Textual comparison (differing type, or both textual/pre-release)
-    auto minLen = qMin(this->value.size(), other.value.size());
-    for (int i = 0; i < minLen; i++) {
-        auto a = this->value.at(i);
-        auto b = other.value.at(i);
-        if (a != b) {
-            // Compare by rune
-            return a.unicode() <=> b.unicode();
-        }
-    }
-    // Compare by length
-    return this->value.size() <=> other.value.size();
-}
-
-namespace {
-void removeLeadingZeros(QString& s)
-{
-    s.remove(0, std::distance(s.begin(), std::ranges::find_if_not(s, [](QChar c) { return c == '0'; })));
-}
-}  // namespace
-
-void Version::parse()
-{
-    auto len = m_string.size();
-    for (int i = 0; i < len;) {
-        Section cur(Section::Type::Textual);
-        auto c = m_string.at(i);
-        if (c == '+') {
-            break;  // Ignore appendices
-        }
-        // custom: the space is special to handle the strings like "1.20 Pre-Release 1"
-        // this is needed to support Modrinth versions
-        if (c == '-' || c == ' ') {
-            // Add dash to component
-            cur.value += c;
-            i++;
-            // If the next rune is non-digit, mark as pre-release (requires >= 1 non-digit after dash so the component has length > 1)
-            if (i < len && !m_string.at(i).isDigit()) {
-                cur.t = Section::Type::PreRelease;
-            }
-        } else if (c.isDigit()) {
-            // Mark as numeric
-            cur.t = Section::Type::Numeric;
-        }
-        for (; i < len; i++) {
-            auto r = m_string.at(i);
-            if ((r.isDigit() != (cur.t == Section::Type::Numeric))   // starts a new section
-                || (r == ' ' && cur.t == Section::Type::Numeric)     // custom: numeric section then a space is a pre-release
-                || (r == '-' && cur.t != Section::Type::PreRelease)  // "---" is a valid pre-release component
-                || r == '+') {
-                // Run completed (do not consume this rune)
-                break;
-            }
-            // Add rune to current run
-            cur.value += r;
-        }
-        if (!cur.value.isEmpty()) {
-            if (cur.t == Section::Type::Numeric) {
-                removeLeadingZeros(cur.value);
-            }
-            m_sections.append(cur);
-        }
-    }
-}
-
-std::strong_ordering Version::operator<=>(const Version& other) const
-{
-    const auto size = qMax(m_sections.size(), other.m_sections.size());
-    for (int i = 0; i < size; ++i) {
-        auto sec1 = (i >= m_sections.size()) ? Section() : m_sections.at(i);
-        auto sec2 = (i >= other.m_sections.size()) ? Section() : other.m_sections.at(i);
-
-        if (auto cmp = sec1 <=> sec2; cmp != std::strong_ordering::equal) {
-            return cmp;
-        }
-    }
-    return std::strong_ordering::equal;
-}

launcher/Version.h

@@ -3,7 +3,6 @@
  *  Prism Launcher - Minecraft Launcher
  *  Copyright (C) 2023 flowln <flowlnlnln@gmail.com>
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
- *  Copyright (c) 2026 Trial97 <alexandru.tripon97@gmail.com>
  *
  *  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
@@ -16,6 +15,23 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * 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.
  */
 
 #pragma once
@@ -25,36 +41,115 @@
 #include <QString>
 #include <QStringView>
 
-// this implements the FlexVer
+class QUrl;
-// https://git.sleeping.town/exa/FlexVer
+
 class Version {
    public:
-    Version(QString str) : m_string(std::move(str)) { parse(); }  // NOLINT(hicpp-explicit-conversions)
+    Version(QString str);
     Version() = default;
 
-   private:
+    bool operator<(const Version& other) const;
-    struct Section {
+    bool operator<=(const Version& other) const;
-        enum class Type : std::uint8_t { Null, Textual, Numeric, PreRelease };
+    bool operator>(const Version& other) const;
-        explicit Section(Type t = Type::Null, QString value = "") : t(t), value(std::move(value)) {}
+    bool operator>=(const Version& other) const;
-        Type t;
+    bool operator==(const Version& other) const;
-        QString value;
+    bool operator!=(const Version& other) const;
-        bool operator==(const Section& other) const = default;
-        std::strong_ordering operator<=>(const Section& other) const;
-    };
 
-   private:
-    void parse();
-
-   public:
     QString toString() const { return m_string; }
     bool isEmpty() const { return m_string.isEmpty(); }
 
     friend QDebug operator<<(QDebug debug, const Version& v);
 
-    bool operator==(const Version& other) const { return (*this <=> other) == std::strong_ordering::equal; }
+   private:
-    std::strong_ordering operator<=>(const Version& other) const;
+    struct Section {
+        explicit Section(QString fullString) : m_fullString(std::move(fullString))
+        {
+            qsizetype cutoff = m_fullString.size();
+            for (int i = 0; i < m_fullString.size(); i++) {
+                if (!m_fullString[i].isDigit()) {
+                    cutoff = i;
+                    break;
+                }
+            }
+
+            auto numPart = QStringView{ m_fullString }.left(cutoff);
+
+            if (!numPart.isEmpty()) {
+                m_isNull = false;
+                m_numPart = numPart.toInt();
+            }
+
+            auto stringPart = QStringView{ m_fullString }.mid(cutoff);
+
+            if (!stringPart.isEmpty()) {
+                m_isNull = false;
+                m_stringPart = stringPart.toString();
+            }
+        }
+
+        explicit Section() = default;
+
+        bool m_isNull = true;
+
+        int m_numPart = 0;
+        QString m_stringPart;
+
+        QString m_fullString;
+
+        inline bool isAppendix() const { return m_stringPart.startsWith('+'); }
+        inline bool isPreRelease() const { return m_stringPart.startsWith('-') && m_stringPart.length() > 1; }
+
+        inline bool operator==(const Section& other) const
+        {
+            if (m_isNull && !other.m_isNull)
+                return false;
+            if (!m_isNull && other.m_isNull)
+                return false;
+
+            if (!m_isNull && !other.m_isNull) {
+                return (m_numPart == other.m_numPart) && (m_stringPart == other.m_stringPart);
+            }
+
+            return true;
+        }
+
+        inline bool operator<(const Section& other) const
+        {
+            static auto unequal_is_less = [](const Section& non_null) -> bool {
+                if (non_null.m_stringPart.isEmpty())
+                    return non_null.m_numPart == 0;
+                return (non_null.m_stringPart != QLatin1Char('.')) && non_null.isPreRelease();
+            };
+
+            if (!m_isNull && other.m_isNull)
+                return unequal_is_less(*this);
+            if (m_isNull && !other.m_isNull)
+                return !unequal_is_less(other);
+
+            if (!m_isNull && !other.m_isNull) {
+                if (m_numPart < other.m_numPart)
+                    return true;
+                if (m_numPart == other.m_numPart && m_stringPart < other.m_stringPart)
+                    return true;
+
+                if (!m_stringPart.isEmpty() && other.m_stringPart.isEmpty())
+                    return false;
+                if (m_stringPart.isEmpty() && !other.m_stringPart.isEmpty())
+                    return true;
+
+                return false;
+            }
+
+            return m_fullString < other.m_fullString;
+        }
+
+        inline bool operator!=(const Section& other) const { return !(*this == other); }
+        inline bool operator>(const Section& other) const { return !(*this < other || *this == other); }
+    };
 
    private:
     QString m_string;
     QList<Section> m_sections;
-};
+
+    void parse();
+};

launcher/archive/ArchiveReader.cpp

@@ -24,7 +24,6 @@
 #include <QDir>
 #include <QFileInfo>
 #include <QUrl>
-#include <functional>
 #include <memory>
 #include <optional>
 
@@ -37,36 +36,25 @@ QStringList ArchiveReader::getFiles()
 bool ArchiveReader::collectFiles(bool onlyFiles)
 {
     return parse([this, onlyFiles](File* f) {
-        if (!onlyFiles || f->isFile()) {
+        if (!onlyFiles || f->isFile())
             m_fileNames << f->filename();
-        }
         return f->skip();
     });
 }
 
-using getPathFunc = std::function<const char*(archive_entry*)>;
-static QString decodeLibArchivePath(archive_entry* entry, const getPathFunc& getUtf8Path, const getPathFunc& getPath)
-{
-    auto fileName = QString::fromUtf8(getUtf8Path(entry));
-    if (fileName.isEmpty()) {
-        fileName = QString::fromLocal8Bit(getPath(entry));
-    }
-    return fileName;
-}
-
 QString ArchiveReader::File::filename()
 {
-    return decodeLibArchivePath(m_entry, archive_entry_pathname_utf8, archive_entry_pathname);
+    return QString::fromUtf8(archive_entry_pathname_utf8(m_entry));
 }
 
 QByteArray ArchiveReader::File::readAll(int* outStatus)
 {
     QByteArray data;
-    const void* buff = nullptr;
+    const void* buff;
-    size_t size = 0;
+    size_t size;
-    la_int64_t offset = 0;
+    la_int64_t offset;
 
-    int status = 0;
+    int status;
     while ((status = archive_read_data_block(m_archive.get(), &buff, &size, &offset)) == ARCHIVE_OK) {
         data.append(static_cast<const char*>(buff), static_cast<qsizetype>(size));
     }
@@ -92,10 +80,10 @@ int ArchiveReader::File::readNextHeader()
     return archive_read_next_header(m_archive.get(), &m_entry);
 }
 
-auto ArchiveReader::goToFile(const QString& filename) -> std::unique_ptr<File>
+auto ArchiveReader::goToFile(QString filename) -> std::unique_ptr<File>
 {
     auto f = std::make_unique<File>();
-    auto* a = f->m_archive.get();
+    auto a = f->m_archive.get();
     archive_read_support_format_all(a);
     archive_read_support_filter_all(a);
     auto fileName = m_archivePath.toStdWString();
@@ -117,16 +105,15 @@ auto ArchiveReader::goToFile(const QString& filename) -> std::unique_ptr<File>
 
 static int copy_data(struct archive* ar, struct archive* aw, bool notBlock = false)
 {
-    int r = 0;
+    int r;
-    const void* buff = nullptr;
+    const void* buff;
-    size_t size = 0;
+    size_t size;
-    la_int64_t offset = 0;
+    la_int64_t offset;
 
     for (;;) {
         r = archive_read_data_block(ar, &buff, &size, &offset);
-        if (r == ARCHIVE_EOF) {
+        if (r == ARCHIVE_EOF)
-            return ARCHIVE_OK;
+            return (ARCHIVE_OK);
-        }
         if (r < ARCHIVE_OK) {
             qCritical() << "Failed reading data block:" << archive_error_string(ar);
             return (r);
@@ -143,43 +130,39 @@ static int copy_data(struct archive* ar, struct archive* aw, bool notBlock = fal
     }
 }
 
-static bool willEscapeRoot(const QDir& root, archive_entry* entry)
+bool willEscapeRoot(const QDir& root, archive_entry* entry)
 {
-    auto entryPath = decodeLibArchivePath(entry, archive_entry_pathname_utf8, archive_entry_pathname);
+    const char* entryPathC = archive_entry_pathname(entry);
-    auto linkTarget = decodeLibArchivePath(entry, archive_entry_symlink_utf8, archive_entry_symlink);
+    const char* linkTargetC = archive_entry_symlink(entry);
-    auto hardLink = decodeLibArchivePath(entry, archive_entry_hardlink_utf8, archive_entry_hardlink);
+    const char* hardlinkC = archive_entry_hardlink(entry);
 
-    if (entryPath.isEmpty() || (linkTarget.isEmpty() && hardLink.isEmpty())) {
+    if (!entryPathC || (!linkTargetC && !hardlinkC))
         return false;
-    }
 
-    bool isHardLink = false;
+    QString entryPath = QString::fromUtf8(entryPathC);
-    if (isHardLink = linkTarget.isEmpty(); isHardLink) {
+    QString linkTarget = linkTargetC ? QString::fromUtf8(linkTargetC) : QString::fromUtf8(hardlinkC);
-        linkTarget = hardLink;
-    }
 
     QString linkFullPath = root.filePath(entryPath);
     auto rootDir = QUrl::fromLocalFile(root.absolutePath());
 
-    if (!rootDir.isParentOf(QUrl::fromLocalFile(linkFullPath))) {
+    if (!rootDir.isParentOf(QUrl::fromLocalFile(linkFullPath)))
         return true;
-    }
 
     QDir linkDir = QFileInfo(linkFullPath).dir();
     if (!QDir::isAbsolutePath(linkTarget)) {
-        linkTarget = (!isHardLink ? linkDir : root).filePath(linkTarget);
+        linkTarget = (linkTargetC ? linkDir : root).filePath(linkTarget);
     }
     return !rootDir.isParentOf(QUrl::fromLocalFile(QDir::cleanPath(linkTarget)));
 }
 
-bool ArchiveReader::File::writeFile(archive* out, const QString& targetFileName, bool notBlock)
+bool ArchiveReader::File::writeFile(archive* out, QString targetFileName, bool notBlock)
 {
     return writeFile(out, targetFileName, {}, notBlock);
 };
 
-bool ArchiveReader::File::writeFile(archive* out, const QString& targetFileName, std::optional<QDir> root, bool notBlock)
+bool ArchiveReader::File::writeFile(archive* out, QString targetFileName, std::optional<QDir> root, bool notBlock)
 {
-    auto* entry = m_entry;
+    auto entry = m_entry;
     std::unique_ptr<archive_entry, decltype(&archive_entry_free)> entryClone(nullptr, &archive_entry_free);
     if (!targetFileName.isEmpty()) {
         entryClone.reset(archive_entry_clone(m_entry));
@@ -192,29 +175,25 @@ bool ArchiveReader::File::writeFile(archive* out, const QString& targetFileName,
         return false;
     }
     if (archive_write_header(out, entry) < ARCHIVE_OK) {
-        qCritical() << "Failed to write header to entry:" << filename() << "-" << archive_error_string(out) << targetFileName;
+        qCritical() << "Failed to write header to entry:" << filename() << "-" << archive_error_string(out);
         return false;
-    }
+    } else if (archive_entry_size(m_entry) > 0) {
-    if (archive_entry_size(m_entry) > 0) {
         auto r = copy_data(m_archive.get(), out, notBlock);
-        if (r < ARCHIVE_OK) {
+        if (r < ARCHIVE_OK)
             qCritical() << "Failed reading data block:" << archive_error_string(out);
-        }
+        if (r < ARCHIVE_WARN)
-        if (r < ARCHIVE_WARN) {
             return false;
-        }
     }
     auto r = archive_write_finish_entry(out);
-    if (r < ARCHIVE_OK) {
+    if (r < ARCHIVE_OK)
         qCritical() << "Failed to finish writing entry:" << archive_error_string(out);
-    }
     return (r >= ARCHIVE_WARN);
 }
 
-bool ArchiveReader::parse(const std::function<bool(File*, bool&)>& doStuff)
+bool ArchiveReader::parse(std::function<bool(File*, bool&)> doStuff)
 {
     auto f = std::make_unique<File>();
-    auto* a = f->m_archive.get();
+    auto a = f->m_archive.get();
     archive_read_support_format_all(a);
     archive_read_support_filter_all(a);
     auto fileName = m_archivePath.toStdWString();
@@ -238,7 +217,7 @@ bool ArchiveReader::parse(const std::function<bool(File*, bool&)>& doStuff)
     return true;
 }
 
-bool ArchiveReader::parse(const std::function<bool(File*)>& doStuff)
+bool ArchiveReader::parse(std::function<bool(File*)> doStuff)
 {
     return parse([doStuff](File* f, bool&) { return doStuff(f); });
 }
@@ -262,32 +241,26 @@ QString ArchiveReader::getZipName()
 
 bool ArchiveReader::exists(const QString& filePath) const
 {
-    if (filePath == QLatin1String("/") || filePath.isEmpty()) {
+    if (filePath == QLatin1String("/") || filePath.isEmpty())
         return true;
-    }
     // Normalize input path (remove trailing slash, if any)
     QString normalizedPath = QDir::cleanPath(filePath);
-    if (normalizedPath.startsWith('/')) {
+    if (normalizedPath.startsWith('/'))
         normalizedPath.remove(0, 1);
-    }
+    if (normalizedPath == QLatin1String("."))
-    if (normalizedPath == QLatin1String(".")) {
         return true;
-    }
+    if (normalizedPath == QLatin1String(".."))
-    if (normalizedPath == QLatin1String("..")) {
         return false;  // root only
-    }
 
     // Check for exact file match
-    if (m_fileNames.contains(normalizedPath, Qt::CaseInsensitive)) {
+    if (m_fileNames.contains(normalizedPath, Qt::CaseInsensitive))
         return true;
-    }
 
     // Check for directory existence by seeing if any file starts with that path
     QString dirPath = normalizedPath + QLatin1Char('/');
     for (const QString& f : m_fileNames) {
-        if (f.startsWith(dirPath, Qt::CaseInsensitive)) {
+        if (f.startsWith(dirPath, Qt::CaseInsensitive))
             return true;
-        }
     }
 
     return false;

launcher/archive/ArchiveReader.h

@@ -23,7 +23,6 @@
 #include <QStringList>
 #include <memory>
 #include <optional>
-#include <utility>
 
 struct archive;
 struct archive_entry;
@@ -31,7 +30,7 @@ namespace MMCZip {
 class ArchiveReader {
    public:
     using ArchivePtr = std::unique_ptr<struct archive, int (*)(struct archive*)>;
-    explicit ArchiveReader(QString fileName) : m_archivePath(std::move(fileName)) {}
+    ArchiveReader(QString fileName) : m_archivePath(fileName) {}
     virtual ~ArchiveReader() = default;
 
     QStringList getFiles();
@@ -51,8 +50,8 @@ class ArchiveReader {
 
         QByteArray readAll(int* outStatus = nullptr);
         bool skip();
-        bool writeFile(archive* out, const QString& targetFileName = "", bool notBlock = false);
+        bool writeFile(archive* out, QString targetFileName = "", bool notBlock = false);
-        bool writeFile(archive* out, const QString& targetFileName, std::optional<QDir> root, bool notBlock = false);
+        bool writeFile(archive* out, QString targetFileName, std::optional<QDir> root, bool notBlock = false);
 
        private:
         int readNextHeader();
@@ -63,14 +62,14 @@ class ArchiveReader {
         archive_entry* m_entry;
     };
 
-    std::unique_ptr<File> goToFile(const QString& filename);
+    std::unique_ptr<File> goToFile(QString filename);
-    bool parse(const std::function<bool(File*)>&);
+    bool parse(std::function<bool(File*)>);
-    bool parse(const std::function<bool(File*, bool&)>&);
+    bool parse(std::function<bool(File*, bool&)>);
 
    private:
     QString m_archivePath;
     size_t m_blockSize = 10240;
 
-    QStringList m_fileNames;
+    QStringList m_fileNames = {};
 };
 }  // namespace MMCZip

launcher/archive/ArchiveWriter.cpp

@@ -174,7 +174,7 @@ bool ArchiveWriter::addFile(const QString& fileName, const QString& fileDest)
     if (fileInfo.isFile() && !fileInfo.isSymLink()) {
         QFile file(fileInfo.absoluteFilePath());
         if (!file.open(QIODevice::ReadOnly)) {
-            qCritical() << "Failed to open file:" << fileInfo.filePath() << "error:" << file.errorString();
+            qCritical() << "Failed to open file:" << fileInfo.filePath();
             return false;
         }
 

launcher/java/JavaChecker.cpp

@@ -179,20 +179,13 @@ void JavaChecker::finished(int exitcode, QProcess::ExitStatus status)
 void JavaChecker::error(QProcess::ProcessError err)
 {
     if (err == QProcess::FailedToStart) {
-        qDebug() << "Java checker has failed to start:" << process->errorString();
+        qDebug() << "Java checker has failed to start.";
         qDebug() << "Process environment:";
         qDebug() << process->environment();
         qDebug() << "Native environment:";
         qDebug() << QProcessEnvironment::systemEnvironment().toStringList();
         killTimer.stop();
-
+        emit checkFinished({ m_path, m_id });
-        Result result = {
-            m_path,
-            m_id,
-        };
-        result.errorLog = process->errorString();
-        result.validity = Result::Validity::Errored;
-        emit checkFinished(result);
     }
     emitSucceeded();
 }

launcher/java/JavaInstallList.cpp

@@ -51,9 +51,8 @@ JavaInstallList::JavaInstallList(QObject* parent, bool onlyManagedVersions)
     : BaseVersionList(parent), m_only_managed_versions(onlyManagedVersions)
 {}
 
-Task::Ptr JavaInstallList::getLoadTask(bool forceReload)
+Task::Ptr JavaInstallList::getLoadTask()
 {
-    Q_UNUSED(forceReload)
     load();
     return getCurrentTask();
 }

launcher/java/JavaInstallList.h

@@ -35,7 +35,7 @@ class JavaInstallList : public BaseVersionList {
    public:
     explicit JavaInstallList(QObject* parent = 0, bool onlyManagedVersions = false);
 
-    Task::Ptr getLoadTask(bool forceReload = false) override;
+    Task::Ptr getLoadTask() override;
     bool isLoaded() override;
     const BaseVersion::Ptr at(int i) const override;
     int count() const override;

launcher/java/JavaUtils.cpp

@@ -42,7 +42,6 @@
 
 #include <QDebug>
 #include "Application.h"
-#include "BuildConfig.h"
 #include "FileSystem.h"
 #include "java/JavaInstallList.h"
 #include "java/JavaUtils.h"
@@ -156,7 +155,7 @@ JavaInstallPtr JavaUtils::GetDefaultJava()
 
 QStringList addJavasFromEnv(QList<QString> javas)
 {
-    auto env = QProcessEnvironment::systemEnvironment().value(QStringLiteral("%1_JAVA_PATHS").arg(BuildConfig.LAUNCHER_ENVNAME));
+    auto env = qEnvironmentVariable("PRISMLAUNCHER_JAVA_PATHS");  // FIXME: use launcher name from buildconfig
 #if defined(Q_OS_WIN32)
     QList<QString> javaPaths = env.replace("\\", "/").split(QLatin1String(";"));
 

launcher/meta/BaseEntity.cpp

@@ -82,12 +82,12 @@ QUrl BaseEntity::url() const
     return QUrl(metaOverride).resolved(localFilename());
 }
 
-Task::Ptr BaseEntity::loadTask(Net::Mode mode, bool forceReload)
+Task::Ptr BaseEntity::loadTask(Net::Mode mode)
 {
     if (m_task && m_task->isRunning()) {
         return m_task;
     }
-    m_task.reset(new BaseEntityLoadTask(this, mode, forceReload));
+    m_task.reset(new BaseEntityLoadTask(this, mode));
     return m_task;
 }
 
@@ -107,9 +107,7 @@ BaseEntity::LoadStatus BaseEntity::status() const
     return m_load_status;
 }
 
-BaseEntityLoadTask::BaseEntityLoadTask(BaseEntity* parent, Net::Mode mode, bool forceReload)
+BaseEntityLoadTask::BaseEntityLoadTask(BaseEntity* parent, Net::Mode mode) : m_entity(parent), m_mode(mode) {}
-    : m_entity(parent), m_mode(mode), m_force_reload(forceReload)
-{}
 
 void BaseEntityLoadTask::executeTask()
 {
@@ -127,11 +125,9 @@ void BaseEntityLoadTask::executeTask()
             }
 
             // on online the hash needs to match
-            const auto& expected = m_entity->m_sha256;
+            hashMatches = m_entity->m_sha256 == m_entity->m_file_sha256;
-            const auto& actual = m_entity->m_file_sha256;
-            hashMatches = expected == actual;
             if (m_mode == Net::Mode::Online && !m_entity->m_sha256.isEmpty() && !hashMatches) {
-                throw Exception(QString("Checksum mismatch, expected sha256: %1, got: %2").arg(expected, actual));
+                throw Exception("mismatched checksum");
             }
 
             // load local file
@@ -153,18 +149,13 @@ void BaseEntityLoadTask::executeTask()
     auto wasLoadedOffline = m_entity->m_load_status != BaseEntity::LoadStatus::NotLoaded && m_mode == Net::Mode::Offline;
     // if has is not present allways fetch from remote(e.g. the main index file), else only fetch if hash doesn't match
     auto wasLoadedRemote = m_entity->m_sha256.isEmpty() ? m_entity->m_load_status == BaseEntity::LoadStatus::Remote : hashMatches;
-    if (wasLoadedOffline || (wasLoadedRemote && !m_force_reload)) {
+    if (wasLoadedOffline || wasLoadedRemote) {
         emitSucceeded();
         return;
     }
     m_task.reset(new NetJob(QObject::tr("Download of meta file %1").arg(m_entity->localFilename()), APPLICATION->network()));
     auto url = m_entity->url();
     auto entry = APPLICATION->metacache()->resolveEntry("meta", m_entity->localFilename());
-    if (m_force_reload) {
-        // clear validators so manual refreshes fetch a fresh body
-        entry->setETag({});
-        entry->setRemoteChangedTimestamp({});
-    }
     entry->setStale(true);
     auto dl = Net::ApiDownload::makeCached(url, entry);
     /*

launcher/meta/BaseEntity.h

@@ -43,7 +43,7 @@ class BaseEntity {
     void setSha256(QString sha256);
 
     virtual void parse(const QJsonObject& obj) = 0;
-    [[nodiscard]] Task::Ptr loadTask(Net::Mode loadType = Net::Mode::Online, bool forceReload = false);
+    [[nodiscard]] Task::Ptr loadTask(Net::Mode loadType = Net::Mode::Online);
 
    protected:
     QString m_sha256;       // the expected sha256
@@ -58,7 +58,7 @@ class BaseEntityLoadTask : public Task {
     Q_OBJECT
 
    public:
-    explicit BaseEntityLoadTask(BaseEntity* parent, Net::Mode mode, bool forceReload);
+    explicit BaseEntityLoadTask(BaseEntity* parent, Net::Mode mode);
     ~BaseEntityLoadTask() override = default;
 
     virtual void executeTask() override;
@@ -68,7 +68,6 @@ class BaseEntityLoadTask : public Task {
    private:
     BaseEntity* m_entity;
     Net::Mode m_mode;
-    bool m_force_reload = false;
     NetJob::Ptr m_task;
 };
 }  // namespace Meta

launcher/meta/Index.cpp

@@ -15,7 +15,6 @@
 
 #include "Index.h"
 
-#include "Application.h"
 #include "JsonFormat.h"
 #include "QObjectPtr.h"
 #include "VersionList.h"
@@ -136,7 +135,7 @@ void Index::connectVersionList(const int row, const VersionList::Ptr& list)
 
 Task::Ptr Index::loadVersion(const QString& uid, const QString& version, Net::Mode mode, bool force)
 {
-    if (mode == Net::Mode::Offline || !APPLICATION->settings()->get("MetaRefreshOnLaunch").toBool()) {
+    if (mode == Net::Mode::Offline) {
         return get(uid, version)->loadTask(mode);
     }
 

launcher/meta/VersionList.cpp

@@ -32,11 +32,11 @@ VersionList::VersionList(const QString& uid, QObject* parent) : BaseVersionList(
     setObjectName("Version list: " + uid);
 }
 
-Task::Ptr VersionList::getLoadTask(bool forceReload)
+Task::Ptr VersionList::getLoadTask()
 {
     auto loadTask = makeShared<SequentialTask>(tr("Load meta for %1", "This is for the task name that loads the meta index.").arg(m_uid));
-    loadTask->addTask(APPLICATION->metadataIndex()->loadTask(Net::Mode::Online, forceReload));
+    loadTask->addTask(APPLICATION->metadataIndex()->loadTask(Net::Mode::Online));
-    loadTask->addTask(this->loadTask(Net::Mode::Online, forceReload));
+    loadTask->addTask(this->loadTask(Net::Mode::Online));
     return loadTask;
 }
 

launcher/meta/VersionList.h

@@ -37,7 +37,7 @@ class VersionList : public BaseVersionList, public BaseEntity {
     enum Roles { UidRole = Qt::UserRole + 100, TimeRole, RequiresRole, VersionPtrRole };
 
     bool isLoaded() override;
-    Task::Ptr getLoadTask(bool forceReload = false) override;
+    Task::Ptr getLoadTask() override;
     const BaseVersion::Ptr at(int i) const override;
     int count() const override;
     void sortVersions() override;

launcher/minecraft/AssetsUtils.cpp

@@ -104,7 +104,7 @@ bool loadAssetsIndexJson(const QString& assetsId, const QString& path, AssetsInd
     // Try to open the file and fail if we can't.
     // TODO: We should probably report this error to the user.
     if (!file.open(QIODevice::ReadOnly)) {
-        qCritical() << "Failed to read assets index file" << path << "error:" << file.errorString();
+        qCritical() << "Failed to read assets index file" << path;
         return false;
     }
     index.id = assetsId;

launcher/minecraft/LaunchProfile.cpp

@@ -349,8 +349,7 @@ void LaunchProfile::getLibraryFiles(const RuntimeContext& runtimeContext,
                                     QStringList& jars,
                                     QStringList& nativeJars,
                                     const QString& overridePath,
-                                    const QString& tempPath,
+                                    const QString& tempPath) const
-                                    bool addJarMods) const
 {
     QStringList native32, native64;
     jars.clear();
@@ -361,7 +360,7 @@ void LaunchProfile::getLibraryFiles(const RuntimeContext& runtimeContext,
     // NOTE: order is important here, add main jar last to the lists
     if (m_mainJar) {
         // FIXME: HACK!! jar modding is weird and unsystematic!
-        if (m_jarMods.size() && addJarMods) {
+        if (m_jarMods.size()) {
             QDir tempDir(tempPath);
             jars.append(tempDir.absoluteFilePath("minecraft.jar"));
         } else {

launcher/minecraft/LaunchProfile.h

@@ -87,8 +87,7 @@ class LaunchProfile : public ProblemProvider {
                          QStringList& jars,
                          QStringList& nativeJars,
                          const QString& overridePath,
-                         const QString& tempPath,
+                         const QString& tempPath) const;
-                         bool addJarMods = true) const;
     bool hasTrait(const QString& trait) const;
     ProblemSeverity getProblemSeverity() const override;
     const QList<PatchProblem> getProblems() const override;

launcher/minecraft/Library.cpp

@@ -149,7 +149,7 @@ QList<Net::NetRequest::Ptr> Library::getDownloads(const RuntimeContext& runtimeC
         if (sha1.size()) {
             auto dl = Net::ApiDownload::makeCached(url, entry, options);
             dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, sha1));
-            qDebug() << "Checksummed Download for:" << rawName().serialize() << "storage:" << storage << "url:" << url << "expected sha1:" << sha1;
+            qDebug() << "Checksummed Download for:" << rawName().serialize() << "storage:" << storage << "url:" << url;
             out.append(dl);
         } else {
             out.append(Net::ApiDownload::makeCached(url, entry, options));

launcher/minecraft/MinecraftInstance.cpp

@@ -59,7 +59,6 @@
 #include "minecraft/launch/AutoInstallJava.h"
 #include "minecraft/launch/ClaimAccount.h"
 #include "minecraft/launch/CreateGameFolders.h"
-#include "minecraft/launch/EnsureAvailableMemory.h"
 #include "minecraft/launch/EnsureOfflineLibraries.h"
 #include "minecraft/launch/ExtractNatives.h"
 #include "minecraft/launch/LauncherPartLaunch.h"
@@ -131,8 +130,7 @@
     for (const auto& gpu : gpus) {
         QString name = qvariant_cast<QString>(gpu[QStringLiteral("Name")]);
         bool defaultGpu = qvariant_cast<bool>(gpu[QStringLiteral("Default")]);
-        bool discrete = qvariant_cast<bool>(gpu.value(QStringLiteral("Discrete"), !defaultGpu));
+        if (!defaultGpu) {
-        if (discrete) {
             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]);
@@ -210,7 +208,6 @@ void MinecraftInstance::loadSpecificSettings()
         m_settings->registerOverride(global_settings->getSetting("MinMemAlloc"), memorySetting);
         m_settings->registerOverride(global_settings->getSetting("MaxMemAlloc"), memorySetting);
         m_settings->registerOverride(global_settings->getSetting("PermGen"), memorySetting);
-        m_settings->registerOverride(global_settings->getSetting("LowMemWarning"), memorySetting);
 
         // Native library workarounds
         auto nativeLibraryWorkaroundsOverride = m_settings->registerSetting("OverrideNativeWorkarounds", false);
@@ -893,14 +890,6 @@ QStringList MinecraftInstance::verboseDescription(AuthSessionPtr session, Minecr
 
     QStringList out;
 
-    out << "Components:";
-    for (int i = 0; i < m_components->rowCount(); ++i) {
-        const auto& component = m_components->getComponent(i);
-        out << indent +
-                   QString("%1) %2 (%3) %4").arg(QString::number(i + 1), component->getName(), component->getID(), component->getVersion());
-    }
-    out << emptyLine;
-
     out << "Launcher: " + getLauncher();
     out << "Main class: " + getMainClass() << emptyLine;
 
@@ -1202,11 +1191,6 @@ LaunchTask* MinecraftInstance::createLaunchTask(AuthSessionPtr session, Minecraf
         process->appendStep(makeShared<ScanModFolders>(pptr));
     }
 
-    // make sure we have enough RAM, warn the user if we don't
-    {
-        process->appendStep(makeShared<EnsureAvailableMemory>(pptr, this));
-    }
-
     // print some instance info here...
     {
         process->appendStep(makeShared<PrintInstanceInfo>(pptr, session, targetToJoin));

launcher/minecraft/ProfileUtils.cpp

@@ -144,13 +144,13 @@ bool saveJsonFile(const QJsonDocument& doc, const QString& filename)
     auto data = doc.toJson();
     QSaveFile jsonFile(filename);
     if (!jsonFile.open(QIODevice::WriteOnly)) {
-        qWarning() << "Couldn't open" << filename << "for writing:" << jsonFile.errorString();
         jsonFile.cancelWriting();
+        qWarning() << "Couldn't open" << filename << "for writing";
         return false;
     }
     jsonFile.write(data);
     if (!jsonFile.commit()) {
-        qWarning() << "Couldn't save" << filename << "error:" << jsonFile.errorString();
+        qWarning() << "Couldn't save" << filename;
         return false;
     }
     return true;

launcher/minecraft/ShortcutUtils.cpp

@@ -71,7 +71,7 @@ bool createInstanceShortcut(const Shortcut& shortcut, const QString& filePath)
 
     QFile iconFile(iconPath);
     if (!iconFile.open(QFile::WriteOnly)) {
-        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for application: %1").arg(iconFile.errorString()));
+        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for application."));
         return false;
     }
 
@@ -101,7 +101,7 @@ bool createInstanceShortcut(const Shortcut& shortcut, const QString& filePath)
 
     QFile iconFile(iconPath);
     if (!iconFile.open(QFile::WriteOnly)) {
-        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for shortcut: %1").arg(iconFile.errorString()));
+        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for shortcut."));
         return false;
     }
     bool success = icon->icon().pixmap(64, 64).save(&iconFile, "PNG");
@@ -127,7 +127,7 @@ bool createInstanceShortcut(const Shortcut& shortcut, const QString& filePath)
 
     QFile iconFile(iconPath);
     if (!iconFile.open(QFile::WriteOnly)) {
-        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for shortcut: %1").arg(iconFile.errorString()));
+        QMessageBox::critical(shortcut.parent, QObject::tr("Create Shortcut"), QObject::tr("Failed to create icon for shortcut."));
         return false;
     }
     bool success = icon->icon().pixmap(64, 64).save(&iconFile, "ICO");

launcher/minecraft/VanillaInstanceCreationTask.cpp

@@ -7,27 +7,30 @@
 #include "minecraft/PackProfile.h"
 #include "settings/INISettingsObject.h"
 
-VanillaCreationTask::VanillaCreationTask(BaseVersion::Ptr version, QString loader, BaseVersion::Ptr loaderVersion)
+VanillaCreationTask::VanillaCreationTask(BaseVersion::Ptr version, QString loader, BaseVersion::Ptr loader_version)
-    : m_version(std::move(version)), m_using_loader(true), m_loader(std::move(loader)), m_loader_version(std::move(loaderVersion))
+    : InstanceCreationTask()
+    , m_version(std::move(version))
+    , m_using_loader(true)
+    , m_loader(std::move(loader))
+    , m_loader_version(std::move(loader_version))
 {}
 
 std::unique_ptr<MinecraftInstance> VanillaCreationTask::createInstance()
 {
     setStatus(tr("Creating instance from version %1").arg(m_version->name()));
 
-    auto inst = std::make_unique<MinecraftInstance>(
+    auto inst = std::make_unique<MinecraftInstance>(m_globalSettings, std::make_unique<INISettingsObject>(FS::PathCombine(m_stagingPath, "instance.cfg")),
-        m_globalSettings, std::make_unique<INISettingsObject>(FS::PathCombine(m_stagingPath, "instance.cfg")), m_stagingPath);
+                           m_stagingPath);
     SettingsObject::Lock lock(inst->settings());
 
-    auto* components = inst->getPackProfile();
+    auto components = inst->getPackProfile();
     components->buildingFromScratch();
     components->setComponentVersion("net.minecraft", m_version->descriptor(), true);
-    if (m_using_loader) {
+    if (m_using_loader)
         components->setComponentVersion(m_loader, m_loader_version->descriptor());
-    }
 
     inst->setName(name());
     inst->setIconKey(m_instIcon);
-    components->saveNow();
+
     return inst;
 }

launcher/minecraft/VanillaInstanceCreationTask.h

@@ -7,8 +7,8 @@
 class VanillaCreationTask final : public InstanceCreationTask {
     Q_OBJECT
    public:
-    explicit VanillaCreationTask(BaseVersion::Ptr version) : m_version(std::move(version)) {}
+    VanillaCreationTask(BaseVersion::Ptr version) : InstanceCreationTask(), m_version(std::move(version)) {}
-    VanillaCreationTask(BaseVersion::Ptr version, QString loader, BaseVersion::Ptr loaderVersion);
+    VanillaCreationTask(BaseVersion::Ptr version, QString loader, BaseVersion::Ptr loader_version);
 
     std::unique_ptr<MinecraftInstance> createInstance() override;
 

launcher/minecraft/World.cpp

@@ -274,6 +274,9 @@ void World::readFromZip(const QFileInfo& file)
         QFileInfo fi(filePath);
         if (fi.fileName().compare(levelDat, Qt::CaseInsensitive) == 0) {
             m_containerOffsetPath = filePath.chopped(levelDat.length());
+            if (!m_containerOffsetPath.isEmpty()) {
+                return false;
+            }
             m_levelDatTime = file->dateTime();
             loadFromLevelDat(file->readAll());
             m_isValid = true;

launcher/minecraft/WorldList.cpp

@@ -157,8 +157,7 @@ bool WorldList::resetIcon(int row)
         return false;
     World& m = m_worlds[row];
     if (m.resetIcon()) {
-        QModelIndex modelIndex = index(row, NameColumn);
+        emit dataChanged(index(row), index(row), { WorldList::IconFileRole });
-        emit dataChanged(modelIndex, modelIndex, { WorldList::IconFileRole });
         return true;
     }
     return false;
@@ -427,7 +426,7 @@ void WorldList::loadWorldsAsync()
                         m_worlds[row].setSize(size);
 
                         // Notify views
-                        QModelIndex modelIndex = index(row, SizeColumn);
+                        QModelIndex modelIndex = index(row);
                         emit dataChanged(modelIndex, modelIndex, { SizeRole });
                     }
                 },

launcher/minecraft/auth/AccountData.h

@@ -41,7 +41,6 @@
 
 #include <QDateTime>
 #include <QMap>
-#include <QNetworkReply>
 #include <QVariantMap>
 
 enum class Validity { None, Assumed, Certain };
@@ -119,6 +118,5 @@ struct AccountData {
     // runtime only information (not saved with the account)
     QString internalId;
     QString errorString;
-    QNetworkReply::NetworkError networkError = QNetworkReply::NoError;
     AccountState accountState = AccountState::Unchecked;
 };

launcher/minecraft/auth/AccountList.cpp

@@ -450,7 +450,7 @@ bool AccountList::loadList()
     // Try to open the file and fail if we can't.
     // TODO: We should probably report this error to the user.
     if (!file.open(QIODevice::ReadOnly)) {
-        qCritical() << QString("Failed to read the account list file %1 (%2).").arg(m_listFilePath).arg(file.errorString()).toUtf8();
+        qCritical() << QString("Failed to read the account list file (%1).").arg(m_listFilePath).toUtf8();
         return false;
     }
 
@@ -567,7 +567,7 @@ bool AccountList::saveList()
     // Try to open the file and fail if we can't.
     // TODO: We should probably report this error to the user.
     if (!file.open(QIODevice::WriteOnly)) {
-        qCritical() << QString("Failed to save the account list file %1 (%2).").arg(m_listFilePath).arg(file.errorString()).toUtf8();
+        qCritical() << QString("Failed to read the account list file (%1).").arg(m_listFilePath).toUtf8();
         return false;
     }
 
@@ -578,7 +578,7 @@ bool AccountList::saveList()
         qDebug() << "Saved account list to" << m_listFilePath;
         return true;
     } else {
-        qDebug() << "Failed to save accounts to" << m_listFilePath << "error:" << file.errorString();
+        qDebug() << "Failed to save accounts to" << m_listFilePath;
         return false;
     }
 }
@@ -648,17 +648,9 @@ void AccountList::tryNext()
     while (m_refreshQueue.length()) {
         auto accountId = m_refreshQueue.front();
         m_refreshQueue.pop_front();
-        bool found = false;
         for (int i = 0; i < count(); i++) {
             auto account = at(i);
             if (account->internalId() == accountId) {
-                found = true;
-                if (!account->shouldRefresh()) {
-                    // Account no longer needs refreshing, skip it.
-                    qDebug() << "RefreshSchedule: Skipping account" << account->profileName() << "with internal ID"
-                             << accountId << "(no longer needs refresh)";
-                    break;
-                }
                 m_currentTask = account->refresh();
                 if (m_currentTask) {
                     connect(m_currentTask.get(), &Task::succeeded, this, &AccountList::authSucceeded);
@@ -668,12 +660,9 @@ void AccountList::tryNext()
                              << accountId;
                     return;
                 }
-                break;
             }
         }
-        if (!found) {
+        qDebug() << "RefreshSchedule: Account with internal ID" << accountId << "not found.";
-            qDebug() << "RefreshSchedule: Account with internal ID" << accountId << "not found.";
-        }
     }
     // if we get here, no account needed refreshing. Schedule refresh in an hour.
     m_refreshTimer->start(1000 * 3600);

launcher/minecraft/auth/steps/LauncherLoginStep.cpp

@@ -56,11 +56,10 @@ void LauncherLoginStep::onRequestDone(QByteArray* response)
     qCDebug(authCredentials()) << *response;
     if (m_request->error() != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << m_request->error();
-        if (Net::isApplicationError(m_request->error()) && !Net::isServerError(m_request->error())) {
+        if (Net::isApplicationError(m_request->error())) {
             emit finished(AccountTaskState::STATE_FAILED_SOFT,
                           tr("Failed to get Minecraft access token: %1").arg(m_request->errorString()));
         } else {
-            m_data->networkError = m_request->error();
             emit finished(AccountTaskState::STATE_OFFLINE, tr("Failed to get Minecraft access token: %1").arg(m_request->errorString()));
         }
         return;

launcher/minecraft/auth/steps/MSADeviceCodeStep.cpp

@@ -113,12 +113,6 @@ DeviceAuthorizationResponse parseDeviceAuthorizationResponse(const QByteArray& d
 
 void MSADeviceCodeStep::deviceAuthorizationFinished(QByteArray* response)
 {
-    if (!m_request->wasSuccessful() || m_request->error() != QNetworkReply::NoError) {
-        qWarning() << "Device authorization failed:" << m_request->error() << m_request->errorString();
-        emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Device authorization failed: %1").arg(m_request->errorString()));
-        return;
-    }
-
     auto rsp = parseDeviceAuthorizationResponse(*response);
     if (!rsp.error.isEmpty() || !rsp.error_description.isEmpty()) {
         qWarning() << "Device authorization failed:" << rsp.error;
@@ -126,6 +120,12 @@ void MSADeviceCodeStep::deviceAuthorizationFinished(QByteArray* response)
                       tr("Device authorization failed: %1").arg(rsp.error_description.isEmpty() ? rsp.error : rsp.error_description));
         return;
     }
+    if (!m_request->wasSuccessful() || m_request->error() != QNetworkReply::NoError) {
+        qWarning() << "Device authorization failed:" << *response;
+        emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Failed to retrieve device authorization"));
+        return;
+    }
+
     if (rsp.device_code.isEmpty() || rsp.user_code.isEmpty() || rsp.verification_uri.isEmpty() || rsp.expires_in == 0) {
         qWarning() << "Device authorization failed: required fields missing";
         emit finished(AccountTaskState::STATE_FAILED_HARD, tr("Device authorization failed: required fields missing"));

launcher/minecraft/auth/steps/MinecraftProfileStep.cpp

@@ -52,11 +52,10 @@ void MinecraftProfileStep::onRequestDone(QByteArray* response)
         qWarning() << " Response:";
         qWarning() << QString::fromUtf8(*response);
 
-        if (Net::isApplicationError(m_request->error()) && !Net::isServerError(m_request->error())) {
+        if (Net::isApplicationError(m_request->error())) {
             emit finished(AccountTaskState::STATE_FAILED_SOFT,
                           tr("Minecraft Java profile acquisition failed: %1").arg(m_request->errorString()));
         } else {
-            m_data->networkError = m_request->error();
             emit finished(AccountTaskState::STATE_OFFLINE,
                           tr("Minecraft Java profile acquisition failed: %1").arg(m_request->errorString()));
         }

launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp

@@ -2,7 +2,7 @@
 
 #include <QJsonDocument>
 #include <QJsonParseError>
-#include <utility>
+#include <QNetworkRequest>
 
 #include "Application.h"
 #include "Logging.h"
@@ -12,7 +12,7 @@
 #include "net/Upload.h"
 
 XboxAuthorizationStep::XboxAuthorizationStep(AccountData* data, Token* token, QString relyingParty, QString authorizationKind)
-    : AuthStep(data), m_token(token), m_relyingParty(std::move(relyingParty)), m_authorizationKind(std::move(authorizationKind))
+    : AuthStep(data), m_token(token), m_relyingParty(relyingParty), m_authorizationKind(authorizationKind)
 {}
 
 QString XboxAuthorizationStep::describe()
@@ -22,7 +22,7 @@ QString XboxAuthorizationStep::describe()
 
 void XboxAuthorizationStep::perform()
 {
-    const QString xboxAuthTemplate = R"XXX(
+    QString xbox_auth_template = R"XXX(
 {
     "Properties": {
         "SandboxId": "RETAIL",
@@ -34,13 +34,15 @@ void XboxAuthorizationStep::perform()
     "TokenType": "JWT"
 }
 )XXX";
-    const auto xboxAuthData = xboxAuthTemplate.arg(m_data->userToken.token, m_relyingParty);
+    auto xbox_auth_data = xbox_auth_template.arg(m_data->userToken.token, m_relyingParty);
     // http://xboxlive.com
-    const QUrl url("https://xsts.auth.xboxlive.com/xsts/authorize");
+    QUrl url("https://xsts.auth.xboxlive.com/xsts/authorize");
-    auto headers = QList<Net::HeaderPair>{ { .headerName = "Content-Type", .headerValue = "application/json" },
+    auto headers = QList<Net::HeaderPair>{
-                                           { .headerName = "Accept", .headerValue = "application/json" },
+        { "Content-Type", "application/json" },
-                                           { .headerName = "x-xbl-contract-version", .headerValue = "1" } };
+        { "Accept", "application/json" },
-    auto [request, response] = Net::Upload::makeByteArray(url, xboxAuthData.toUtf8());
+        { "x-xbl-contract-version", "1" }
+    };
+    auto [request, response] = Net::Upload::makeByteArray(url, xbox_auth_data.toUtf8());
     m_request = request;
     m_request->addHeaderProxy(std::make_unique<Net::RawHeaderProxy>(headers));
     m_request->enableAutoRetry(true);
@@ -60,14 +62,15 @@ void XboxAuthorizationStep::onRequestDone(QByteArray* response)
     qCDebug(authCredentials()) << *response;
     if (m_request->error() != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << m_request->error();
-        if (Net::isApplicationError(m_request->error()) && !Net::isServerError(m_request->error())) {
+        if (Net::isApplicationError(m_request->error())) {
-            if (processSTSError(*response)) {
+            if (!processSTSError(*response)) {
-                return;
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("Failed to get authorization for %1 services. Error %2.").arg(m_authorizationKind, m_request->error()));
+            } else {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("Unknown STS error for %1 services: %2").arg(m_authorizationKind, m_request->errorString()));
             }
-            emit finished(AccountTaskState::STATE_FAILED_SOFT,
-                          tr("Unknown STS error for %1 services: %2").arg(m_authorizationKind, m_request->errorString()));
         } else {
-            m_data->networkError = m_request->error();
             emit finished(AccountTaskState::STATE_OFFLINE,
                           tr("Failed to get authorization for %1 services: %2").arg(m_authorizationKind, m_request->errorString()));
         }
@@ -96,8 +99,8 @@ bool XboxAuthorizationStep::processSTSError(const QByteArray& response)
 {
     if (m_request->error() == QNetworkReply::AuthenticationRequiredError) {
         QJsonParseError jsonError;
-        const QJsonDocument doc = QJsonDocument::fromJson(response, &jsonError);
+        QJsonDocument doc = QJsonDocument::fromJson(response, &jsonError);
-        if (jsonError.error != QJsonParseError::NoError) {
+        if (jsonError.error) {
             qWarning() << "Cannot parse error XSTS response as JSON:" << jsonError.errorString();
             emit finished(AccountTaskState::STATE_FAILED_SOFT,
                           tr("Cannot parse %1 authorization error response as JSON: %2").arg(m_authorizationKind, jsonError.errorString()));

launcher/minecraft/auth/steps/XboxUserStep.cpp

@@ -56,10 +56,9 @@ void XboxUserStep::onRequestDone(QByteArray* response)
 {
     if (m_request->error() != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << m_request->error();
-        if (Net::isApplicationError(m_request->error()) && !Net::isServerError(m_request->error())) {
+        if (Net::isApplicationError(m_request->error())) {
             emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Xbox user authentication failed: %1").arg(m_request->errorString()));
         } else {
-            m_data->networkError = m_request->error();
             emit finished(AccountTaskState::STATE_OFFLINE, tr("Xbox user authentication failed: %1").arg(m_request->errorString()));
         }
         return;

launcher/minecraft/launch/EnsureAvailableMemory.cpp

@@ -1,113 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-/*
- *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2026 Octol1ttle <l1ttleofficial@outlook.com>
- *
- *  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, see <https://www.gnu.org/licenses/>.
- */
-
-#include "EnsureAvailableMemory.h"
-
-#include "HardwareInfo.h"
-#include "ui/dialogs/CustomMessageBox.h"
-
-EnsureAvailableMemory::EnsureAvailableMemory(LaunchTask* parent, MinecraftInstance* instance) : LaunchStep(parent), m_instance(instance) {}
-
-void EnsureAvailableMemory::executeTask()
-{
-#ifdef Q_OS_MACOS
-    QString text;
-    switch (MacOSHardwareInfo::memoryPressureLevel()) {
-        case MacOSHardwareInfo::MemoryPressureLevel::Normal:
-            emitSucceeded();
-            return;
-        case MacOSHardwareInfo::MemoryPressureLevel::Warning:
-            text =
-                tr("The system is under increased memory pressure.\n"
-                   "This may lead to lag or slowdowns.\n"
-                   "If possible, close other applications before continuing.\n\n"
-                   "Launch anyway?");
-            break;
-        case MacOSHardwareInfo::MemoryPressureLevel::Critical:
-            text =
-                tr("Your system is under critical memory pressure.\n"
-                   "This may lead to severe slowdowns, crashes or system instability.\n"
-                   "It is recommended to close other applications or restart your system.\n\n"
-                   "Launch anyway?");
-            break;
-    }
-
-    bool shouldAbort = false;
-
-    if (m_instance->settings()->get("LowMemWarning").toBool()) {
-        auto* dialog = CustomMessageBox::selectable(nullptr, tr("High memory pressure"), text, QMessageBox::Icon::Warning,
-                                                    QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No,
-                                                    QMessageBox::StandardButton::No);
-
-        shouldAbort = dialog->exec() == QMessageBox::No;
-        dialog->deleteLater();
-    }
-
-    const auto message = tr("The system is under high memory pressure");
-    if (shouldAbort) {
-        emit logLine(message, MessageLevel::Fatal);
-        emitFailed(message);
-        return;
-    }
-
-    emit logLine(message, MessageLevel::Warning);
-    emitSucceeded();
-#else
-    const uint64_t available = HardwareInfo::availableRamMiB();
-    if (available == 0) {
-        // could not read
-        emitSucceeded();
-        return;
-    }
-
-    const uint64_t settingMin = m_instance->settings()->get("MinMemAlloc").toUInt();
-    const uint64_t settingMax = m_instance->settings()->get("MaxMemAlloc").toUInt();
-    const uint64_t max = std::max(settingMin, settingMax);
-
-    if (static_cast<double>(max) * 0.9 > static_cast<double>(available)) {
-        bool shouldAbort = false;
-
-        if (m_instance->settings()->get("LowMemWarning").toBool()) {
-            auto* dialog = CustomMessageBox::selectable(
-                nullptr, tr("Low free memory"),
-                tr("There might not be enough free RAM to launch this instance with the current memory settings.\n\n"
-                   "Maximum allocated: %1 MiB\nFree: %2 MiB (out of %3 MiB total)\n\n"
-                   "Launch anyway? This may cause slowdowns in the game and your system.")
-                    .arg(max)
-                    .arg(available)
-                    .arg(HardwareInfo::totalRamMiB()),
-                QMessageBox::Icon::Warning, QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No,
-                QMessageBox::StandardButton::No);
-
-            shouldAbort = dialog->exec() == QMessageBox::No;
-            dialog->deleteLater();
-        }
-
-        const auto message = tr("Not enough RAM available to launch this instance");
-        if (shouldAbort) {
-            emit logLine(message, MessageLevel::Fatal);
-            emitFailed(message);
-            return;
-        }
-
-        emit logLine(message, MessageLevel::Warning);
-    }
-
-    emitSucceeded();
-#endif
-}

launcher/minecraft/launch/EnsureAvailableMemory.h

@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-/*
- *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2026 Octol1ttle <l1ttleofficial@outlook.com>
- *
- *  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, see <https://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "launch/LaunchStep.h"
-#include "minecraft/MinecraftInstance.h"
-
-class EnsureAvailableMemory : public LaunchStep {
-    Q_OBJECT
-
-   public:
-    explicit EnsureAvailableMemory(LaunchTask* parent, MinecraftInstance* instance);
-    ~EnsureAvailableMemory() override = default;
-
-    void executeTask() override;
-    bool canAbort() const override { return false; }
-
-   private:
-    MinecraftInstance* m_instance;
-};

launcher/minecraft/launch/EnsureOfflineLibraries.cpp

@@ -27,27 +27,16 @@ void EnsureOfflineLibraries::executeTask()
 {
     const auto profile = m_instance->getPackProfile()->getProfile();
     QStringList allJars;
-    profile->getLibraryFiles(m_instance->runtimeContext(), allJars, allJars, m_instance->getLocalLibraryPath(), m_instance->binRoot(),
+    profile->getLibraryFiles(m_instance->runtimeContext(), allJars, allJars, m_instance->getLocalLibraryPath(), m_instance->binRoot());
-                             false);
-
-    QStringList missing;
     for (const auto& jar : allJars) {
         if (!QFileInfo::exists(jar)) {
-            missing.append(jar);
+            emit logLine(tr("This instance cannot be launched because some libraries are missing or have not been downloaded yet. Please "
+                            "try again in online mode with a working Internet connection"),
+                         MessageLevel::Fatal);
+            emitFailed("Required libraries are missing");
+            return;
         }
     }
 
-    if (missing.isEmpty()) {
+    emitSucceeded();
-        emitSucceeded();
-        return;
-    }
-
-    emit logLine("Missing libraries:", MessageLevel::Error);
-    for (const auto& jar : missing) {
-        emit logLine("  " + jar, MessageLevel::Error);
-    }
-    emit logLine(tr("\nThis instance cannot be launched because some libraries are missing or have not been downloaded yet. Please "
-                    "try again in online mode with a working Internet connection"),
-                 MessageLevel::Fatal);
-    emitFailed("Required libraries are missing");
 }

launcher/minecraft/launch/LauncherPartLaunch.cpp

@@ -164,9 +164,9 @@ 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: %1");
+            const char* reason = QT_TR_NOOP("Could not launch Minecraft!");
-            emit logLine(QString(reason).arg(m_process.errorString()), MessageLevel::Fatal);
+            emit logLine(reason, MessageLevel::Fatal);
-            emitFailed(tr(reason).arg(m_process.errorString()));
+            emitFailed(tr(reason));
             return;
         }
         case LoggedProcess::Aborted:

launcher/minecraft/launch/PrintInstanceInfo.cpp

@@ -61,19 +61,13 @@ void PrintInstanceInfo::executeTask()
     auto instance = m_parent->instance();
     QStringList log;
 
-    log << "";
     log << "OS: " + QString("%1 | %2 | %3").arg(QSysInfo::prettyProductName(), QSysInfo::kernelType(), QSysInfo::kernelVersion());
 #ifdef Q_OS_FREEBSD
     ::runSysctlHwModel(log);
     ::runPciconf(log);
 #else
     log << "CPU: " + HardwareInfo::cpuInfo();
-#ifdef Q_OS_MACOS
-    log << "Memory pressure level: " + MacOSHardwareInfo::memoryPressureLevelName();
-#else
     log << QString("RAM: %1 MiB (available: %2 MiB)").arg(HardwareInfo::totalRamMiB()).arg(HardwareInfo::availableRamMiB());
-#endif
-
 #endif
     log.append(HardwareInfo::gpuInfo());
     log << "";

launcher/minecraft/mod/DataPack.cpp

@@ -216,7 +216,7 @@ static std::pair<Version, Version> map(int format, const QMap<std::pair<int, int
 int DataPack::compare(const Resource& other, SortType type) const
 {
     const auto& cast_other = static_cast<const DataPack&>(other);
-    if (type == SortType::PackFormat) {
+    if (type == SortType::PACK_FORMAT) {
         auto this_ver = packFormat();
         auto other_ver = cast_other.packFormat();
 

launcher/minecraft/mod/DataPackFolderModel.cpp

@@ -40,26 +40,25 @@
 #include <QIcon>
 #include <QStyle>
 
+#include "Version.h"
+
 #include "minecraft/mod/tasks/LocalDataPackParseTask.h"
 
-DataPackFolderModel::DataPackFolderModel(const QString& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
+DataPackFolderModel::DataPackFolderModel(const QString& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
-    : ResourceFolderModel(QDir(dir), instance, isIndexed, createDir, parent)
+    : ResourceFolderModel(QDir(dir), instance, is_indexed, create_dir, parent)
 {
-    m_columnNames = QStringList({ "Enable", "Image", "Name", "Pack Format", "Last Modified", "Size", "File Name" });
+    m_column_names = QStringList({ "Enable", "Image", "Name", "Pack Format", "Last Modified" });
-    m_columnNamesTranslated =
+    m_column_names_translated = QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified") });
-        QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified"), tr("Size"), tr("File Name") });
+    m_column_sort_keys = { SortType::ENABLED, SortType::NAME, SortType::NAME, SortType::PACK_FORMAT, SortType::DATE };
-    m_columnSortKeys = { SortType::Enabled, SortType::Name, SortType::Name,    SortType::PackFormat,
+    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch, QHeaderView::Interactive,
-                         SortType::Date,    SortType::Size, SortType::Filename };
+                              QHeaderView::Interactive };
-    m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,    QHeaderView::Interactive,
+    m_columnsHideable = { false, true, false, true, true };
-                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
-    m_columnsHideable = { false, true, false, true, true, true, true };
 }
 
 QVariant DataPackFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index)) {
+    if (!validateIndex(index))
         return {};
-    }
 
     int row = index.row();
     int column = index.column();
@@ -68,13 +67,11 @@ QVariant DataPackFolderModel::data(const QModelIndex& index, int role) const
         case Qt::BackgroundRole:
             return rowBackground(row);
         case Qt::DisplayRole:
-            if (column == PackFormatColumn) {
+            switch (column) {
-                const auto& resource = at(row);
+                case PackFormatColumn: {
-                return resource.packFormatStr();
+                    const auto& resource = at(row);
-            }
+                    return resource.packFormatStr();
-            if (column == SizeColumn) {
+                }
-                const auto& resource = at(row);
-                return resource.sizeStr();
             }
             break;
         case Qt::DecorationRole: {
@@ -95,8 +92,6 @@ QVariant DataPackFolderModel::data(const QModelIndex& index, int role) const
                 return QSize(32, 32);
             }
             break;
-        default:
-            break;
     }
 
     // map the columns to the base equivilents
@@ -114,14 +109,7 @@ QVariant DataPackFolderModel::data(const QModelIndex& index, int role) const
         case ProviderColumn:
             mappedIndex = index.siblingAtColumn(ResourceFolderModel::ProviderColumn);
             break;
-        case FileNameColumn:
+            // FIXME: there is no size column due to an oversight
-            mappedIndex = index.siblingAtColumn(ResourceFolderModel::FileNameColumn);
-            break;
-        case SizeColumn:
-            mappedIndex = index.siblingAtColumn(ResourceFolderModel::SizeColumn);
-            break;
-        default:
-            break;
     }
 
     if (mappedIndex.isValid()) {
@@ -141,8 +129,6 @@ QVariant DataPackFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
                 case PackFormatColumn:
                 case DateColumn:
                 case ImageColumn:
-                case SizeColumn:
-                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return {};
@@ -159,10 +145,6 @@ QVariant DataPackFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
                     return tr("The data pack format ID, as well as the Minecraft versions it was designed for.");
                 case DateColumn:
                     return tr("The date and time this data pack was last changed (or added).");
-                case SizeColumn:
-                    return tr("The size of the data pack.");
-                case FileNameColumn:
-                    return tr("The file name of the data pack.");
                 default:
                     return {};
             }
@@ -178,7 +160,7 @@ QVariant DataPackFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
 
 int DataPackFolderModel::columnCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : NumColumns;
+    return parent.isValid() ? 0 : NUM_COLUMNS;
 }
 
 Resource* DataPackFolderModel::createResource(const QFileInfo& file)
@@ -188,5 +170,5 @@ Resource* DataPackFolderModel::createResource(const QFileInfo& file)
 
 Task* DataPackFolderModel::createParseTask(Resource& resource)
 {
-    return new LocalDataPackParseTask(m_nextResolutionTicket, static_cast<DataPack*>(&resource));
+    return new LocalDataPackParseTask(m_next_resolution_ticket, static_cast<DataPack*>(&resource));
 }

launcher/minecraft/mod/DataPackFolderModel.h

@@ -39,24 +39,16 @@
 #include "ResourceFolderModel.h"
 
 #include "DataPack.h"
+#include "ResourcePack.h"
 
 class DataPackFolderModel : public ResourceFolderModel {
     Q_OBJECT
    public:
-    enum Columns : std::uint8_t {
+    enum Columns { ActiveColumn = 0, ImageColumn, NameColumn, PackFormatColumn, DateColumn, NUM_COLUMNS };
-        ActiveColumn = 0,
-        ImageColumn,
-        NameColumn,
-        PackFormatColumn,
-        DateColumn,
-        SizeColumn,
-        FileNameColumn,
-        NumColumns
-    };
 
-    explicit DataPackFolderModel(const QString& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
+    explicit DataPackFolderModel(const QString& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
 
-    QString id() const override { return "datapacks"; }
+    virtual QString id() const override { return "datapacks"; }
 
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
@@ -64,7 +56,7 @@ class DataPackFolderModel : public ResourceFolderModel {
     int columnCount(const QModelIndex& parent) const override;
 
     [[nodiscard]] Resource* createResource(const QFileInfo& file) override;
-    [[nodiscard]] Task* createParseTask(Resource& /*unused*/) override;
+    [[nodiscard]] Task* createParseTask(Resource&) override;
 
     RESOURCE_HELPERS(DataPack)
 };

launcher/minecraft/mod/Mod.cpp

@@ -40,7 +40,6 @@
 #include <QDir>
 #include <QRegularExpression>
 #include <QString>
-#include <algorithm>
 
 #include "MTPixmapCache.h"
 #include "MetadataHandler.h"
@@ -50,34 +49,6 @@
 #include "minecraft/mod/tasks/LocalModParseTask.h"
 #include "modplatform/ModIndex.h"
 
-namespace {
-
-int compareVersionLists(const QStringList& leftVersions, const QStringList& rightVersions)
-{
-    const qsizetype commonSize = std::min(leftVersions.size(), rightVersions.size());
-
-    for (qsizetype i = 0; i < commonSize; i++) {
-        const auto leftVersion = Version(leftVersions.at(i).trimmed());
-        const auto rightVersion = Version(rightVersions.at(i).trimmed());
-
-        if (leftVersion > rightVersion)
-            return 1;
-
-        if (leftVersion < rightVersion)
-            return -1;
-    }
-
-    if (leftVersions.size() > rightVersions.size())
-        return 1;
-
-    if (leftVersions.size() < rightVersions.size())
-        return -1;
-
-    return 0;
-}
-
-}  // namespace
-
 Mod::Mod(const QFileInfo& file) : Resource(file), m_local_details()
 {
     m_enabled = (file.suffix() != "disabled");
@@ -90,18 +61,18 @@ void Mod::setDetails(const ModDetails& details)
 
 int Mod::compare(const Resource& other, SortType type) const
 {
-    auto cast_other = dynamic_cast<const Mod*>(&other);
+    auto cast_other = dynamic_cast<Mod const*>(&other);
     if (!cast_other)
         return Resource::compare(other, type);
 
     switch (type) {
         default:
-        case SortType::Enabled:
+        case SortType::ENABLED:
-        case SortType::Name:
+        case SortType::NAME:
-        case SortType::Date:
+        case SortType::DATE:
-        case SortType::Size:
+        case SortType::SIZE:
             return Resource::compare(other, type);
-        case SortType::Version: {
+        case SortType::VERSION: {
             auto this_ver = Version(version());
             auto other_ver = Version(cast_other->version());
             if (this_ver > other_ver)
@@ -110,38 +81,38 @@ int Mod::compare(const Resource& other, SortType type) const
                 return -1;
             break;
         }
-        case SortType::Side: {
+        case SortType::SIDE: {
             auto compare_result = QString::compare(side(), cast_other->side(), Qt::CaseInsensitive);
             if (compare_result != 0)
                 return compare_result;
             break;
         }
-        case SortType::McVersions: {
+        case SortType::MC_VERSIONS: {
-            auto compare_result = compareVersionLists(mcVersions(), cast_other->mcVersions());
+            auto compare_result = QString::compare(mcVersions(), cast_other->mcVersions(), Qt::CaseInsensitive);
             if (compare_result != 0)
                 return compare_result;
             break;
         }
-        case SortType::Loaders: {
+        case SortType::LOADERS: {
             auto compare_result = QString::compare(loaders(), cast_other->loaders(), Qt::CaseInsensitive);
             if (compare_result != 0)
                 return compare_result;
             break;
         }
-        case SortType::ReleaseType: {
+        case SortType::RELEASE_TYPE: {
             auto compare_result = QString::compare(releaseType(), cast_other->releaseType(), Qt::CaseInsensitive);
             if (compare_result != 0)
                 return compare_result;
             break;
         }
-        case SortType::RequiredBy: {
+        case SortType::REQUIRED_BY: {
             if (requiredByCount() > cast_other->requiredByCount())
                 return 1;
             if (requiredByCount() < cast_other->requiredByCount())
                 return -1;
             break;
         }
-        case SortType::Requires: {
+        case SortType::REQUIRES: {
             if (requiresCount() > cast_other->requiresCount())
                 return 1;
             if (requiresCount() < cast_other->requiresCount())
@@ -226,19 +197,14 @@ auto Mod::side() const -> QString
     return ModPlatform::SideUtils::toString(ModPlatform::Side::UniversalSide);
 }
 
-auto Mod::mcVersions() const -> QStringList
+auto Mod::mcVersions() const -> QString
 {
     if (metadata())
-        return metadata()->mcVersions;
+        return metadata()->mcVersions.join(", ");
 
     return {};
 }
 
-auto Mod::mcVersionsString() const -> QString
-{
-    return mcVersions().join(", ");
-}
-
 auto Mod::releaseType() const -> QString
 {
     if (metadata())

launcher/minecraft/mod/Mod.h

@@ -68,8 +68,7 @@ class Mod : public Resource {
     auto issueTracker() const -> QString;
     auto side() const -> QString;
     auto loaders() const -> QString;
-    auto mcVersions() const -> QStringList;
+    auto mcVersions() const -> QString;
-    auto mcVersionsString() const -> QString;
     auto releaseType() const -> QString;
     QStringList dependencies() const;
 

launcher/minecraft/mod/ModFolderModel.cpp

@@ -51,39 +51,38 @@
 #include <QUrl>
 #include <QUuid>
 #include <algorithm>
-#include <set>
 
+#include "minecraft/Component.h"
 #include "minecraft/mod/Resource.h"
 #include "minecraft/mod/ResourceFolderModel.h"
 #include "minecraft/mod/tasks/LocalModParseTask.h"
 #include "modplatform/ModIndex.h"
 #include "ui/dialogs/CustomMessageBox.h"
 
-ModFolderModel::ModFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
+ModFolderModel::ModFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
-    : ResourceFolderModel(QDir(dir), instance, isIndexed, createDir, parent)
+    : ResourceFolderModel(QDir(dir), instance, is_indexed, create_dir, parent)
 {
-    m_columnNames = QStringList({ "Enable", "Image", "Name", "Version", "Last Modified", "Provider", "Size", "Side", "Loaders",
+    m_column_names = QStringList({ "Enable", "Image", "Name", "Version", "Last Modified", "Provider", "Size", "Side", "Loaders",
-                                  "Minecraft Versions", "Release Type", "Requires", "Required By", "File Name" });
+                                   "Minecraft Versions", "Release Type", "Requires", "Required By" });
-    m_columnNamesTranslated =
+    m_column_names_translated =
         QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Version"), tr("Last Modified"), tr("Provider"), tr("Size"), tr("Side"),
-                      tr("Loaders"), tr("Minecraft Versions"), tr("Release Type"), tr("Requires"), tr("Required By"), tr("File Name") });
+                      tr("Loaders"), tr("Minecraft Versions"), tr("Release Type"), tr("Requires"), tr("Required By") });
-    m_columnSortKeys = { SortType::Enabled,     SortType::Name,     SortType::Name,       SortType::Version, SortType::Date,
+    m_column_sort_keys = { SortType::ENABLED,      SortType::NAME,     SortType::NAME,       SortType::VERSION, SortType::DATE,
-                         SortType::Provider,    SortType::Size,     SortType::Side,       SortType::Loaders, SortType::McVersions,
+                           SortType::PROVIDER,     SortType::SIZE,     SortType::SIDE,       SortType::LOADERS, SortType::MC_VERSIONS,
-                         SortType::ReleaseType, SortType::Requires, SortType::RequiredBy, SortType::Filename };
+                           SortType::RELEASE_TYPE, SortType::REQUIRES, SortType::REQUIRED_BY };
-    m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,     QHeaderView::Interactive,
+    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,     QHeaderView::Interactive,
-                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive,
+                              QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive,
-                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive,
+                              QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive,
-                            QHeaderView::Interactive, QHeaderView::Interactive };
+                              QHeaderView::Interactive };
-    m_columnsHideable = { false, true, false, true, true, true, true, true, true, true, true, true, true, true };
+    m_columnsHideable = { false, true, false, true, true, true, true, true, true, true, true, true, true };
 
     connect(this, &ModFolderModel::parseFinished, this, &ModFolderModel::onParseFinished);
 }
 
 QVariant ModFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index)) {
+    if (!validateIndex(index))
         return {};
-    }
 
     int row = index.row();
     int column = index.column();
@@ -110,7 +109,7 @@ QVariant ModFolderModel::data(const QModelIndex& index, int role) const
                     return at(row).loaders();
                 }
                 case McVersionsColumn: {
-                    return at(row).mcVersionsString();
+                    return at(row).mcVersions();
                 }
                 case ReleaseTypeColumn: {
                     return at(row).releaseType();
@@ -121,8 +120,6 @@ QVariant ModFolderModel::data(const QModelIndex& index, int role) const
                 case RequiresColumn: {
                     return at(row).requiresCount();
                 }
-                default:
-                    break;
             }
             break;
         case Qt::DecorationRole: {
@@ -158,11 +155,6 @@ QVariant ModFolderModel::data(const QModelIndex& index, int role) const
         case SizeColumn:
             mappedIndex = index.siblingAtColumn(ResourceFolderModel::SizeColumn);
             break;
-        case FileNameColumn:
-            mappedIndex = index.siblingAtColumn(ResourceFolderModel::FileNameColumn);
-            break;
-        default:
-            break;
     }
 
     if (mappedIndex.isValid()) {
@@ -190,7 +182,6 @@ QVariant ModFolderModel::headerData(int section, [[maybe_unused]] Qt::Orientatio
                 case SizeColumn:
                 case RequiredByColumn:
                 case RequiresColumn:
-                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return QVariant();
@@ -222,8 +213,6 @@ QVariant ModFolderModel::headerData(int section, [[maybe_unused]] Qt::Orientatio
                     return tr("For each mod, the number of other mods which depend on it.");
                 case RequiresColumn:
                     return tr("For each mod, the number of other mods it depends on.");
-                case FileNameColumn:
-                    return tr("The file name of the mod.");
                 default:
                     return QVariant();
             }
@@ -234,12 +223,12 @@ QVariant ModFolderModel::headerData(int section, [[maybe_unused]] Qt::Orientatio
 
 int ModFolderModel::columnCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : NumColumns;
+    return parent.isValid() ? 0 : NUM_COLUMNS;
 }
 
 Task* ModFolderModel::createParseTask(Resource& resource)
 {
-    return new LocalModParseTask(m_nextResolutionTicket, resource.type(), resource.fileinfo());
+    return new LocalModParseTask(m_next_resolution_ticket, resource.type(), resource.fileinfo());
 }
 
 bool ModFolderModel::isValid()
@@ -247,37 +236,35 @@ bool ModFolderModel::isValid()
     return m_dir.exists() && m_dir.isReadable();
 }
 
-void ModFolderModel::onParseSucceeded(int ticket, const QString& resourceId)
+void ModFolderModel::onParseSucceeded(int ticket, QString mod_id)
 {
-    auto iter = m_activeParseTasks.constFind(ticket);
+    auto iter = m_active_parse_tasks.constFind(ticket);
-    if (iter == m_activeParseTasks.constEnd()) {
+    if (iter == m_active_parse_tasks.constEnd())
         return;
-    }
 
-    int row = m_resourcesIndex[resourceId];
+    int row = m_resources_index[mod_id];
 
-    const auto& parseTask = *iter;
+    auto parse_task = *iter;
-    auto* castTask = static_cast<LocalModParseTask*>(parseTask.get());
+    auto cast_task = static_cast<LocalModParseTask*>(parse_task.get());
 
-    Q_ASSERT(castTask->token() == ticket);
+    Q_ASSERT(cast_task->token() == ticket);
 
-    auto resource = find(resourceId);
+    auto resource = find(mod_id);
 
-    auto result = castTask->result();
+    auto result = cast_task->result();
     if (result && resource) {
         auto* mod = static_cast<Mod*>(resource.get());
         mod->finishResolvingWithDetails(std::move(result->details));
+
     }
     emit dataChanged(index(row, RequiresColumn), index(row, RequiredByColumn));
 }
 
-namespace {
+Mod* findById(QSet<Mod*> mods, QString modId)
-Mod* findById(QSet<Mod*> mods, const QString& resourceId)
 {
-    auto found = std::ranges::find_if(mods, [resourceId](Mod* m) { return m->mod_id() == resourceId; });
+    auto found = std::find_if(mods.begin(), mods.end(), [modId](Mod* m) { return m->mod_id() == modId; });
     return found != mods.end() ? *found : nullptr;
 }
-}  // namespace
 
 void ModFolderModel::onParseFinished()
 {
@@ -290,25 +277,25 @@ void ModFolderModel::onParseFinished()
     m_requires.clear();
     m_requiredBy.clear();
 
-    auto findByProjectID = [mods](const QVariant& modId, ModPlatform::ResourceProvider provider) -> Mod* {
+    auto findByProjectID = [mods](QVariant modId, ModPlatform::ResourceProvider provider) -> Mod* {
-        auto found = std::ranges::find_if(mods, [modId, provider](Mod* m) {
+        auto found = std::find_if(mods.begin(), mods.end(), [modId, provider](Mod* m) {
             return m->metadata() && m->metadata()->provider == provider && m->metadata()->project_id == modId;
         });
         return found != mods.end() ? *found : nullptr;
     };
-    for (auto* mod : mods) {
+    for (auto mod : mods) {
         auto id = mod->mod_id();
-        for (const auto& dep : mod->dependencies()) {
+        for (auto dep : mod->dependencies()) {
-            auto* d = findById(mods, dep);
+            auto d = findById(mods, dep);
             if (d) {
                 m_requires[id] << d;
                 m_requiredBy[d->mod_id()] << mod;
             }
         }
         if (mod->metadata()) {
-            for (const auto& dep : mod->metadata()->dependencies) {
+            for (auto dep : mod->metadata()->dependencies) {
                 if (dep.type == ModPlatform::DependencyType::REQUIRED) {
-                    auto* d = findByProjectID(dep.addonId, mod->metadata()->provider);
+                    auto d = findByProjectID(dep.addonId, mod->metadata()->provider);
                     if (d) {
                         m_requires[id] << d;
                         m_requiredBy[d->mod_id()] << mod;
@@ -317,31 +304,30 @@ void ModFolderModel::onParseFinished()
             }
         }
     }
-    for (auto* mod : mods) {
+    for (auto mod : mods) {
         auto id = mod->mod_id();
         if (mod->requiredByCount() != m_requiredBy[id].count() || mod->requiresCount() != m_requires[id].count()) {
             mod->setRequiredByCount(m_requiredBy[id].count());
             mod->setRequiresCount(m_requires[id].count());
-            int row = m_resourcesIndex[mod->internalId()];
+            int row = m_resources_index[mod->internal_id()];
             emit dataChanged(index(row), index(row, columnCount(QModelIndex()) - 1));
         }
     }
 }
 
-namespace {
+QSet<Mod*> collectMods(QSet<Mod*> mods, QHash<QString, QSet<Mod*>> relation, std::set<QString>& seen, bool shouldBeEnabled)
-
-QSet<Mod*> collectMods(const QSet<Mod*>& mods, QHash<QString, QSet<Mod*>> relation, std::set<QString>& seen, bool shouldBeEnabled)
 {
     QSet<Mod*> affectedList = {};
     QSet<Mod*> needToCheck = {};
-    for (auto* mod : mods) {
+    for (auto mod : mods) {
         auto id = mod->mod_id();
-        if (!seen.contains(id)) {
+        if (seen.count(id) == 0) {
             seen.insert(id);
-            for (auto* affected : relation[id]) {
+            for (auto affected : relation[id]) {
                 auto affectedId = affected->mod_id();
 
-                if (findById(mods, affectedId) == nullptr && !seen.contains(affectedId)) {
+                if (findById(mods, affectedId) == nullptr && seen.count(affectedId) == 0) {
+                    seen.insert(affectedId);
                     if (shouldBeEnabled != affected->enabled()) {
                         affectedList << affected;
                     }
@@ -356,13 +342,11 @@ QSet<Mod*> collectMods(const QSet<Mod*>& mods, QHash<QString, QSet<Mod*>> relati
     }
     return affectedList;
 }
-}  // namespace
 
 QModelIndexList ModFolderModel::getAffectedMods(const QModelIndexList& indexes, EnableAction action)
 {
-    if (indexes.isEmpty()) {
+    if (indexes.isEmpty())
         return {};
-    }
 
     QModelIndexList affectedList = {};
     auto affectedModsList = selectedMods(indexes);
@@ -382,9 +366,9 @@ QModelIndexList ModFolderModel::getAffectedMods(const QModelIndexList& indexes,
             return {};  // this function should not be called with TOGGLE
         }
     }
-    for (auto* affected : affectedMods) {
+    for (auto affected : affectedMods) {
         auto affectedId = affected->mod_id();
-        auto row = m_resourcesIndex[affected->internalId()];
+        auto row = m_resources_index[affected->internal_id()];
         affectedList << index(row, 0);
     }
     return affectedList;
@@ -392,9 +376,8 @@ QModelIndexList ModFolderModel::getAffectedMods(const QModelIndexList& indexes,
 
 bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAction action)
 {
-    if (indexes.isEmpty()) {
+    if (indexes.isEmpty())
         return {};
-    }
 
     auto indexedModsList = selectedMods(indexes);
     auto indexedMods = QSet(indexedModsList.begin(), indexedModsList.end());
@@ -413,7 +396,7 @@ bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAc
             break;
         }
         case EnableAction::TOGGLE: {
-            for (auto* mod : indexedMods) {
+            for (auto mod : indexedMods) {
                 if (mod->enabled()) {
                     toDisable << mod;
                 } else {
@@ -428,10 +411,10 @@ bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAc
     auto requiredToDisable = collectMods(toDisable, m_requiredBy, seen, false);
 
     toDisable.removeIf([toEnable](Mod* m) { return toEnable.contains(m); });
-    auto toList = [this](const QSet<Mod*>& mods) {
+    auto toList = [this](QSet<Mod*> mods) {
         QModelIndexList list;
-        for (auto* mod : mods) {
+        for (auto mod : mods) {
-            auto row = m_resourcesIndex[mod->internalId()];
+            auto row = m_resources_index[mod->internal_id()];
             list << index(row, 0);
         }
         return list;
@@ -464,8 +447,8 @@ bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAc
             yesButton = tr("Disable Required");
         }
 
-        auto* box = CustomMessageBox::selectable(nullptr, title, message, QMessageBox::Warning,
+        auto box = CustomMessageBox::selectable(nullptr, title, message, QMessageBox::Warning,
-                                                 QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::No);
+                                                QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::No);
         box->button(QMessageBox::No)->setText(noButton);
         box->button(QMessageBox::Yes)->setText(yesButton);
         auto response = box->exec();
@@ -483,23 +466,21 @@ bool ModFolderModel::setResourceEnabled(const QModelIndexList& indexes, EnableAc
     return disableStatus && enableStatus;
 }
 
-namespace {
+QStringList reqToList(QSet<Mod*> l)
-QStringList reqToList(const QSet<Mod*>& l)
 {
     QStringList req;
-    for (auto* m : l) {
+    for (auto m : l) {
         req << m->name();
     }
     return req;
 }
-}  // namespace
 
-QStringList ModFolderModel::requiresList(const QString& id)
+QStringList ModFolderModel::requiresList(QString id)
 {
     return reqToList(m_requires[id]);
 }
 
-QStringList ModFolderModel::requiredByList(const QString& id)
+QStringList ModFolderModel::requiredByList(QString id)
 {
     return reqToList(m_requiredBy[id]);
 }
@@ -508,7 +489,7 @@ bool ModFolderModel::deleteResources(const QModelIndexList& indexes)
 {
     auto deleteInvalid = [](QSet<Mod*>& mods) {
         for (auto it = mods.begin(); it != mods.end();) {
-            auto* mod = *it;
+            auto mod = *it;
             // the QFileInfo::exists is used instead of mod->fileinfo().exists
             // because the later somehow caches that the file exists
             if (!mod || !QFileInfo::exists(mod->fileinfo().absoluteFilePath())) {
@@ -519,14 +500,14 @@ bool ModFolderModel::deleteResources(const QModelIndexList& indexes)
         }
     };
     auto rsp = ResourceFolderModel::deleteResources(indexes);
-    for (auto* mod : allMods()) {
+    for (auto mod : allMods()) {
         auto id = mod->mod_id();
         deleteInvalid(m_requiredBy[id]);
         deleteInvalid(m_requires[id]);
         if (mod->requiredByCount() != m_requiredBy[id].count() || mod->requiresCount() != m_requires[id].count()) {
             mod->setRequiredByCount(m_requiredBy[id].count());
             mod->setRequiresCount(m_requires[id].count());
-            int row = m_resourcesIndex[mod->internalId()];
+            int row = m_resources_index[mod->internal_id()];
             emit dataChanged(index(row, RequiresColumn), index(row, RequiredByColumn));
         }
     }

launcher/minecraft/mod/ModFolderModel.h

@@ -46,6 +46,7 @@
 
 #include "Mod.h"
 #include "ResourceFolderModel.h"
+#include "minecraft/Component.h"
 #include "minecraft/mod/Resource.h"
 
 class BaseInstance;
@@ -58,7 +59,7 @@ class QFileSystemWatcher;
 class ModFolderModel : public ResourceFolderModel {
     Q_OBJECT
    public:
-    enum Columns : std::uint8_t {
+    enum Columns {
         ActiveColumn = 0,
         ImageColumn,
         NameColumn,
@@ -72,12 +73,11 @@ class ModFolderModel : public ResourceFolderModel {
         ReleaseTypeColumn,
         RequiresColumn,
         RequiredByColumn,
-        FileNameColumn,
+        NUM_COLUMNS
-        NumColumns
     };
-    ModFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
+    ModFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
 
-    QString id() const override { return "mods"; }
+    virtual QString id() const override { return "mods"; }
 
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
@@ -85,7 +85,7 @@ class ModFolderModel : public ResourceFolderModel {
     int columnCount(const QModelIndex& parent) const override;
 
     [[nodiscard]] Resource* createResource(const QFileInfo& file) override { return new Mod(file); }
-    [[nodiscard]] Task* createParseTask(Resource& /*unused*/) override;
+    [[nodiscard]] Task* createParseTask(Resource&) override;
 
     bool isValid();
 
@@ -97,11 +97,11 @@ class ModFolderModel : public ResourceFolderModel {
     RESOURCE_HELPERS(Mod)
 
    public:
-    QStringList requiresList(const QString& id);
+    QStringList requiresList(QString id);
-    QStringList requiredByList(const QString& id);
+    QStringList requiredByList(QString id);
 
    private slots:
-    void onParseSucceeded(int ticket, const QString& resourceId) override;
+    void onParseSucceeded(int ticket, QString resource_id) override;
     void onParseFinished();
 
    private:

launcher/minecraft/mod/Resource.cpp

@@ -4,75 +4,71 @@
 #include <QFileInfo>
 #include <QRegularExpression>
 #include <tuple>
-#include <utility>
 
 #include "FileSystem.h"
 #include "StringUtils.h"
 #include "minecraft/MinecraftInstance.h"
 #include "minecraft/PackProfile.h"
 
-Resource::Resource(QObject* parent) : QObject(parent), m_size_info(0) {}
+Resource::Resource(QObject* parent) : QObject(parent) {}
 
-Resource::Resource(QFileInfo fileInfo) : m_size_info(0)
+Resource::Resource(QFileInfo file_info) : QObject()
 {
-    setFile(fileInfo);
+    setFile(file_info);
 }
 
-void Resource::setFile(QFileInfo fileInfo)
+void Resource::setFile(QFileInfo file_info)
 {
-    m_file_info = std::move(fileInfo);
+    m_file_info = file_info;
     parseFile();
 }
 
-namespace {
+static std::tuple<QString, qint64> calculateFileSize(const QFileInfo& file)
-std::tuple<QString, qint64> calculateFileSize(const QFileInfo& file)
 {
     if (file.isDir()) {
         auto dir = QDir(file.absoluteFilePath());
         dir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot);
         auto count = dir.count();
         auto str = QObject::tr("item");
-        if (count != 1) {
+        if (count != 1)
             str = QObject::tr("items");
-        }
         return { QString("%1 %2").arg(QString::number(count), str), count };
     }
     return { StringUtils::humanReadableFileSize(file.size(), true), file.size() };
 }
-}  // namespace
 
 void Resource::parseFile()
 {
-    QString fileName{ m_file_info.fileName() };
+    QString file_name{ m_file_info.fileName() };
 
     m_type = ResourceType::UNKNOWN;
 
-    m_internal_id = fileName;
+    m_internal_id = file_name;
 
     std::tie(m_size_str, m_size_info) = calculateFileSize(m_file_info);
     if (m_file_info.isDir()) {
         m_type = ResourceType::FOLDER;
-        m_name = fileName;
+        m_name = file_name;
     } else if (m_file_info.isFile()) {
-        if (fileName.endsWith(".disabled")) {
+        if (file_name.endsWith(".disabled")) {
-            fileName.chop(9);
+            file_name.chop(9);
             m_enabled = false;
         }
 
-        if (fileName.endsWith(".zip") || fileName.endsWith(".jar")) {
+        if (file_name.endsWith(".zip") || file_name.endsWith(".jar")) {
             m_type = ResourceType::ZIPFILE;
-            fileName.chop(4);
+            file_name.chop(4);
-        } else if (fileName.endsWith(".nilmod")) {
+        } else if (file_name.endsWith(".nilmod")) {
             m_type = ResourceType::ZIPFILE;
-            fileName.chop(7);
+            file_name.chop(7);
-        } else if (fileName.endsWith(".litemod")) {
+        } else if (file_name.endsWith(".litemod")) {
             m_type = ResourceType::LITEMOD;
-            fileName.chop(8);
+            file_name.chop(8);
         } else {
             m_type = ResourceType::SINGLEFILE;
         }
 
-        m_name = fileName;
+        m_name = file_name;
     }
 
     m_changed_date_time = m_file_info.lastModified();
@@ -80,45 +76,39 @@ void Resource::parseFile()
 
 auto Resource::name() const -> QString
 {
-    if (metadata()) {
+    if (metadata())
         return metadata()->name;
-    }
 
     return m_name;
 }
 
-namespace {
+static void removeThePrefix(QString& string)
-void removeThePrefix(QString& string)
 {
     static const QRegularExpression s_regex(QStringLiteral("^(?:the|teh) +"), QRegularExpression::CaseInsensitiveOption);
     string.remove(s_regex);
     string = string.trimmed();
 }
-}  // namespace
 
 auto Resource::provider() const -> QString
 {
-    if (metadata()) {
+    if (metadata())
         return ModPlatform::ProviderCapabilities::readableName(metadata()->provider);
-    }
 
     return tr("Unknown");
 }
 
 auto Resource::homepage() const -> QString
 {
-    if (metadata()) {
+    if (metadata())
         return ModPlatform::getMetaURL(metadata()->provider, metadata()->project_id);
-    }
 
     return {};
 }
 
 void Resource::setMetadata(std::shared_ptr<Metadata::ModStruct>&& metadata)
 {
-    if (status() == ResourceStatus::NoMetadata) {
+    if (status() == ResourceStatus::NO_METADATA)
-        setStatus(ResourceStatus::Installed);
+        setStatus(ResourceStatus::INSTALLED);
-    }
 
     m_metadata = metadata;
 }
@@ -143,12 +133,12 @@ void Resource::updateIssues(const BaseInstance* inst)
         return;
     }
 
-    const auto* mcInst = dynamic_cast<const MinecraftInstance*>(inst);
+    auto mcInst = dynamic_cast<const MinecraftInstance*>(inst);
     if (mcInst == nullptr) {
         return;
     }
 
-    auto* profile = mcInst->getPackProfile();
+    auto profile = mcInst->getPackProfile();
     QString mcVersion = profile->getComponentVersion("net.minecraft");
 
     if (!m_metadata->mcVersions.empty() && !m_metadata->mcVersions.contains(mcVersion)) {
@@ -161,59 +151,46 @@ int Resource::compare(const Resource& other, SortType type) const
 {
     switch (type) {
         default:
-        case SortType::Enabled:
+        case SortType::ENABLED:
-            if (enabled() && !other.enabled()) {
+            if (enabled() && !other.enabled())
                 return 1;
-            }
+            if (!enabled() && other.enabled())
-            if (!enabled() && other.enabled()) {
                 return -1;
-            }
             break;
-        case SortType::Name: {
+        case SortType::NAME: {
-            QString thisName{ name() };
+            QString this_name{ name() };
-            QString otherName{ other.name() };
+            QString other_name{ other.name() };
 
             // TODO do we need this? it could result in 0 being returned
-            removeThePrefix(thisName);
+            removeThePrefix(this_name);
-            removeThePrefix(otherName);
+            removeThePrefix(other_name);
 
-            return QString::compare(thisName, otherName, Qt::CaseInsensitive);
+            return QString::compare(this_name, other_name, Qt::CaseInsensitive);
         }
-        case SortType::Date:
+        case SortType::DATE:
-            if (dateTimeChanged() > other.dateTimeChanged()) {
+            if (dateTimeChanged() > other.dateTimeChanged())
                 return 1;
-            }
+            if (dateTimeChanged() < other.dateTimeChanged())
-            if (dateTimeChanged() < other.dateTimeChanged()) {
                 return -1;
-            }
             break;
-        case SortType::Filename:
+        case SortType::SIZE: {
-            return fileinfo().fileName().localeAwareCompare(other.fileinfo().fileName());
-
-        case SortType::Size: {
             if (this->type() != other.type()) {
-                if (this->type() == ResourceType::FOLDER) {
+                if (this->type() == ResourceType::FOLDER)
                     return -1;
-                }
+                if (other.type() == ResourceType::FOLDER)
-                if (other.type() == ResourceType::FOLDER) {
                     return 1;
-                }
             }
 
-            if (sizeInfo() > other.sizeInfo()) {
+            if (sizeInfo() > other.sizeInfo())
                 return 1;
-            }
+            if (sizeInfo() < other.sizeInfo())
-            if (sizeInfo() < other.sizeInfo()) {
                 return -1;
-            }
             break;
         }
-
+        case SortType::PROVIDER: {
-        case SortType::Provider: {
+            auto compare_result = QString::compare(provider(), other.provider(), Qt::CaseInsensitive);
-            auto compareResult = QString::compare(provider(), other.provider(), Qt::CaseInsensitive);
+            if (compare_result != 0)
-            if (compareResult != 0) {
+                return compare_result;
-                return compareResult;
-            }
             break;
         }
     }
@@ -223,20 +200,13 @@ int Resource::compare(const Resource& other, SortType type) const
 
 bool Resource::applyFilter(QRegularExpression filter) const
 {
-    if (filter.match(name()).hasMatch()) {
+    return filter.match(name()).hasMatch();
-        return true;
-    }
-    if (filter.match(fileinfo().fileName()).hasMatch()) {
-        return true;
-    }
-    return false;
 }
 
 bool Resource::enable(EnableAction action)
 {
-    if (m_type == ResourceType::UNKNOWN || m_type == ResourceType::FOLDER) {
+    if (m_type == ResourceType::UNKNOWN || m_type == ResourceType::FOLDER)
         return false;
-    }
 
     QString path = m_file_info.absoluteFilePath();
     QFile file(path);
@@ -255,16 +225,14 @@ bool Resource::enable(EnableAction action)
             break;
     }
 
-    if (m_enabled == enable) {
+    if (m_enabled == enable)
         return false;
-    }
 
     if (enable) {
         // m_enabled is false, but there's no '.disabled' suffix.
         // TODO: Report error?
-        if (!path.endsWith(".disabled")) {
+        if (!path.endsWith(".disabled"))
             return false;
-        }
         path.chop(9);
     } else {
         path += ".disabled";
@@ -272,9 +240,8 @@ bool Resource::enable(EnableAction action)
             path = FS::getUniqueResourceName(path);
         }
     }
-    if (!file.rename(path)) {
+    if (!file.rename(path))
         return false;
-    }
 
     setFile(QFileInfo(path));
 
@@ -282,34 +249,33 @@ bool Resource::enable(EnableAction action)
     return true;
 }
 
-auto Resource::destroy(const QDir& indexDir, bool preserveMetadata, bool attemptTrash) -> bool
+auto Resource::destroy(const QDir& index_dir, bool preserve_metadata, bool attempt_trash) -> bool
 {
     m_type = ResourceType::UNKNOWN;
 
-    if (!preserveMetadata) {
+    if (!preserve_metadata) {
         qDebug() << QString("Destroying metadata for '%1' on purpose").arg(name());
-        destroyMetadata(indexDir);
+        destroyMetadata(index_dir);
     }
 
-    return (attemptTrash && FS::trash(m_file_info.filePath())) || FS::deletePath(m_file_info.filePath());
+    return (attempt_trash && FS::trash(m_file_info.filePath())) || FS::deletePath(m_file_info.filePath());
 }
 
-auto Resource::destroyMetadata(const QDir& indexDir) -> void
+auto Resource::destroyMetadata(const QDir& index_dir) -> void
 {
     if (metadata()) {
-        Metadata::remove(indexDir, metadata()->slug);
+        Metadata::remove(index_dir, metadata()->slug);
     } else {
         auto n = name();
-        Metadata::remove(indexDir, n);
+        Metadata::remove(index_dir, n);
     }
     m_metadata = nullptr;
 }
 
 bool Resource::isSymLinkUnder(const QString& instPath) const
 {
-    if (isSymLink()) {
+    if (isSymLink())
         return true;
-    }
 
     auto instDir = QDir(instPath);
 
@@ -327,9 +293,8 @@ bool Resource::isMoreThanOneHardLink() const
 auto Resource::getOriginalFileName() const -> QString
 {
     auto fileName = m_file_info.fileName();
-    if (!m_enabled) {
+    if (!m_enabled)
         fileName.chop(9);
-    }
     return fileName;
 }
 
@@ -359,16 +324,16 @@ QDebug operator<<(QDebug debug, ResourceType type)
 QDebug operator<<(QDebug debug, ResourceStatus status)
 {
     switch (status) {
-        case ResourceStatus::Installed:
+        case ResourceStatus::INSTALLED:
             debug << "INSTALLED";
             break;
-        case ResourceStatus::NotInstalled:
+        case ResourceStatus::NOT_INSTALLED:
             debug << "NOT_INSTALLED";
             break;
-        case ResourceStatus::NoMetadata:
+        case ResourceStatus::NO_METADATA:
             debug << "NO_METADATA";
             break;
-        case ResourceStatus::Unknown:
+        case ResourceStatus::UNKNOWN:
         default:
             debug << "UNKNOWN";
             break;

launcher/minecraft/mod/Resource.h

@@ -45,7 +45,7 @@
 
 class BaseInstance;
 
-enum class ResourceType : std::uint8_t {
+enum class ResourceType {
     UNKNOWN,     //!< Indicates an unspecified resource type.
     ZIPFILE,     //!< The resource is a zip file containing the resource's class files.
     SINGLEFILE,  //!< The resource is a single file (not a zip file).
@@ -55,33 +55,32 @@ enum class ResourceType : std::uint8_t {
 
 QDebug operator<<(QDebug debug, ResourceType type);
 
-enum class ResourceStatus : std::uint8_t {
+enum class ResourceStatus {
-    Installed,     // Both JAR and Metadata are present
+    INSTALLED,      // Both JAR and Metadata are present
-    NotInstalled,  // Only the Metadata is present
+    NOT_INSTALLED,  // Only the Metadata is present
-    NoMetadata,    // Only the JAR is present
+    NO_METADATA,    // Only the JAR is present
-    Unknown,       // Default status
+    UNKNOWN,        // Default status
 };
 
 QDebug operator<<(QDebug debug, ResourceStatus status);
 
-enum class SortType : std::uint8_t {
+enum class SortType {
-    Name,
+    NAME,
-    Date,
+    DATE,
-    Version,
+    VERSION,
-    Enabled,
+    ENABLED,
-    PackFormat,
+    PACK_FORMAT,
-    Provider,
+    PROVIDER,
-    Size,
+    SIZE,
-    Side,
+    SIDE,
-    McVersions,
+    MC_VERSIONS,
-    Loaders,
+    LOADERS,
-    ReleaseType,
+    RELEASE_TYPE,
-    Requires,
+    REQUIRES,
-    RequiredBy,
+    REQUIRED_BY,
-    Filename,
 };
 
-enum class EnableAction : std::uint8_t { ENABLE, DISABLE, TOGGLE };
+enum class EnableAction { ENABLE, DISABLE, TOGGLE };
 
 /** General class for managed resources. It mirrors a file in disk, with some more info
  *  for display and house-keeping purposes.
@@ -93,19 +92,20 @@ class Resource : public QObject {
     Q_DISABLE_COPY(Resource)
    public:
     using Ptr = shared_qobject_ptr<Resource>;
+    using WeakPtr = QPointer<Resource>;
 
     Resource(QObject* parent = nullptr);
-    Resource(QFileInfo fileInfo);
+    Resource(QFileInfo file_info);
-    Resource(const QString& filePath) : Resource(QFileInfo(filePath)) {}
+    Resource(QString file_path) : Resource(QFileInfo(file_path)) {}
 
     ~Resource() override = default;
 
-    void setFile(QFileInfo fileInfo);
+    void setFile(QFileInfo file_info);
     void parseFile();
 
     auto fileinfo() const -> QFileInfo { return m_file_info; }
     auto dateTimeChanged() const -> QDateTime { return m_changed_date_time; }
-    auto internalId() const -> QString { return m_internal_id; }
+    auto internal_id() const -> QString { return m_internal_id; }
     auto type() const -> ResourceType { return m_type; }
     bool enabled() const { return m_enabled; }
     auto getOriginalFileName() const -> QString;
@@ -138,7 +138,7 @@ class Resource : public QObject {
      *  = 0: 'this' is equal to 'other'
      *  < 0: 'this' comes before 'other'
      */
-    virtual int compare(const Resource& other, SortType type = SortType::Name) const;
+    virtual int compare(const Resource& other, SortType type = SortType::NAME) const;
 
     /** Returns whether the given filter should filter out 'this' (false),
      *  or if such filter includes the Resource (true).
@@ -163,9 +163,9 @@ class Resource : public QObject {
     }
 
     // Delete all files of this resource.
-    auto destroy(const QDir& indexDir, bool preserveMetadata = false, bool attemptTrash = true) -> bool;
+    auto destroy(const QDir& index_dir, bool preserve_metadata = false, bool attempt_trash = true) -> bool;
     // Delete the metadata only.
-    auto destroyMetadata(const QDir& indexDir) -> void;
+    auto destroyMetadata(const QDir& index_dir) -> void;
 
     auto isSymLink() const -> bool { return m_file_info.isSymLink(); }
 
@@ -195,7 +195,7 @@ class Resource : public QObject {
     ResourceType m_type = ResourceType::UNKNOWN;
 
     /* Installation status of the resource. */
-    ResourceStatus m_status = ResourceStatus::Unknown;
+    ResourceStatus m_status = ResourceStatus::UNKNOWN;
 
     std::shared_ptr<Metadata::ModStruct> m_metadata = nullptr;
 

launcher/minecraft/mod/ResourceFolderModel.cpp

@@ -11,7 +11,6 @@
 #include <QStyle>
 #include <QThreadPool>
 #include <QUrl>
-#include <algorithm>
 #include <utility>
 
 #include "Application.h"
@@ -28,10 +27,10 @@
 #include "tasks/Task.h"
 #include "ui/dialogs/CustomMessageBox.h"
 
-ResourceFolderModel::ResourceFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
+ResourceFolderModel::ResourceFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
-    : QAbstractListModel(parent), m_dir(dir), m_instance(instance), m_watcher(this), m_isIndexed(isIndexed)
+    : QAbstractListModel(parent), m_dir(dir), m_instance(instance), m_watcher(this), m_is_indexed(is_indexed)
 {
-    if (createDir) {
+    if (create_dir) {
         FS::ensureFolderPathExists(m_dir.absolutePath());
     }
 
@@ -50,75 +49,70 @@ ResourceFolderModel::ResourceFolderModel(const QDir& dir, BaseInstance* instance
 
 ResourceFolderModel::~ResourceFolderModel()
 {
-    while (!QThreadPool::globalInstance()->waitForDone(100)) {
+    while (!QThreadPool::globalInstance()->waitForDone(100))
         QCoreApplication::processEvents();
-    }
 }
 
 bool ResourceFolderModel::startWatching(const QStringList& paths)
 {
     // Remove orphaned metadata next time
-    m_firstFolderLoad = true;
+    m_first_folder_load = true;
 
-    if (m_isWatching) {
+    if (m_is_watching)
         return false;
-    }
 
-    auto couldntBeWatched = m_watcher.addPaths(paths);
+    auto couldnt_be_watched = m_watcher.addPaths(paths);
-    for (const auto& path : paths) {
+    for (auto path : paths) {
-        if (couldntBeWatched.contains(path)) {
+        if (couldnt_be_watched.contains(path))
             qDebug() << "Failed to start watching" << path;
-        } else {
+        else
             qDebug() << "Started watching" << path;
-        }
     }
 
     update();
 
-    m_isWatching = !m_isWatching;
+    m_is_watching = !m_is_watching;
-    return m_isWatching;
+    return m_is_watching;
 }
 
 bool ResourceFolderModel::stopWatching(const QStringList& paths)
 {
-    if (!m_isWatching) {
+    if (!m_is_watching)
         return false;
-    }
 
-    auto couldntBeStopped = m_watcher.removePaths(paths);
+    auto couldnt_be_stopped = m_watcher.removePaths(paths);
-    for (const auto& path : paths) {
+    for (auto path : paths) {
-        if (couldntBeStopped.contains(path)) {
+        if (couldnt_be_stopped.contains(path))
             qDebug() << "Failed to stop watching" << path;
-        } else {
+        else
             qDebug() << "Stopped watching" << path;
-        }
     }
 
-    m_isWatching = !m_isWatching;
+    m_is_watching = !m_is_watching;
-    return !m_isWatching;
+    return !m_is_watching;
 }
 
-bool ResourceFolderModel::installResource(QString originalPath)
+bool ResourceFolderModel::installResource(QString original_path)
 {
     // NOTE: fix for GH-1178: remove trailing slash to avoid issues with using the empty result of QFileInfo::fileName
-    originalPath = FS::NormalizePath(originalPath);
+    original_path = FS::NormalizePath(original_path);
-    QFileInfo fileInfo(originalPath);
+    QFileInfo file_info(original_path);
 
-    if (!fileInfo.exists() || !fileInfo.isReadable()) {
+    if (!file_info.exists() || !file_info.isReadable()) {
-        qWarning() << "Caught attempt to install non-existing file or file-like object:" << originalPath;
+        qWarning() << "Caught attempt to install non-existing file or file-like object:" << original_path;
         return false;
     }
-    qDebug() << "Installing:" << fileInfo.absoluteFilePath();
+    qDebug() << "Installing:" << file_info.absoluteFilePath();
 
-    Resource resource(fileInfo);
+    Resource resource(file_info);
     if (!resource.valid()) {
-        qWarning() << originalPath << "is not a valid resource. Ignoring it.";
+        qWarning() << original_path << "is not a valid resource. Ignoring it.";
         return false;
     }
 
-    auto newPath = FS::NormalizePath(m_dir.filePath(fileInfo.fileName()));
+    auto new_path = FS::NormalizePath(m_dir.filePath(file_info.fileName()));
-    if (originalPath == newPath) {
+    if (original_path == new_path) {
-        qWarning() << "Overwriting the mod (" << originalPath << ") with itself makes no sense...";
+        qWarning() << "Overwriting the mod (" << original_path << ") with itself makes no sense...";
         return false;
     }
 
@@ -126,47 +120,45 @@ bool ResourceFolderModel::installResource(QString originalPath)
         case ResourceType::SINGLEFILE:
         case ResourceType::ZIPFILE:
         case ResourceType::LITEMOD: {
-            if (QFile::exists(newPath) || QFile::exists(newPath + QString(".disabled"))) {
+            if (QFile::exists(new_path) || QFile::exists(new_path + QString(".disabled"))) {
-                if (!FS::deletePath(newPath)) {
+                if (!FS::deletePath(new_path)) {
-                    qCritical() << "Cleaning up new location (" << newPath << ") was unsuccessful!";
+                    qCritical() << "Cleaning up new location (" << new_path << ") was unsuccessful!";
                     return false;
                 }
-                qDebug() << newPath << "has been deleted.";
+                qDebug() << new_path << "has been deleted.";
             }
 
-            if (!QFile::copy(originalPath, newPath)) {
+            if (!QFile::copy(original_path, new_path)) {
-                qCritical() << "Copy from" << originalPath << "to" << newPath << "has failed.";
+                qCritical() << "Copy from" << original_path << "to" << new_path << "has failed.";
                 return false;
             }
 
-            FS::updateTimestamp(newPath);
+            FS::updateTimestamp(new_path);
 
-            QFileInfo newPathFileInfo(newPath);
+            QFileInfo new_path_file_info(new_path);
-            resource.setFile(newPathFileInfo);
+            resource.setFile(new_path_file_info);
 
-            if (!m_isWatching) {
+            if (!m_is_watching)
                 return update();
-            }
 
             return true;
         }
         case ResourceType::FOLDER: {
-            if (QFile::exists(newPath)) {
+            if (QFile::exists(new_path)) {
-                qDebug() << "Ignoring folder '" << originalPath << "', it would merge with" << newPath;
+                qDebug() << "Ignoring folder '" << original_path << "', it would merge with" << new_path;
                 return false;
             }
 
-            if (!FS::copy(originalPath, newPath)()) {
+            if (!FS::copy(original_path, new_path)()) {
-                qWarning() << "Copy of folder from" << originalPath << "to" << newPath << "has (potentially partially) failed.";
+                qWarning() << "Copy of folder from" << original_path << "to" << new_path << "has (potentially partially) failed.";
                 return false;
             }
 
-            QFileInfo newpathInfo(newPath);
+            QFileInfo newpathInfo(new_path);
             resource.setFile(newpathInfo);
 
-            if (!m_isWatching) {
+            if (!m_is_watching)
                 return update();
-            }
 
             return true;
         }
@@ -176,24 +168,24 @@ bool ResourceFolderModel::installResource(QString originalPath)
     return false;
 }
 
-void ResourceFolderModel::installResourceWithFlameMetadata(const QString& path, ModPlatform::IndexedVersion& vers)
+void ResourceFolderModel::installResourceWithFlameMetadata(QString path, ModPlatform::IndexedVersion& vers)
 {
-    auto install = [this, path] { installResource(path); };
+    auto install = [this, path] { installResource(std::move(path)); };
     if (vers.addonId.isValid()) {
         ModPlatform::IndexedPack pack{
-            .addonId = vers.addonId,
+            vers.addonId,
-            .provider = ModPlatform::ResourceProvider::FLAME,
+            ModPlatform::ResourceProvider::FLAME,
         };
 
         auto [job, response] = FlameAPI().getProject(vers.addonId.toString());
         connect(job.get(), &Task::failed, this, install);
         connect(job.get(), &Task::aborted, this, install);
         connect(job.get(), &Task::succeeded, [response, this, &vers, install, &pack] {
-            QJsonParseError parseError{};
+            QJsonParseError parse_error{};
-            QJsonDocument doc = QJsonDocument::fromJson(*response, &parseError);
+            QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
-            if (parseError.error != QJsonParseError::NoError) {
+            if (parse_error.error != QJsonParseError::NoError) {
-                qWarning() << "Error while parsing JSON response for mod info at" << parseError.offset
+                qWarning() << "Error while parsing JSON response for mod info at" << parse_error.offset
-                           << "reason:" << parseError.errorString();
+                           << "reason:" << parse_error.errorString();
                 qDebug() << *response;
                 return;
             }
@@ -204,9 +196,9 @@ void ResourceFolderModel::installResourceWithFlameMetadata(const QString& path,
                 qDebug() << doc;
                 qWarning() << "Error while reading mod info:" << e.cause();
             }
-            LocalResourceUpdateTask updateMetadata(indexDir(), pack, vers);
+            LocalResourceUpdateTask update_metadata(indexDir(), pack, vers);
-            connect(&updateMetadata, &Task::finished, this, install);
+            connect(&update_metadata, &Task::finished, this, install);
-            updateMetadata.start();
+            update_metadata.start();
         });
 
         job->start();
@@ -215,7 +207,7 @@ void ResourceFolderModel::installResourceWithFlameMetadata(const QString& path,
     }
 }
 
-bool ResourceFolderModel::uninstallResource(const QString& fileName, bool preserveMetadata)
+bool ResourceFolderModel::uninstallResource(const QString& file_name, bool preserve_metadata)
 {
     for (auto& resource : m_resources) {
         auto resourceFileInfo = resource->fileinfo();
@@ -224,8 +216,8 @@ bool ResourceFolderModel::uninstallResource(const QString& fileName, bool preser
             resourceFileName.chop(9);
         }
 
-        if (resourceFileName == fileName) {
+        if (resourceFileName == file_name) {
-            auto res = resource->destroy(indexDir(), preserveMetadata, false);
+            auto res = resource->destroy(indexDir(), preserve_metadata, false);
 
             update();
 
@@ -237,16 +229,14 @@ bool ResourceFolderModel::uninstallResource(const QString& fileName, bool preser
 
 bool ResourceFolderModel::deleteResources(const QModelIndexList& indexes)
 {
-    if (indexes.isEmpty()) {
+    if (indexes.isEmpty())
         return true;
-    }
 
     for (auto i : indexes) {
-        if (i.column() != 0) {
+        if (i.column() != 0)
             continue;
-        }
 
-        const auto& resource = m_resources.at(i.row());
+        auto& resource = m_resources.at(i.row());
         resource->destroy(indexDir());
     }
 
@@ -257,16 +247,14 @@ bool ResourceFolderModel::deleteResources(const QModelIndexList& indexes)
 
 void ResourceFolderModel::deleteMetadata(const QModelIndexList& indexes)
 {
-    if (indexes.isEmpty()) {
+    if (indexes.isEmpty())
         return;
-    }
 
     for (auto i : indexes) {
-        if (i.column() != 0) {
+        if (i.column() != 0)
             continue;
-        }
 
-        const auto& resource = m_resources.at(i.row());
+        auto& resource = m_resources.at(i.row());
         resource->destroyMetadata(indexDir());
     }
 
@@ -283,36 +271,33 @@ bool ResourceFolderModel::setResourceEnabled(const QModelIndexList& indexes, Ena
                                          QMessageBox::Warning, QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
                 ->exec();
 
-        if (response != QMessageBox::Yes) {
+        if (response != QMessageBox::Yes)
             return false;
-        }
     }
 
-    if (indexes.isEmpty()) {
+    if (indexes.isEmpty())
         return true;
-    }
 
     bool succeeded = true;
-    for (const auto& idx : indexes) {
+    for (auto const& idx : indexes) {
-        if (!validateIndex(idx) || idx.column() != 0) {
+        if (!validateIndex(idx) || idx.column() != 0)
             continue;
-        }
 
         int row = idx.row();
 
         auto& resource = m_resources[row];
 
         // Preserve the row, but change its ID
-        auto oldId = resource->internalId();
+        auto old_id = resource->internal_id();
         if (!resource->enable(action)) {
             succeeded = false;
             continue;
         }
 
-        auto newId = resource->internalId();
+        auto new_id = resource->internal_id();
 
-        m_resourcesIndex.remove(oldId);
+        m_resources_index.remove(old_id);
-        m_resourcesIndex[newId] = row;
+        m_resources_index[new_id] = row;
 
         emit dataChanged(index(row, 0), index(row, columnCount(QModelIndex()) - 1));
     }
@@ -327,25 +312,24 @@ bool ResourceFolderModel::update()
     QMutexLocker lock(&s_update_task_mutex);
 
     // Already updating, so we schedule a future update and return.
-    if (m_currentUpdateTask) {
+    if (m_current_update_task) {
-        m_scheduledUpdate = true;
+        m_scheduled_update = true;
         return false;
     }
 
-    m_currentUpdateTask.reset(createUpdateTask());
+    m_current_update_task.reset(createUpdateTask());
-    if (!m_currentUpdateTask) {
+    if (!m_current_update_task)
         return false;
-    }
 
-    connect(m_currentUpdateTask.get(), &Task::succeeded, this, &ResourceFolderModel::onUpdateSucceeded,
+    connect(m_current_update_task.get(), &Task::succeeded, this, &ResourceFolderModel::onUpdateSucceeded,
             Qt::ConnectionType::QueuedConnection);
-    connect(m_currentUpdateTask.get(), &Task::failed, this, &ResourceFolderModel::onUpdateFailed, Qt::ConnectionType::QueuedConnection);
+    connect(m_current_update_task.get(), &Task::failed, this, &ResourceFolderModel::onUpdateFailed, Qt::ConnectionType::QueuedConnection);
     connect(
-        m_currentUpdateTask.get(), &Task::finished, this,
+        m_current_update_task.get(), &Task::finished, this,
         [this] {
-            m_currentUpdateTask.reset();
+            m_current_update_task.reset();
-            if (m_scheduledUpdate) {
+            if (m_scheduled_update) {
-                m_scheduledUpdate = false;
+                m_scheduled_update = false;
                 update();
             } else {
                 emit updateFinished();
@@ -356,16 +340,16 @@ bool ResourceFolderModel::update()
     Task::Ptr preUpdate{ createPreUpdateTask() };
 
     if (preUpdate != nullptr) {
-        auto* task = new SequentialTask("ResourceFolderModel::update");
+        auto task = new SequentialTask("ResourceFolderModel::update");
 
         task->addTask(preUpdate);
-        task->addTask(m_currentUpdateTask);
+        task->addTask(m_current_update_task);
 
         connect(task, &Task::finished, [task] { task->deleteLater(); });
 
         QThreadPool::globalInstance()->start(task);
     } else {
-        QThreadPool::globalInstance()->start(m_currentUpdateTask.get());
+        QThreadPool::globalInstance()->start(m_current_update_task.get());
     }
 
     return true;
@@ -378,25 +362,24 @@ void ResourceFolderModel::resolveResource(Resource::Ptr res)
     }
 
     Task::Ptr task{ createParseTask(*res) };
-    if (!task) {
+    if (!task)
         return;
-    }
 
-    int ticket = m_nextResolutionTicket.fetch_add(1);
+    int ticket = m_next_resolution_ticket.fetch_add(1);
 
     res->setResolving(true, ticket);
-    m_activeParseTasks.insert(ticket, task);
+    m_active_parse_tasks.insert(ticket, task);
 
     connect(
-        task.get(), &Task::succeeded, this, [this, ticket, res] { onParseSucceeded(ticket, res->internalId()); },
+        task.get(), &Task::succeeded, this, [this, ticket, res] { onParseSucceeded(ticket, res->internal_id()); },
         Qt::ConnectionType::QueuedConnection);
     connect(
-        task.get(), &Task::failed, this, [this, ticket, res] { onParseFailed(ticket, res->internalId()); },
+        task.get(), &Task::failed, this, [this, ticket, res] { onParseFailed(ticket, res->internal_id()); },
         Qt::ConnectionType::QueuedConnection);
     connect(
         task.get(), &Task::finished, this,
         [this, ticket] {
-            m_activeParseTasks.remove(ticket);
+            m_active_parse_tasks.remove(ticket);
             emit parseFinished();
         },
         Qt::ConnectionType::QueuedConnection);
@@ -411,45 +394,44 @@ void ResourceFolderModel::resolveResource(Resource::Ptr res)
 
 void ResourceFolderModel::onUpdateSucceeded()
 {
-    auto updateResults = static_cast<ResourceFolderLoadTask*>(m_currentUpdateTask.get())->result();
+    auto update_results = static_cast<ResourceFolderLoadTask*>(m_current_update_task.get())->result();
 
-    auto& newResources = updateResults->resources;
+    auto& new_resources = update_results->resources;
 
-    auto currentList = m_resourcesIndex.keys();
+    auto current_list = m_resources_index.keys();
-    QSet<QString> currentSet(currentList.begin(), currentList.end());
+    QSet<QString> current_set(current_list.begin(), current_list.end());
 
-    auto newList = newResources.keys();
+    auto new_list = new_resources.keys();
-    QSet<QString> newSet(newList.begin(), newList.end());
+    QSet<QString> new_set(new_list.begin(), new_list.end());
 
-    applyUpdates(currentSet, newSet, newResources);
+    applyUpdates(current_set, new_set, new_resources);
 }
 
-void ResourceFolderModel::onParseSucceeded(int ticket, const QString& resourceId)
+void ResourceFolderModel::onParseSucceeded(int ticket, QString resource_id)
 {
-    auto iter = m_activeParseTasks.constFind(ticket);
+    auto iter = m_active_parse_tasks.constFind(ticket);
-    if (iter == m_activeParseTasks.constEnd() || !m_resourcesIndex.contains(resourceId)) {
+    if (iter == m_active_parse_tasks.constEnd() || !m_resources_index.contains(resource_id))
         return;
-    }
 
-    int row = m_resourcesIndex[resourceId];
+    int row = m_resources_index[resource_id];
     emit dataChanged(index(row), index(row, columnCount(QModelIndex()) - 1));
 }
 
 Task* ResourceFolderModel::createUpdateTask()
 {
-    auto indexDir2 = indexDir();
+    auto index_dir = indexDir();
-    auto* task = new ResourceFolderLoadTask(dir(), indexDir2, m_isIndexed, m_firstFolderLoad,
+    auto task = new ResourceFolderLoadTask(dir(), index_dir, m_is_indexed, m_first_folder_load,
-                                            [this](const QFileInfo& file) { return createResource(file); });
+                                           [this](const QFileInfo& file) { return createResource(file); });
-    m_firstFolderLoad = false;
+    m_first_folder_load = false;
     return task;
 }
 
 bool ResourceFolderModel::hasPendingParseTasks() const
 {
-    return !m_activeParseTasks.isEmpty();
+    return !m_active_parse_tasks.isEmpty();
 }
 
-void ResourceFolderModel::directoryChanged(const QString& /*path*/)
+void ResourceFolderModel::directoryChanged(QString path)
 {
     update();
 }
@@ -464,9 +446,8 @@ Qt::ItemFlags ResourceFolderModel::flags(const QModelIndex& index) const
 {
     Qt::ItemFlags defaultFlags = QAbstractListModel::flags(index);
     auto flags = defaultFlags | Qt::ItemIsDropEnabled;
-    if (index.isValid()) {
+    if (index.isValid())
         flags |= Qt::ItemIsUserCheckable;
-    }
     return flags;
 }
 
@@ -477,25 +458,21 @@ QStringList ResourceFolderModel::mimeTypes() const
     return types;
 }
 
-bool ResourceFolderModel::dropMimeData(const QMimeData* data,
+bool ResourceFolderModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int, int, const QModelIndex&)
-                                       Qt::DropAction action,
-                                       int /*row*/,
-                                       int /*column*/,
-                                       const QModelIndex& /*parent*/)
 {
     if (action == Qt::IgnoreAction) {
         return true;
     }
 
     // check if the action is supported
-    if ((data == nullptr) || !(action & supportedDropActions())) {
+    if (!data || !(action & supportedDropActions())) {
         return false;
     }
 
     // files dropped from outside?
     if (data->hasUrls()) {
         auto urls = data->urls();
-        for (const auto& url : urls) {
+        for (auto url : urls) {
             // only local files may be dropped...
             if (!url.isLocalFile()) {
                 continue;
@@ -511,12 +488,14 @@ bool ResourceFolderModel::dropMimeData(const QMimeData* data,
 
 bool ResourceFolderModel::validateIndex(const QModelIndex& index) const
 {
-    if (!index.isValid()) {
+    if (!index.isValid())
         return false;
-    }
 
     int row = index.row();
-    return row >= 0 && row < m_resources.size();
+    if (row < 0 || row >= m_resources.size())
+        return false;
+
+    return true;
 }
 
 // HACK: all subclasses need to call this to have the whole row painted
@@ -525,15 +504,15 @@ QBrush ResourceFolderModel::rowBackground(int row) const
 {
     if (APPLICATION->settings()->get("ShowModIncompat").toBool() && m_resources[row]->hasIssues()) {
         return { QColor(255, 0, 0, 40) };
+    } else {
+        return {};
     }
-    return {};
 }
 
 QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index)) {
+    if (!validateIndex(index))
         return {};
-    }
 
     int row = index.row();
     int column = index.column();
@@ -551,13 +530,11 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
                     return m_resources[row]->provider();
                 case SizeColumn:
                     return m_resources[row]->sizeStr();
-                case FileNameColumn:
-                    return m_resources[row]->fileinfo().fileName();
                 default:
                     return {};
             }
         case Qt::ToolTipRole: {
-            QString tooltip = m_resources[row]->internalId();
+            QString tooltip = m_resources[row]->internal_id();
 
             if (column == NameColumn) {
                 if (APPLICATION->settings()->get("ShowModIncompat").toBool()) {
@@ -568,7 +545,7 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
 
                 if (at(row).isSymLinkUnder(instDirPath())) {
                     tooltip +=
-                        m_resources[row]->internalId() +
+                        m_resources[row]->internal_id() +
                         tr("\nWarning: This resource is symbolically linked from elsewhere. Editing it will also change the original."
                            "\nCanonical Path: %1")
                             .arg(at(row).fileinfo().canonicalFilePath());
@@ -585,8 +562,7 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
             if (column == NameColumn) {
                 if (APPLICATION->settings()->get("ShowModIncompat").toBool() && at(row).hasIssues()) {
                     return QIcon::fromTheme("status-bad");
-                }
+                } else if (at(row).isSymLinkUnder(instDirPath()) || at(row).isMoreThanOneHardLink()) {
-                if (at(row).isSymLinkUnder(instDirPath()) || at(row).isMoreThanOneHardLink()) {
                     return QIcon::fromTheme("status-yellow");
                 }
             }
@@ -594,9 +570,8 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
             return {};
         }
         case Qt::CheckStateRole:
-            if (column == ActiveColumn) {
+            if (column == ActiveColumn)
                 return m_resources[row]->enabled() ? Qt::Checked : Qt::Unchecked;
-            }
             return {};
         default:
             return {};
@@ -606,9 +581,8 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
 bool ResourceFolderModel::setData(const QModelIndex& index, [[maybe_unused]] const QVariant& value, int role)
 {
     int row = index.row();
-    if (row < 0 || row >= rowCount(index.parent()) || !index.isValid()) {
+    if (row < 0 || row >= rowCount(index.parent()) || !index.isValid())
         return false;
-    }
 
     if (role == Qt::CheckStateRole) {
         return setResourceEnabled({ index }, EnableAction::TOGGLE);
@@ -627,7 +601,6 @@ QVariant ResourceFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
                 case DateColumn:
                 case ProviderColumn:
                 case SizeColumn:
-                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return {};
@@ -645,8 +618,6 @@ QVariant ResourceFolderModel::headerData(int section, [[maybe_unused]] Qt::Orien
                     return tr("The source provider of the resource.");
                 case SizeColumn:
                     return tr("The size of the resource.");
-                case FileNameColumn:
-                    return tr("The file name of the resource.");
                 default:
                     return {};
             }
@@ -667,22 +638,22 @@ void ResourceFolderModel::setupHeaderAction(QAction* act, int column)
 
 void ResourceFolderModel::saveColumns(QTreeView* tree)
 {
-    const auto stateSettingName = QString("UI/%1_Page/Columns").arg(id());
+    auto const stateSettingName = QString("UI/%1_Page/Columns").arg(id());
-    const auto overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
+    auto const overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
-    const auto visibilitySettingName = QString("UI/%1_Page/ColumnsVisibility").arg(id());
+    auto const visibilitySettingName = QString("UI/%1_Page/ColumnsVisibility").arg(id());
 
     auto stateSetting = m_instance->settings()->getSetting(stateSettingName);
     stateSetting->set(QString::fromUtf8(tree->header()->saveState().toBase64()));
 
     // neither passthrough nor override settings works for this usecase as I need to only set the global when the gate is false
-    auto* settings = m_instance->settings();
+    auto settings = m_instance->settings();
     if (!settings->get(overrideSettingName).toBool()) {
         settings = APPLICATION->settings();
     }
     auto visibility = Json::toMap(settings->get(visibilitySettingName).toString());
-    for (auto i = 0; i < m_columnNames.size(); ++i) {
+    for (auto i = 0; i < m_column_names.size(); ++i) {
         if (m_columnsHideable[i]) {
-            auto name = m_columnNames[i];
+            auto name = m_column_names[i];
             visibility[name] = !tree->isColumnHidden(i);
         }
     }
@@ -691,24 +662,24 @@ void ResourceFolderModel::saveColumns(QTreeView* tree)
 
 void ResourceFolderModel::loadColumns(QTreeView* tree)
 {
-    const auto stateSettingName = QString("UI/%1_Page/Columns").arg(id());
+    auto const stateSettingName = QString("UI/%1_Page/Columns").arg(id());
-    const auto overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
+    auto const overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
-    const auto visibilitySettingName = QString("UI/%1_Page/ColumnsVisibility").arg(id());
+    auto const visibilitySettingName = QString("UI/%1_Page/ColumnsVisibility").arg(id());
 
     auto stateSetting = m_instance->settings()->getOrRegisterSetting(stateSettingName, "");
     tree->header()->restoreState(QByteArray::fromBase64(stateSetting->get().toString().toUtf8()));
 
-    auto setVisible = [this, tree](const QVariant& value) {
+    auto setVisible = [this, tree](QVariant value) {
         auto visibility = Json::toMap(value.toString());
-        for (auto i = 0; i < m_columnNames.size(); ++i) {
+        for (auto i = 0; i < m_column_names.size(); ++i) {
             if (m_columnsHideable[i]) {
-                auto name = m_columnNames[i];
+                auto name = m_column_names[i];
                 tree->setColumnHidden(i, !visibility.value(name, false).toBool());
             }
         }
     };
 
-    const auto defaultValue = Json::fromMap({
+    auto const defaultValue = Json::fromMap({
         { "Image", true },
         { "Version", true },
         { "Last Modified", true },
@@ -716,7 +687,7 @@ void ResourceFolderModel::loadColumns(QTreeView* tree)
         { "Pack Format", true },
     });
     // neither passthrough nor override settings works for this usecase as I need to only set the global when the gate is false
-    auto* settings = m_instance->settings();
+    auto settings = m_instance->settings();
     if (!settings->getOrRegisterSetting(overrideSettingName, false)->get().toBool()) {
         settings = APPLICATION->settings();
     }
@@ -725,7 +696,7 @@ void ResourceFolderModel::loadColumns(QTreeView* tree)
 
     // allways connect the signal in case the setting is toggled on and off
     auto gSetting = APPLICATION->settings()->getOrRegisterSetting(visibilitySettingName, defaultValue);
-    connect(gSetting.get(), &Setting::SettingChanged, tree, [this, setVisible, overrideSettingName](const Setting&, const QVariant& value) {
+    connect(gSetting.get(), &Setting::SettingChanged, tree, [this, setVisible, overrideSettingName](const Setting&, QVariant value) {
         if (!m_instance->settings()->get(overrideSettingName).toBool()) {
             setVisible(value);
         }
@@ -734,11 +705,11 @@ void ResourceFolderModel::loadColumns(QTreeView* tree)
 
 QMenu* ResourceFolderModel::createHeaderContextMenu(QTreeView* tree)
 {
-    auto* menu = new QMenu(tree);
+    auto menu = new QMenu(tree);
 
     {  // action to decide if the visibility is per instance or not
-        auto* act = new QAction(tr("Override Columns Visibility"), menu);
+        auto act = new QAction(tr("Override Columns Visibility"), menu);
-        const auto overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
+        auto const overrideSettingName = QString("UI/%1_Page/ColumnsOverride").arg(id());
 
         act->setCheckable(true);
         act->setChecked(m_instance->settings()->getOrRegisterSetting(overrideSettingName, false)->get().toBool());
@@ -754,10 +725,9 @@ QMenu* ResourceFolderModel::createHeaderContextMenu(QTreeView* tree)
 
     for (int col = 0; col < columnCount(); ++col) {
         // Skip creating actions for columns that should not be hidden
-        if (!m_columnsHideable.at(col)) {
+        if (!m_columnsHideable.at(col))
             continue;
-        }
+        auto act = new QAction(menu);
-        auto* act = new QAction(menu);
         setupHeaderAction(act, col);
 
         act->setCheckable(true);
@@ -766,9 +736,8 @@ QMenu* ResourceFolderModel::createHeaderContextMenu(QTreeView* tree)
         connect(act, &QAction::toggled, tree, [this, col, tree](bool toggled) {
             tree->setColumnHidden(col, !toggled);
             for (int c = 0; c < columnCount(); ++c) {
-                if (m_columnResizeModes.at(c) == QHeaderView::ResizeToContents) {
+                if (m_column_resize_modes.at(c) == QHeaderView::ResizeToContents)
                     tree->resizeColumnToContents(c);
-                }
             }
             saveColumns(tree);
         });
@@ -786,43 +755,41 @@ QSortFilterProxyModel* ResourceFolderModel::createFilterProxyModel(QObject* pare
 
 SortType ResourceFolderModel::columnToSortKey(size_t column) const
 {
-    Q_ASSERT(m_columnSortKeys.size() == columnCount());
+    Q_ASSERT(m_column_sort_keys.size() == columnCount());
-    return m_columnSortKeys.at(column);
+    return m_column_sort_keys.at(column);
 }
 
 /* Standard Proxy Model for createFilterProxyModel */
-bool ResourceFolderModel::ProxyModel::filterAcceptsRow(int sourceRow, [[maybe_unused]] const QModelIndex& sourceParent) const
+bool ResourceFolderModel::ProxyModel::filterAcceptsRow(int source_row, [[maybe_unused]] const QModelIndex& source_parent) const
 {
     auto* model = qobject_cast<ResourceFolderModel*>(sourceModel());
-    if (!model) {
+    if (!model)
         return true;
-    }
 
-    const auto& resource = model->at(sourceRow);
+    const auto& resource = model->at(source_row);
 
     return resource.applyFilter(filterRegularExpression());
 }
 
-bool ResourceFolderModel::ProxyModel::lessThan(const QModelIndex& sourceLeft, const QModelIndex& sourceRight) const
+bool ResourceFolderModel::ProxyModel::lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const
 {
     auto* model = qobject_cast<ResourceFolderModel*>(sourceModel());
-    if (!model || !sourceLeft.isValid() || !sourceRight.isValid() || sourceLeft.column() != sourceRight.column()) {
+    if (!model || !source_left.isValid() || !source_right.isValid() || source_left.column() != source_right.column()) {
-        return QSortFilterProxyModel::lessThan(sourceLeft, sourceRight);
+        return QSortFilterProxyModel::lessThan(source_left, source_right);
     }
 
     // we are now guaranteed to have two valid indexes in the same column... we love the provided invariants unconditionally and
     // proceed.
 
-    auto columnSortKey = model->columnToSortKey(sourceLeft.column());
+    auto column_sort_key = model->columnToSortKey(source_left.column());
-    const auto& resourceLeft = model->at(sourceLeft.row());
+    auto const& resource_left = model->at(source_left.row());
-    const auto& resourceRight = model->at(sourceRight.row());
+    auto const& resource_right = model->at(source_right.row());
 
-    auto compareResult = resourceLeft.compare(resourceRight, columnSortKey);
+    auto compare_result = resource_left.compare(resource_right, column_sort_key);
-    if (compareResult == 0) {
+    if (compare_result == 0)
-        return QSortFilterProxyModel::lessThan(sourceLeft, sourceRight);
+        return QSortFilterProxyModel::lessThan(source_left, source_right);
-    }
 
-    return compareResult < 0;
+    return compare_result < 0;
 }
 
 QString ResourceFolderModel::instDirPath() const
@@ -830,51 +797,50 @@ QString ResourceFolderModel::instDirPath() const
     return QFileInfo(m_instance->instanceRoot()).absoluteFilePath();
 }
 
-void ResourceFolderModel::onParseFailed(int ticket, const QString& resourceId)
+void ResourceFolderModel::onParseFailed(int ticket, QString resource_id)
 {
-    auto iter = m_activeParseTasks.constFind(ticket);
+    auto iter = m_active_parse_tasks.constFind(ticket);
-    if (iter == m_activeParseTasks.constEnd() || !m_resourcesIndex.contains(resourceId)) {
+    if (iter == m_active_parse_tasks.constEnd() || !m_resources_index.contains(resource_id))
         return;
-    }
 
-    auto removedIndex = m_resourcesIndex[resourceId];
+    auto removed_index = m_resources_index[resource_id];
-    auto removedIt = m_resources.begin() + removedIndex;
+    auto removed_it = m_resources.begin() + removed_index;
-    Q_ASSERT(removedIt != m_resources.end());
+    Q_ASSERT(removed_it != m_resources.end());
 
-    beginRemoveRows(QModelIndex(), removedIndex, removedIndex);
+    beginRemoveRows(QModelIndex(), removed_index, removed_index);
-    m_resources.erase(removedIt);
+    m_resources.erase(removed_it);
 
     // update index
-    m_resourcesIndex.clear();
+    m_resources_index.clear();
     int idx = 0;
-    for (const auto& mod : qAsConst(m_resources)) {
+    for (auto const& mod : qAsConst(m_resources)) {
-        m_resourcesIndex[mod->internalId()] = idx;
+        m_resources_index[mod->internal_id()] = idx;
         idx++;
     }
     endRemoveRows();
 }
 
-void ResourceFolderModel::applyUpdates(QSet<QString>& currentSet, QSet<QString>& newSet, QMap<QString, Resource::Ptr>& newResources)
+void ResourceFolderModel::applyUpdates(QSet<QString>& current_set, QSet<QString>& new_set, QMap<QString, Resource::Ptr>& new_resources)
 {
     // see if the kept resources changed in some way
     {
-        QSet<QString> keptSet = currentSet;
+        QSet<QString> kept_set = current_set;
-        keptSet.intersect(newSet);
+        kept_set.intersect(new_set);
 
-        for (const auto& kept : keptSet) {
+        for (auto const& kept : kept_set) {
-            auto rowIt = m_resourcesIndex.constFind(kept);
+            auto row_it = m_resources_index.constFind(kept);
-            Q_ASSERT(rowIt != m_resourcesIndex.constEnd());
+            Q_ASSERT(row_it != m_resources_index.constEnd());
-            auto row = rowIt.value();
+            auto row = row_it.value();
 
-            auto& newResource = newResources[kept];
+            auto& new_resource = new_resources[kept];
-            const auto& currentResource = m_resources.at(row);
+            auto const& current_resource = m_resources.at(row);
 
-            if (newResource->dateTimeChanged() == currentResource->dateTimeChanged()) {
+            if (new_resource->dateTimeChanged() == current_resource->dateTimeChanged()) {
                 // no significant change
-                bool hadIssues = !currentResource->hasIssues();
+                bool hadIssues = !current_resource->hasIssues();
-                currentResource->updateIssues(m_instance);
+                current_resource->updateIssues(m_instance);
 
-                if (hadIssues != currentResource->hasIssues()) {
+                if (hadIssues != current_resource->hasIssues()) {
                     emit dataChanged(index(row, 0), index(row, columnCount({}) - 1));
                 }
                 continue;
@@ -882,16 +848,16 @@ void ResourceFolderModel::applyUpdates(QSet<QString>& currentSet, QSet<QString>&
 
             // If the resource is resolving, but something about it changed, we don't want to
             // continue the resolving.
-            if (currentResource->isResolving()) {
+            if (current_resource->isResolving()) {
-                auto ticket = currentResource->resolutionTicket();
+                auto ticket = current_resource->resolutionTicket();
-                if (m_activeParseTasks.contains(ticket)) {
+                if (m_active_parse_tasks.contains(ticket)) {
-                    auto* task = (*m_activeParseTasks.find(ticket)).get();
+                    auto task = (*m_active_parse_tasks.find(ticket)).get();
                     task->abort();
                 }
             }
 
-            m_resources[row].reset(newResource);
+            m_resources[row].reset(new_resource);
-            newResource->updateIssues(m_instance);
+            new_resource->updateIssues(m_instance);
 
             resolveResource(m_resources.at(row));
             emit dataChanged(index(row, 0), index(row, columnCount(QModelIndex()) - 1));
@@ -900,47 +866,46 @@ void ResourceFolderModel::applyUpdates(QSet<QString>& currentSet, QSet<QString>&
 
     // remove resources no longer present
     {
-        QSet<QString> removedSet = currentSet;
+        QSet<QString> removed_set = current_set;
-        removedSet.subtract(newSet);
+        removed_set.subtract(new_set);
 
-        QList<int> removedRows;
+        QList<int> removed_rows;
-        for (const auto& removed : removedSet) {
+        for (auto& removed : removed_set)
-            removedRows.append(m_resourcesIndex[removed]);
+            removed_rows.append(m_resources_index[removed]);
-        }
 
-        std::ranges::sort(removedRows, std::greater());
+        std::sort(removed_rows.begin(), removed_rows.end(), std::greater<int>());
 
-        for (auto& removedIndex : removedRows) {
+        for (auto& removed_index : removed_rows) {
-            auto removedIt = m_resources.begin() + removedIndex;
+            auto removed_it = m_resources.begin() + removed_index;
 
-            Q_ASSERT(removedIt != m_resources.end());
+            Q_ASSERT(removed_it != m_resources.end());
 
-            if ((*removedIt)->isResolving()) {
+            if ((*removed_it)->isResolving()) {
-                auto ticket = (*removedIt)->resolutionTicket();
+                auto ticket = (*removed_it)->resolutionTicket();
-                if (m_activeParseTasks.contains(ticket)) {
+                if (m_active_parse_tasks.contains(ticket)) {
-                    auto* task = (*m_activeParseTasks.find(ticket)).get();
+                    auto task = (*m_active_parse_tasks.find(ticket)).get();
                     task->abort();
                 }
             }
 
-            beginRemoveRows(QModelIndex(), removedIndex, removedIndex);
+            beginRemoveRows(QModelIndex(), removed_index, removed_index);
-            m_resources.erase(removedIt);
+            m_resources.erase(removed_it);
             endRemoveRows();
         }
     }
 
     // add new resources to the end
     {
-        QSet<QString> addedSet = newSet;
+        QSet<QString> added_set = new_set;
-        addedSet.subtract(currentSet);
+        added_set.subtract(current_set);
 
         // When you have a Qt build with assertions turned on, proceeding here will abort the application
-        if (addedSet.size() > 0) {
+        if (added_set.size() > 0) {
             beginInsertRows(QModelIndex(), static_cast<int>(m_resources.size()),
-                            static_cast<int>(m_resources.size() + addedSet.size() - 1));
+                            static_cast<int>(m_resources.size() + added_set.size() - 1));
 
-            for (const auto& added : addedSet) {
+            for (auto& added : added_set) {
-                auto res = newResources[added];
+                auto res = new_resources[added];
                 res->updateIssues(m_instance);
                 m_resources.append(res);
                 resolveResource(m_resources.last());
@@ -952,10 +917,10 @@ void ResourceFolderModel::applyUpdates(QSet<QString>& currentSet, QSet<QString>&
 
     // update index
     {
-        m_resourcesIndex.clear();
+        m_resources_index.clear();
         int idx = 0;
-        for (const auto& mod : qAsConst(m_resources)) {
+        for (auto const& mod : qAsConst(m_resources)) {
-            m_resourcesIndex[mod->internalId()] = idx;
+            m_resources_index[mod->internal_id()] = idx;
             idx++;
         }
     }
@@ -963,19 +928,17 @@ void ResourceFolderModel::applyUpdates(QSet<QString>& currentSet, QSet<QString>&
 Resource::Ptr ResourceFolderModel::find(QString id)
 {
     auto iter =
-        std::find_if(m_resources.constBegin(), m_resources.constEnd(), [&](const Resource::Ptr& r) { return r->internalId() == id; });
+        std::find_if(m_resources.constBegin(), m_resources.constEnd(), [&](Resource::Ptr const& r) { return r->internal_id() == id; });
-    if (iter == m_resources.constEnd()) {
+    if (iter == m_resources.constEnd())
         return nullptr;
-    }
     return *iter;
 }
 QList<Resource*> ResourceFolderModel::allResources()
 {
     QList<Resource*> result;
     result.reserve(m_resources.size());
-    for (const Resource ::Ptr& resource : m_resources) {
+    for (const Resource ::Ptr& resource : m_resources)
         result.append((resource.get()));
-    }
     return result;
 }
 
@@ -983,9 +946,8 @@ QList<Resource*> ResourceFolderModel::selectedResources(const QModelIndexList& i
 {
     QList<Resource*> result;
     for (const QModelIndex& index : indexes) {
-        if (index.column() != 0) {
+        if (index.column() != 0)
             continue;
-        }
         result.append(&at(index.row()));
     }
     return result;

launcher/minecraft/mod/ResourceFolderModel.h

@@ -61,7 +61,7 @@ class QSortFilterProxyModel;
 class ResourceFolderModel : public QAbstractListModel {
     Q_OBJECT
    public:
-    ResourceFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
+    ResourceFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
     ~ResourceFolderModel() override;
 
     virtual QString id() const { return "resource"; }
@@ -93,13 +93,13 @@ class ResourceFolderModel : public QAbstractListModel {
      */
     virtual bool installResource(QString path);
 
-    virtual void installResourceWithFlameMetadata(const QString& path, ModPlatform::IndexedVersion& vers);
+    virtual void installResourceWithFlameMetadata(QString path, ModPlatform::IndexedVersion& vers);
 
     /** Uninstall (i.e. remove all data about it) a resource, given its file name.
      *
      *  Returns whether the removal was successful.
      */
-    virtual bool uninstallResource(const QString& fileName, bool preserveMetadata = false);
+    virtual bool uninstallResource(const QString& file_name, bool preserve_metadata = false);
     virtual bool deleteResources(const QModelIndexList&);
     virtual void deleteMetadata(const QModelIndexList&);
 
@@ -125,7 +125,7 @@ class ResourceFolderModel : public QAbstractListModel {
 
     Resource::Ptr find(QString id);
 
-    const QDir& dir() const { return m_dir; }
+    QDir const& dir() const { return m_dir; }
 
     /** Checks whether there's any parse tasks being done.
      *
@@ -137,12 +137,12 @@ class ResourceFolderModel : public QAbstractListModel {
     /* Qt behavior */
 
     /* Basic columns */
-    enum Columns : std::uint8_t { ActiveColumn = 0, NameColumn, DateColumn, ProviderColumn, SizeColumn, FileNameColumn, NumColumns };
+    enum Columns { ActiveColumn = 0, NameColumn, DateColumn, ProviderColumn, SizeColumn, NUM_COLUMNS };
 
-    QStringList columnNames(bool translated = true) const { return translated ? m_columnNamesTranslated : m_columnNames; }
+    QStringList columnNames(bool translated = true) const { return translated ? m_column_names_translated : m_column_names; }
 
     int rowCount(const QModelIndex& parent = {}) const override { return parent.isValid() ? 0 : static_cast<int>(size()); }
-    int columnCount(const QModelIndex& parent = {}) const override { return parent.isValid() ? 0 : NumColumns; }
+    int columnCount(const QModelIndex& parent = {}) const override { return parent.isValid() ? 0 : NUM_COLUMNS; }
 
     Qt::DropActions supportedDropActions() const override;
 
@@ -171,19 +171,18 @@ class ResourceFolderModel : public QAbstractListModel {
     QSortFilterProxyModel* createFilterProxyModel(QObject* parent = nullptr);
 
     SortType columnToSortKey(size_t column) const;
-    QList<QHeaderView::ResizeMode> columnResizeModes() const { return m_columnResizeModes; }
+    QList<QHeaderView::ResizeMode> columnResizeModes() const { return m_column_resize_modes; }
 
     class ProxyModel : public QSortFilterProxyModel {
        public:
         explicit ProxyModel(QObject* parent = nullptr) : QSortFilterProxyModel(parent) {}
 
        protected:
-        bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override;
+        bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const override;
-        bool lessThan(const QModelIndex& sourceLeft, const QModelIndex& sourceRight) const override;
+        bool lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const override;
     };
 
     QString instDirPath() const;
-    BaseInstance* instance() const { return m_instance; }
 
    signals:
     void updateFinished();
@@ -207,7 +206,7 @@ class ResourceFolderModel : public QAbstractListModel {
      *  This task should load and parse all heavy info needed by a resource, such as parsing a manifest. It gets executed
      *  in the background, so it slowly updates the UI as tasks get done.
      */
-    [[nodiscard]] virtual Task* createParseTask(Resource& /*unused*/) { return nullptr; }
+    [[nodiscard]] virtual Task* createParseTask(Resource&) { return nullptr; }
 
     /** Standard implementation of the model update logic.
      *
@@ -215,10 +214,10 @@ class ResourceFolderModel : public QAbstractListModel {
      *  to act only on those disparities.
      *
      */
-    void applyUpdates(QSet<QString>& currentSet, QSet<QString>& newSet, QMap<QString, Resource::Ptr>& newResources);
+    void applyUpdates(QSet<QString>& current_set, QSet<QString>& new_set, QMap<QString, Resource::Ptr>& new_resources);
 
    protected slots:
-    void directoryChanged(const QString&);
+    void directoryChanged(QString);
 
     /** Called when the update task is successful.
      *
@@ -234,40 +233,39 @@ class ResourceFolderModel : public QAbstractListModel {
      *  This is just a simple reference implementation. You probably want to override it with your own logic in a subclass
      *  if the resource is complex and has more stuff to parse.
      */
-    virtual void onParseSucceeded(int ticket, const QString& resourceId);
+    virtual void onParseSucceeded(int ticket, QString resource_id);
-    virtual void onParseFailed(int ticket, const QString& resourceId);
+    virtual void onParseFailed(int ticket, QString resource_id);
 
    protected:
     // Represents the relationship between a column's index (represented by the list index), and it's sorting key.
     // As such, the order in with they appear is very important!
-    QList<SortType> m_columnSortKeys = { SortType::Enabled,  SortType::Name, SortType::Date,
+    QList<SortType> m_column_sort_keys = { SortType::ENABLED, SortType::NAME, SortType::DATE, SortType::PROVIDER, SortType::SIZE };
-                                         SortType::Provider, SortType::Size, SortType::Filename };
+    QStringList m_column_names = { "Enable", "Name", "Last Modified", "Provider", "Size" };
-    QStringList m_columnNames = { "Enable", "Name", "Last Modified", "Provider", "Size", "File Name" };
+    QStringList m_column_names_translated = { tr("Enable"), tr("Name"), tr("Last Modified"), tr("Provider"), tr("Size") };
-    QStringList m_columnNamesTranslated = { tr("Enable"), tr("Name"), tr("Last Modified"), tr("Provider"), tr("Size"), tr("File Name") };
+    QList<QHeaderView::ResizeMode> m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Stretch, QHeaderView::Interactive,
-    QList<QHeaderView::ResizeMode> m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Stretch,     QHeaderView::Interactive,
+                                                             QHeaderView::Interactive, QHeaderView::Interactive };
-                                                           QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
+    QList<bool> m_columnsHideable = { false, false, true, true, true };
-    QList<bool> m_columnsHideable = { false, false, true, true, true, true };
 
     QDir m_dir;
     BaseInstance* m_instance;
     QFileSystemWatcher m_watcher;
-    bool m_isWatching = false;
+    bool m_is_watching = false;
 
-    bool m_isIndexed;
+    bool m_is_indexed;
-    bool m_firstFolderLoad = true;
+    bool m_first_folder_load = true;
 
-    Task::Ptr m_currentUpdateTask = nullptr;
+    Task::Ptr m_current_update_task = nullptr;
-    bool m_scheduledUpdate = false;
+    bool m_scheduled_update = false;
 
     QList<Resource::Ptr> m_resources;
 
     // Represents the relationship between a resource's internal ID and it's row position on the model.
-    QMap<QString, int> m_resourcesIndex;
+    QMap<QString, int> m_resources_index;
 
     // Runs off-thread
     ConcurrentTask m_resourceResolver;
     bool m_resourceResolverRunning = false;
 
-    QMap<int, Task::Ptr> m_activeParseTasks;
+    QMap<int, Task::Ptr> m_active_parse_tasks;
-    std::atomic<int> m_nextResolutionTicket = 0;
+    std::atomic<int> m_next_resolution_ticket = 0;
 };

launcher/minecraft/mod/ResourcePackFolderModel.cpp

@@ -39,26 +39,27 @@
 #include <QIcon>
 #include <QStyle>
 
+#include "Version.h"
+
 #include "minecraft/mod/tasks/LocalDataPackParseTask.h"
 
-ResourcePackFolderModel::ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
+ResourcePackFolderModel::ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
-    : ResourceFolderModel(dir, instance, isIndexed, createDir, parent)
+    : ResourceFolderModel(dir, instance, is_indexed, create_dir, parent)
 {
-    m_columnNames = QStringList({ "Enable", "Image", "Name", "Pack Format", "Last Modified", "Provider", "Size", "File Name" });
+    m_column_names = QStringList({ "Enable", "Image", "Name", "Pack Format", "Last Modified", "Provider", "Size" });
-    m_columnNamesTranslated = QStringList(
+    m_column_names_translated =
-        { tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified"), tr("Provider"), tr("Size"), tr("File Name") });
+        QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified"), tr("Provider"), tr("Size") });
-    m_columnSortKeys = { SortType::Enabled, SortType::Name,     SortType::Name, SortType::PackFormat,
+    m_column_sort_keys = { SortType::ENABLED, SortType::NAME,     SortType::NAME, SortType::PACK_FORMAT,
-                         SortType::Date,    SortType::Provider, SortType::Size, SortType::Filename };
+                           SortType::DATE,    SortType::PROVIDER, SortType::SIZE };
-    m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,     QHeaderView::Interactive,
+    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,    QHeaderView::Interactive,
-                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
+                              QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
-    m_columnsHideable = { false, true, false, true, true, true, true, true };
+    m_columnsHideable = { false, true, false, true, true, true, true };
 }
 
 QVariant ResourcePackFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index)) {
+    if (!validateIndex(index))
         return {};
-    }
 
     int row = index.row();
     int column = index.column();
@@ -91,8 +92,6 @@ QVariant ResourcePackFolderModel::data(const QModelIndex& index, int role) const
                 return QSize(32, 32);
             }
             break;
-        default:
-            break;
     }
 
     // map the columns to the base equivilents
@@ -113,11 +112,6 @@ QVariant ResourcePackFolderModel::data(const QModelIndex& index, int role) const
         case SizeColumn:
             mappedIndex = index.siblingAtColumn(ResourceFolderModel::SizeColumn);
             break;
-        case FileNameColumn:
-            mappedIndex = index.siblingAtColumn(ResourceFolderModel::FileNameColumn);
-            break;
-        default:
-            break;
     }
 
     if (mappedIndex.isValid()) {
@@ -139,7 +133,6 @@ QVariant ResourcePackFolderModel::headerData(int section, [[maybe_unused]] Qt::O
                 case ImageColumn:
                 case ProviderColumn:
                 case SizeColumn:
-                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return {};
@@ -160,8 +153,6 @@ QVariant ResourcePackFolderModel::headerData(int section, [[maybe_unused]] Qt::O
                     return tr("The source provider of the resource pack.");
                 case SizeColumn:
                     return tr("The size of the resource pack.");
-                case FileNameColumn:
-                    return tr("The file name of the resource pack.");
                 default:
                     return {};
             }
@@ -177,10 +168,10 @@ QVariant ResourcePackFolderModel::headerData(int section, [[maybe_unused]] Qt::O
 
 int ResourcePackFolderModel::columnCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : NumColumns;
+    return parent.isValid() ? 0 : NUM_COLUMNS;
 }
 
 Task* ResourcePackFolderModel::createParseTask(Resource& resource)
 {
-    return new LocalDataPackParseTask(m_nextResolutionTicket, dynamic_cast<ResourcePack*>(&resource));
+    return new LocalDataPackParseTask(m_next_resolution_ticket, dynamic_cast<ResourcePack*>(&resource));
 }

launcher/minecraft/mod/ResourcePackFolderModel.h

@@ -7,19 +7,9 @@
 class ResourcePackFolderModel : public ResourceFolderModel {
     Q_OBJECT
    public:
-    enum Columns : std::uint8_t {
+    enum Columns { ActiveColumn = 0, ImageColumn, NameColumn, PackFormatColumn, DateColumn, ProviderColumn, SizeColumn, NUM_COLUMNS };
-        ActiveColumn = 0,
-        ImageColumn,
-        NameColumn,
-        PackFormatColumn,
-        DateColumn,
-        ProviderColumn,
-        SizeColumn,
-        FileNameColumn,
-        NumColumns
-    };
 
-    explicit ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
+    explicit ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
 
     QString id() const override { return "resourcepacks"; }
 
@@ -29,7 +19,7 @@ class ResourcePackFolderModel : public ResourceFolderModel {
     int columnCount(const QModelIndex& parent) const override;
 
     [[nodiscard]] Resource* createResource(const QFileInfo& file) override { return new ResourcePack(file); }
-    [[nodiscard]] Task* createParseTask(Resource& /*unused*/) override;
+    [[nodiscard]] Task* createParseTask(Resource&) override;
 
     RESOURCE_HELPERS(ResourcePack)
 };

launcher/minecraft/mod/ShaderPackFolderModel.h

@@ -18,7 +18,7 @@ class ShaderPackFolderModel : public ResourceFolderModel {
 
     [[nodiscard]] Task* createParseTask(Resource& resource) override
     {
-        return new LocalShaderPackParseTask(m_nextResolutionTicket, static_cast<ShaderPack&>(resource));
+        return new LocalShaderPackParseTask(m_next_resolution_ticket, static_cast<ShaderPack&>(resource));
     }
 
     QDir indexDir() const override { return m_dir; }

launcher/minecraft/mod/TexturePackFolderModel.cpp

@@ -36,30 +36,28 @@
 #include "TexturePackFolderModel.h"
 
 #include "minecraft/mod/tasks/LocalTexturePackParseTask.h"
+#include "minecraft/mod/tasks/ResourceFolderLoadTask.h"
 
-TexturePackFolderModel::TexturePackFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent)
+TexturePackFolderModel::TexturePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
-    : ResourceFolderModel(QDir(dir), instance, isIndexed, createDir, parent)
+    : ResourceFolderModel(QDir(dir), instance, is_indexed, create_dir, parent)
 {
-    m_columnNames = QStringList({ "Enable", "Image", "Name", "Last Modified", "Provider", "Size", "File Name" });
+    m_column_names = QStringList({ "Enable", "Image", "Name", "Last Modified", "Provider", "Size" });
-    m_columnNamesTranslated =
+    m_column_names_translated = QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Last Modified"), tr("Provider"), tr("Size") });
-        QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Last Modified"), tr("Provider"), tr("Size"), tr("File Name") });
+    m_column_sort_keys = { SortType::ENABLED, SortType::NAME, SortType::NAME, SortType::DATE, SortType::PROVIDER, SortType::SIZE };
-    m_columnSortKeys = { SortType::Enabled,  SortType::Name, SortType::Name,    SortType::Date,
+    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,
-                         SortType::Provider, SortType::Size, SortType::Filename };
+                              QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
-    m_columnResizeModes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,    QHeaderView::Interactive,
+    m_columnsHideable = { false, true, false, true, true, true };
-                            QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
-    m_columnsHideable = { false, true, false, true, true, true, true };
 }
 
 Task* TexturePackFolderModel::createParseTask(Resource& resource)
 {
-    return new LocalTexturePackParseTask(m_nextResolutionTicket, static_cast<TexturePack&>(resource));
+    return new LocalTexturePackParseTask(m_next_resolution_ticket, static_cast<TexturePack&>(resource));
 }
 
 QVariant TexturePackFolderModel::data(const QModelIndex& index, int role) const
 {
-    if (!validateIndex(index)) {
+    if (!validateIndex(index))
         return {};
-    }
 
     int row = index.row();
     int column = index.column();
@@ -78,8 +76,6 @@ QVariant TexturePackFolderModel::data(const QModelIndex& index, int role) const
                 return QSize(32, 32);
             }
             break;
-        default:
-            break;
     }
 
     // map the columns to the base equivilents
@@ -100,11 +96,6 @@ QVariant TexturePackFolderModel::data(const QModelIndex& index, int role) const
         case SizeColumn:
             mappedIndex = index.siblingAtColumn(ResourceFolderModel::SizeColumn);
             break;
-        case FileNameColumn:
-            mappedIndex = index.siblingAtColumn(ResourceFolderModel::FileNameColumn);
-            break;
-        default:
-            break;
     }
 
     if (mappedIndex.isValid()) {
@@ -125,7 +116,6 @@ QVariant TexturePackFolderModel::headerData(int section, [[maybe_unused]] Qt::Or
                 case ImageColumn:
                 case ProviderColumn:
                 case SizeColumn:
-                case FileNameColumn:
                     return columnNames().at(section);
                 default:
                     return {};
@@ -142,8 +132,6 @@ QVariant TexturePackFolderModel::headerData(int section, [[maybe_unused]] Qt::Or
                     return tr("The source provider of the texture pack.");
                 case SizeColumn:
                     return tr("The size of the texture pack.");
-                case FileNameColumn:
-                    return tr("The file name of the texture pack.");
                 default:
                     return {};
             }
@@ -157,5 +145,5 @@ QVariant TexturePackFolderModel::headerData(int section, [[maybe_unused]] Qt::Or
 
 int TexturePackFolderModel::columnCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : NumColumns;
+    return parent.isValid() ? 0 : NUM_COLUMNS;
 }

launcher/minecraft/mod/TexturePackFolderModel.h

@@ -44,20 +44,11 @@ class TexturePackFolderModel : public ResourceFolderModel {
     Q_OBJECT
 
    public:
-    enum Columns : std::uint8_t {
+    enum Columns { ActiveColumn = 0, ImageColumn, NameColumn, DateColumn, ProviderColumn, SizeColumn, NUM_COLUMNS };
-        ActiveColumn = 0,
-        ImageColumn,
-        NameColumn,
-        DateColumn,
-        ProviderColumn,
-        SizeColumn,
-        FileNameColumn,
-        NumColumns
-    };
 
-    explicit TexturePackFolderModel(const QDir& dir, BaseInstance* instance, bool isIndexed, bool createDir, QObject* parent = nullptr);
+    explicit TexturePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent = nullptr);
 
-    QString id() const override { return "texturepacks"; }
+    virtual QString id() const override { return "texturepacks"; }
 
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
@@ -65,7 +56,7 @@ class TexturePackFolderModel : public ResourceFolderModel {
     int columnCount(const QModelIndex& parent) const override;
 
     [[nodiscard]] Resource* createResource(const QFileInfo& file) override { return new TexturePack(file); }
-    [[nodiscard]] Task* createParseTask(Resource& /*unused*/) override;
+    [[nodiscard]] Task* createParseTask(Resource&) override;
 
     RESOURCE_HELPERS(TexturePack)
 };

launcher/minecraft/mod/tasks/LocalModParseTask.cpp

@@ -751,7 +751,7 @@ bool loadIconFile(const Mod& mod, QPixmap* pixmap)
             if (icon_info.exists() && icon_info.isFile()) {
                 QFile icon(icon_info.filePath());
                 if (!icon.open(QIODevice::ReadOnly)) {
-                    return png_invalid("failed to open file " + icon_info.filePath() + " " + icon.errorString());
+                    return png_invalid("failed  to open file " + icon_info.filePath());
                 }
                 auto data = icon.readAll();
 

launcher/minecraft/mod/tasks/ResourceFolderLoadTask.cpp

@@ -41,28 +41,26 @@
 #include "minecraft/mod/MetadataHandler.h"
 
 #include <QThread>
-#include <utility>
 
-ResourceFolderLoadTask::ResourceFolderLoadTask(const QDir& resourceDir,
+ResourceFolderLoadTask::ResourceFolderLoadTask(const QDir& resource_dir,
-                                               const QDir& indexDir,
+                                               const QDir& index_dir,
-                                               bool isIndexed,
+                                               bool is_indexed,
-                                               bool cleanOrphan,
+                                               bool clean_orphan,
-                                               std::function<Resource*(const QFileInfo&)> createFunction)
+                                               std::function<Resource*(const QFileInfo&)> create_function)
     : Task(false)
-    , m_resource_dir(resourceDir)
+    , m_resource_dir(resource_dir)
-    , m_index_dir(indexDir)
+    , m_index_dir(index_dir)
-    , m_is_indexed(isIndexed)
+    , m_is_indexed(is_indexed)
-    , m_clean_orphan(cleanOrphan)
+    , m_clean_orphan(clean_orphan)
-    , m_create_func(std::move(createFunction))
+    , m_create_func(create_function)
     , m_result(new Result())
     , m_thread_to_spawn_into(thread())
 {}
 
 void ResourceFolderLoadTask::executeTask()
 {
-    if (thread() != m_thread_to_spawn_into) {
+    if (thread() != m_thread_to_spawn_into)
         connect(this, &Task::finished, this->thread(), &QThread::quit);
-    }
 
     if (m_is_indexed) {
         // Read metadata first
@@ -73,7 +71,7 @@ void ResourceFolderLoadTask::executeTask()
     m_resource_dir.refresh();
     for (auto entry : m_resource_dir.entryInfoList()) {
         auto filePath = entry.absoluteFilePath();
-        if (auto* app = APPLICATION_DYN; (app != nullptr) && app->checkQSavePath(filePath)) {
+        if (auto app = APPLICATION_DYN; app && app->checkQSavePath(filePath)) {
             continue;
         }
         auto newFilePath = FS::getUniqueResourceName(filePath);
@@ -85,29 +83,29 @@ void ResourceFolderLoadTask::executeTask()
         Resource* resource = m_create_func(entry);
 
         if (resource->enabled()) {
-            if (m_result->resources.contains(resource->internalId())) {
+            if (m_result->resources.contains(resource->internal_id())) {
-                m_result->resources[resource->internalId()]->setStatus(ResourceStatus::Installed);
+                m_result->resources[resource->internal_id()]->setStatus(ResourceStatus::INSTALLED);
                 // Delete the object we just created, since a valid one is already in the mods list.
                 delete resource;
             } else {
-                m_result->resources[resource->internalId()].reset(resource);
+                m_result->resources[resource->internal_id()].reset(resource);
-                m_result->resources[resource->internalId()]->setStatus(ResourceStatus::NoMetadata);
+                m_result->resources[resource->internal_id()]->setStatus(ResourceStatus::NO_METADATA);
             }
         } else {
-            QString choppedId = resource->internalId().chopped(9);
+            QString chopped_id = resource->internal_id().chopped(9);
-            if (m_result->resources.contains(choppedId)) {
+            if (m_result->resources.contains(chopped_id)) {
-                m_result->resources[resource->internalId()].reset(resource);
+                m_result->resources[resource->internal_id()].reset(resource);
 
-                auto metadata = m_result->resources[choppedId]->metadata();
+                auto metadata = m_result->resources[chopped_id]->metadata();
                 if (metadata) {
                     resource->setMetadata(*metadata);
 
-                    m_result->resources[resource->internalId()]->setStatus(ResourceStatus::Installed);
+                    m_result->resources[resource->internal_id()]->setStatus(ResourceStatus::INSTALLED);
-                    m_result->resources.remove(choppedId);
+                    m_result->resources.remove(chopped_id);
                 }
             } else {
-                m_result->resources[resource->internalId()].reset(resource);
+                m_result->resources[resource->internal_id()].reset(resource);
-                m_result->resources[resource->internalId()]->setStatus(ResourceStatus::NoMetadata);
+                m_result->resources[resource->internal_id()]->setStatus(ResourceStatus::NO_METADATA);
             }
         }
     }
@@ -118,41 +116,38 @@ void ResourceFolderLoadTask::executeTask()
         QMutableMapIterator iter(m_result->resources);
         while (iter.hasNext()) {
             auto resource = iter.next().value();
-            if (resource->status() == ResourceStatus::NotInstalled) {
+            if (resource->status() == ResourceStatus::NOT_INSTALLED) {
                 resource->destroy(m_index_dir, false, false);
                 iter.remove();
             }
         }
     }
 
-    for (const auto& mod : m_result->resources) {
+    for (auto mod : m_result->resources)
         mod->moveToThread(m_thread_to_spawn_into);
-    }
 
-    if (m_aborted) {
+    if (m_aborted)
         emit finished();
-    } else {
+    else
         emitSucceeded();
-    }
 }
 
 void ResourceFolderLoadTask::getFromMetadata()
 {
     m_index_dir.refresh();
-    for (const auto& entry : m_index_dir.entryList(QDir::Files)) {
+    for (auto entry : m_index_dir.entryList(QDir::Files)) {
         if (!entry.endsWith(".pw.toml")) {
             continue;
         }
 
         auto metadata = Metadata::get(m_index_dir, entry);
 
-        if (!metadata.isValid()) {
+        if (!metadata.isValid())
             continue;
-        }
 
         auto* resource = m_create_func(QFileInfo(m_resource_dir.filePath(metadata.filename)));
         resource->setMetadata(metadata);
-        resource->setStatus(ResourceStatus::NotInstalled);
+        resource->setStatus(ResourceStatus::NOT_INSTALLED);
-        m_result->resources[resource->internalId()].reset(resource);
+        m_result->resources[resource->internal_id()].reset(resource);
     }
 }

launcher/minecraft/mod/tasks/ResourceFolderLoadTask.h

@@ -41,7 +41,7 @@
 #include <QObject>
 #include <QRunnable>
 #include <memory>
-#include "minecraft/mod/Resource.h"
+#include "minecraft/mod/Mod.h"
 #include "tasks/Task.h"
 
 class ResourceFolderLoadTask : public Task {
@@ -54,11 +54,11 @@ class ResourceFolderLoadTask : public Task {
     ResultPtr result() const { return m_result; }
 
    public:
-    ResourceFolderLoadTask(const QDir& resourceDir,
+    ResourceFolderLoadTask(const QDir& resource_dir,
-                           const QDir& indexDir,
+                           const QDir& index_dir,
-                           bool isIndexed,
+                           bool is_indexed,
-                           bool cleanOrphan,
+                           bool clean_orphan,
-                           std::function<Resource*(const QFileInfo&)> createFunction);
+                           std::function<Resource*(const QFileInfo&)> create_function);
 
     bool canAbort() const override { return true; }
     bool abort() override
@@ -76,7 +76,7 @@ class ResourceFolderLoadTask : public Task {
     QDir m_resource_dir, m_index_dir;
     bool m_is_indexed;
     bool m_clean_orphan;
-    std::function<Resource*(const QFileInfo&)> m_create_func;
+    std::function<Resource*(QFileInfo const&)> m_create_func;
     ResultPtr m_result;
 
     std::atomic<bool> m_aborted = false;

launcher/minecraft/skins/SkinList.cpp

@@ -121,7 +121,7 @@ bool SkinList::update()
     auto folderContents = m_dir.entryInfoList();
     // if there are any untracked files...
     for (QFileInfo entry : folderContents) {
-        if (!entry.isFile() || entry.suffix() != "png")
+        if (!entry.isFile() && entry.suffix() != "png")
             continue;
 
         SkinModel w(entry.absoluteFilePath());

launcher/modplatform/CheckUpdateTask.h

@@ -15,15 +15,15 @@ class CheckUpdateTask : public Task {
                     std::vector<Version>& mcVersions,
                     QList<ModPlatform::ModLoaderType> loadersList,
                     ResourceFolderModel* resourceModel)
-        : m_resources(resources), m_gameVersions(mcVersions), m_loadersList(std::move(loadersList)), m_resourceModel(resourceModel)
+        : Task(), m_resources(resources), m_gameVersions(mcVersions), m_loadersList(std::move(loadersList)), m_resourceModel(resourceModel)
     {}
 
     struct Update {
         QString name;
-        QString oldHash;
+        QString old_hash;
-        QString oldVersion;
+        QString old_version;
-        QString newVersion;
+        QString new_version;
-        std::optional<ModPlatform::IndexedVersionType> newVersionType;
+        std::optional<ModPlatform::IndexedVersionType> new_version_type;
         QString changelog;
         ModPlatform::ResourceProvider provider;
         shared_qobject_ptr<ResourceDownloadTask> download;
@@ -31,19 +31,19 @@ class CheckUpdateTask : public Task {
 
        public:
         Update(QString name,
-               QString oldH,
+               QString old_h,
-               QString oldV,
+               QString old_v,
-               QString newV,
+               QString new_v,
-               std::optional<ModPlatform::IndexedVersionType> newVType,
+               std::optional<ModPlatform::IndexedVersionType> new_v_type,
                QString changelog,
                ModPlatform::ResourceProvider p,
                shared_qobject_ptr<ResourceDownloadTask> t,
                bool enabled = true)
             : name(std::move(name))
-            , oldHash(std::move(oldH))
+            , old_hash(std::move(old_h))
-            , oldVersion(std::move(oldV))
+            , old_version(std::move(old_v))
-            , newVersion(std::move(newV))
+            , new_version(std::move(new_v))
-            , newVersionType(newVType)
+            , new_version_type(std::move(new_v_type))
             , changelog(std::move(changelog))
             , provider(p)
             , download(std::move(t))
@@ -54,11 +54,14 @@ class CheckUpdateTask : public Task {
     auto getUpdates() -> std::vector<Update>&& { return std::move(m_updates); }
     auto getDependencies() -> QList<std::shared_ptr<GetModDependenciesTask::PackDependency>>&& { return std::move(m_deps); }
 
+   public slots:
+    bool abort() override = 0;
+
    protected slots:
     void executeTask() override = 0;
 
    signals:
-    void checkFailed(Resource* failed, QString reason, QUrl recoverUrl = {});
+    void checkFailed(Resource* failed, QString reason, QUrl recover_url = {});
 
    protected:
     QList<Resource*>& m_resources;

launcher/modplatform/EnsureMetadataTask.cpp

@@ -99,7 +99,7 @@ void EnsureMetadataTask::executeTask()
         }
 
         // They already have the right metadata :o
-        if (resource->status() != ResourceStatus::NoMetadata && resource->metadata() && resource->metadata()->provider == m_provider) {
+        if (resource->status() != ResourceStatus::NO_METADATA && resource->metadata() && resource->metadata()->provider == m_provider) {
             qDebug() << "Resource" << resource->name() << "already has metadata!";
             emitReady(resource);
             continue;
@@ -263,7 +263,7 @@ Task::Ptr EnsureMetadataTask::modrinthVersionsTask()
 Task::Ptr EnsureMetadataTask::modrinthProjectsTask()
 {
     QHash<QString, QString> addonIds;
-    for (const auto& data : m_tempVersions)
+    for (auto const& data : m_tempVersions)
         addonIds.insert(data.addonId.toString(), data.hash);
 
     Task::Ptr proj_task;
@@ -404,7 +404,7 @@ Task::Ptr EnsureMetadataTask::flameVersionsTask()
 Task::Ptr EnsureMetadataTask::flameProjectsTask()
 {
     QHash<QString, QString> addonIds;
-    for (const auto& hash : m_resources.keys()) {
+    for (auto const& hash : m_resources.keys()) {
         if (m_tempVersions.contains(hash)) {
             auto data = m_tempVersions.find(hash).value();
 

launcher/modplatform/ModIndex.h

@@ -32,7 +32,6 @@ class QIODevice;
 namespace ModPlatform {
 
 enum class ModLoaderType : std::uint16_t {
-    None = 0U,
     NeoForge = 1U << 0U,
     Forge = 1U << 1U,
     Cauldron = 1U << 2U,
@@ -125,7 +124,7 @@ struct IndexedVersion {
     bool is_preferred = true;
     QString changelog;
     QList<Dependency> dependencies;
-    Side side = Side::NoSide;  // this is for flame API
+    Side side;  // this is for flame API
 
     // For internal use, not provided by APIs
     bool is_currently_selected = false;
@@ -173,7 +172,7 @@ struct IndexedPack {
     QString logoName;
     QString logoUrl;
     QString websiteUrl;
-    Side side = Side::NoSide;
+    Side side;
 
     bool versionsLoaded = false;
     QList<IndexedVersion> versions;

launcher/modplatform/ResourceAPI.cpp

@@ -2,6 +2,7 @@
 
 #include "Application.h"
 #include "Json.h"
+#include "Version.h"
 #include "net/NetJob.h"
 
 #include "modplatform/ModIndex.h"
@@ -116,8 +117,7 @@ Task::Ptr ResourceAPI::getProjectVersions(VersionSearchArgs&& args, Callback<QVe
             }
 
             auto orderSortPredicate = [](const ModPlatform::IndexedVersion& a, const ModPlatform::IndexedVersion& b) -> bool {
-                // dates are in RFC 3339 format
+                return Version(a.version) > Version(b.version);
-                return a.date > b.date;
             };
             std::sort(unsortedVersions.begin(), unsortedVersions.end(), orderSortPredicate);
         } catch (const JSONValidationError& e) {
@@ -148,9 +148,9 @@ Task::Ptr ResourceAPI::getProjectVersions(VersionSearchArgs&& args, Callback<QVe
     return netJob;
 }
 
-Task::Ptr ResourceAPI::getProjectInfo(ProjectInfoArgs&& args, Callback<ModPlatform::IndexedPack::Ptr>&& callbacks, bool askRetry) const
+Task::Ptr ResourceAPI::getProjectInfo(ProjectInfoArgs&& args, Callback<ModPlatform::IndexedPack::Ptr>&& callbacks) const
 {
-    auto [job, response] = getProject(args.pack->addonId.toString(), askRetry);
+    auto [job, response] = getProject(args.pack->addonId.toString());
 
     QObject::connect(job.get(), &NetJob::succeeded, [this, response, callbacks, args] {
         auto pack = args.pack;
@@ -284,7 +284,7 @@ QString ResourceAPI::mapMCVersionToModrinth(Version v) const
     return verStr;
 }
 
-std::pair<Task::Ptr, QByteArray*> ResourceAPI::getProject(QString addonId, bool askRetry) const
+std::pair<Task::Ptr, QByteArray*> ResourceAPI::getProject(QString addonId) const
 {
     auto project_url_optional = getInfoURL(addonId);
     if (!project_url_optional.has_value())
@@ -293,7 +293,6 @@ std::pair<Task::Ptr, QByteArray*> ResourceAPI::getProject(QString addonId, bool
     auto project_url = project_url_optional.value();
 
     auto netJob = makeShared<NetJob>(QString("%1::GetProject").arg(addonId), APPLICATION->network());
-    netJob->setAskRetry(askRetry);
 
     auto [action, response] = Net::ApiDownload::makeByteArray(QUrl(project_url));
     netJob->addNetAction(action);

launcher/modplatform/ResourceAPI.h

@@ -115,10 +115,10 @@ class ResourceAPI {
    public slots:
     virtual Task::Ptr searchProjects(SearchArgs&&, Callback<QList<ModPlatform::IndexedPack::Ptr>>&&) const;
 
-    virtual std::pair<Task::Ptr, QByteArray*> getProject(QString addonId, bool askRetry = true) const;
+    virtual std::pair<Task::Ptr, QByteArray*> getProject(QString addonId) const;
     virtual std::pair<Task::Ptr, QByteArray*> getProjects(QStringList addonIds) const = 0;
 
-    virtual Task::Ptr getProjectInfo(ProjectInfoArgs&&, Callback<ModPlatform::IndexedPack::Ptr>&&, bool askRetry = true) const;
+    virtual Task::Ptr getProjectInfo(ProjectInfoArgs&&, Callback<ModPlatform::IndexedPack::Ptr>&&) const;
     Task::Ptr getProjectVersions(VersionSearchArgs&& args, Callback<QVector<ModPlatform::IndexedVersion>>&& callbacks) const;
     virtual Task::Ptr getDependencyVersion(DependencySearchArgs&&, Callback<ModPlatform::IndexedVersion>&&) const;
 

launcher/modplatform/atlauncher/ATLPackInstallTask.cpp

@@ -38,7 +38,6 @@
 
 #include <QtConcurrent>
 #include <algorithm>
-#include <utility>
 
 #include "FileSystem.h"
 #include "Json.h"
@@ -60,28 +59,18 @@
 #include "BuildConfig.h"
 #include "ui/dialogs/BlockedModsDialog.h"
 
-namespace {
-bool isPathTraversal(const QString& basePath, const QString& entryName)
-{
-    auto safeName = FS::RemoveInvalidPathChars(entryName);
-    auto fullPath = FS::PathCombine(basePath, safeName);
-    auto baseUrl = QUrl::fromLocalFile(basePath);
-    return !baseUrl.isParentOf(QUrl::fromLocalFile(fullPath));
-}
-
-Meta::Version::Ptr getComponentVersion(const QString& uid, const QString& version)
-{
-    return APPLICATION->metadataIndex()->getLoadedVersion(uid, version);
-}
-}  // namespace
-
 namespace ATLauncher {
 
+static Meta::Version::Ptr getComponentVersion(const QString& uid, const QString& version);
+
 PackInstallTask::PackInstallTask(UserInteractionSupport* support, QString packName, QString version, InstallMode installMode)
-    : m_support(support), m_install_mode(installMode), m_pack_name(packName), m_version_name(std::move(version))
 {
+    m_support = support;
+    m_pack_name = packName;
     static const QRegularExpression s_regex("[^A-Za-z0-9]");
     m_pack_safe_name = packName.replace(s_regex, "");
+    m_version_name = version;
+    m_install_mode = installMode;
 }
 
 bool PackInstallTask::abort()
@@ -118,10 +107,11 @@ void PackInstallTask::onDownloadSucceeded(QByteArray* responsePtr)
     QByteArray response = std::move(*responsePtr);
     jobPtr.reset();
 
-    QJsonParseError parseError{};
+    QJsonParseError parse_error{};
-    QJsonDocument doc = QJsonDocument::fromJson(response, &parseError);
+    QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
-    if (parseError.error != QJsonParseError::NoError) {
+    if (parse_error.error != QJsonParseError::NoError) {
-        qWarning() << "Error while parsing JSON response from ATLauncher at" << parseError.offset << "reason:" << parseError.errorString();
+        qWarning() << "Error while parsing JSON response from ATLauncher at" << parse_error.offset
+                   << "reason:" << parse_error.errorString();
         qWarning() << response;
         return;
     }
@@ -138,7 +128,7 @@ void PackInstallTask::onDownloadSucceeded(QByteArray* responsePtr)
 
     // Derived from the installation mode
     QString message;
-    bool resetDirectory = false;
+    bool resetDirectory;
 
     switch (m_install_mode) {
         case InstallMode::Reinstall:
@@ -158,9 +148,8 @@ void PackInstallTask::onDownloadSucceeded(QByteArray* responsePtr)
     }
 
     // Display message if one exists
-    if (!message.isEmpty()) {
+    if (!message.isEmpty())
         m_support->displayMessage(message);
-    }
 
     auto ver = getComponentVersion("net.minecraft", m_version.minecraft);
     if (!ver) {
@@ -184,7 +173,7 @@ void PackInstallTask::onDownloadFailed(QString reason)
 {
     qDebug() << "PackInstallTask::onDownloadFailed:" << QThread::currentThreadId();
     jobPtr.reset();
-    emitFailed(std::move(reason));
+    emitFailed(reason);
 }
 
 void PackInstallTask::onDownloadAborted()
@@ -213,30 +202,26 @@ void PackInstallTask::deleteExistingFiles()
     keeps.files.append(VersionKeep{ "root", "servers.dat" });
 
     // Merge with version deletes and keeps
-    for (const auto& item : m_version.deletes.files) {
+    for (const auto& item : m_version.deletes.files)
         deletes.files.append(item);
-    }
+    for (const auto& item : m_version.deletes.folders)
-    for (const auto& item : m_version.deletes.folders) {
         deletes.folders.append(item);
-    }
+    for (const auto& item : m_version.keeps.files)
-    for (const auto& item : m_version.keeps.files) {
         keeps.files.append(item);
-    }
+    for (const auto& item : m_version.keeps.folders)
-    for (const auto& item : m_version.keeps.folders) {
         keeps.folders.append(item);
-    }
 
     auto getPathForBase = [this](const QString& base) {
         auto minecraftPath = FS::PathCombine(m_stagingPath, "minecraft");
 
         if (base == "root") {
             return minecraftPath;
-        }
+        } else if (base == "config") {
-        if (base == "config") {
             return FS::PathCombine(minecraftPath, "config");
+        } else {
+            qWarning() << "Unrecognised base path" << base;
+            return minecraftPath;
         }
-        qWarning() << "Unrecognised base path" << base;
-        return minecraftPath;
     };
 
     auto convertToSystemPath = [](const QString& path) {
@@ -246,22 +231,24 @@ void PackInstallTask::deleteExistingFiles()
     };
 
     auto shouldKeep = [keeps, getPathForBase, convertToSystemPath](const QString& fullPath) {
-        if (std::ranges::any_of(keeps.files, [&fullPath, &getPathForBase, &convertToSystemPath](const auto& item) {
+        for (const auto& item : keeps.files) {
-                auto basePath = getPathForBase(item.base);
+            auto basePath = getPathForBase(item.base);
-                auto targetPath = convertToSystemPath(item.target);
+            auto targetPath = convertToSystemPath(item.target);
-                auto path = FS::PathCombine(basePath, targetPath);
+            auto path = FS::PathCombine(basePath, targetPath);
-                return fullPath == path;
+
-            })) {
+            if (fullPath == path) {
-            return true;
+                return true;
+            }
         }
 
-        if (std::ranges::any_of(keeps.folders, [&fullPath, &getPathForBase, &convertToSystemPath](const auto& item) {
+        for (const auto& item : keeps.folders) {
-                auto basePath = getPathForBase(item.base);
+            auto basePath = getPathForBase(item.base);
-                auto targetPath = convertToSystemPath(item.target);
+            auto targetPath = convertToSystemPath(item.target);
-                auto path = FS::PathCombine(basePath, targetPath);
+            auto path = FS::PathCombine(basePath, targetPath);
-                return fullPath.startsWith(path);
+
-            })) {
+            if (fullPath.startsWith(path)) {
-            return true;
+                return true;
+            }
         }
 
         return false;
@@ -275,9 +262,8 @@ void PackInstallTask::deleteExistingFiles()
         auto targetPath = convertToSystemPath(item.target);
         auto fullPath = FS::PathCombine(basePath, targetPath);
 
-        if (shouldKeep(fullPath)) {
+        if (shouldKeep(fullPath))
             continue;
-        }
 
         filesToDelete.insert(fullPath);
     }
@@ -291,9 +277,8 @@ void PackInstallTask::deleteExistingFiles()
         while (it.hasNext()) {
             auto path = it.next();
 
-            if (shouldKeep(path)) {
+            if (shouldKeep(path))
                 continue;
-            }
 
             filesToDelete.insert(path);
         }
@@ -305,7 +290,7 @@ void PackInstallTask::deleteExistingFiles()
     }
 }
 
-QString PackInstallTask::getDirForModType(ModType type, const QString& raw)
+QString PackInstallTask::getDirForModType(ModType type, QString raw)
 {
     switch (type) {
         // Mod types that can either be ignored at this stage, or ignored
@@ -353,7 +338,7 @@ QString PackInstallTask::getDirForModType(ModType type, const QString& raw)
     return Q_NULLPTR;
 }
 
-QString PackInstallTask::getVersionForLoader(const QString& uid)
+QString PackInstallTask::getVersionForLoader(QString uid)
 {
     if (m_version.loader.recommended || m_version.loader.latest || m_version.loader.choose) {
         auto vlist = APPLICATION->metadataIndex()->get(uid);
@@ -374,19 +359,16 @@ QString PackInstallTask::getVersionForLoader(const QString& uid)
                 // filtering for those loaders.
                 if (m_version.loader.type != "fabric") {
                     auto iter = std::find_if(reqs.begin(), reqs.end(), [](const Meta::Require& req) { return req.uid == "net.minecraft"; });
-                    if (iter == reqs.end()) {
+                    if (iter == reqs.end())
                         continue;
-                    }
+                    if (iter->equalsVersion != m_version.minecraft)
-                    if (iter->equalsVersion != m_version.minecraft) {
                         continue;
-                    }
                 }
 
                 if (m_version.loader.recommended) {
                     // first recommended build we find, we use.
-                    if (!version->isRecommended()) {
+                    if (!version->isRecommended())
                         continue;
-                    }
                 }
 
                 return version->descriptor();
@@ -394,8 +376,7 @@ QString PackInstallTask::getVersionForLoader(const QString& uid)
 
             emitFailed(tr("Failed to find version for %1 loader").arg(m_version.loader.type));
             return Q_NULLPTR;
-        }
+        } else if (m_version.loader.choose) {
-        if (m_version.loader.choose) {
             // Fabric Loader doesn't depend on a given Minecraft version.
             if (m_version.loader.type == "fabric") {
                 return m_support->chooseVersion(vlist, Q_NULLPTR);
@@ -439,8 +420,7 @@ QString PackInstallTask::detectLibrary(const VersionLibrary& library)
 
         if (name == QString("guava")) {
             return "com.google.guava:guava:" + version;
-        }
+        } else if (name == QString("commons-lang3")) {
-        if (name == QString("commons-lang3")) {
             return "org.apache.commons:commons-lang3:" + version;
         }
     }
@@ -448,7 +428,7 @@ QString PackInstallTask::detectLibrary(const VersionLibrary& library)
     return "org.multimc.atlauncher:" + library.md5 + ":1";
 }
 
-bool PackInstallTask::createLibrariesComponent(const QString& instanceRoot, PackProfile* profile)
+bool PackInstallTask::createLibrariesComponent(QString instanceRoot, PackProfile* profile)
 {
     if (m_version.libraries.isEmpty()) {
         return true;
@@ -473,18 +453,18 @@ bool PackInstallTask::createLibrariesComponent(const QString& instanceRoot, Pack
     }
 
     auto id = QUuid::createUuid().toString(QUuid::WithoutBraces);
-    auto targetId = "org.multimc.atlauncher." + id;
+    auto target_id = "org.multimc.atlauncher." + id;
 
     auto patchDir = FS::PathCombine(instanceRoot, "patches");
     if (!FS::ensureFolderPathExists(patchDir)) {
         return false;
     }
-    auto patchFileName = FS::PathCombine(patchDir, targetId + ".json");
+    auto patchFileName = FS::PathCombine(patchDir, target_id + ".json");
 
     auto f = std::make_shared<VersionFile>();
     f->name = m_pack_name + " " + m_version_name + " (libraries)";
 
-    const static QMap<QString, QString> s_liteLoaderMap = {
+    const static QMap<QString, QString> liteLoaderMap = {
         { "61179803bcd5fb7790789b790908663d", "1.12-SNAPSHOT" },   { "1420785ecbfed5aff4a586c5c9dd97eb", "1.12.2-SNAPSHOT" },
         { "073f68e2fcb518b91fd0d99462441714", "1.6.2_03" },        { "10a15b52fc59b1bfb9c05b56de1097d6", "1.6.2_02" },
         { "b52f90f08303edd3d4c374e268a5acf1", "1.6.2_04" },        { "ea747e24e03e24b7cad5bc8a246e0319", "1.6.2_01" },
@@ -504,8 +484,8 @@ bool PackInstallTask::createLibrariesComponent(const QString& instanceRoot, Pack
 
     for (const auto& lib : m_version.libraries) {
         // If the library is LiteLoader, we need to ignore it and handle it separately.
-        if (s_liteLoaderMap.contains(lib.md5)) {
+        if (liteLoaderMap.contains(lib.md5)) {
-            auto ver = getComponentVersion("com.mumfrey.liteloader", s_liteLoaderMap.value(lib.md5));
+            auto ver = getComponentVersion("com.mumfrey.liteloader", liteLoaderMap.value(lib.md5));
             if (ver) {
                 componentsToInstall.insert("com.mumfrey.liteloader", ver);
                 continue;
@@ -522,9 +502,8 @@ bool PackInstallTask::createLibrariesComponent(const QString& instanceRoot, Pack
                 libExempt = Version(libSpecifier.version()) >= Version(existingLib.version());
             }
         }
-        if (libExempt) {
+        if (libExempt)
             continue;
-        }
 
         auto library = std::make_shared<Library>();
         library->setRawName(libName);
@@ -557,11 +536,11 @@ bool PackInstallTask::createLibrariesComponent(const QString& instanceRoot, Pack
     file.write(OneSixVersionFormat::versionFileToJson(f).toJson());
     file.close();
 
-    profile->appendComponent(ComponentPtr{ new Component(profile, targetId, f) });
+    profile->appendComponent(ComponentPtr{ new Component(profile, target_id, f) });
     return true;
 }
 
-bool PackInstallTask::createPackComponent(const QString& instanceRoot, PackProfile* profile)
+bool PackInstallTask::createPackComponent(QString instanceRoot, PackProfile* profile)
 {
     if (m_version.mainClass.mainClass.isEmpty() && m_version.extraArguments.arguments.isEmpty()) {
         return true;
@@ -592,13 +571,13 @@ bool PackInstallTask::createPackComponent(const QString& instanceRoot, PackProfi
     }
 
     auto id = QUuid::createUuid().toString(QUuid::WithoutBraces);
-    auto targetId = "org.multimc.atlauncher." + id;
+    auto target_id = "org.multimc.atlauncher." + id;
 
     auto patchDir = FS::PathCombine(instanceRoot, "patches");
     if (!FS::ensureFolderPathExists(patchDir)) {
         return false;
     }
-    auto patchFileName = FS::PathCombine(patchDir, targetId + ".json");
+    auto patchFileName = FS::PathCombine(patchDir, target_id + ".json");
 
     QStringList mainClasses;
     QStringList tweakers;
@@ -625,9 +604,8 @@ bool PackInstallTask::createPackComponent(const QString& instanceRoot, PackProfi
     for (auto arg : args) {
         if (arg.startsWith("--tweakClass=") || previous == "--tweakClass") {
             auto tweakClass = arg.remove("--tweakClass=");
-            if (tweakers.contains(tweakClass)) {
+            if (tweakers.contains(tweakClass))
                 continue;
-            }
 
             f->addTweakers.append(tweakClass);
         }
@@ -640,13 +618,13 @@ bool PackInstallTask::createPackComponent(const QString& instanceRoot, PackProfi
 
     QFile file(patchFileName);
     if (!file.open(QFile::WriteOnly)) {
-        qCritical() << "Error opening" << file.fileName() << "for writing:" << file.errorString();
+        qCritical() << "Error opening" << file.fileName() << "for reading:" << file.errorString();
         return false;
     }
     file.write(OneSixVersionFormat::versionFileToJson(f).toJson());
     file.close();
 
-    profile->appendComponent(ComponentPtr{ new Component(profile, targetId, f) });
+    profile->appendComponent(ComponentPtr{ new Component(profile, target_id, f) });
     return true;
 }
 
@@ -676,7 +654,7 @@ void PackInstallTask::installConfigs()
     connect(jobPtr.get(), &NetJob::failed, [this](QString reason) {
         abortable = false;
         jobPtr.reset();
-        emitFailed(std::move(reason));
+        emitFailed(reason);
     });
     connect(jobPtr.get(), &NetJob::progress, [this](qint64 current, qint64 total) {
         abortable = true;
@@ -733,17 +711,15 @@ void PackInstallTask::downloadMods()
     jarmods.clear();
     jobPtr.reset(new NetJob(tr("Mod download"), APPLICATION->network()));
 
-    QList<VersionMod> blockedMods;
+    QList<VersionMod> blocked_mods;
     for (const auto& mod : m_version.mods) {
         // skip non-client mods
-        if (!mod.client) {
+        if (!mod.client)
             continue;
-        }
 
         // skip optional mods that were not selected
-        if (mod.optional && !selectedMods.contains(mod.name)) {
+        if (mod.optional && !selectedMods.contains(mod.name))
             continue;
-        }
 
         QString url;
         switch (mod.download) {
@@ -751,7 +727,7 @@ void PackInstallTask::downloadMods()
                 url = BuildConfig.ATL_DOWNLOAD_SERVER_URL + mod.url;
                 break;
             case DownloadType::Browser: {
-                blockedMods.append(mod);
+                blocked_mods.append(mod);
                 continue;
             }
             case DownloadType::Direct:
@@ -787,9 +763,8 @@ void PackInstallTask::downloadMods()
             jobPtr->addNetAction(dl);
         } else {
             auto relpath = getDirForModType(mod.type, mod.type_raw);
-            if (relpath == Q_NULLPTR) {
+            if (relpath == Q_NULLPTR)
                 continue;
-            }
 
             auto entry = APPLICATION->metacache()->resolveEntry("ATLauncherPacks", cacheName);
             entry->setStale(true);
@@ -823,51 +798,49 @@ void PackInstallTask::downloadMods()
             modsToCopy[entry->getFullPath()] = path;
         }
     }
-    if (!blockedMods.isEmpty()) {
+    if (!blocked_mods.isEmpty()) {
         QList<BlockedMod> mods;
 
-        for (const auto& mod : blockedMods) {
+        for (auto mod : blocked_mods) {
-            BlockedMod blockedMod;
+            BlockedMod blocked_mod;
-            blockedMod.name = mod.file;
+            blocked_mod.name = mod.file;
-            blockedMod.websiteUrl = mod.url;
+            blocked_mod.websiteUrl = mod.url;
-            blockedMod.hash = mod.md5;
+            blocked_mod.hash = mod.md5;
-            blockedMod.matched = false;
+            blocked_mod.matched = false;
-            blockedMod.localPath = "";
+            blocked_mod.localPath = "";
 
-            mods.append(blockedMod);
+            mods.append(blocked_mod);
         }
 
         qWarning() << "Blocked mods found, displaying mod list";
 
-        BlockedModsDialog messageDialog(nullptr, tr("Blocked mods found"),
+        BlockedModsDialog message_dialog(nullptr, tr("Blocked mods found"),
-                                        tr("The following files are not available for download in third party launchers.<br/>"
+                                         tr("The following files are not available for download in third party launchers.<br/>"
-                                           "You will need to manually download them and add them to the instance."),
+                                            "You will need to manually download them and add them to the instance."),
-                                        mods, "md5");
+                                         mods, "md5");
 
-        messageDialog.setModal(true);
+        message_dialog.setModal(true);
 
-        if (messageDialog.exec() != 0) {
+        if (message_dialog.exec()) {
             qDebug() << "Post dialog blocked mods list:" << mods;
-            for (const auto& blocked : mods) {
+            for (auto blocked : mods) {
                 if (!blocked.matched) {
                     qDebug() << blocked.name << "was not matched to a local file, skipping copy";
                     continue;
                 }
-                auto modIter =
+                auto modIter = std::find_if(blocked_mods.begin(), blocked_mods.end(),
-                    std::ranges::find_if(blockedMods, [blocked](const VersionMod& mod) { return mod.url == blocked.websiteUrl; });
+                                            [blocked](const VersionMod& mod) { return mod.url == blocked.websiteUrl; });
-                if (modIter == blockedMods.end()) {
+                if (modIter == blocked_mods.end())
                     continue;
-                }
+                auto mod = *modIter;
-                const auto& mod = *modIter;
                 if (mod.type == ModType::Extract || mod.type == ModType::TexturePackExtract || mod.type == ModType::ResourcePackExtract) {
                     modsToExtract.insert(blocked.localPath, mod);
                 } else if (mod.type == ModType::Decomp) {
                     modsToDecomp.insert(blocked.localPath, mod);
                 } else {
                     auto relpath = getDirForModType(mod.type, mod.type_raw);
-                    if (relpath == Q_NULLPTR) {
+                    if (relpath == Q_NULLPTR)
                         continue;
-                    }
 
                     auto path = FS::PathCombine(m_stagingPath, "minecraft", relpath, mod.file);
 
@@ -945,8 +918,8 @@ bool PackInstallTask::extractMods(const QMap<QString, VersionMod>& toExtract,
 
     setStatus(tr("Extracting mods..."));
     for (auto iter = toExtract.begin(); iter != toExtract.end(); iter++) {
-        const auto& modPath = iter.key();
+        auto& modPath = iter.key();
-        const auto& mod = iter.value();
+        auto& mod = iter.value();
 
         QString extractToDir;
         if (mod.type == ModType::Extract) {
@@ -965,10 +938,6 @@ bool PackInstallTask::extractMods(const QMap<QString, VersionMod>& toExtract,
             folderToExtract = mod.extractFolder;
             static const QRegularExpression s_regex("^/");
             folderToExtract.remove(s_regex);
-            if (isPathTraversal(extractToPath, folderToExtract)) {
-                qWarning() << "Blocked path traversal in" << mod.extractFolder;
-                return false;
-            }
         }
 
         qDebug() << "Extracting " + mod.file + " to " + extractToDir;
@@ -979,18 +948,13 @@ bool PackInstallTask::extractMods(const QMap<QString, VersionMod>& toExtract,
     }
 
     for (auto iter = toDecomp.begin(); iter != toDecomp.end(); iter++) {
-        const auto& modPath = iter.key();
+        auto& modPath = iter.key();
-        const auto& mod = iter.value();
+        auto& mod = iter.value();
         auto extractToDir = getDirForModType(mod.decompType, mod.decompType_raw);
 
         QDir extractDir(m_stagingPath);
         auto extractToPath = FS::PathCombine(extractDir.absolutePath(), "minecraft", extractToDir, mod.decompFile);
 
-        if (isPathTraversal(extractToPath, mod.decompFile)) {
-            qWarning() << "Blocked path traversal in decompFile" << mod.decompFile;
-            return false;
-        }
-
         qDebug() << "Extracting " + mod.decompFile + " to " + extractToDir;
         if (!MMCZip::extractFile(modPath, mod.decompFile, extractToPath)) {
             qWarning() << "Failed to extract" << mod.decompFile;
@@ -999,8 +963,8 @@ bool PackInstallTask::extractMods(const QMap<QString, VersionMod>& toExtract,
     }
 
     for (auto iter = toCopy.begin(); iter != toCopy.end(); iter++) {
-        const auto& from = iter.key();
+        auto& from = iter.key();
-        const auto& to = iter.value();
+        auto& to = iter.value();
 
         // If the file already exists, assume the mod is the correct copy - and remove
         // the copy from the Configs.zip
@@ -1030,7 +994,7 @@ void PackInstallTask::install()
     MinecraftInstance instance(m_globalSettings, std::make_unique<INISettingsObject>(instanceConfigPath), m_stagingPath);
     {
         SettingsObject::Lock lock(instance.settings());
-        auto* components = instance.getPackProfile();
+        auto components = instance.getPackProfile();
         components->buildingFromScratch();
 
         // Use a component to add libraries BEFORE Minecraft
@@ -1045,23 +1009,20 @@ void PackInstallTask::install()
         // Loader
         if (m_version.loader.type == QString("forge")) {
             auto version = getVersionForLoader("net.minecraftforge");
-            if (version == Q_NULLPTR) {
+            if (version == Q_NULLPTR)
                 return;
-            }
 
             components->setComponentVersion("net.minecraftforge", version);
         } else if (m_version.loader.type == QString("neoforge")) {
             auto version = getVersionForLoader("net.neoforged");
-            if (version == Q_NULLPTR) {
+            if (version == Q_NULLPTR)
                 return;
-            }
 
             components->setComponentVersion("net.neoforged", version);
         } else if (m_version.loader.type == QString("fabric")) {
             auto version = getVersionForLoader("net.fabricmc.fabric-loader");
-            if (version == Q_NULLPTR) {
+            if (version == Q_NULLPTR)
                 return;
-            }
 
             components->setComponentVersion("net.fabricmc.fabric-loader", version);
         } else if (m_version.loader.type != QString()) {
@@ -1094,4 +1055,9 @@ void PackInstallTask::install()
     emitSucceeded();
 }
 
+static Meta::Version::Ptr getComponentVersion(const QString& uid, const QString& version)
+{
+    return APPLICATION->metadataIndex()->getLoadedVersion(uid, version);
+}
+
 }  // namespace ATLauncher

launcher/modplatform/atlauncher/ATLPackInstallTask.h

@@ -44,13 +44,14 @@
 #include "minecraft/MinecraftInstance.h"
 #include "minecraft/PackProfile.h"
 #include "net/NetJob.h"
+#include "settings/INISettingsObject.h"
 
-#include <cstdint>
+#include <memory>
 #include <optional>
 
 namespace ATLauncher {
 
-enum class InstallMode : std::uint8_t {
+enum class InstallMode {
     Install,
     Reinstall,
     Update,
@@ -85,13 +86,13 @@ class PackInstallTask : public InstanceTask {
                              QString packName,
                              QString version,
                              InstallMode installMode = InstallMode::Install);
-    ~PackInstallTask() override { delete m_support; }
+    virtual ~PackInstallTask() { delete m_support; }
 
     bool canAbort() const override { return true; }
     bool abort() override;
 
    protected:
-    void executeTask() override;
+    virtual void executeTask() override;
 
    private slots:
     void onDownloadSucceeded(QByteArray* responsePtr);
@@ -102,12 +103,12 @@ class PackInstallTask : public InstanceTask {
     void onModsExtracted();
 
    private:
-    QString getDirForModType(ModType type, const QString& raw);
+    QString getDirForModType(ModType type, QString raw);
-    QString getVersionForLoader(const QString& uid);
+    QString getVersionForLoader(QString uid);
-    static QString detectLibrary(const VersionLibrary& library);
+    QString detectLibrary(const VersionLibrary& library);
 
-    bool createLibrariesComponent(const QString& instanceRoot, PackProfile* profile);
+    bool createLibrariesComponent(QString instanceRoot, PackProfile* profile);
-    bool createPackComponent(const QString& instanceRoot, PackProfile* profile);
+    bool createPackComponent(QString instanceRoot, PackProfile* profile);
 
     void deleteExistingFiles();
     void installConfigs();

launcher/modplatform/flame/FlameAPI.h

@@ -79,7 +79,6 @@ class FlameAPI : public ResourceAPI {
             case ModPlatform::LegacyFabric:
             case ModPlatform::Ornithe:
             case ModPlatform::Rift:
-            case ModPlatform::None:
                 break;  // not supported
         }
         return 0;