Merge branch 'develop' of https://github.com/PrismLauncher/PrismLauncher into develop

.envrc

@@ -0,0 +1 @@
+use flake

.github/workflows/build.yml

@@ -15,6 +15,12 @@ on:
       SPARKLE_ED25519_KEY:
         description: Private key for signing Sparkle updates
         required: false
+      WINDOWS_CODESIGN_CERT:
+        description: Certificate for signing Windows builds
+        required: false
+      WINDOWS_CODESIGN_PASSWORD:
+        description: Password for signing Windows builds
+        required: false
       CACHIX_AUTH_TOKEN:
         description: Private token for authenticating against Cachix cache
         required: false
@@ -40,6 +46,7 @@ jobs:
           - os: windows-2022
             name: "Windows-MinGW-w64"
             msystem: clang64
+            vcvars_arch: 'amd64_x86'
 
           - os: windows-2022
             name: "Windows-MSVC-Legacy"
@@ -61,7 +68,7 @@ jobs:
             qt_ver: 6
             qt_host: windows
             qt_arch: ''
-            qt_version: '6.4.2'
+            qt_version: '6.5.1'
             qt_modules: 'qt5compat qtimageformats'
             qt_tools: ''
 
@@ -73,7 +80,7 @@ jobs:
             qt_ver: 6
             qt_host: windows
             qt_arch: 'win64_msvc2019_arm64'
-            qt_version: '6.4.2'
+            qt_version: '6.5.1'
             qt_modules: 'qt5compat qtimageformats'
             qt_tools: ''
 
@@ -83,7 +90,7 @@ jobs:
             qt_ver: 6
             qt_host: mac
             qt_arch: ''
-            qt_version: '6.3.0'
+            qt_version: '6.5.1'
             qt_modules: 'qt5compat qtimageformats'
             qt_tools: ''
 
@@ -145,13 +152,13 @@ jobs:
 
       - name: Setup ccache
         if: (runner.os != 'Windows' || matrix.msystem == '') && inputs.build_type == 'Debug'
-        uses: hendrikmuhs/ccache-action@v1.2.8
+        uses: hendrikmuhs/ccache-action@v1.2.9
         with:
           key: ${{ matrix.os }}-qt${{ matrix.qt_ver }}-${{ matrix.architecture }}
 
       - name: Retrieve ccache cache (Windows MinGW-w64)
         if: runner.os == 'Windows' && matrix.msystem != '' && inputs.build_type == 'Debug'
-        uses: actions/cache@v3.2.4
+        uses: actions/cache@v3.3.1
         with:
           path: '${{ github.workspace }}\.ccache'
           key: ${{ matrix.os }}-mingw-w64-ccache-${{ github.run_id }}
@@ -201,6 +208,8 @@ jobs:
         if: runner.os == 'Windows' && matrix.architecture == 'arm64'
         uses: jurplel/install-qt-action@v3
         with:
+           aqtversion: '==3.1.*'
+           py7zrversion: '>=0.20.2'
            version: ${{ matrix.qt_version }}
            host: 'windows'
            target: 'desktop'
@@ -216,6 +225,8 @@ jobs:
         if: runner.os == 'Linux' && matrix.qt_ver == 6 || runner.os == 'macOS' || (runner.os == 'Windows' && matrix.msystem == '')
         uses: jurplel/install-qt-action@v3
         with:
+           aqtversion: '==3.1.*'
+           py7zrversion: '>=0.20.2'
            version: ${{ matrix.qt_version }}
            host: ${{ matrix.qt_host }}
            target: 'desktop'
@@ -225,7 +236,7 @@ jobs:
            cache: ${{ inputs.is_qt_cached }}
 
       - name: Install MSVC (Windows MSVC)
-        if: runner.os == 'Windows' && matrix.msystem == ''
+        if: runner.os == 'Windows'  # We want this for MinGW builds as well, as we need SignTool
         uses: ilammy/msvc-dev-cmd@v1
         with:
           vsversion: 2022
@@ -376,6 +387,23 @@ jobs:
             Copy-Item D:/a/PollyMC/Qt/Tools/OpenSSL/Win_x86/bin/libssl-1_1.dll -Destination libssl-1_1.dll
           }
 
+      - name: Fetch codesign certificate (Windows)
+        if: runner.os == 'Windows'
+        shell: bash  # yes, we are not using MSYS2 or PowerShell here
+        run: |
+          echo '${{ secrets.WINDOWS_CODESIGN_CERT }}' | base64 --decode > codesign.pfx
+
+      - name: Sign executable (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          if (Get-Content ./codesign.pfx){
+            cd ${{ env.INSTALL_DIR }}
+            # We ship the exact same executable for portable and non-portable editions, so signing just once is fine
+            SignTool sign /fd sha256 /td sha256 /f ../codesign.pfx /p '${{ secrets.WINDOWS_CODESIGN_PASSWORD }}' /tr http://timestamp.digicert.com pollymc.exe pollymc_filelink.exe
+          } else {
+            ":warning: Skipped code signing for Windows, as certificate was not present." >> $env:GITHUB_STEP_SUMMARY
+          }
+
       - name: Package (Windows MinGW-w64, portable)
         if: runner.os == 'Windows' && matrix.msystem != ''
         shell: msys2 {0}
@@ -395,6 +423,15 @@ jobs:
           cd ${{ env.INSTALL_DIR }}
           makensis -NOCD "${{ github.workspace }}/${{ env.BUILD_DIR }}/program_info/win_install.nsi"
 
+      - name: Sign installer (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          if (Get-Content ./codesign.pfx){
+            SignTool sign /fd sha256 /td sha256 /f codesign.pfx /p '${{ secrets.WINDOWS_CODESIGN_PASSWORD }}' /tr http://timestamp.digicert.com PollyMC-Setup.exe
+          } else {
+            ":warning: Skipped code signing for Windows, as certificate was not present." >> $env:GITHUB_STEP_SUMMARY
+          }
+
       - name: Package (Linux)
         if: runner.os == 'Linux'
         run: |

.github/workflows/trigger_builds.yml

@@ -29,4 +29,6 @@ jobs:
       is_qt_cached: true
     secrets:
       SPARKLE_ED25519_KEY: ${{ secrets.SPARKLE_ED25519_KEY }}
+      WINDOWS_CODESIGN_CERT: ${{ secrets.WINDOWS_CODESIGN_CERT }}
+      WINDOWS_CODESIGN_PASSWORD: ${{ secrets.WINDOWS_CODESIGN_PASSWORD }}
       CACHIX_AUTH_TOKEN: ${{ secrets.CACHIX_AUTH_TOKEN }}

.github/workflows/trigger_release.yml

@@ -15,6 +15,9 @@ jobs:
       is_qt_cached: false
     secrets:
       SPARKLE_ED25519_KEY: ${{ secrets.SPARKLE_ED25519_KEY }}
+      WINDOWS_CODESIGN_CERT: ${{ secrets.WINDOWS_CODESIGN_CERT }}
+      WINDOWS_CODESIGN_PASSWORD: ${{ secrets.WINDOWS_CODESIGN_PASSWORD }}
+      CACHIX_AUTH_TOKEN: ${{ secrets.CACHIX_AUTH_TOKEN }}
 
   create_release:
     needs: build_release

.github/workflows/winget.yml

@@ -7,7 +7,7 @@ jobs:
   publish:
     runs-on: windows-latest
     steps:
-      - uses: vedantmgoyal2009/winget-releaser@v1
+      - uses: vedantmgoyal2009/winget-releaser@v2
         with:
           identifier: PrismLauncher.PrismLauncher
           version: ${{ github.event.release.tag_name }}

.gitignore

@@ -12,10 +12,14 @@ html/
 *.pro.user
 CMakeLists.txt.user
 CMakeLists.txt.user.*
+CMakeSettings.json
+/CMakeFiles
+CMakeCache.txt
 /.project
 /.settings
 /.idea
 /.vscode
+/.vs
 cmake-build-*/
 Debug
 
@@ -43,7 +47,9 @@ run/
 .cache/
 
 # Nix/NixOS
-result/
+.direnv/
+.pre-commit-config.yaml
+result
 
 # Flatpak
 .flatpak-builder

BUILD.md

@@ -1,53 +1,3 @@
 # Build Instructions
 
-Full build instructions will be available on [the website](https://prismlauncher.org/wiki/development/build-instructions/).
+Full build instructions are available on [the website](https://prismlauncher.org/wiki/development/build-instructions/).
-
-If you would like to contribute or fix an issue with the Build instructions you will be able to do so [here](https://github.com/PrismLauncher/website/blob/master/src/wiki/development/build-instructions.md).
-
-## Getting the source
-
-Clone the source code using git, and grab all the submodules. This is generic for all platforms you want to build on.
-```
-git clone --recursive https://github.com/PrismLauncher/PrismLauncher
-cd PrismLauncher
-```
-
-## Linux
-
-This guide will mostly mention dependant packages by their Debian naming and commands are done by a user in the sudoers file.
-### Dependencies
-
-- A C++ compiler capable of building C++17 code (can be found in the package `build-essential`).
-- Qt Development tools 5.12 or newer (on Debian 11 or Debian-based distributions, `qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools libqt5core5a libqt5network5 libqt5gui5`).
-- `cmake` 3.15 or newer.
-- `extra-cmake-modules`.
-- zlib (`zlib1g-dev` on Debian 11 or Debian-based distributions).
-- Java Development Kit (Java JDK) (`openjdk-17-jdk` on Debian 11 or Debian-based distributions).
-- Mesa GL headers (`libgl1-mesa-dev` on Debian 11 or Debian-based distributions).
-- (Optional) `scdoc` to generate man pages.
-
-In conclusion, to check if all you need is installed (including optional):
-
-```
-sudo apt install build-essential qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools libqt5core5a libqt5network5 libqt5gui5 cmake extra-cmake-modules zlib1g-dev openjdk-17-jdk libgl1-mesa-dev scdoc
-```
-
-### Compiling
-#### Building and installing on the system
-This is usually the suggested way to build the client.
-
-```
-cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="/usr" -DENABLE_LTO=ON
-cmake --build build -j$(nproc)
-sudo cmake --install build
-```
-
-#### Building a portable binary
-
-```
-cmake -S . -B build -DCMAKE_INSTALL_PREFIX=install
-cmake --build build -j$(nproc)
-cmake --install build
-cmake --install build --component portable
-```
-

CMakeLists.txt

@@ -174,7 +174,7 @@ set(Launcher_SUBREDDIT_URL "" CACHE STRING "URL for the subreddit.")
 
 # Builds
 set(Launcher_FORCE_BUNDLED_LIBS OFF CACHE BOOL "Prevent using system libraries, if they are available as submodules")
-set(Launcher_QT_VERSION_MAJOR "5" CACHE STRING "Major Qt version to build against")
+set(Launcher_QT_VERSION_MAJOR "6" CACHE STRING "Major Qt version to build against")
 
 # API Keys
 # NOTE: These API keys are here for convenience. If you rebrand this software or intend to break the terms of service
@@ -345,6 +345,8 @@ elseif(UNIX)
     install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${Launcher_SVG} DESTINATION "${KDE_INSTALL_ICONDIR}/hicolor/scalable/apps")
     install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${Launcher_mrpack_MIMEInfo} DESTINATION ${KDE_INSTALL_MIMEDIR})
 
+    install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/launcher/qtlogging.ini" DESTINATION "${KDE_INSTALL_DATADIR}/${Launcher_Name}")
+    
     if(Launcher_ManPage)
         install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${Launcher_ManPage} DESTINATION "${KDE_INSTALL_MANDIR}/man6")
     endif()
@@ -372,6 +374,8 @@ else()
     message(FATAL_ERROR "Platform not supported")
 endif()
 
+
+
 ################################ Included Libs ################################
 
 include(ExternalProject)
@@ -442,12 +446,11 @@ add_subdirectory(libraries/gamemode)
 add_subdirectory(libraries/murmur2) # Hash for usage with the CurseForge API
 if (NOT ghc_filesystem_FOUND)
     message(STATUS "Using bundled ghc_filesystem")
-    set(GHC_FILESYSTEM_WITH_INSTALL OFF) # Workaround ghc::filesystem bug
     add_subdirectory(libraries/filesystem) # Implementation of std::filesystem for old C++, for usage in old macOS
-    add_library(ghcFilesystem::ghc_filesystem ALIAS ghc_filesystem)
 else()
     message(STATUS "Using system ghc_filesystem")
 endif()
+add_subdirectory(libraries/qdcss) # css parser
 
 ############################### Built Artifacts ###############################
 

flake.lock

@@ -3,11 +3,11 @@
     "flake-compat": {
       "flake": false,
       "locked": {
-        "lastModified": 1668681692,
+        "lastModified": 1673956053,
-        "narHash": "sha256-Ht91NGdewz8IQLtWZ9LCeNXMSXHUss+9COoqu6JLmXU=",
+        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
         "owner": "edolstra",
         "repo": "flake-compat",
-        "rev": "009399224d5e398d03b22badca40a37ac85412a1",
+        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
         "type": "github"
       },
       "original": {
@@ -16,6 +16,58 @@
         "type": "github"
       }
     },
+    "flake-compat_2": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1673956053,
+        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "locked": {
+        "lastModified": 1676283394,
+        "narHash": "sha256-XX2f9c3iySLCw54rJ/CZs+ZK6IQy7GXNY4nSOyu2QG4=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "3db36a8b464d0c4532ba1c7dda728f4576d6d073",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "pre-commit-hooks",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1660459072,
+        "narHash": "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=",
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "rev": "a20de23b925fd8264fd7fad6454652e142fd7f73",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "type": "github"
+      }
+    },
     "libnbtplusplus": {
       "flake": false,
       "locked": {
@@ -34,11 +86,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1671417167,
+        "lastModified": 1678693419,
-        "narHash": "sha256-JkHam6WQOwZN1t2C2sbp1TqMv3TVRjzrdoejqfefwrM=",
+        "narHash": "sha256-bbSv5yqZAW6dz+3f3f3pOUZbxpPN+3OgCljgn7P+nnQ=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "bb31220cca6d044baa6dc2715b07497a2a7c4bc7",
+        "rev": "8e3fad82be64c06fbfb9fd43993aec9ef4623936",
         "type": "github"
       },
       "original": {
@@ -48,11 +100,55 @@
         "type": "github"
       }
     },
+    "nixpkgs-stable": {
+      "locked": {
+        "lastModified": 1673800717,
+        "narHash": "sha256-SFHraUqLSu5cC6IxTprex/nTsI81ZQAtDvlBvGDWfnA=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "2f9fd351ec37f5d479556cd48be4ca340da59b8f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-22.11",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "pre-commit-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat_2",
+        "flake-utils": [
+          "flake-utils"
+        ],
+        "gitignore": "gitignore",
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "nixpkgs-stable": "nixpkgs-stable"
+      },
+      "locked": {
+        "lastModified": 1678376203,
+        "narHash": "sha256-3tyYGyC8h7fBwncLZy5nCUjTJPrHbmNwp47LlNLOHSM=",
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "rev": "1a20b9708962096ec2481eeb2ddca29ed747770a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "flake-compat": "flake-compat",
+        "flake-utils": "flake-utils",
         "libnbtplusplus": "libnbtplusplus",
-        "nixpkgs": "nixpkgs"
+        "nixpkgs": "nixpkgs",
+        "pre-commit-hooks": "pre-commit-hooks"
       }
     }
   },

flake.nix

@@ -3,35 +3,89 @@
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
-    flake-compat = { url = "github:edolstra/flake-compat"; flake = false; };
+    flake-utils.url = "github:numtide/flake-utils";
-    libnbtplusplus = { url = "github:PrismLauncher/libnbtplusplus"; flake = false; };
+    pre-commit-hooks = {
+      url = "github:cachix/pre-commit-hooks.nix";
+      inputs.nixpkgs.follows = "nixpkgs";
+      inputs.flake-utils.follows = "flake-utils";
+    };
+    flake-compat = {
+      url = "github:edolstra/flake-compat";
+      flake = false;
+    };
+    libnbtplusplus = {
+      url = "github:PrismLauncher/libnbtplusplus";
+      flake = false;
+    };
   };
 
-  outputs = { self, nixpkgs, libnbtplusplus, ... }:
+  outputs = {
-    let
+    self,
+    nixpkgs,
+    flake-utils,
+    pre-commit-hooks,
+    libnbtplusplus,
+    ...
+  }: let
     # User-friendly version number.
     version = builtins.substring 0 8 self.lastModifiedDate;
 
     # Supported systems (qtbase is currently broken for "aarch64-darwin")
-      supportedSystems = [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" ];
+    supportedSystems = with flake-utils.lib.system; [
+      x86_64-linux
+      x86_64-darwin
+      aarch64-linux
+    ];
 
-      # Helper function to generate an attrset '{ x86_64-linux = f "x86_64-linux"; ... }'.
+    packagesFn = pkgs: {
-      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
+      prismlauncher-qt5 = pkgs.libsForQt5.callPackage ./nix {
-
+        inherit version self libnbtplusplus;
-      # Nixpkgs instantiated for supported systems.
+      };
-      pkgs = forAllSystems (system: nixpkgs.legacyPackages.${system});
+      prismlauncher = pkgs.qt6Packages.callPackage ./nix {
-
+        inherit version self libnbtplusplus;
-      packagesFn = pkgs: rec {
+      };
-        prismlauncher-qt5 = pkgs.libsForQt5.callPackage ./nix { inherit version self libnbtplusplus; };
-        prismlauncher = pkgs.qt6Packages.callPackage ./nix { inherit version self libnbtplusplus; };
     };
   in
-    {
+    flake-utils.lib.eachSystem supportedSystems (system: let
-      packages = forAllSystems (system:
+      pkgs = nixpkgs.legacyPackages.${system};
-        let packages = packagesFn pkgs.${system}; in
+    in {
-        packages // { default = packages.prismlauncher; }
+      checks = {
-      );
+        pre-commit-check = pre-commit-hooks.lib.${system}.run {
+          src = ./.;
+          hooks = {
+            markdownlint.enable = true;
 
-      overlay = final: packagesFn;
+            alejandra.enable = true;
+            deadnix.enable = true;
+
+            clang-format = {
+              enable =
+                false; # As most of the codebase is **not** formatted, we don't want clang-format yet
+              types_or = ["c" "c++"];
+            };
+          };
+        };
+      };
+
+      packages = let
+        packages = packagesFn pkgs;
+      in
+        packages // {default = packages.prismlauncher;};
+
+      devShells.default = pkgs.mkShell {
+        inherit (self.checks.${system}.pre-commit-check) shellHook;
+        packages = with pkgs; [
+          nodePackages.markdownlint-cli
+          alejandra
+          deadnix
+          clang-tools
+        ];
+
+        inputsFrom = [self.packages.${system}.default];
+        buildInputs = with pkgs; [ccache ninja];
+      };
+    })
+    // {
+      overlays.default = final: _: (packagesFn final);
     };
 }

flatpak/org.prismlauncher.PrismLauncher.yml

@@ -32,6 +32,7 @@ modules:
     config-opts:
       - -DLauncher_BUILD_PLATFORM=flatpak
       - -DCMAKE_BUILD_TYPE=Debug
+      - -DLauncher_QT_VERSION_MAJOR=5
     build-options:
       env:
         JAVA_HOME: /usr/lib/sdk/openjdk17/jvm/openjdk-17

launcher/Application.cpp

@@ -7,6 +7,8 @@
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
  *  Copyright (C) 2022 Lenny McLennington <lenny@sneed.church>
  *  Copyright (C) 2022 Tayou <tayou@gmx.net>
+ *  Copyright (C) 2023 TheKodeToad <TheKodeToad@proton.me>
+ *  Copyright (C) 2023 Rachel Powers <508861+Ryex@users.noreply.github.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
@@ -45,6 +47,7 @@
 #include "net/PasteUpload.h"
 #include "pathmatcher/MultiMatcher.h"
 #include "pathmatcher/SimplePrefixMatcher.h"
+#include "settings/INIFile.h"
 #include "ui/MainWindow.h"
 #include "ui/InstanceWindow.h"
 
@@ -79,6 +82,7 @@
 #include <iostream>
 #include <mutex>
 
+#include <QFileOpenEvent>
 #include <QAccessible>
 #include <QCommandLineParser>
 #include <QDir>
@@ -100,8 +104,6 @@
 #include "icons/IconList.h"
 #include "net/HttpMetaCache.h"
 
-#include "ui/GuiUtil.h"
-
 #include "java/JavaUtils.h"
 
 #include "updater/ExternalUpdater.h"
@@ -286,6 +288,7 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         if (QFile::exists(FS::PathCombine(m_rootPath, "portable.txt"))) {
             dataPath = m_rootPath;
             adjustedBy = "Portable data path";
+            m_portable = true;
         }
 #endif
     }
@@ -411,6 +414,47 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
                 "%{if-category}[%{category}]: %{endif}"
                 "%{message}");
       
+        bool foundLoggingRules = false;
+        
+        auto logRulesFile = QStringLiteral("qtlogging.ini");
+        auto logRulesPath = FS::PathCombine(dataPath, logRulesFile);
+        
+        qDebug() << "Testing" << logRulesPath << "...";              
+        foundLoggingRules = QFile::exists(logRulesPath);
+
+        // search the dataPath()
+        // seach app data standard path
+        if(!foundLoggingRules && !isPortable() && dirParam.isEmpty()) {
+            logRulesPath = QStandardPaths::locate(QStandardPaths::AppDataLocation, FS::PathCombine("..", logRulesFile));
+            if(!logRulesPath.isEmpty()) {
+                qDebug() << "Found" << logRulesPath << "...";
+                foundLoggingRules = true;
+            }
+        }
+        // seach root path
+        if(!foundLoggingRules) {
+           logRulesPath = FS::PathCombine(m_rootPath, logRulesFile); 
+            qDebug() << "Testing" << logRulesPath << "...";
+            foundLoggingRules = QFile::exists(logRulesPath);
+        }
+        
+        if(foundLoggingRules) {
+            // load and set logging rules
+            qDebug() << "Loading logging rules from:" << logRulesPath;
+            QSettings loggingRules(logRulesPath, QSettings::IniFormat); 
+            loggingRules.beginGroup("Rules");
+            QStringList rule_names = loggingRules.childKeys();
+            QStringList rules;
+            qDebug() << "Setting log rules:";
+            for (auto rule_name : rule_names) {
+                auto rule = QString("%1=%2").arg(rule_name).arg(loggingRules.value(rule_name).toString());
+                rules.append(rule);
+                qDebug() << "    " << rule;
+            }
+            auto rules_str = rules.join("\n");
+            QLoggingCategory::setFilterRules(rules_str);
+        }
+
         qDebug() << "<> Log initialized.";
     }
 
@@ -516,6 +560,8 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         m_settings->registerSetting("InstanceDir", "instances");
         m_settings->registerSetting({"CentralModsDir", "ModsDir"}, "mods");
         m_settings->registerSetting("IconsDir", "icons");
+        m_settings->registerSetting("DownloadsDir", QStandardPaths::writableLocation(QStandardPaths::DownloadLocation));
+        m_settings->registerSetting("DownloadsDirWatchRecursive", false);
 
         // Editors
         m_settings->registerSetting("JsonEditor", QString());
@@ -612,6 +658,9 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         m_settings->registerSetting("UpdateDialogGeometry", "");
 
         m_settings->registerSetting("ModDownloadGeometry", "");
+        m_settings->registerSetting("RPDownloadGeometry", "");
+        m_settings->registerSetting("TPDownloadGeometry", "");
+        m_settings->registerSetting("ShaderDownloadGeometry", "");
 
         // HACK: This code feels so stupid is there a less stupid way of doing this?
         {
@@ -659,6 +708,7 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
             m_settings->reset("CFKeyOverride");
         }
         m_settings->registerSetting("FlameKeyShouldBeFetchedOnStartup", true);
+        m_settings->registerSetting("ModrinthToken", "");
         m_settings->registerSetting("UserAgentOverride", "");
 
         // Init page provider
@@ -827,9 +877,7 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         }
     });
 
-    {
+    applyCurrentlySelectedTheme(true);
-        applyCurrentlySelectedTheme();
-    }
 
     updateCapabilities();
 
@@ -1120,9 +1168,9 @@ QList<ITheme*> Application::getValidApplicationThemes()
     return m_themeManager->getValidApplicationThemes();
 }
 
-void Application::applyCurrentlySelectedTheme()
+void Application::applyCurrentlySelectedTheme(bool initial)
 {
-    m_themeManager->applyCurrentlySelectedTheme();
+    m_themeManager->applyCurrentlySelectedTheme(initial);
 }
 
 void Application::setApplicationTheme(const QString& name)
@@ -1564,6 +1612,15 @@ QString Application::getFlameAPIKey()
     return BuildConfig.FLAME_API_KEY;
 }
 
+QString Application::getModrinthAPIToken()
+{
+    QString tokenOverride = m_settings->get("ModrinthToken").toString();
+    if (!tokenOverride.isEmpty())
+        return tokenOverride;
+
+    return QString();
+}
+
 QString Application::getUserAgent()
 {
     QString uaOverride = m_settings->get("UserAgentOverride").toString();

launcher/Application.h

@@ -3,6 +3,7 @@
  *  Prism Launcher - Minecraft Launcher
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
  *  Copyright (C) 2022 Tayou <tayou@gmx.net>
+ *  Copyright (C) 2023 TheKodeToad <TheKodeToad@proton.me>
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -119,7 +120,7 @@ public:
 
     void setIconTheme(const QString& name);
 
-    void applyCurrentlySelectedTheme();
+    void applyCurrentlySelectedTheme(bool initial = false);
 
     QList<ITheme*> getValidApplicationThemes();
 
@@ -177,6 +178,7 @@ public:
 
     QString getMSAClientID();
     QString getFlameAPIKey();
+    QString getModrinthAPIToken();
     QString getUserAgent();
     QString getUserAgentUncached();
 
@@ -185,6 +187,10 @@ public:
         return m_rootPath;
     }
 
+    bool isPortable() {
+        return m_portable;
+    }
+
     const Capabilities capabilities() {
         return m_capabilities;
     }
@@ -273,6 +279,7 @@ private:
     QString m_rootPath;
     Status m_status = Application::StartingUp;
     Capabilities m_capabilities;
+    bool m_portable = false; 
 
 #ifdef Q_OS_MACOS
     Qt::ApplicationState m_prevAppState = Qt::ApplicationInactive;

launcher/BaseInstance.cpp

@@ -40,6 +40,8 @@
 #include <QDir>
 #include <QDebug>
 #include <QRegularExpression>
+#include <QJsonDocument>
+#include <QJsonObject>
 
 #include "settings/INISettingsObject.h"
 #include "settings/Setting.h"
@@ -64,6 +66,8 @@ BaseInstance::BaseInstance(SettingsObjectPtr globalSettings, SettingsObjectPtr s
     m_settings->registerSetting("totalTimePlayed", 0);
     m_settings->registerSetting("lastTimePlayed", 0);
 
+    m_settings->registerSetting("linkedInstances", "[]");
+
     // Game time override
     auto gameTimeOverride = m_settings->registerSetting("OverrideGameTime", false);
     m_settings->registerOverride(globalSettings->getSetting("ShowGameTime"), gameTimeOverride);
@@ -182,6 +186,38 @@ bool BaseInstance::shouldStopOnConsoleOverflow() const
     return m_settings->get("ConsoleOverflowStop").toBool();
 }
 
+QStringList BaseInstance::getLinkedInstances() const
+{
+    return m_settings->get("linkedInstances").toStringList();
+}
+
+void BaseInstance::setLinkedInstances(const QStringList& list)
+{
+    auto linkedInstances = m_settings->get("linkedInstances").toStringList();
+    m_settings->set("linkedInstances", list);
+}
+
+void BaseInstance::addLinkedInstanceId(const QString& id)
+{
+    auto linkedInstances = m_settings->get("linkedInstances").toStringList();
+    linkedInstances.append(id);
+    setLinkedInstances(linkedInstances);
+}
+
+bool BaseInstance::removeLinkedInstanceId(const QString& id)
+{
+    auto linkedInstances = m_settings->get("linkedInstances").toStringList();
+    int numRemoved = linkedInstances.removeAll(id);
+    setLinkedInstances(linkedInstances);
+    return numRemoved > 0;
+}
+
+bool BaseInstance::isLinkedToInstanceId(const QString& id) const
+{
+    auto linkedInstances = m_settings->get("linkedInstances").toStringList();
+    return linkedInstances.contains(id);
+}
+
 void BaseInstance::iconUpdated(QString key)
 {
     if(iconKey() == key)

launcher/BaseInstance.h

@@ -282,6 +282,12 @@ public:
     int getConsoleMaxLines() const;
     bool shouldStopOnConsoleOverflow() const;
 
+    QStringList getLinkedInstances() const;
+    void setLinkedInstances(const QStringList& list);
+    void addLinkedInstanceId(const QString& id);
+    bool removeLinkedInstanceId(const QString& id);
+    bool isLinkedToInstanceId(const QString& id) const;
+
 protected:
     void changeStatus(Status newStatus);
 

launcher/CMakeLists.txt

@@ -26,6 +26,7 @@ set(CORE_SOURCES
     MMCZip.cpp
     StringUtils.h
     StringUtils.cpp
+    QVariantUtils.h
     RuntimeContext.h
 
     # Basic instance manipulation tasks (derived from InstanceTask)
@@ -125,6 +126,8 @@ set(NET_SOURCES
     net/HttpMetaCache.h
     net/MetaCacheSink.cpp
     net/MetaCacheSink.h
+    net/Logging.h
+    net/Logging.cpp
     net/NetAction.h
     net/NetJob.cpp
     net/NetJob.h
@@ -534,13 +537,6 @@ set(MODRINTH_SOURCES
     modplatform/modrinth/ModrinthInstanceCreationTask.h
 )
 
-set(MODPACKSCH_SOURCES
-    modplatform/modpacksch/FTBPackInstallTask.h
-    modplatform/modpacksch/FTBPackInstallTask.cpp
-    modplatform/modpacksch/FTBPackManifest.h
-    modplatform/modpacksch/FTBPackManifest.cpp
-)
-
 set(PACKWIZ_SOURCES
     modplatform/packwiz/Packwiz.h
     modplatform/packwiz/Packwiz.cpp
@@ -569,6 +565,18 @@ set(ATLAUNCHER_SOURCES
     modplatform/atlauncher/ATLShareCode.h
 )
 
+set(LINKEXE_SOURCES
+    filelink/FileLink.h
+    filelink/FileLink.cpp
+    FileSystem.h
+    FileSystem.cpp
+    Exception.h
+    StringUtils.h
+    StringUtils.cpp
+    DesktopServices.h
+    DesktopServices.cpp
+)
+
 ######## Logging categories ########
 
 ecm_qt_declare_logging_category(CORE_SOURCES
@@ -580,6 +588,55 @@ ecm_qt_declare_logging_category(CORE_SOURCES
     EXPORT "${Launcher_Name}"
 )
 
+ecm_qt_export_logging_category(
+    IDENTIFIER taskLogC
+    CATEGORY_NAME "launcher.task"
+    DEFAULT_SEVERITY Debug
+    DESCRIPTION "Task actions"
+    EXPORT "${Launcher_Name}"
+)
+
+ecm_qt_export_logging_category(
+    IDENTIFIER taskNetLogC
+    CATEGORY_NAME "launcher.task.net"
+    DEFAULT_SEVERITY Debug
+    DESCRIPTION "task network action"
+    EXPORT "${Launcher_Name}"
+)
+
+ecm_qt_export_logging_category(
+    IDENTIFIER taskDownloadLogC
+    CATEGORY_NAME "launcher.task.net.download"
+    DEFAULT_SEVERITY Debug
+    DESCRIPTION "task network download actions"
+    EXPORT "${Launcher_Name}"
+)
+ecm_qt_export_logging_category(
+    IDENTIFIER taskUploadLogC
+    CATEGORY_NAME "launcher.task.net.upload"
+    DEFAULT_SEVERITY Debug
+    DESCRIPTION "task network upload actions"
+    EXPORT "${Launcher_Name}"
+)
+
+ecm_qt_export_logging_category(
+    IDENTIFIER taskMetaCacheLogC
+    CATEGORY_NAME "launcher.task.net.metacache"
+    DEFAULT_SEVERITY Debug
+    DESCRIPTION "task network meta-cache actions"
+    EXPORT "${Launcher_Name}"
+)
+
+ecm_qt_export_logging_category(
+    IDENTIFIER taskHttpMetaCacheLogC
+    CATEGORY_NAME "launcher.task.net.metacache.http"
+    DEFAULT_SEVERITY Debug
+    DESCRIPTION "task network http meta-cache actions"
+    EXPORT "${Launcher_Name}"
+)
+
+
+
 if(KDE_INSTALL_LOGGINGCATEGORIESDIR)  # only install if there is a standard path for this
     ecm_qt_install_logging_categories(
         EXPORT "${Launcher_Name}"
@@ -609,7 +666,6 @@ set(LOGIC_SOURCES
     ${FTB_SOURCES}
     ${FLAME_SOURCES}
     ${MODRINTH_SOURCES}
-    ${MODPACKSCH_SOURCES}
     ${PACKWIZ_SOURCES}
     ${TECHNIC_SOURCES}
     ${ATLAUNCHER_SOURCES}
@@ -730,8 +786,11 @@ SET(LAUNCHER_SOURCES
     ui/pages/instance/ManagedPackPage.cpp
     ui/pages/instance/ManagedPackPage.h
     ui/pages/instance/TexturePackPage.h
+    ui/pages/instance/TexturePackPage.cpp
     ui/pages/instance/ResourcePackPage.h
+    ui/pages/instance/ResourcePackPage.cpp
     ui/pages/instance/ShaderPackPage.h
+    ui/pages/instance/ShaderPackPage.cpp
     ui/pages/instance/ModFolderPage.cpp
     ui/pages/instance/ModFolderPage.h
     ui/pages/instance/NotesPage.cpp
@@ -783,6 +842,16 @@ SET(LAUNCHER_SOURCES
     ui/pages/modplatform/ModModel.cpp
     ui/pages/modplatform/ModModel.h
 
+    ui/pages/modplatform/ResourcePackPage.cpp
+    ui/pages/modplatform/ResourcePackModel.cpp
+
+    # Needed for MOC to find them without a corresponding .cpp
+    ui/pages/modplatform/TexturePackPage.h
+    ui/pages/modplatform/TexturePackModel.cpp
+
+    ui/pages/modplatform/ShaderPackPage.cpp
+    ui/pages/modplatform/ShaderPackModel.cpp
+
     ui/pages/modplatform/atlauncher/AtlFilterModel.cpp
     ui/pages/modplatform/atlauncher/AtlFilterModel.h
     ui/pages/modplatform/atlauncher/AtlListModel.cpp
@@ -794,13 +863,6 @@ SET(LAUNCHER_SOURCES
     ui/pages/modplatform/atlauncher/AtlUserInteractionSupportImpl.cpp
     ui/pages/modplatform/atlauncher/AtlUserInteractionSupportImpl.h
 
-    ui/pages/modplatform/ftb/FtbFilterModel.cpp
-    ui/pages/modplatform/ftb/FtbFilterModel.h
-    ui/pages/modplatform/ftb/FtbListModel.cpp
-    ui/pages/modplatform/ftb/FtbListModel.h
-    ui/pages/modplatform/ftb/FtbPage.cpp
-    ui/pages/modplatform/ftb/FtbPage.h
-
     ui/pages/modplatform/legacy_ftb/Page.cpp
     ui/pages/modplatform/legacy_ftb/Page.h
     ui/pages/modplatform/legacy_ftb/ListModel.h
@@ -923,6 +985,8 @@ SET(LAUNCHER_SOURCES
     ui/widgets/VariableSizedImageObject.cpp
     ui/widgets/ProjectItem.h
     ui/widgets/ProjectItem.cpp
+    ui/widgets/SubTaskProgressBar.h
+    ui/widgets/SubTaskProgressBar.cpp
     ui/widgets/VersionListView.cpp
     ui/widgets/VersionListView.h
     ui/widgets/VersionSelectWidget.cpp
@@ -977,13 +1041,13 @@ qt_wrap_ui(LAUNCHER_UI
     ui/pages/modplatform/flame/FlamePage.ui
     ui/pages/modplatform/legacy_ftb/Page.ui
     ui/pages/modplatform/ImportPage.ui
-    ui/pages/modplatform/ftb/FtbPage.ui
     ui/pages/modplatform/modrinth/ModrinthPage.ui
     ui/pages/modplatform/technic/TechnicPage.ui
     ui/widgets/InstanceCardWidget.ui
     ui/widgets/CustomCommands.ui
     ui/widgets/InfoFrame.ui
     ui/widgets/ModFilterWidget.ui
+    ui/widgets/SubTaskProgressBar.ui
     ui/widgets/ThemeCustomizationWidget.ui
     ui/dialogs/CopyInstanceDialog.ui
     ui/dialogs/ProfileSetupDialog.ui
@@ -1038,6 +1102,7 @@ target_link_libraries(Launcher_logic
     nbt++
     ${ZLIB_LIBRARIES}
     tomlplusplus::tomlplusplus
+    qdcss
     BuildConfig
     Katabasis
     Qt${QT_VERSION_MAJOR}::Widgets
@@ -1106,6 +1171,41 @@ install(TARGETS ${Launcher_Name}
     FRAMEWORK DESTINATION ${FRAMEWORK_DEST_DIR} COMPONENT Runtime
 )
 
+if(WIN32)
+    add_library(filelink_logic STATIC ${LINKEXE_SOURCES})
+    target_include_directories(filelink_logic PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+    target_link_libraries(filelink_logic
+        systeminfo
+        BuildConfig
+        ghcFilesystem::ghc_filesystem
+        Qt${QT_VERSION_MAJOR}::Widgets
+        Qt${QT_VERSION_MAJOR}::Core
+        Qt${QT_VERSION_MAJOR}::Network
+        # Qt${QT_VERSION_MAJOR}::Concurrent
+        ${Launcher_QT_LIBS}
+    )
+
+    add_executable("${Launcher_Name}_filelink" WIN32 filelink/main.cpp)
+
+    target_sources("${Launcher_Name}_filelink" PRIVATE filelink/filelink.exe.manifest)
+
+    target_link_libraries("${Launcher_Name}_filelink" filelink_logic)
+
+    if(DEFINED Launcher_APP_BINARY_NAME)
+        set_target_properties("${Launcher_Name}_filelink" PROPERTIES OUTPUT_NAME "${Launcher_APP_BINARY_NAME}_filelink")
+    endif()
+    if(DEFINED Launcher_BINARY_RPATH)
+        SET_TARGET_PROPERTIES("${Launcher_Name}_filelink" PROPERTIES INSTALL_RPATH "${Launcher_BINARY_RPATH}")
+    endif()
+
+    install(TARGETS "${Launcher_Name}_filelink"
+        BUNDLE DESTINATION "." COMPONENT Runtime
+        LIBRARY DESTINATION ${LIBRARY_DEST_DIR} COMPONENT Runtime
+        RUNTIME DESTINATION ${BINARY_DEST_DIR} COMPONENT Runtime
+        FRAMEWORK DESTINATION ${FRAMEWORK_DEST_DIR} COMPONENT Runtime
+    )
+endif()
+
 if (UNIX AND APPLE)
     # Add Sparkle updater
     # It has to be copied here instead of just allowing fixup_bundle to install it, otherwise essential parts of
@@ -1122,6 +1222,12 @@ if(INSTALL_BUNDLE STREQUAL "full")
         CODE "file(WRITE \"\${CMAKE_INSTALL_PREFIX}/${RESOURCES_DEST_DIR}/qt.conf\" \" \")"
         COMPONENT Runtime
     )
+    # add qtlogging.ini as a config file
+    install(
+        FILES "qtlogging.ini"
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/${RESOURCES_DEST_DIR}
+        COMPONENT Runtime
+    )
     # Bundle plugins
     # Image formats
     install(

launcher/DesktopServices.cpp

@@ -37,7 +37,6 @@
 #include <QDesktopServices>
 #include <QProcess>
 #include <QDebug>
-#include "Application.h"
 
 /**
  * This shouldn't exist, but until QTBUG-9328 and other unreported bugs are fixed, it needs to be a thing.

launcher/FileSystem.h

@@ -3,6 +3,7 @@
  *  Prism Launcher - Minecraft Launcher
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
  *  Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
+ *  Copyright (C) 2022 Rachel Powers <508861+Ryex@users.noreply.github.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
@@ -39,9 +40,13 @@
 #include "Exception.h"
 #include "pathmatcher/IPathMatcher.h"
 
+#include <system_error>
+
 #include <QDir>
 #include <QFlags>
+#include <QLocalServer>
 #include <QObject>
+#include <QThread>
 
 namespace FS {
 
@@ -77,7 +82,9 @@ bool ensureFilePathExists(QString filenamepath);
  */
 bool ensureFolderPathExists(QString filenamepath);
 
-/// @brief Copies a directory and it's contents from src to dest
+/**
+ * @brief Copies a directory and it's contents from src to dest
+ */
 class copy : public QObject {
     Q_OBJECT
    public:
@@ -122,6 +129,127 @@ class copy : public QObject {
     int m_copied;
 };
 
+struct LinkPair {
+    QString src;
+    QString dst;
+};
+
+struct LinkResult {
+    QString src;
+    QString dst;
+    QString err_msg;
+    int err_value;
+};
+
+class ExternalLinkFileProcess : public QThread {
+    Q_OBJECT
+   public:
+    ExternalLinkFileProcess(QString server, bool useHardLinks, QObject* parent = nullptr)
+        : QThread(parent), m_useHardLinks(useHardLinks), m_server(server)
+    {}
+
+    void run() override
+    {
+        runLinkFile();
+        emit processExited();
+    }
+
+   signals:
+    void processExited();
+
+   private:
+    void runLinkFile();
+
+    bool m_useHardLinks = false;
+
+    QString m_server;
+};
+
+/**
+ * @brief links (a file / a directory and it's contents) from src to dest
+ */
+class create_link : public QObject {
+    Q_OBJECT
+   public:
+    create_link(const QList<LinkPair> path_pairs, QObject* parent = nullptr) : QObject(parent) { m_path_pairs.append(path_pairs); }
+    create_link(const QString& src, const QString& dst, QObject* parent = nullptr) : QObject(parent)
+    {
+        LinkPair pair = { src, dst };
+        m_path_pairs.append(pair);
+    }
+    create_link& useHardLinks(const bool useHard)
+    {
+        m_useHardLinks = useHard;
+        return *this;
+    }
+    create_link& matcher(const IPathMatcher* filter)
+    {
+        m_matcher = filter;
+        return *this;
+    }
+    create_link& whitelist(bool whitelist)
+    {
+        m_whitelist = whitelist;
+        return *this;
+    }
+    create_link& linkRecursively(bool recursive)
+    {
+        m_recursive = recursive;
+        return *this;
+    }
+    create_link& setMaxDepth(int depth)
+    {
+        m_max_depth = depth;
+        return *this;
+    }
+    create_link& debug(bool d)
+    {
+        m_debug = d;
+        return *this;
+    }
+
+    std::error_code getOSError() { return m_os_err; }
+
+    bool operator()(bool dryRun = false) { return operator()(QString(), dryRun); }
+
+    int totalLinked() { return m_linked; }
+
+    void runPrivileged() { runPrivileged(QString()); }
+    void runPrivileged(const QString& offset);
+
+    QList<LinkResult> getResults() { return m_path_results; }
+
+   signals:
+    void fileLinked(const QString& srcName, const QString& dstName);
+    void linkFailed(const QString& srcName, const QString& dstName, const QString& err_msg, int err_value);
+    void finished();
+    void finishedPrivileged(bool gotResults);
+
+   private:
+    bool operator()(const QString& offset, bool dryRun = false);
+    void make_link_list(const QString& offset);
+    bool make_links();
+
+   private:
+    bool m_useHardLinks = false;
+    const IPathMatcher* m_matcher = nullptr;
+    bool m_whitelist = false;
+    bool m_recursive = true;
+
+    /// @brief >= -1 = infinite, 0 = link files at src/* to dest/*, 1 = link files at src/*/* to dest/*/*, etc.
+    int m_max_depth = -1;
+
+    QList<LinkPair> m_path_pairs;
+    QList<LinkResult> m_path_results;
+    QList<LinkPair> m_links_to_make;
+
+    int m_linked;
+    bool m_debug = false;
+    std::error_code m_os_err;
+
+    QLocalServer m_linkServer;
+};
+
 /**
  * @brief moves a file by renaming it
  * @param source source file path
@@ -138,13 +266,30 @@ bool deletePath(QString path);
 /**
  * Trash a folder / file
  */
-bool trash(QString path, QString *pathInTrash = nullptr);
+bool trash(QString path, QString* pathInTrash = nullptr);
 
 QString PathCombine(const QString& path1, const QString& path2);
 QString PathCombine(const QString& path1, const QString& path2, const QString& path3);
 QString PathCombine(const QString& path1, const QString& path2, const QString& path3, const QString& path4);
 
-QString AbsolutePath(QString path);
+QString AbsolutePath(const QString& path);
+
+/**
+ * @brief depth of path. "foo.txt" -> 0 , "bar/foo.txt" -> 1, /baz/bar/foo.txt -> 2, etc.
+ *
+ * @param path path to measure
+ * @return int number of components before base path
+ */
+int pathDepth(const QString& path);
+
+/**
+ * @brief  cut off segments of path until it is a max of length depth
+ *
+ * @param path path to truncate
+ * @param depth max depth of new path
+ * @return QString truncated path
+ */
+QString pathTruncate(const QString& path, int depth);
 
 /**
  * Resolve an executable
@@ -186,4 +331,194 @@ bool overrideFolder(QString overwritten_path, QString override_path);
  * Creates a shortcut to the specified target file at the specified destination path.
  */
 bool createShortcut(QString destination, QString target, QStringList args, QString name, QString icon);
-}
+
+enum class FilesystemType {
+    FAT,
+    NTFS,
+    REFS,
+    EXT,
+    EXT_2_OLD,
+    EXT_2_3_4,
+    XFS,
+    BTRFS,
+    NFS,
+    ZFS,
+    APFS,
+    HFS,
+    HFSPLUS,
+    HFSX,
+    FUSEBLK,
+    F2FS,
+    UNKNOWN
+};
+
+/**
+ * @brief Ordered Mapping of enum types to reported filesystem names
+ * this mapping is non exsaustive, it just attempts to capture the filesystems which could be reasonalbly be in use .
+ * all string values are in uppercase, use `QString.toUpper()` or equivalent during lookup.
+ *
+ * QMap is ordered
+ *
+ */
+static const QMap<FilesystemType, QStringList> s_filesystem_type_names = {
+    {FilesystemType::FAT,        { "FAT" }},
+    {FilesystemType::NTFS,       { "NTFS" }},
+    {FilesystemType::REFS,       { "REFS" }},
+    {FilesystemType::EXT_2_OLD,  { "EXT_2_OLD", "EXT2_OLD" }},
+    {FilesystemType::EXT_2_3_4,  { "EXT2/3/4", "EXT_2_3_4", "EXT2", "EXT3", "EXT4" }},
+    {FilesystemType::EXT,        { "EXT" }},
+    {FilesystemType::XFS,        { "XFS" }},
+    {FilesystemType::BTRFS,      { "BTRFS" }},
+    {FilesystemType::NFS,        { "NFS" }},
+    {FilesystemType::ZFS,        { "ZFS" }},
+    {FilesystemType::APFS,       { "APFS" }},
+    {FilesystemType::HFS,        { "HFS" }},
+    {FilesystemType::HFSPLUS,    { "HFSPLUS" }},
+    {FilesystemType::HFSX,       { "HFSX" }},
+    {FilesystemType::FUSEBLK,    { "FUSEBLK" }},
+    {FilesystemType::F2FS,       { "F2FS" }},
+    {FilesystemType::UNKNOWN,    { "UNKNOWN" }}
+};
+
+/**
+ * @brief Get the string name of Filesystem enum object
+ *
+ * @param type
+ * @return QString
+ */
+QString getFilesystemTypeName(FilesystemType type);
+
+/**
+ * @brief Get the Filesystem enum object from a name
+ *  Does a lookup of the type name and returns an exact match
+ *
+ * @param name
+ * @return FilesystemType
+ */
+FilesystemType getFilesystemType(const QString& name);
+
+/**
+ * @brief Get the Filesystem enum object from a name
+ *  Does a fuzzy lookup of the type name and returns an apropreate match
+ *
+ * @param name
+ * @return FilesystemType
+ */
+FilesystemType getFilesystemTypeFuzzy(const QString& name);
+
+struct FilesystemInfo {
+    FilesystemType fsType = FilesystemType::UNKNOWN;
+    QString fsTypeName;
+    int blockSize;
+    qint64 bytesAvailable;
+    qint64 bytesFree;
+    qint64 bytesTotal;
+    QString name;
+    QString rootPath;
+};
+
+/**
+ * @brief path to the near ancestor that exists
+ *
+ */
+QString nearestExistentAncestor(const QString& path);
+
+/**
+ * @brief colect information about the filesystem under a file
+ *
+ */
+FilesystemInfo statFS(const QString& path);
+
+static const QList<FilesystemType> s_clone_filesystems = { FilesystemType::BTRFS, FilesystemType::APFS, FilesystemType::ZFS,
+                                                           FilesystemType::XFS, FilesystemType::REFS };
+
+/**
+ * @brief if the Filesystem is reflink/clone capable
+ *
+ */
+bool canCloneOnFS(const QString& path);
+bool canCloneOnFS(const FilesystemInfo& info);
+bool canCloneOnFS(FilesystemType type);
+
+/**
+ * @brief if the Filesystems are reflink/clone capable and both are on the same device
+ *
+ */
+bool canClone(const QString& src, const QString& dst);
+
+/**
+ * @brief Copies a directory and it's contents from src to dest
+ */
+class clone : public QObject {
+    Q_OBJECT
+   public:
+    clone(const QString& src, const QString& dst, QObject* parent = nullptr) : QObject(parent)
+    {
+        m_src.setPath(src);
+        m_dst.setPath(dst);
+    }
+    clone& matcher(const IPathMatcher* filter)
+    {
+        m_matcher = filter;
+        return *this;
+    }
+    clone& whitelist(bool whitelist)
+    {
+        m_whitelist = whitelist;
+        return *this;
+    }
+
+    bool operator()(bool dryRun = false) { return operator()(QString(), dryRun); }
+
+    int totalCloned() { return m_cloned; }
+
+   signals:
+    void fileCloned(const QString& src, const QString& dst);
+    void cloneFailed(const QString& src, const QString& dst);
+
+   private:
+    bool operator()(const QString& offset, bool dryRun = false);
+
+   private:
+    const IPathMatcher* m_matcher = nullptr;
+    bool m_whitelist = false;
+    QDir m_src;
+    QDir m_dst;
+    int m_cloned;
+};
+
+/**
+ * @brief clone/reflink file from src to dst
+ *
+ */
+bool clone_file(const QString& src, const QString& dst, std::error_code& ec);
+
+#if defined(Q_OS_WIN)
+bool win_ioctl_clone(const std::wstring& src_path, const std::wstring& dst_path, std::error_code& ec);
+#elif defined(Q_OS_LINUX)
+bool linux_ficlone(const std::string& src_path, const std::string& dst_path, std::error_code& ec);
+#elif defined(Q_OS_MACOS) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
+bool macos_bsd_clonefile(const std::string& src_path, const std::string& dst_path, std::error_code& ec);
+#endif
+
+static const QList<FilesystemType> s_non_link_filesystems = {
+    FilesystemType::FAT,
+};
+
+/**
+ * @brief if the Filesystem is symlink capable
+ *
+ */
+bool canLinkOnFS(const QString& path);
+bool canLinkOnFS(const FilesystemInfo& info);
+bool canLinkOnFS(FilesystemType type);
+
+/**
+ * @brief if the Filesystem is symlink capable on both ends
+ *
+ */
+bool canLink(const QString& src, const QString& dst);
+
+uintmax_t hardLinkCount(const QString& path);
+
+}  // namespace FS

launcher/InstanceCopyPrefs.cpp

@@ -16,8 +16,13 @@ bool InstanceCopyPrefs::allTrue() const
         copyScreenshots;
 }
 
+
 // Returns a single RegEx string of the selected folders/files to filter out (ex: ".minecraft/saves|.minecraft/server.dat")
 QString InstanceCopyPrefs::getSelectedFiltersAsRegex() const
+{
+    return getSelectedFiltersAsRegex({});
+}
+QString InstanceCopyPrefs::getSelectedFiltersAsRegex(const QStringList& additionalFilters) const
 {
     QStringList filters;
 
@@ -42,6 +47,10 @@ QString InstanceCopyPrefs::getSelectedFiltersAsRegex() const
     if(!copyScreenshots)
         filters << "screenshots";
 
+    for (auto filter : additionalFilters) {
+        filters << filter;
+    }
+
     // If we have any filters to add, join them as a single regex string to return:
     if (!filters.isEmpty()) {
         const QString MC_ROOT = "[.]?minecraft/";
@@ -93,6 +102,31 @@ bool InstanceCopyPrefs::isCopyScreenshotsEnabled() const
     return copyScreenshots;
 }
 
+bool InstanceCopyPrefs::isUseSymLinksEnabled() const
+{
+    return useSymLinks;
+}
+
+bool InstanceCopyPrefs::isUseHardLinksEnabled() const
+{
+    return useHardLinks;
+}
+
+bool InstanceCopyPrefs::isLinkRecursivelyEnabled() const
+{
+    return linkRecursively;
+}
+
+bool InstanceCopyPrefs::isDontLinkSavesEnabled() const
+{
+    return dontLinkSaves;
+}
+
+bool InstanceCopyPrefs::isUseCloneEnabled() const
+{
+    return useClone;
+}
+
 // ======= Setters =======
 void InstanceCopyPrefs::enableCopySaves(bool b)
 {
@@ -133,3 +167,28 @@ void InstanceCopyPrefs::enableCopyScreenshots(bool b)
 {
     copyScreenshots = b;
 }
+
+void InstanceCopyPrefs::enableUseSymLinks(bool b)
+{
+    useSymLinks = b;
+}
+
+void InstanceCopyPrefs::enableLinkRecursively(bool b)
+{
+    linkRecursively = b;
+}
+
+void InstanceCopyPrefs::enableUseHardLinks(bool b)
+{
+    useHardLinks = b;
+}
+
+void InstanceCopyPrefs::enableDontLinkSaves(bool b)
+{
+    dontLinkSaves = b;
+}
+
+void InstanceCopyPrefs::enableUseClone(bool b)
+{
+    useClone = b;
+}

launcher/InstanceCopyPrefs.h

@@ -10,6 +10,7 @@ struct InstanceCopyPrefs {
    public:
     [[nodiscard]] bool allTrue() const;
     [[nodiscard]] QString getSelectedFiltersAsRegex() const;
+    [[nodiscard]] QString getSelectedFiltersAsRegex(const QStringList& additionalFilters) const;
     // Getters
     [[nodiscard]] bool isCopySavesEnabled() const;
     [[nodiscard]] bool isKeepPlaytimeEnabled() const;
@@ -19,6 +20,11 @@ struct InstanceCopyPrefs {
     [[nodiscard]] bool isCopyServersEnabled() const;
     [[nodiscard]] bool isCopyModsEnabled() const;
     [[nodiscard]] bool isCopyScreenshotsEnabled() const;
+    [[nodiscard]] bool isUseSymLinksEnabled() const;
+    [[nodiscard]] bool isLinkRecursivelyEnabled() const;
+    [[nodiscard]] bool isUseHardLinksEnabled() const;
+    [[nodiscard]] bool isDontLinkSavesEnabled() const;
+    [[nodiscard]] bool isUseCloneEnabled() const;
     // Setters
     void enableCopySaves(bool b);
     void enableKeepPlaytime(bool b);
@@ -28,6 +34,11 @@ struct InstanceCopyPrefs {
     void enableCopyServers(bool b);
     void enableCopyMods(bool b);
     void enableCopyScreenshots(bool b);
+    void enableUseSymLinks(bool b);
+    void enableLinkRecursively(bool b);
+    void enableUseHardLinks(bool b);
+    void enableDontLinkSaves(bool b);
+    void enableUseClone(bool b);
 
    protected: // data
     bool copySaves = true;
@@ -38,4 +49,9 @@ struct InstanceCopyPrefs {
     bool copyServers = true;
     bool copyMods = true;
     bool copyScreenshots = true;
+    bool useSymLinks = false;
+    bool linkRecursively = false;
+    bool useHardLinks = false;
+    bool dontLinkSaves = false;
+    bool useClone = false;
 };

launcher/InstanceCopyTask.cpp

@@ -1,18 +1,31 @@
 #include "InstanceCopyTask.h"
-#include "settings/INISettingsObject.h"
+#include <QDebug>
+#include <QtConcurrentRun>
 #include "FileSystem.h"
 #include "NullInstance.h"
 #include "pathmatcher/RegexpMatcher.h"
-#include <QtConcurrentRun>
+#include "settings/INISettingsObject.h"
 
 InstanceCopyTask::InstanceCopyTask(InstancePtr origInstance, const InstanceCopyPrefs& prefs)
 {
     m_origInstance = origInstance;
     m_keepPlaytime = prefs.isKeepPlaytimeEnabled();
+    m_useLinks = prefs.isUseSymLinksEnabled();
+    m_linkRecursively = prefs.isLinkRecursivelyEnabled();
+    m_useHardLinks = prefs.isLinkRecursivelyEnabled() && prefs.isUseHardLinksEnabled();
+    m_copySaves = prefs.isLinkRecursivelyEnabled() && prefs.isDontLinkSavesEnabled() && prefs.isCopySavesEnabled();
+    m_useClone = prefs.isUseCloneEnabled();
 
     QString filters = prefs.getSelectedFiltersAsRegex();
+    if (m_useLinks || m_useHardLinks) {
         if (!filters.isEmpty())
-    {
+            filters += "|";
+        filters += "instance.cfg";
+    }
+
+    qDebug() << "CopyFilters:" << filters;
+
+    if (!filters.isEmpty()) {
         // Set regex filter:
         // FIXME: get this from the original instance type...
         auto matcherReal = new RegexpMatcher(filters);
@@ -25,11 +38,78 @@ void InstanceCopyTask::executeTask()
 {
     setStatus(tr("Copying instance %1").arg(m_origInstance->name()));
 
-    m_copyFuture = QtConcurrent::run(QThreadPool::globalInstance(), [this]{
+    auto copySaves = [&]() {
+        FS::copy savesCopy(FS::PathCombine(m_origInstance->instanceRoot(), "saves"), FS::PathCombine(m_stagingPath, "saves"));
+        savesCopy.followSymlinks(true);
+
+        return savesCopy();
+    };
+
+    m_copyFuture = QtConcurrent::run(QThreadPool::globalInstance(), [this, copySaves] {
+        if (m_useClone) {
+            FS::clone folderClone(m_origInstance->instanceRoot(), m_stagingPath);
+            folderClone.matcher(m_matcher.get());
+
+            return folderClone();
+        } else if (m_useLinks || m_useHardLinks) {
+            FS::create_link folderLink(m_origInstance->instanceRoot(), m_stagingPath);
+            int depth = m_linkRecursively ? -1 : 0;  // we need to at least link the top level instead of the instance folder
+            folderLink.linkRecursively(true).setMaxDepth(depth).useHardLinks(m_useHardLinks).matcher(m_matcher.get());
+
+            bool there_were_errors = false;
+
+            if (!folderLink()) {
+#if defined Q_OS_WIN32
+                if (!m_useHardLinks) {
+                    qDebug() << "EXPECTED: Link failure, Windows requires permissions for symlinks";
+
+                    qDebug() << "attempting to run with privelage";
+
+                    QEventLoop loop;
+                    bool got_priv_results = false;
+
+                    connect(&folderLink, &FS::create_link::finishedPrivileged, this, [&](bool gotResults) {
+                        if (!gotResults) {
+                            qDebug() << "Privileged run exited without results!";
+                        }
+                        got_priv_results = gotResults;
+                        loop.quit();
+                    });
+                    folderLink.runPrivileged();
+
+                    loop.exec();  // wait for the finished signal
+
+                    for (auto result : folderLink.getResults()) {
+                        if (result.err_value != 0) {
+                            there_were_errors = true;
+                        }
+                    }
+
+                    if (m_copySaves) {
+                        there_were_errors |= !copySaves();
+                    }
+
+                    return got_priv_results && !there_were_errors;
+                } else {
+                    qDebug() << "Link Failed!" << folderLink.getOSError().value() << folderLink.getOSError().message().c_str();
+                }
+#else
+                qDebug() << "Link Failed!" << folderLink.getOSError().value() << folderLink.getOSError().message().c_str();
+#endif
+                return false;
+            }
+
+            if (m_copySaves) {
+                there_were_errors |= !copySaves();
+            }
+
+            return !there_were_errors;
+        } else {
             FS::copy folderCopy(m_origInstance->instanceRoot(), m_stagingPath);
             folderCopy.followSymlinks(false).matcher(m_matcher.get());
 
             return folderCopy();
+        }
     });
     connect(&m_copyFutureWatcher, &QFutureWatcher<bool>::finished, this, &InstanceCopyTask::copyFinished);
     connect(&m_copyFutureWatcher, &QFutureWatcher<bool>::canceled, this, &InstanceCopyTask::copyAborted);
@@ -39,8 +119,7 @@ void InstanceCopyTask::executeTask()
 void InstanceCopyTask::copyFinished()
 {
     auto successful = m_copyFuture.result();
-    if(!successful)
+    if (!successful) {
-    {
         emitFailed(tr("Instance folder copy failed."));
         return;
     }
@@ -50,9 +129,11 @@ void InstanceCopyTask::copyFinished()
     InstancePtr inst(new NullInstance(m_globalSettings, instanceSettings, m_stagingPath));
     inst->setName(name());
     inst->setIconKey(m_instIcon);
-    if(!m_keepPlaytime) {
+    if (!m_keepPlaytime) {
         inst->resetTimePlayed();
     }
+    if (m_useLinks)
+        inst->addLinkedInstanceId(m_origInstance->id());
     emitSucceeded();
 }
 

launcher/InstanceCopyTask.h

@@ -30,4 +30,9 @@ private:
     QFutureWatcher<bool> m_copyFutureWatcher;
     std::unique_ptr<IPathMatcher> m_matcher;
     bool m_keepPlaytime;
+    bool m_useLinks = false;
+    bool m_useHardLinks = false;
+    bool m_copySaves = false;
+    bool m_linkRecursively = false;
+    bool m_useClone = false;
 };

launcher/InstanceCreationTask.h

@@ -34,7 +34,7 @@ class InstanceCreationTask : public InstanceTask {
     QString getError() const { return m_error_message; }
 
    protected:
-    void setError(QString message) { m_error_message = message; };
+    void setError(const QString& message) { m_error_message = message; };
 
    protected:
     bool m_abort = false;

launcher/InstanceImportTask.cpp

@@ -41,6 +41,7 @@
 #include "MMCZip.h"
 #include "NullInstance.h"
 
+#include "QObjectPtr.h"
 #include "icons/IconList.h"
 #include "icons/IconUtils.h"
 
@@ -66,7 +67,12 @@ bool InstanceImportTask::abort()
 
     if (m_filesNetJob)
         m_filesNetJob->abort();
+    if (m_extractFuture.isRunning()) {
+        // NOTE: The tasks created by QtConcurrent::run() can't actually get cancelled,
+        // but we can use this call to check the state when the extraction finishes.
         m_extractFuture.cancel();
+        m_extractFuture.waitForFinished();
+    }
 
     return Task::abort();
 }
@@ -93,6 +99,7 @@ void InstanceImportTask::executeTask()
 
         connect(m_filesNetJob.get(), &NetJob::succeeded, this, &InstanceImportTask::downloadSucceeded);
         connect(m_filesNetJob.get(), &NetJob::progress, this, &InstanceImportTask::downloadProgressChanged);
+        connect(m_filesNetJob.get(), &NetJob::stepProgress, this, &InstanceImportTask::propogateStepProgress);
         connect(m_filesNetJob.get(), &NetJob::failed, this, &InstanceImportTask::downloadFailed);
         connect(m_filesNetJob.get(), &NetJob::aborted, this, &InstanceImportTask::downloadAborted);
 
@@ -185,18 +192,20 @@ void InstanceImportTask::processZipPack()
     // make sure we extract just the pack
     m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractSubDir, m_packZip.get(), root, extractDir.absolutePath());
     connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &InstanceImportTask::extractFinished);
-    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &InstanceImportTask::extractAborted);
     m_extractFutureWatcher.setFuture(m_extractFuture);
 }
 
 void InstanceImportTask::extractFinished()
 {
     m_packZip.reset();
-    if (!m_extractFuture.result())
+
-    {
+    if (m_extractFuture.isCanceled())
+        return;
+    if (!m_extractFuture.result().has_value()) {
         emitFailed(tr("Failed to extract modpack"));
         return;
     }
+
     QDir extractDir(m_stagingPath);
 
     qDebug() << "Fixing permissions for extracted pack files...";
@@ -250,14 +259,9 @@ void InstanceImportTask::extractFinished()
     }
 }
 
-void InstanceImportTask::extractAborted()
-{
-    emitAborted();
-}
-
 void InstanceImportTask::processFlame()
 {
-    FlameCreationTask* inst_creation_task = nullptr;
+    shared_qobject_ptr<FlameCreationTask> inst_creation_task = nullptr;
     if (!m_extra_info.isEmpty()) {
         auto pack_id_it = m_extra_info.constFind("pack_id");
         Q_ASSERT(pack_id_it != m_extra_info.constEnd());
@@ -272,10 +276,10 @@ void InstanceImportTask::processFlame()
         if (original_instance_id_it != m_extra_info.constEnd())
             original_instance_id = original_instance_id_it.value();
 
-        inst_creation_task = new FlameCreationTask(m_stagingPath, m_globalSettings, m_parent, pack_id, pack_version_id, original_instance_id);
+        inst_creation_task = makeShared<FlameCreationTask>(m_stagingPath, m_globalSettings, m_parent, pack_id, pack_version_id, original_instance_id);
     } else {
         // FIXME: Find a way to get IDs in directly imported ZIPs
-        inst_creation_task = new FlameCreationTask(m_stagingPath, m_globalSettings, m_parent, {}, {});
+        inst_creation_task = makeShared<FlameCreationTask>(m_stagingPath, m_globalSettings, m_parent, QString(), QString());
     }
 
     inst_creation_task->setName(*this);
@@ -283,18 +287,19 @@ void InstanceImportTask::processFlame()
     inst_creation_task->setGroup(m_instGroup);
     inst_creation_task->setConfirmUpdate(shouldConfirmUpdate());
     
-    connect(inst_creation_task, &Task::succeeded, this, [this, inst_creation_task] {
+    connect(inst_creation_task.get(), &Task::succeeded, this, [this, inst_creation_task] {
         setOverride(inst_creation_task->shouldOverride(), inst_creation_task->originalInstanceID());
         emitSucceeded();
     });
-    connect(inst_creation_task, &Task::failed, this, &InstanceImportTask::emitFailed);
+    connect(inst_creation_task.get(), &Task::failed, this, &InstanceImportTask::emitFailed);
-    connect(inst_creation_task, &Task::progress, this, &InstanceImportTask::setProgress);
+    connect(inst_creation_task.get(), &Task::progress, this, &InstanceImportTask::setProgress);
-    connect(inst_creation_task, &Task::status, this, &InstanceImportTask::setStatus);
+    connect(inst_creation_task.get(), &Task::stepProgress, this, &InstanceImportTask::propogateStepProgress);
-    connect(inst_creation_task, &Task::finished, inst_creation_task, &InstanceCreationTask::deleteLater);
+    connect(inst_creation_task.get(), &Task::status, this, &InstanceImportTask::setStatus);
+    connect(inst_creation_task.get(), &Task::details, this, &InstanceImportTask::setDetails);
 
-    connect(this, &Task::aborted, inst_creation_task, &InstanceCreationTask::abort);
+    connect(this, &Task::aborted, inst_creation_task.get(), &InstanceCreationTask::abort);
-    connect(inst_creation_task, &Task::aborted, this, &Task::abort);
+    connect(inst_creation_task.get(), &Task::aborted, this, &Task::abort);
-    connect(inst_creation_task, &Task::abortStatusChanged, this, &Task::setAbortable);
+    connect(inst_creation_task.get(), &Task::abortStatusChanged, this, &Task::setAbortable);
 
     inst_creation_task->start();
 }
@@ -361,7 +366,7 @@ void InstanceImportTask::processModrinth()
     } else {
         QString pack_id;
         if (!m_sourceUrl.isEmpty()) {
-            QRegularExpression regex(R"(data\/(.*)\/versions)");
+            QRegularExpression regex(R"(data\/([^\/]*)\/versions)");
             pack_id = regex.match(m_sourceUrl.toString()).captured(1);
         }
 
@@ -380,7 +385,9 @@ void InstanceImportTask::processModrinth()
     });
     connect(inst_creation_task, &Task::failed, this, &InstanceImportTask::emitFailed);
     connect(inst_creation_task, &Task::progress, this, &InstanceImportTask::setProgress);
+    connect(inst_creation_task, &Task::stepProgress, this, &InstanceImportTask::propogateStepProgress);
     connect(inst_creation_task, &Task::status, this, &InstanceImportTask::setStatus);
+    connect(inst_creation_task, &Task::details, this, &InstanceImportTask::setDetails);
     connect(inst_creation_task, &Task::finished, inst_creation_task, &InstanceCreationTask::deleteLater);
 
     connect(this, &Task::aborted, inst_creation_task, &InstanceCreationTask::abort);

launcher/InstanceImportTask.h

@@ -81,7 +81,6 @@ private slots:
     void downloadProgressChanged(qint64 current, qint64 total);
     void downloadAborted();
     void extractFinished();
-    void extractAborted();
 
 private: /* data */
     NetJob::Ptr m_filesNetJob;

launcher/InstanceList.cpp

@@ -129,6 +129,16 @@ QMimeData* InstanceList::mimeData(const QModelIndexList& indexes) const
     return mimeData;
 }
 
+QStringList InstanceList::getLinkedInstancesById(const QString &id) const
+{
+    QStringList linkedInstances;
+    for (auto inst : m_instances) {
+        if (inst->isLinkedToInstanceId(id))
+            linkedInstances.append(inst->id());
+    }
+    return linkedInstances;
+}
+
 int InstanceList::rowCount(const QModelIndex& parent) const
 {
     Q_UNUSED(parent);
@@ -787,7 +797,9 @@ class InstanceStaging : public Task {
         connect(child, &Task::aborted, this, &InstanceStaging::childAborted);
         connect(child, &Task::abortStatusChanged, this, &InstanceStaging::setAbortable);
         connect(child, &Task::status, this, &InstanceStaging::setStatus);
+        connect(child, &Task::details, this, &InstanceStaging::setDetails);
         connect(child, &Task::progress, this, &InstanceStaging::setProgress);
+        connect(child, &Task::stepProgress, this, &InstanceStaging::propogateStepProgress);
         connect(&m_backoffTimer, &QTimer::timeout, this, &InstanceStaging::childSucceded);
     }
 
@@ -865,7 +877,7 @@ Task* InstanceList::wrapInstanceTask(InstanceTask* task)
 
 QString InstanceList::getStagedInstancePath()
 {
-    QString key = QUuid::createUuid().toString();
+    QString key = QUuid::createUuid().toString(QUuid::WithoutBraces);
     QString tempDir = ".LAUNCHER_TEMP/";
     QString relPath = FS::PathCombine(tempDir, key);
     QDir rootPath(m_instDir);

launcher/InstanceList.h

@@ -154,6 +154,8 @@ public:
     QStringList mimeTypes() const override;
     QMimeData *mimeData(const QModelIndexList &indexes) const override;
 
+    QStringList getLinkedInstancesById(const QString &id) const;
+
 signals:
     void dataIsInvalid();
     void instancesChanged();

launcher/InstancePageProvider.h

@@ -36,9 +36,10 @@ public:
         values.append(new VersionPage(onesix.get()));
         values.append(ManagedPackPage::createPage(onesix.get()));
         auto modsPage = new ModFolderPage(onesix.get(), onesix->loaderModList());
-        modsPage->setFilter("%1 (*.zip *.jar *.litemod)");
+        modsPage->setFilter("%1 (*.zip *.jar *.litemod *.nilmod)");
         values.append(modsPage);
         values.append(new CoreModFolderPage(onesix.get(), onesix->coreModList()));
+        values.append(new NilModFolderPage(onesix.get(), onesix->nilModList()));
         values.append(new ResourcePackPage(onesix.get(), onesix->resourcePackList()));
         values.append(new TexturePackPage(onesix.get(), onesix->texturePackList()));
         values.append(new ShaderPackPage(onesix.get(), onesix->shaderPackList()));

launcher/JavaCommon.cpp

@@ -122,8 +122,7 @@ void JavaCommon::TestCheck::run()
         return;
     }
     checker.reset(new JavaChecker());
-    connect(checker.get(), SIGNAL(checkFinished(JavaCheckResult)), this,
+    connect(checker.get(), &JavaChecker::checkFinished, this, &JavaCommon::TestCheck::checkFinished);
-            SLOT(checkFinished(JavaCheckResult)));
     checker->m_path = m_path;
     checker->performCheck();
 }
@@ -137,8 +136,7 @@ void JavaCommon::TestCheck::checkFinished(JavaCheckResult result)
         return;
     }
     checker.reset(new JavaChecker());
-    connect(checker.get(), SIGNAL(checkFinished(JavaCheckResult)), this,
+    connect(checker.get(), &JavaChecker::checkFinished, this, &JavaCommon::TestCheck::checkFinishedWithArgs);
-            SLOT(checkFinishedWithArgs(JavaCheckResult)));
     checker->m_path = m_path;
     checker->m_args = m_args;
     checker->m_minMem = m_minMem;

launcher/Launcher.in

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Basic start script for running the launcher with the libs packaged with it.
 
 function printerror {

launcher/LoggedProcess.cpp

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-only
 /*
- *  PolyMC - Minecraft Launcher
+ *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2022,2023 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (c) 2023 flowln <flowlnlnln@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
@@ -43,12 +44,8 @@ LoggedProcess::LoggedProcess(QObject *parent) : QProcess(parent)
     // QProcess has a strange interface... let's map a lot of those into a few.
     connect(this, &QProcess::readyReadStandardOutput, this, &LoggedProcess::on_stdOut);
     connect(this, &QProcess::readyReadStandardError, this, &LoggedProcess::on_stdErr);
-    connect(this, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(on_exit(int,QProcess::ExitStatus)));
+    connect(this, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &LoggedProcess::on_exit);
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    connect(this, &QProcess::errorOccurred, this, &LoggedProcess::on_error);
-    connect(this, SIGNAL(errorOccurred(QProcess::ProcessError)), this, SLOT(on_error(QProcess::ProcessError)));
-#else
-    connect(this, SIGNAL(error(QProcess::ProcessError)), this, SLOT(on_error(QProcess::ProcessError)));
-#endif
     connect(this, &QProcess::stateChanged, this, &LoggedProcess::on_stateChange);
 }
 
@@ -60,14 +57,23 @@ LoggedProcess::~LoggedProcess()
     }
 }
 
-QStringList reprocess(const QByteArray& data, QTextDecoder& decoder)
+QStringList LoggedProcess::reprocess(const QByteArray& data, QTextDecoder& decoder)
 {
     auto str = decoder.toUnicode(data);
+
+    if (!m_leftover_line.isEmpty()) {
+        str.prepend(m_leftover_line);
+        m_leftover_line = "";
+    }
+
 #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
     auto lines = str.remove(QChar::CarriageReturn).split(QChar::LineFeed, QString::SkipEmptyParts);
 #else
     auto lines = str.remove(QChar::CarriageReturn).split(QChar::LineFeed, Qt::SkipEmptyParts);
 #endif
+
+    if (!str.endsWith(QChar::LineFeed))
+        m_leftover_line = lines.takeLast();
     return lines;
 }
 

launcher/LoggedProcess.h

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 /*
- *  PolyMC - Minecraft Launcher
+ *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2022,2023 Sefa Eyeoglu <contact@scrumplex.net>
  *
  *  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
@@ -88,9 +88,12 @@ private slots:
 private:
     void changeState(LoggedProcess::State state);
 
+    QStringList reprocess(const QByteArray& data, QTextDecoder& decoder);
+
 private:
     QTextDecoder m_err_decoder = QTextDecoder(QTextCodec::codecForLocale());
     QTextDecoder m_out_decoder = QTextDecoder(QTextCodec::codecForLocale());
+    QString m_leftover_line;
     bool m_killed = false;
     State m_state = NotRunning;
     int m_exit_code = 0;

launcher/MMCTime.cpp

@@ -18,6 +18,8 @@
 #include <MMCTime.h>
 
 #include <QObject>
+#include <QDateTime>
+#include <QTextStream>
 
 QString Time::prettifyDuration(int64_t duration) {
     int seconds = (int) (duration % 60);
@@ -36,3 +38,65 @@ QString Time::prettifyDuration(int64_t duration) {
     }
     return QObject::tr("%1d %2h %3min").arg(days).arg(hours).arg(minutes);
 }
+
+QString Time::humanReadableDuration(double duration, int precision) {
+
+    using days = std::chrono::duration<int, std::ratio<86400>>;
+
+    QString outStr;
+    QTextStream os(&outStr);
+
+    bool neg = false;
+    if (duration < 0) {
+        neg = true; // flag
+        duration  *= -1; // invert
+    }
+        
+    auto std_duration = std::chrono::duration<double>(duration);
+    auto d = std::chrono::duration_cast<days>(std_duration);
+    std_duration -= d;
+    auto h = std::chrono::duration_cast<std::chrono::hours>(std_duration);
+    std_duration -= h;
+    auto m = std::chrono::duration_cast<std::chrono::minutes>(std_duration);
+    std_duration -= m;
+    auto s = std::chrono::duration_cast<std::chrono::seconds>(std_duration);
+    std_duration -= s;
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(std_duration);
+
+    auto dc = d.count();
+    auto hc = h.count();
+    auto mc = m.count();
+    auto sc = s.count();
+    auto msc = ms.count();
+
+    if (neg) {
+        os << '-';
+    }
+    if (dc) {
+        os << dc << QObject::tr("days");
+    }
+    if (hc) {
+        if (dc)
+            os << " ";
+        os << qSetFieldWidth(2) << hc << QObject::tr("h"); // hours
+    }
+    if (mc) {
+        if (dc || hc)
+            os << " ";
+        os << qSetFieldWidth(2) << mc << QObject::tr("m"); // minutes
+    }
+    if (dc || hc || mc || sc) {
+        if (dc || hc || mc)
+            os << " ";
+        os << qSetFieldWidth(2) << sc << QObject::tr("s"); // seconds
+    }
+    if ((msc && (precision > 0)) || !(dc || hc || mc || sc)) {
+        if (dc || hc || mc || sc)
+            os << " ";
+        os << qSetFieldWidth(0) << qSetRealNumberPrecision(precision) << msc << QObject::tr("ms"); // miliseconds
+    }
+
+    os.flush();
+
+    return outStr;
+}

launcher/MMCTime.h

@@ -22,4 +22,13 @@ namespace Time {
 
 QString prettifyDuration(int64_t duration);
 
+/**
+ * @brief Returns a string with short form time duration ie. `2days 1h3m4s56.0ms`.
+ * miliseconds are only included if `precision` is greater than 0.
+ * 
+ * @param duration a number of seconds as floating point
+ * @param precision number of decmial points to display on fractons of a second, defualts to 0.
+ * @return QString 
+ */
+QString humanReadableDuration(double duration, int precision = 0);
 }

launcher/MMCZip.cpp

@@ -94,20 +94,28 @@ bool MMCZip::mergeZipFiles(QuaZip *into, QFileInfo from, QSet<QString> &containe
     return true;
 }
 
-bool MMCZip::compressDirFiles(QuaZip *zip, QString dir, QFileInfoList files)
+bool MMCZip::compressDirFiles(QuaZip *zip, QString dir, QFileInfoList files, bool followSymlinks)
 {
     QDir directory(dir);
     if (!directory.exists()) return false;
 
     for (auto e : files) {
         auto filePath = directory.relativeFilePath(e.absoluteFilePath());
-        if( !JlCompress::compressFile(zip, e.absoluteFilePath(), filePath)) return false;
+        auto srcPath = e.absoluteFilePath();
+        if (followSymlinks) {
+            if (e.isSymLink()) {
+                srcPath = e.symLinkTarget();
+            } else {
+                srcPath = e.canonicalFilePath();
+            }
+        }
+        if( !JlCompress::compressFile(zip, srcPath, filePath)) return false;
     }
 
     return true;
 }
 
-bool MMCZip::compressDirFiles(QString fileCompressed, QString dir, QFileInfoList files)
+bool MMCZip::compressDirFiles(QString fileCompressed, QString dir, QFileInfoList files, bool followSymlinks)
 {
     QuaZip zip(fileCompressed);
     QDir().mkpath(QFileInfo(fileCompressed).absolutePath());
@@ -116,7 +124,7 @@ bool MMCZip::compressDirFiles(QString fileCompressed, QString dir, QFileInfoList
         return false;
     }
 
-    auto result = compressDirFiles(&zip, dir, files);
+    auto result = compressDirFiles(&zip, dir, files, followSymlinks);
 
     zip.close();
     if(zip.getZipError()!=0) {
@@ -275,7 +283,8 @@ bool MMCZip::findFilesInZip(QuaZip * zip, const QString & what, QStringList & re
 // ours
 std::optional<QStringList> MMCZip::extractSubDir(QuaZip *zip, const QString & subdir, const QString &target)
 {
-    QDir directory(target);
+    auto target_top_dir = QUrl::fromLocalFile(target);
+
     QStringList extracted;
 
     qDebug() << "Extracting subdir" << subdir << "from" << zip->getZipName() << "to" << target;
@@ -294,48 +303,53 @@ std::optional<QStringList> MMCZip::extractSubDir(QuaZip *zip, const QString & su
         return std::nullopt;
     }
 
-    do
+    do {
-    {
+        QString file_name = zip->getCurrentFileName();
-        QString name = zip->getCurrentFileName();
+        if (!file_name.startsWith(subdir))
-        if(!name.startsWith(subdir))
-        {
             continue;
-        }
 
-        name.remove(0, subdir.size());
+        auto relative_file_name = QDir::fromNativeSeparators(file_name.remove(0, subdir.size()));
-        auto original_name = name;
+        auto original_name = relative_file_name;
+
+        // Fix subdirs/files ending with a / getting transformed into absolute paths
+        if (relative_file_name.startsWith('/'))
+            relative_file_name = relative_file_name.mid(1);
 
         // Fix weird "folders with a single file get squashed" thing
-        QString path;
+        QString sub_path;
-        if(name.contains('/') && !name.endsWith('/')){
+        if (relative_file_name.contains('/') && !relative_file_name.endsWith('/')) {
-            path = name.section('/', 0, -2) + "/";
+            sub_path = relative_file_name.section('/', 0, -2) + '/';
-            FS::ensureFolderPathExists(FS::PathCombine(target, path));
+            FS::ensureFolderPathExists(FS::PathCombine(target, sub_path));
 
-            name = name.split('/').last();
+            relative_file_name = relative_file_name.split('/').last();
         }
 
-        QString absFilePath;
+        QString target_file_path;
-        if(name.isEmpty())
+        if (relative_file_name.isEmpty()) {
-        {
+            target_file_path = target + '/';
-            absFilePath = directory.absoluteFilePath(name) + "/";
+        } else {
-        }
+            target_file_path = FS::PathCombine(target_top_dir.toLocalFile(), sub_path, relative_file_name);
-        else
+            if (relative_file_name.endsWith('/') && !target_file_path.endsWith('/'))
-        {
+                target_file_path += '/';
-            absFilePath = directory.absoluteFilePath(path + name);
         }
 
-        if (!JlCompress::extractFile(zip, "", absFilePath))
+        if (!target_top_dir.isParentOf(QUrl::fromLocalFile(target_file_path))) {
-        {
+            qWarning() << "Extracting" << relative_file_name << "was cancelled, because it was effectively outside of the target path" << target;
-            qWarning() << "Failed to extract file" << original_name << "to" << absFilePath;
+            return std::nullopt;
+        }
+
+        if (!JlCompress::extractFile(zip, "", target_file_path)) {
+            qWarning() << "Failed to extract file" << original_name << "to" << target_file_path;
             JlCompress::removeFile(extracted);
             return std::nullopt;
         }
 
-        extracted.append(absFilePath);
+        extracted.append(target_file_path);
-        QFile::setPermissions(absFilePath, QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser | QFileDevice::Permission::ExeUser);
+        QFile::setPermissions(target_file_path, QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser | QFileDevice::Permission::ExeUser);
 
-        qDebug() << "Extracted file" << name << "to" << absFilePath;
+        qDebug() << "Extracted file" << relative_file_name << "to" << target_file_path;
     } while (zip->goToNextFile());
+
     return extracted;
 }
 

launcher/MMCZip.h

@@ -59,18 +59,20 @@ namespace MMCZip
      * \param zip target archive
      * \param dir directory that will be compressed (to compress with relative paths)
      * \param files list of files to compress
+     * \param followSymlinks should follow symlinks when compressing file data
      * \return true for success or false for failure
      */
-    bool compressDirFiles(QuaZip *zip, QString dir, QFileInfoList files);
+    bool compressDirFiles(QuaZip *zip, QString dir, QFileInfoList files, bool followSymlinks = false);
 
     /**
      * Compress directory, by providing a list of files to compress
      * \param fileCompressed target archive file
      * \param dir directory that will be compressed (to compress with relative paths)
      * \param files list of files to compress
+     * \param followSymlinks should follow symlinks when compressing file data
      * \return true for success or false for failure
      */
-    bool compressDirFiles(QString fileCompressed, QString dir, QFileInfoList files);
+    bool compressDirFiles(QString fileCompressed, QString dir, QFileInfoList files, bool followSymlinks = false);
 
     /**
      * take a source jar, add mods to it, resulting in target jar

launcher/MangoHud.cpp

@@ -19,6 +19,7 @@
 #include <QStringList>
 #include <QDir>
 #include <QString>
+#include <QSysInfo>
 #include <QtGlobal>
 
 #include "MangoHud.h"
@@ -75,9 +76,27 @@ QString getLibraryString()
     }
 
     for (QString vkLayer : vkLayerList) {
-        QString filePath = FS::PathCombine(vkLayer, "MangoHud.json");
+        // prefer to use architecture specific vulkan layers
-        if (!QFile::exists(filePath))
+        QString currentArch = QSysInfo::currentCpuArchitecture();
+
+        if (currentArch == "arm64") {
+            currentArch = "aarch64";
+        }
+
+        QStringList manifestNames = { QString("MangoHud.%1.json").arg(currentArch), "MangoHud.json" };
+
+        QString filePath = "";
+        for (QString manifestName : manifestNames) {
+            QString tryPath = FS::PathCombine(vkLayer, manifestName);
+            if (QFile::exists(tryPath)) {
+                filePath = tryPath;
+                break;
+            }
+        }
+
+        if (filePath.isEmpty()) {
             continue;
+        }
 
         auto conf = Json::requireDocument(filePath, vkLayer);
         auto confObject = Json::requireObject(conf, vkLayer);

launcher/QVariantUtils.h

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2023 flowln <flowlnlnln@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/>.
+ *
+ * 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
+
+
+#include <QVariant>
+#include <QList>
+
+namespace QVariantUtils {
+
+template <typename T> 
+inline QList<T> toList(QVariant src) {
+    QVariantList variantList = src.toList();
+
+    QList<T> list_t;
+    list_t.reserve(variantList.size());
+    for (const QVariant& v : variantList)
+    {
+        list_t.append(v.value<T>());
+    }
+    return list_t; 
+}
+
+template <typename T> 
+inline QVariant fromList(QList<T> val) {
+    QVariantList variantList;
+    variantList.reserve(val.size());
+    for (const T& v : val)
+    {
+        variantList.append(v);
+    }
+
+    return variantList;
+}
+
+}

launcher/ResourceDownloadTask.cpp

@@ -53,6 +53,7 @@ ResourceDownloadTask::ResourceDownloadTask(ModPlatform::IndexedPack pack,
     m_filesNetJob->addNetAction(Net::Download::makeFile(m_pack_version.downloadUrl, dir.absoluteFilePath(getFilename())));
     connect(m_filesNetJob.get(), &NetJob::succeeded, this, &ResourceDownloadTask::downloadSucceeded);
     connect(m_filesNetJob.get(), &NetJob::progress, this, &ResourceDownloadTask::downloadProgressChanged);
+    connect(m_filesNetJob.get(), &NetJob::stepProgress, this, &ResourceDownloadTask::propogateStepProgress);
     connect(m_filesNetJob.get(), &NetJob::failed, this, &ResourceDownloadTask::downloadFailed);
 
     addTask(m_filesNetJob);

launcher/StringUtils.cpp

@@ -1,5 +1,45 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2023 flowln <flowlnlnln@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/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
+
 #include "StringUtils.h"
 
+#include <QRegularExpression>
+#include <QUuid>
+#include <cmath>
+
 /// If you're wondering where these came from exactly, then know you're not the only one =D
 
 /// TAKEN FROM Qt, because it doesn't expose it intelligently
@@ -74,3 +114,71 @@ int StringUtils::naturalCompare(const QString& s1, const QString& s2, Qt::CaseSe
     // The two strings are the same (02 == 2) so fall back to the normal sort
     return QString::compare(s1, s2, cs);
 }
+
+QString StringUtils::truncateUrlHumanFriendly(QUrl& url, int max_len, bool hard_limit)
+{
+    auto display_options = QUrl::RemoveUserInfo | QUrl::RemoveFragment | QUrl::NormalizePathSegments;
+    auto str_url = url.toDisplayString(display_options);
+
+    if (str_url.length() <= max_len)
+        return str_url;
+
+    auto url_path_parts = url.path().split('/');
+    QString last_path_segment = url_path_parts.takeLast();
+
+    if (url_path_parts.size() >= 1 && url_path_parts.first().isEmpty())
+        url_path_parts.removeFirst();  // drop empty first segment (from leading / )
+
+    if (url_path_parts.size() >= 1)
+        url_path_parts.removeLast();  // drop the next to last path segment
+
+    auto url_template = QStringLiteral("%1://%2/%3%4");
+
+    auto url_compact = url_path_parts.isEmpty()
+                           ? url_template.arg(url.scheme(), url.host(), QStringList({ "...", last_path_segment }).join('/'), url.query())
+                           : url_template.arg(url.scheme(), url.host(),
+                                              QStringList({ url_path_parts.join('/'), "...", last_path_segment }).join('/'), url.query());
+
+    // remove url parts one by one if it's still too long
+    while (url_compact.length() > max_len && url_path_parts.size() >= 1) {
+        url_path_parts.removeLast();  // drop the next to last path segment
+        url_compact = url_path_parts.isEmpty()
+                          ? url_template.arg(url.scheme(), url.host(), QStringList({ "...", last_path_segment }).join('/'), url.query())
+                          : url_template.arg(url.scheme(), url.host(),
+                                             QStringList({ url_path_parts.join('/'), "...", last_path_segment }).join('/'), url.query());
+    }
+
+    if ((url_compact.length() >= max_len) && hard_limit) {
+        // still too long, truncate normaly
+        url_compact = QString(str_url);
+        auto to_remove = url_compact.length() - max_len + 3;
+        url_compact.remove(url_compact.length() - to_remove - 1, to_remove);
+        url_compact.append("...");
+    }
+
+    return url_compact;
+}
+
+static const QStringList s_units_si{ "KB", "MB", "GB", "TB" };
+static const QStringList s_units_kibi{ "KiB", "MiB", "GiB", "TiB" };
+
+QString StringUtils::humanReadableFileSize(double bytes, bool use_si, int decimal_points)
+{
+    const QStringList units = use_si ? s_units_si : s_units_kibi;
+    const int scale = use_si ? 1000 : 1024;
+
+    int u = -1;
+    double r = pow(10, decimal_points);
+
+    do {
+        bytes /= scale;
+        u++;
+    } while (round(abs(bytes) * r) / r >= scale && u < units.length() - 1);
+
+    return QString::number(bytes, 'f', 2) + " " + units[u];
+}
+
+QString StringUtils::getRandomAlphaNumeric()
+{
+    return QUuid::createUuid().toString(QUuid::Id128);
+}

launcher/StringUtils.h

@@ -1,6 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2023 flowln <flowlnlnln@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/>.
+ *
+ * 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
 
 #include <QString>
+#include <QUrl>
 
 namespace StringUtils {
 
@@ -29,4 +66,17 @@ inline QString fromStdString(string s)
 #endif
 
 int naturalCompare(const QString& s1, const QString& s2, Qt::CaseSensitivity cs);
+
+/**
+ * @brief Truncate a url while keeping its readability py placing the `...` in the middle of the path  
+ * @param url Url to truncate
+ * @param max_len max lenght of url in charaters
+ * @param hard_limit if truncating the path can't get the url short enough, truncate it normaly.
+ */
+QString truncateUrlHumanFriendly(QUrl &url, int max_len, bool hard_limit = false);
+
+QString humanReadableFileSize(double bytes, bool use_si = false, int decimal_points = 1);
+
+
+QString getRandomAlphaNumeric();
 }  // namespace StringUtils

launcher/filelink/FileLink.cpp

@@ -0,0 +1,277 @@
+// SPDX-FileCopyrightText: 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Rachel Powers <508861+Ryex@users.noreply.github.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 "FileLink.h"
+#include "BuildConfig.h"
+
+#include "StringUtils.h"
+
+#include <iostream>
+
+#include <QAccessible>
+#include <QCommandLineParser>
+
+#include <QDebug>
+
+#include <DesktopServices.h>
+
+#include <sys.h>
+
+#if defined Q_OS_WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <stdio.h>
+#include <windows.h>
+#endif
+
+// Snippet from https://github.com/gulrak/filesystem#using-it-as-single-file-header
+
+#ifdef __APPLE__
+#include <Availability.h>  // for deployment target to support pre-catalina targets without std::fs
+#endif                     // __APPLE__
+
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#include <filesystem>
+namespace fs = std::filesystem;
+#endif  // MacOS min version check
+#endif  // Other OSes version check
+
+#ifndef GHC_USE_STD_FS
+#include <ghc/filesystem.hpp>
+namespace fs = ghc::filesystem;
+#endif
+
+FileLinkApp::FileLinkApp(int& argc, char** argv) : QCoreApplication(argc, argv), socket(new QLocalSocket(this))
+{
+#if defined Q_OS_WIN32
+    // attach the parent console
+    if (AttachConsole(ATTACH_PARENT_PROCESS)) {
+        // if attach succeeds, reopen and sync all the i/o
+        if (freopen("CON", "w", stdout)) {
+            std::cout.sync_with_stdio();
+        }
+        if (freopen("CON", "w", stderr)) {
+            std::cerr.sync_with_stdio();
+        }
+        if (freopen("CON", "r", stdin)) {
+            std::cin.sync_with_stdio();
+        }
+        auto out = GetStdHandle(STD_OUTPUT_HANDLE);
+        DWORD written;
+        const char* endline = "\n";
+        WriteConsole(out, endline, strlen(endline), &written, NULL);
+        consoleAttached = true;
+    }
+#endif
+    setOrganizationName(BuildConfig.LAUNCHER_NAME);
+    setOrganizationDomain(BuildConfig.LAUNCHER_DOMAIN);
+    setApplicationName(BuildConfig.LAUNCHER_NAME + "FileLink");
+    setApplicationVersion(BuildConfig.printableVersionString() + "\n" + BuildConfig.GIT_COMMIT);
+
+    // Commandline parsing
+    QCommandLineParser parser;
+    parser.setApplicationDescription(QObject::tr("a batch MKLINK program for windows to be used with prismlauncher"));
+
+    parser.addOptions({ { { "s", "server" }, "Join the specified server on launch", "pipe name" },
+                        { { "H", "hard" }, "use hard links instead of symbolic", "true/false" } });
+    parser.addHelpOption();
+    parser.addVersionOption();
+
+    parser.process(arguments());
+
+    QString serverToJoin = parser.value("server");
+    m_useHardLinks = QVariant(parser.value("hard")).toBool();
+
+    qDebug() << "link program launched";
+
+    if (!serverToJoin.isEmpty()) {
+        qDebug() << "joining server" << serverToJoin;
+        joinServer(serverToJoin);
+    } else {
+        qDebug() << "no server to join";
+        exit();
+    }
+}
+
+void FileLinkApp::joinServer(QString server)
+{
+    blockSize = 0;
+
+    in.setDevice(&socket);
+
+    connect(&socket, &QLocalSocket::connected, this, [&]() { qDebug() << "connected to server"; });
+
+    connect(&socket, &QLocalSocket::readyRead, this, &FileLinkApp::readPathPairs);
+
+    connect(&socket, &QLocalSocket::errorOccurred, this, [&](QLocalSocket::LocalSocketError socketError) {
+        switch (socketError) {
+            case QLocalSocket::ServerNotFoundError:
+                qDebug()
+                    << ("The host was not found. Please make sure "
+                        "that the server is running and that the "
+                        "server name is correct.");
+                break;
+            case QLocalSocket::ConnectionRefusedError:
+                qDebug()
+                    << ("The connection was refused by the peer. "
+                        "Make sure the server is running, "
+                        "and check that the server name "
+                        "is correct.");
+                break;
+            case QLocalSocket::PeerClosedError:
+                qDebug() << ("The connection was closed by the peer. ");
+                break;
+            default:
+                qDebug() << "The following error occurred: " << socket.errorString();
+        }
+    });
+
+    connect(&socket, &QLocalSocket::disconnected, this, [&]() {
+        qDebug() << "disconnected from server, should exit";
+        exit();
+    });
+
+    socket.connectToServer(server);
+}
+
+void FileLinkApp::runLink()
+{
+    std::error_code os_err;
+
+    qDebug() << "creating links";
+
+    for (auto link : m_links_to_make) {
+        QString src_path = link.src;
+        QString dst_path = link.dst;
+
+        FS::ensureFilePathExists(dst_path);
+        if (m_useHardLinks) {
+            qDebug() << "making hard link:" << src_path << "to" << dst_path;
+            fs::create_hard_link(StringUtils::toStdString(src_path), StringUtils::toStdString(dst_path), os_err);
+        } else if (fs::is_directory(StringUtils::toStdString(src_path))) {
+            qDebug() << "making directory_symlink:" << src_path << "to" << dst_path;
+            fs::create_directory_symlink(StringUtils::toStdString(src_path), StringUtils::toStdString(dst_path), os_err);
+        } else {
+            qDebug() << "making symlink:" << src_path << "to" << dst_path;
+            fs::create_symlink(StringUtils::toStdString(src_path), StringUtils::toStdString(dst_path), os_err);
+        }
+
+        if (os_err) {
+            qWarning() << "Failed to link files:" << QString::fromStdString(os_err.message());
+            qDebug() << "Source file:" << src_path;
+            qDebug() << "Destination file:" << dst_path;
+            qDebug() << "Error category:" << os_err.category().name();
+            qDebug() << "Error code:" << os_err.value();
+
+            FS::LinkResult result = { src_path, dst_path, QString::fromStdString(os_err.message()), os_err.value() };
+            m_path_results.append(result);
+        } else {
+            FS::LinkResult result = { src_path, dst_path };
+            m_path_results.append(result);
+        }
+    }
+
+    sendResults();
+    qDebug() << "done, should exit soon";
+}
+
+void FileLinkApp::sendResults()
+{
+    // construct block of data to send
+    QByteArray block;
+    QDataStream out(&block, QIODevice::WriteOnly);
+
+    qint32 blocksize = quint32(sizeof(quint32));
+    for (auto result : m_path_results) {
+        blocksize += quint32(result.src.size());
+        blocksize += quint32(result.dst.size());
+        blocksize += quint32(result.err_msg.size());
+        blocksize += quint32(sizeof(quint32));
+    }
+    qDebug() << "About to write block of size:" << blocksize;
+    out << blocksize;
+
+    out << quint32(m_path_results.length());
+    for (auto result : m_path_results) {
+        out << result.src;
+        out << result.dst;
+        out << result.err_msg;
+        out << quint32(result.err_value);
+    }
+
+    qint64 byteswritten = socket.write(block);
+    bool bytesflushed = socket.flush();
+    qDebug() << "block flushed" << byteswritten << bytesflushed;
+}
+
+void FileLinkApp::readPathPairs()
+{
+    m_links_to_make.clear();
+    qDebug() << "Reading path pairs from server";
+    qDebug() << "bytes available" << socket.bytesAvailable();
+    if (blockSize == 0) {
+        // Relies on the fact that QDataStream serializes a quint32 into
+        // sizeof(quint32) bytes
+        if (socket.bytesAvailable() < (int)sizeof(quint32))
+            return;
+        qDebug() << "reading block size";
+        in >> blockSize;
+    }
+    qDebug() << "blocksize is" << blockSize;
+    qDebug() << "bytes available" << socket.bytesAvailable();
+    if (socket.bytesAvailable() < blockSize || in.atEnd())
+        return;
+
+    quint32 numLinks;
+    in >> numLinks;
+    qDebug() << "numLinks" << numLinks;
+
+    for (int i = 0; i < numLinks; i++) {
+        FS::LinkPair pair;
+        in >> pair.src;
+        in >> pair.dst;
+        qDebug() << "link" << pair.src << "to" << pair.dst;
+        m_links_to_make.append(pair);
+    }
+
+    runLink();
+}
+
+FileLinkApp::~FileLinkApp()
+{
+    qDebug() << "link program shutting down";
+    // Shut down logger by setting the logger function to nothing
+    qInstallMessageHandler(nullptr);
+
+#if defined Q_OS_WIN32
+    // Detach from Windows console
+    if (consoleAttached) {
+        fclose(stdout);
+        fclose(stdin);
+        fclose(stderr);
+        FreeConsole();
+    }
+#endif
+}

launcher/filelink/FileLink.h

@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Rachel Powers <508861+Ryex@users.noreply.github.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 <QtCore>
+
+#include <QApplication>
+#include <QDataStream>
+#include <QDateTime>
+#include <QDebug>
+#include <QFlag>
+#include <QIcon>
+#include <QLocalSocket>
+#include <QUrl>
+#include <memory>
+
+#define PRISM_EXTERNAL_EXE
+#include "FileSystem.h"
+
+class FileLinkApp : public QCoreApplication {
+    // friends for the purpose of limiting access to deprecated stuff
+    Q_OBJECT
+   public:
+    FileLinkApp(int& argc, char** argv);
+    virtual ~FileLinkApp();
+
+   private:
+    void joinServer(QString server);
+    void readPathPairs();
+    void runLink();
+    void sendResults();
+
+    bool m_useHardLinks = false;
+
+    QDateTime m_startTime;
+    QLocalSocket socket;
+    QDataStream in;
+    quint32 blockSize;
+
+    QList<FS::LinkPair> m_links_to_make;
+    QList<FS::LinkResult> m_path_results;
+
+#if defined Q_OS_WIN32
+    // used on Windows to attach the standard IO streams
+    bool consoleAttached = false;
+#endif
+};

launcher/filelink/filelink.exe.manifest

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+    </windowsSettings>
+  </application>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- Windows 10, Windows 11 -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+      <!-- Windows 8.1 -->
+      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+      <!-- Windows 8 -->
+      <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+      <!-- Windows 7 -->
+      <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+    </application>
+  </compatibility>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel
+          level="requireAdministrator"
+          uiAccess="false"/>
+       </requestedPrivileges>
+    </security>
+  </trustInfo>
+</assembly>

launcher/filelink/main.cpp

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Rachel Powers <508861+Ryex@users.noreply.github.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 "FileLink.h"
+
+int main(int argc, char* argv[])
+{
+    FileLinkApp ldh(argc, argv);
+
+    return ldh.exec();
+}

launcher/icons/IconList.cpp

@@ -66,9 +66,8 @@ IconList::IconList(const QStringList &builtinPaths, QString path, QObject *paren
 
     m_watcher.reset(new QFileSystemWatcher());
     is_watching = false;
-    connect(m_watcher.get(), SIGNAL(directoryChanged(QString)),
+    connect(m_watcher.get(), &QFileSystemWatcher::directoryChanged, this, &IconList::directoryChanged);
-            SLOT(directoryChanged(QString)));
+    connect(m_watcher.get(), &QFileSystemWatcher::fileChanged, this, &IconList::fileChanged);
-    connect(m_watcher.get(), SIGNAL(fileChanged(QString)), SLOT(fileChanged(QString)));
 
     directoryChanged(path);
 

launcher/java/JavaChecker.cpp

@@ -87,15 +87,11 @@ void JavaChecker::performCheck()
     process->setProcessEnvironment(CleanEnviroment());
     qDebug() << "Running java checker: " + m_path + args.join(" ");;
 
-    connect(process.get(), SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(finished(int, QProcess::ExitStatus)));
+    connect(process.get(), QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &JavaChecker::finished);
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    connect(process.get(), &QProcess::errorOccurred, this, &JavaChecker::error);
-    connect(process.get(), SIGNAL(errorOccurred(QProcess::ProcessError)), this, SLOT(error(QProcess::ProcessError)));
+    connect(process.get(), &QProcess::readyReadStandardOutput, this, &JavaChecker::stdoutReady);
-#else
+    connect(process.get(), &QProcess::readyReadStandardError, this, &JavaChecker::stderrReady);
-    connect(process.get(), SIGNAL(error(QProcess::ProcessError)), this, SLOT(error(QProcess::ProcessError)));
+    connect(&killTimer, &QTimer::timeout, this, &JavaChecker::timeout);
-#endif
-    connect(process.get(), SIGNAL(readyReadStandardOutput()), this, SLOT(stdoutReady()));
-    connect(process.get(), SIGNAL(readyReadStandardError()), this, SLOT(stderrReady()));
-    connect(&killTimer, SIGNAL(timeout()), SLOT(timeout()));
     killTimer.setSingleShot(true);
     killTimer.start(15000);
     process->start();

launcher/java/JavaCheckerJob.cpp

@@ -38,7 +38,7 @@ void JavaCheckerJob::executeTask()
     for (auto iter : javacheckers)
     {
         javaresults.append(JavaCheckResult());
-        connect(iter.get(), SIGNAL(checkFinished(JavaCheckResult)), SLOT(partFinished(JavaCheckResult)));
+        connect(iter.get(), &JavaChecker::checkFinished, this, &JavaCheckerJob::partFinished);
         iter->performCheck();
     }
 }

launcher/launch/steps/Update.cpp

@@ -26,9 +26,11 @@ void Update::executeTask()
     m_updateTask.reset(m_parent->instance()->createUpdateTask(m_mode));
     if(m_updateTask)
     {
-        connect(m_updateTask.get(), SIGNAL(finished()), this, SLOT(updateFinished()));
+        connect(m_updateTask.get(), &Task::finished, this, &Update::updateFinished);
-        connect(m_updateTask.get(), &Task::progress, this, &Task::setProgress);
+        connect(m_updateTask.get(), &Task::progress, this, &Update::setProgress);
-        connect(m_updateTask.get(), &Task::status, this, &Task::setStatus);
+        connect(m_updateTask.get(), &Task::stepProgress, this, &Update::propogateStepProgress);
+        connect(m_updateTask.get(), &Task::status, this, &Update::setStatus);
+        connect(m_updateTask.get(), &Task::details, this, &Update::setDetails);
         emit progressReportingRequest();
         return;
     }

launcher/meta/Version.cpp

@@ -99,6 +99,11 @@ QString Meta::Version::localFilename() const
     return m_uid + '/' + m_version + ".json";
 }
 
+::Version Meta::Version::toComparableVersion() const
+{
+    return { const_cast<Meta::Version*>(this)->descriptor() };
+}
+
 void Meta::Version::setType(const QString &type)
 {
     m_type = type;

launcher/meta/Version.h

@@ -16,6 +16,7 @@
 #pragma once
 
 #include "BaseVersion.h"
+#include "../Version.h"
 
 #include <QJsonObject>
 #include <QStringList>
@@ -85,6 +86,8 @@ public:
 
     QString localFilename() const override;
 
+    [[nodiscard]] ::Version toComparableVersion() const;
+
 public: // for usage by format parsers only
     void setType(const QString &type);
     void setTime(const qint64 time);

launcher/minecraft/MinecraftInstance.cpp

@@ -290,6 +290,11 @@ QString MinecraftInstance::coreModsDir() const
     return FS::PathCombine(gameRoot(), "coremods");
 }
 
+QString MinecraftInstance::nilModsDir() const
+{
+    return FS::PathCombine(gameRoot(), "nilmods");
+}
+
 QString MinecraftInstance::resourcePacksDir() const
 {
     return FS::PathCombine(gameRoot(), "resourcepacks");
@@ -927,7 +932,10 @@ QString MinecraftInstance::getStatusbarDescription()
     if(m_settings->get("ShowGameTime").toBool())
     {
         if (lastTimePlayed() > 0) {
-            description.append(tr(", last played for %1").arg(Time::prettifyDuration(lastTimePlayed())));
+            QDateTime lastLaunchTime = QDateTime::fromMSecsSinceEpoch(lastLaunch());
+            description.append(tr(", last played on %1 for %2")
+                                   .arg(QLocale().toString(lastLaunchTime, QLocale::ShortFormat))
+                                   .arg(Time::prettifyDuration(lastTimePlayed())));
         }
 
         if (totalTimePlayed() > 0) {
@@ -1114,67 +1122,79 @@ JavaVersion MinecraftInstance::getJavaVersion()
     return JavaVersion(settings()->get("JavaVersion").toString());
 }
 
-std::shared_ptr<ModFolderModel> MinecraftInstance::loaderModList() const
+std::shared_ptr<ModFolderModel> MinecraftInstance::loaderModList()
 {
     if (!m_loader_mod_list)
     {
         bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool();
-        m_loader_mod_list.reset(new ModFolderModel(modsRoot(), is_indexed));
+        m_loader_mod_list.reset(new ModFolderModel(modsRoot(), this, is_indexed));
         m_loader_mod_list->disableInteraction(isRunning());
         connect(this, &BaseInstance::runningStatusChanged, m_loader_mod_list.get(), &ModFolderModel::disableInteraction);
     }
     return m_loader_mod_list;
 }
 
-std::shared_ptr<ModFolderModel> MinecraftInstance::coreModList() const
+std::shared_ptr<ModFolderModel> MinecraftInstance::coreModList()
 {
     if (!m_core_mod_list)
     {
         bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool();
-        m_core_mod_list.reset(new ModFolderModel(coreModsDir(), is_indexed));
+        m_core_mod_list.reset(new ModFolderModel(coreModsDir(), this, is_indexed));
         m_core_mod_list->disableInteraction(isRunning());
         connect(this, &BaseInstance::runningStatusChanged, m_core_mod_list.get(), &ModFolderModel::disableInteraction);
     }
     return m_core_mod_list;
 }
 
-std::shared_ptr<ResourcePackFolderModel> MinecraftInstance::resourcePackList() const
+std::shared_ptr<ModFolderModel> MinecraftInstance::nilModList()
+{
+    if (!m_nil_mod_list)
+    {
+        bool is_indexed = !APPLICATION->settings()->get("ModMetadataDisabled").toBool();
+        m_nil_mod_list.reset(new ModFolderModel(nilModsDir(), this, is_indexed, false));
+        m_nil_mod_list->disableInteraction(isRunning());
+        connect(this, &BaseInstance::runningStatusChanged, m_nil_mod_list.get(), &ModFolderModel::disableInteraction);
+    }
+    return m_nil_mod_list;
+}
+
+std::shared_ptr<ResourcePackFolderModel> MinecraftInstance::resourcePackList()
 {
     if (!m_resource_pack_list)
     {
-        m_resource_pack_list.reset(new ResourcePackFolderModel(resourcePacksDir()));
+        m_resource_pack_list.reset(new ResourcePackFolderModel(resourcePacksDir(), this));
     }
     return m_resource_pack_list;
 }
 
-std::shared_ptr<TexturePackFolderModel> MinecraftInstance::texturePackList() const
+std::shared_ptr<TexturePackFolderModel> MinecraftInstance::texturePackList()
 {
     if (!m_texture_pack_list)
     {
-        m_texture_pack_list.reset(new TexturePackFolderModel(texturePacksDir()));
+        m_texture_pack_list.reset(new TexturePackFolderModel(texturePacksDir(), this));
     }
     return m_texture_pack_list;
 }
 
-std::shared_ptr<ShaderPackFolderModel> MinecraftInstance::shaderPackList() const
+std::shared_ptr<ShaderPackFolderModel> MinecraftInstance::shaderPackList()
 {
     if (!m_shader_pack_list)
     {
-        m_shader_pack_list.reset(new ShaderPackFolderModel(shaderPacksDir()));
+        m_shader_pack_list.reset(new ShaderPackFolderModel(shaderPacksDir(), this));
     }
     return m_shader_pack_list;
 }
 
-std::shared_ptr<WorldList> MinecraftInstance::worldList() const
+std::shared_ptr<WorldList> MinecraftInstance::worldList()
 {
     if (!m_world_list)
     {
-        m_world_list.reset(new WorldList(worldDir()));
+        m_world_list.reset(new WorldList(worldDir(), this));
     }
     return m_world_list;
 }
 
-std::shared_ptr<GameOptions> MinecraftInstance::gameOptionsModel() const
+std::shared_ptr<GameOptions> MinecraftInstance::gameOptionsModel()
 {
     if (!m_game_options)
     {

launcher/minecraft/MinecraftInstance.h

@@ -85,6 +85,7 @@ public:
     QString shaderPacksDir() const;
     QString modsRoot() const override;
     QString coreModsDir() const;
+    QString nilModsDir() const;
     QString modsCacheLocation() const;
     QString libDir() const;
     QString worldDir() const;
@@ -115,13 +116,14 @@ public:
     std::shared_ptr<PackProfile> getPackProfile() const;
 
     //////  Mod Lists  //////
-    std::shared_ptr<ModFolderModel> loaderModList() const;
+    std::shared_ptr<ModFolderModel> loaderModList();
-    std::shared_ptr<ModFolderModel> coreModList() const;
+    std::shared_ptr<ModFolderModel> coreModList();
-    std::shared_ptr<ResourcePackFolderModel> resourcePackList() const;
+    std::shared_ptr<ModFolderModel> nilModList();
-    std::shared_ptr<TexturePackFolderModel> texturePackList() const;
+    std::shared_ptr<ResourcePackFolderModel> resourcePackList();
-    std::shared_ptr<ShaderPackFolderModel> shaderPackList() const;
+    std::shared_ptr<TexturePackFolderModel> texturePackList();
-    std::shared_ptr<WorldList> worldList() const;
+    std::shared_ptr<ShaderPackFolderModel> shaderPackList();
-    std::shared_ptr<GameOptions> gameOptionsModel() const;
+    std::shared_ptr<WorldList> worldList();
+    std::shared_ptr<GameOptions> gameOptionsModel();
 
     //////  Launch stuff //////
     Task::Ptr createUpdateTask(Net::Mode mode) override;
@@ -171,6 +173,7 @@ protected: // data
     std::shared_ptr<PackProfile> m_components;
     mutable std::shared_ptr<ModFolderModel> m_loader_mod_list;
     mutable std::shared_ptr<ModFolderModel> m_core_mod_list;
+    mutable std::shared_ptr<ModFolderModel> m_nil_mod_list;
     mutable std::shared_ptr<ResourcePackFolderModel> m_resource_pack_list;
     mutable std::shared_ptr<ShaderPackFolderModel> m_shader_pack_list;
     mutable std::shared_ptr<TexturePackFolderModel> m_texture_pack_list;

launcher/minecraft/MinecraftLoadAndCheck.cpp

@@ -22,6 +22,7 @@ void MinecraftLoadAndCheck::executeTask()
     connect(m_task.get(), &Task::failed, this, &MinecraftLoadAndCheck::subtaskFailed);
     connect(m_task.get(), &Task::aborted, this, [this]{ subtaskFailed(tr("Aborted")); });
     connect(m_task.get(), &Task::progress, this, &MinecraftLoadAndCheck::progress);
+    connect(m_task.get(), &Task::stepProgress, this, &MinecraftLoadAndCheck::propogateStepProgress);
     connect(m_task.get(), &Task::status, this, &MinecraftLoadAndCheck::setStatus);
 }
 

launcher/minecraft/MinecraftUpdate.cpp

@@ -100,7 +100,9 @@ void MinecraftUpdate::next()
         disconnect(task.get(), &Task::failed, this, &MinecraftUpdate::subtaskFailed);
         disconnect(task.get(), &Task::aborted, this, &Task::abort);
         disconnect(task.get(), &Task::progress, this, &MinecraftUpdate::progress);
+        disconnect(task.get(), &Task::stepProgress, this, &MinecraftUpdate::propogateStepProgress);
         disconnect(task.get(), &Task::status, this, &MinecraftUpdate::setStatus);
+        disconnect(task.get(), &Task::details, this, &MinecraftUpdate::setDetails);
     }
     if(m_currentTask == m_tasks.size())
     {
@@ -118,7 +120,9 @@ void MinecraftUpdate::next()
     connect(task.get(), &Task::failed, this, &MinecraftUpdate::subtaskFailed);
     connect(task.get(), &Task::aborted, this, &Task::abort);
     connect(task.get(), &Task::progress, this, &MinecraftUpdate::progress);
+    connect(task.get(), &Task::stepProgress, this, &MinecraftUpdate::propogateStepProgress);
     connect(task.get(), &Task::status, this, &MinecraftUpdate::setStatus);
+    connect(task.get(), &Task::details, this, &MinecraftUpdate::setDetails);
     // if the task is already running, do not start it again
     if(!task->isRunning())
     {

launcher/minecraft/PackProfile.cpp

@@ -1,7 +1,10 @@
-// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2022-2023 Sefa Eyeoglu <contact@scrumplex.net>
+//
+// SPDX-License-Identifier: GPL-3.0-only AND Apache-2.0
+
 /*
  *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2022-2023 Sefa Eyeoglu <contact@scrumplex.net>
  *  Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
  *
  *  This program is free software: you can redistribute it and/or modify
@@ -49,6 +52,7 @@
 #include "minecraft/OneSixVersionFormat.h"
 #include "FileSystem.h"
 #include "minecraft/MinecraftInstance.h"
+#include "minecraft/ProfileUtils.h"
 #include "Json.h"
 
 #include "PackProfile.h"
@@ -730,16 +734,47 @@ void PackProfile::invalidateLaunchProfile()
 
 void PackProfile::installJarMods(QStringList selectedFiles)
 {
+    // FIXME: get rid of _internal
     installJarMods_internal(selectedFiles);
 }
 
 void PackProfile::installCustomJar(QString selectedFile)
 {
+    // FIXME: get rid of _internal
     installCustomJar_internal(selectedFile);
 }
 
+bool PackProfile::installComponents(QStringList selectedFiles)
+{
+    const QString patchDir = FS::PathCombine(d->m_instance->instanceRoot(), "patches");
+    if (!FS::ensureFolderPathExists(patchDir))
+        return false;
+
+    bool result = true;
+    for (const QString& source : selectedFiles) {
+        const QFileInfo sourceInfo(source);
+
+        auto versionFile = ProfileUtils::parseJsonFile(sourceInfo, false);
+        const QString target = FS::PathCombine(patchDir, versionFile->uid + ".json");
+
+        if (!QFile::copy(source, target)) {
+            qWarning() << "Component" << source << "could not be copied to target" << target;
+            result = false;
+            continue;
+        }
+
+        appendComponent(makeShared<Component>(this, versionFile->uid, versionFile));
+    }
+
+    scheduleSave();
+    invalidateLaunchProfile();
+
+    return result;
+}
+
 void PackProfile::installAgents(QStringList selectedFiles)
 {
+    // FIXME: get rid of _internal
     installAgents_internal(selectedFiles);
 }
 

launcher/minecraft/PackProfile.h

@@ -1,7 +1,10 @@
-// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2022-2023 Sefa Eyeoglu <contact@scrumplex.net>
+//
+// SPDX-License-Identifier: GPL-3.0-only AND Apache-2.0
+
 /*
  *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2022-2023 Sefa Eyeoglu <contact@scrumplex.net>
  *  Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
  *
  *  This program is free software: you can redistribute it and/or modify
@@ -86,6 +89,9 @@ public:
     /// install a jar/zip as a replacement for the main jar
     void installCustomJar(QString selectedFile);
 
+    /// install MMC/Prism component files
+    bool installComponents(QStringList selectedFiles);
+
     /// install Java agent files
     void installAgents(QStringList selectedFiles);
 

launcher/minecraft/World.cpp

@@ -56,6 +56,8 @@
 
 #include <optional>
 
+#include "FileSystem.h"
+
 using std::optional;
 using std::nullopt;
 
@@ -567,3 +569,25 @@ bool World::operator==(const World &other) const
 {
     return is_valid == other.is_valid && folderName() == other.folderName();
 }
+
+bool World::isSymLinkUnder(const QString& instPath) const
+{
+    if (isSymLink())
+        return true;
+
+    auto instDir = QDir(instPath);
+
+    auto relAbsPath = instDir.relativeFilePath(m_containerFile.absoluteFilePath());
+    auto relCanonPath = instDir.relativeFilePath(m_containerFile.canonicalFilePath());
+
+    return relAbsPath != relCanonPath;
+}
+
+bool World::isMoreThanOneHardLink() const
+{
+    if (m_containerFile.isDir())
+    {
+        return FS::hardLinkCount(QDir(m_containerFile.absoluteFilePath()).filePath("level.dat")) > 1;
+    }
+    return FS::hardLinkCount(m_containerFile.absoluteFilePath()) > 1;
+}

launcher/minecraft/World.h

@@ -95,6 +95,21 @@ public:
     // WEAK compare operator - used for replacing worlds
     bool operator==(const World &other) const;
 
+    [[nodiscard]] auto isSymLink() const -> bool{ return m_containerFile.isSymLink(); }
+
+    /**
+     * @brief Take a instance path, checks if the file pointed to by the resource is a symlink or under a symlink in that instance
+     * 
+     * @param instPath path to an instance directory
+     * @return true 
+     * @return false 
+     */
+    [[nodiscard]] bool isSymLinkUnder(const QString& instPath) const;
+
+    [[nodiscard]] bool isMoreThanOneHardLink() const;
+
+    QString canonicalFilePath() const { return m_containerFile.canonicalFilePath(); }
+
 private:
     void readFromZip(const QFileInfo &file);
     void readFromFS(const QFileInfo &file);

launcher/minecraft/WorldList.cpp

@@ -45,16 +45,15 @@
 #include <QFileSystemWatcher>
 #include <QDebug>
 
-WorldList::WorldList(const QString &dir)
+WorldList::WorldList(const QString &dir, BaseInstance* instance)
-    : QAbstractListModel(), m_dir(dir)
+    : QAbstractListModel(), m_instance(instance), m_dir(dir)
 {
     FS::ensureFolderPathExists(m_dir.absolutePath());
     m_dir.setFilter(QDir::Readable | QDir::NoDotAndDotDot | QDir::Files | QDir::Dirs);
     m_dir.setSorting(QDir::Name | QDir::IgnoreCase | QDir::LocaleAware);
     m_watcher = new QFileSystemWatcher(this);
     is_watching = false;
-    connect(m_watcher, SIGNAL(directoryChanged(QString)), this,
+    connect(m_watcher, &QFileSystemWatcher::directoryChanged, this, &WorldList::directoryChanged);
-            SLOT(directoryChanged(QString)));
 }
 
 void WorldList::startWatching()
@@ -128,6 +127,10 @@ bool WorldList::isValid()
     return m_dir.exists() && m_dir.isReadable();
 }
 
+QString WorldList::instDirPath() const {
+    return QFileInfo(m_instance->instanceRoot()).absoluteFilePath();
+}
+
 bool WorldList::deleteWorld(int index)
 {
     if (index >= worlds.size() || index < 0)
@@ -173,7 +176,7 @@ bool WorldList::resetIcon(int row)
 
 int WorldList::columnCount(const QModelIndex &parent) const
 {
-    return parent.isValid()? 0 : 4;
+    return parent.isValid()? 0 : 5;
 }
 
 QVariant WorldList::data(const QModelIndex &index, int role) const
@@ -207,6 +210,14 @@ QVariant WorldList::data(const QModelIndex &index, int role) const
         case SizeColumn:
             return locale.formattedDataSize(world.bytes());
 
+        case InfoColumn:
+            if (world.isSymLinkUnder(instDirPath())) {
+                return tr("This world is symbolically linked from elsewhere.");
+            }
+            if (world.isMoreThanOneHardLink()) {
+                return tr("\nThis world is hard linked elsewhere.");
+            }
+            return "";
         default:
             return QVariant();
         }
@@ -223,6 +234,15 @@ QVariant WorldList::data(const QModelIndex &index, int role) const
 
     case Qt::ToolTipRole:
     {   
+        if (column == InfoColumn) {
+            if (world.isSymLinkUnder(instDirPath())) {
+                return tr("Warning: This world is symbolically linked from elsewhere. Editing it will also change the original." 
+                          "\nCanonical Path: %1").arg(world.canonicalFilePath());
+            }
+            if (world.isMoreThanOneHardLink()) {
+                return tr("Warning: This world is hard linked elsewhere. Editing it will also change the original.");
+            }
+        }
         return world.folderName();
     }
     case ObjectRole:
@@ -274,6 +294,9 @@ QVariant WorldList::headerData(int section, Qt::Orientation orientation, int rol
         case SizeColumn:
             //: World size on disk
             return tr("Size");
+        case InfoColumn:
+            //: special warnings?
+            return tr("Info");
         default:
             return QVariant();
         }
@@ -289,6 +312,8 @@ QVariant WorldList::headerData(int section, Qt::Orientation orientation, int rol
             return tr("Date and time the world was last played.");
         case SizeColumn:
             return tr("Size of the world on disk.");
+        case InfoColumn:
+            return tr("Information and warnings about the world.");
         default:
             return QVariant();
         }

launcher/minecraft/WorldList.h

@@ -21,6 +21,7 @@
 #include <QAbstractListModel>
 #include <QMimeData>
 #include "minecraft/World.h"
+#include "BaseInstance.h"
 
 class QFileSystemWatcher;
 
@@ -33,7 +34,8 @@ public:
         NameColumn,
         GameModeColumn,
         LastPlayedColumn,
-        SizeColumn
+        SizeColumn,
+        InfoColumn
     };
 
     enum Roles
@@ -48,7 +50,7 @@ public:
         IconFileRole
     };
 
-    WorldList(const QString &dir);
+    WorldList(const QString &dir, BaseInstance* instance);
 
     virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
 
@@ -112,6 +114,8 @@ public:
         return m_dir;
     }
 
+    QString instDirPath() const;
+
     const QList<World> &allWorlds() const
     {
         return worlds;
@@ -124,6 +128,7 @@ signals:
     void changed();
 
 protected:
+    BaseInstance* m_instance;
     QFileSystemWatcher *m_watcher;
     bool is_watching;
     QDir m_dir;

launcher/minecraft/auth/AuthRequest.cpp

@@ -55,12 +55,12 @@ void AuthRequest::get(const QNetworkRequest &req, int timeout/* = 60*1000*/) {
     reply_ = APPLICATION->network()->get(request_);
     status_ = Requesting;
     timedReplies_.add(new Katabasis::Reply(reply_, timeout));
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) // QNetworkReply::errorOccurred added in 5.15
-    connect(reply_, SIGNAL(errorOccurred(QNetworkReply::NetworkError)), this, SLOT(onRequestError(QNetworkReply::NetworkError)));
+    connect(reply_, &QNetworkReply::errorOccurred, this, &AuthRequest::onRequestError);
-#else
+#else // &QNetworkReply::error SIGNAL depricated
-    connect(reply_, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onRequestError(QNetworkReply::NetworkError)));
+    connect(reply_, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &AuthRequest::onRequestError);
 #endif
-    connect(reply_, SIGNAL(finished()), this, SLOT(onRequestFinished()));
+    connect(reply_, &QNetworkReply::finished, this, &AuthRequest::onRequestFinished);
     connect(reply_, &QNetworkReply::sslErrors, this, &AuthRequest::onSslErrors);
 }
 
@@ -70,14 +70,14 @@ void AuthRequest::post(const QNetworkRequest &req, const QByteArray &data, int t
     status_ = Requesting;
     reply_ = APPLICATION->network()->post(request_, data_);
     timedReplies_.add(new Katabasis::Reply(reply_, timeout));
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) // QNetworkReply::errorOccurred added in 5.15
-    connect(reply_, SIGNAL(errorOccurred(QNetworkReply::NetworkError)), this, SLOT(onRequestError(QNetworkReply::NetworkError)));
+    connect(reply_, &QNetworkReply::errorOccurred, this, &AuthRequest::onRequestError);
-#else
+#else // &QNetworkReply::error SIGNAL depricated
-    connect(reply_, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onRequestError(QNetworkReply::NetworkError)));
+    connect(reply_, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &AuthRequest::onRequestError);
 #endif
-    connect(reply_, SIGNAL(finished()), this, SLOT(onRequestFinished()));
+    connect(reply_, &QNetworkReply::finished, this, &AuthRequest::onRequestFinished);
     connect(reply_, &QNetworkReply::sslErrors, this, &AuthRequest::onSslErrors);
-    connect(reply_, SIGNAL(uploadProgress(qint64,qint64)), this, SLOT(onUploadProgress(qint64,qint64)));
+    connect(reply_, &QNetworkReply::uploadProgress, this, &AuthRequest::onUploadProgress);
 }
 
 void AuthRequest::onRequestFinished() {

launcher/minecraft/auth/MinecraftAccount.cpp

@@ -145,8 +145,8 @@ shared_qobject_ptr<AccountTask> MinecraftAccount::login(QString password) {
     Q_ASSERT(m_currentTask.get() == nullptr);
 
     m_currentTask.reset(new MojangLogin(&data, password));
-    connect(m_currentTask.get(), SIGNAL(succeeded()), SLOT(authSucceeded()));
+    connect(m_currentTask.get(), &Task::succeeded, this, &MinecraftAccount::authSucceeded);
-    connect(m_currentTask.get(), SIGNAL(failed(QString)), SLOT(authFailed(QString)));
+    connect(m_currentTask.get(), &Task::failed, this, &MinecraftAccount::authFailed);
     connect(m_currentTask.get(), &Task::aborted, this, [this]{ authFailed(tr("Aborted")); });
     emit activityChanged(true);
     return m_currentTask;
@@ -156,8 +156,8 @@ shared_qobject_ptr<AccountTask> MinecraftAccount::loginMSA() {
     Q_ASSERT(m_currentTask.get() == nullptr);
 
     m_currentTask.reset(new MSAInteractive(&data));
-    connect(m_currentTask.get(), SIGNAL(succeeded()), SLOT(authSucceeded()));
+    connect(m_currentTask.get(), &Task::succeeded, this, &MinecraftAccount::authSucceeded);
-    connect(m_currentTask.get(), SIGNAL(failed(QString)), SLOT(authFailed(QString)));
+    connect(m_currentTask.get(), &Task::failed, this, &MinecraftAccount::authFailed);
     connect(m_currentTask.get(), &Task::aborted, this, [this]{ authFailed(tr("Aborted")); });
     emit activityChanged(true);
     return m_currentTask;
@@ -167,8 +167,8 @@ shared_qobject_ptr<AccountTask> MinecraftAccount::loginOffline() {
     Q_ASSERT(m_currentTask.get() == nullptr);
 
     m_currentTask.reset(new OfflineLogin(&data));
-    connect(m_currentTask.get(), SIGNAL(succeeded()), SLOT(authSucceeded()));
+    connect(m_currentTask.get(), &Task::succeeded, this, &MinecraftAccount::authSucceeded);
-    connect(m_currentTask.get(), SIGNAL(failed(QString)), SLOT(authFailed(QString)));
+    connect(m_currentTask.get(), &Task::failed, this, &MinecraftAccount::authFailed);
     connect(m_currentTask.get(), &Task::aborted, this, [this]{ authFailed(tr("Aborted")); });
     emit activityChanged(true);
     return m_currentTask;
@@ -203,8 +203,8 @@ shared_qobject_ptr<AccountTask> MinecraftAccount::refresh() {
         m_currentTask.reset(new MojangRefresh(&data));
     }
 
-    connect(m_currentTask.get(), SIGNAL(succeeded()), SLOT(authSucceeded()));
+    connect(m_currentTask.get(), &Task::succeeded, this, &MinecraftAccount::authSucceeded);
-    connect(m_currentTask.get(), SIGNAL(failed(QString)), SLOT(authFailed(QString)));
+    connect(m_currentTask.get(), &Task::failed, this, &MinecraftAccount::authFailed);
     connect(m_currentTask.get(), &Task::aborted, this, [this]{ authFailed(tr("Aborted")); });
     emit activityChanged(true);
     return m_currentTask;

launcher/minecraft/auth/steps/XboxUserStep.cpp

@@ -38,6 +38,10 @@ void XboxUserStep::perform() {
     QNetworkRequest request = QNetworkRequest(QUrl("https://user.auth.xboxlive.com/user/authenticate"));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     request.setRawHeader("Accept", "application/json");
+    // set contract-verison header (prevent err 400 bad-request?)
+    // https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/reference/live/rest/additional/httpstandardheaders
+    request.setRawHeader("x-xbl-contract-version", "1"); 
+
     auto *requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &XboxUserStep::onRequestDone);
     requestor->post(request, xbox_auth_data.toUtf8());

launcher/minecraft/launch/ScanModFolders.cpp

@@ -55,6 +55,12 @@ void ScanModFolders::executeTask()
     if(!cores->update()) {
         m_coreModsDone = true;
     }
+
+    auto nils = m_inst->nilModList();
+    connect(nils.get(), &ModFolderModel::updateFinished, this, &ScanModFolders::nilModsDone);
+    if(!nils->update()) {
+        m_nilModsDone = true;
+    }
     checkDone();
 }
 
@@ -70,9 +76,15 @@ void ScanModFolders::coreModsDone()
     checkDone();
 }
 
+void ScanModFolders::nilModsDone()
+{
+    m_nilModsDone = true;
+    checkDone();
+}
+
 void ScanModFolders::checkDone()
 {
-    if(m_modsDone && m_coreModsDone) {
+    if(m_modsDone && m_coreModsDone && m_nilModsDone) {
         emitSucceeded();
     }
 }

launcher/minecraft/launch/ScanModFolders.h

@@ -33,10 +33,12 @@ public:
 private slots:
     void coreModsDone();
     void modsDone();
+    void nilModsDone();
 private:
     void checkDone();
 
 private: // DATA
     bool m_modsDone = false;
+    bool m_nilModsDone = false;
     bool m_coreModsDone = false;
 };

launcher/minecraft/mod/ModFolderModel.cpp

@@ -39,18 +39,23 @@
 #include <FileSystem.h>
 #include <QDebug>
 #include <QFileSystemWatcher>
+#include <QIcon>
 #include <QMimeData>
 #include <QString>
+#include <QStyle>
 #include <QThreadPool>
 #include <QUrl>
 #include <QUuid>
 #include <algorithm>
 
+#include "Application.h"
+
 #include "minecraft/mod/tasks/LocalModParseTask.h"
 #include "minecraft/mod/tasks/ModFolderLoadTask.h"
 #include "modplatform/ModIndex.h"
 
-ModFolderModel::ModFolderModel(const QString &dir, bool is_indexed) : ResourceFolderModel(QDir(dir)), m_is_indexed(is_indexed)
+ModFolderModel::ModFolderModel(const QString& dir, BaseInstance* instance, bool is_indexed, bool create_dir)
+    : ResourceFolderModel(QDir(dir), instance, nullptr, create_dir), m_is_indexed(is_indexed)
 {
     m_column_sort_keys = { SortType::ENABLED, SortType::NAME, SortType::VERSION, SortType::DATE, SortType::PROVIDER };
 }
@@ -97,8 +102,25 @@ QVariant ModFolderModel::data(const QModelIndex &index, int role) const
         }
 
     case Qt::ToolTipRole:
+        if (column == NAME_COLUMN) {
+            if (at(row)->isSymLinkUnder(instDirPath())) {
+                return 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());
+            }
+            if (at(row)->isMoreThanOneHardLink()) {
+                return m_resources[row]->internal_id() +
+                    tr("\nWarning: This resource is hard linked elsewhere. Editing it will also change the original.");
+            }
+        }
         return m_resources[row]->internal_id();
+    case Qt::DecorationRole: {
+        if (column == NAME_COLUMN && (at(row)->isSymLinkUnder(instDirPath()) || at(row)->isMoreThanOneHardLink()))
+            return APPLICATION->getThemedIcon("status-yellow");
 
+        return {};
+    }
     case Qt::CheckStateRole:
         switch (column)
         {

launcher/minecraft/mod/ModFolderModel.h

@@ -75,7 +75,7 @@ public:
         Enable,
         Toggle
     };
-    ModFolderModel(const QString &dir, bool is_indexed = false);
+    ModFolderModel(const QString &dir, BaseInstance* instance, bool is_indexed = false, bool create_dir = true);
 
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 

launcher/minecraft/mod/Resource.cpp

@@ -1,6 +1,8 @@
 #include "Resource.h"
 
+
 #include <QRegularExpression>
+#include <QFileInfo>
 
 #include "FileSystem.h"
 
@@ -37,6 +39,9 @@ void Resource::parseFile()
         if (file_name.endsWith(".zip") || file_name.endsWith(".jar")) {
             m_type = ResourceType::ZIPFILE;
             file_name.chop(4);
+        } else if (file_name.endsWith(".nilmod")) {
+            m_type = ResourceType::ZIPFILE;
+            file_name.chop(7);
         } else if (file_name.endsWith(".litemod")) {
             m_type = ResourceType::LITEMOD;
             file_name.chop(8);
@@ -149,3 +154,21 @@ bool Resource::destroy()
 
     return FS::deletePath(m_file_info.filePath());
 }
+
+bool Resource::isSymLinkUnder(const QString& instPath) const 
+{
+    if (isSymLink())
+        return true;
+
+    auto instDir = QDir(instPath);
+
+    auto relAbsPath = instDir.relativeFilePath(m_file_info.absoluteFilePath());
+    auto relCanonPath = instDir.relativeFilePath(m_file_info.canonicalFilePath());
+
+    return relAbsPath != relCanonPath;
+}
+
+bool Resource::isMoreThanOneHardLink() const 
+{
+    return FS::hardLinkCount(m_file_info.absoluteFilePath()) > 1;
+}

launcher/minecraft/mod/Resource.h

@@ -94,6 +94,19 @@ class Resource : public QObject {
     // Delete all files of this resource.
     bool destroy();
 
+    [[nodiscard]] auto isSymLink() const -> bool { return m_file_info.isSymLink(); }
+
+    /**
+     * @brief Take a instance path, checks if the file pointed to by the resource is a symlink or under a symlink in that instance
+     * 
+     * @param instPath path to an instance directory
+     * @return true 
+     * @return false 
+     */
+    [[nodiscard]] bool isSymLinkUnder(const QString& instPath) const;
+
+    [[nodiscard]] bool isMoreThanOneHardLink() const;
+
    protected:
     /* The file corresponding to this resource. */
     QFileInfo m_file_info;

launcher/minecraft/mod/ResourceFolderModel.cpp

@@ -2,25 +2,32 @@
 
 #include <QCoreApplication>
 #include <QDebug>
+#include <QFileInfo>
+#include <QIcon>
 #include <QMimeData>
+#include <QStyle>
 #include <QThreadPool>
 #include <QUrl>
 
+#include "Application.h"
 #include "FileSystem.h"
 
 #include "minecraft/mod/tasks/BasicFolderLoadTask.h"
 
 #include "tasks/Task.h"
 
-ResourceFolderModel::ResourceFolderModel(QDir dir, QObject* parent) : QAbstractListModel(parent), m_dir(dir), m_watcher(this)
+ResourceFolderModel::ResourceFolderModel(QDir dir, BaseInstance* instance, QObject* parent, bool create_dir)
+    : QAbstractListModel(parent), m_dir(dir), m_instance(instance), m_watcher(this)
 {
+    if (create_dir) {
         FS::ensureFolderPathExists(m_dir.absolutePath());
+    }
 
     m_dir.setFilter(QDir::Readable | QDir::NoDotAndDotDot | QDir::Files | QDir::Dirs);
     m_dir.setSorting(QDir::Name | QDir::IgnoreCase | QDir::LocaleAware);
 
     connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &ResourceFolderModel::directoryChanged);
-    connect(&m_helper_thread_task, &ConcurrentTask::finished, this, [this]{ m_helper_thread_task.clear(); });
+    connect(&m_helper_thread_task, &ConcurrentTask::finished, this, [this] { m_helper_thread_task.clear(); });
 }
 
 ResourceFolderModel::~ResourceFolderModel()
@@ -415,7 +422,26 @@ QVariant ResourceFolderModel::data(const QModelIndex& index, int role) const
                     return {};
             }
         case Qt::ToolTipRole:
+            if (column == NAME_COLUMN) {
+                if (at(row).isSymLinkUnder(instDirPath())) {
+                    return 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());;
+                }
+                if (at(row).isMoreThanOneHardLink()) {
+                    return m_resources[row]->internal_id() +
+                        tr("\nWarning: This resource is hard linked elsewhere. Editing it will also change the original.");
+                }
+            }
+            
             return m_resources[row]->internal_id();
+        case Qt::DecorationRole: {
+            if (column == NAME_COLUMN && (at(row).isSymLinkUnder(instDirPath()) || at(row).isMoreThanOneHardLink()))
+                return APPLICATION->getThemedIcon("status-yellow");
+
+            return {};
+        }
         case Qt::CheckStateRole:
             switch (column) {
                 case ACTIVE_COLUMN:
@@ -529,3 +555,7 @@ void ResourceFolderModel::enableInteraction(bool enabled)
         return (compare_result.first < 0);
     return (compare_result.first > 0);
 }
+
+QString ResourceFolderModel::instDirPath() const {
+    return QFileInfo(m_instance->instanceRoot()).absoluteFilePath();
+}

launcher/minecraft/mod/ResourceFolderModel.h

@@ -9,6 +9,8 @@
 
 #include "Resource.h"
 
+#include "BaseInstance.h"
+
 #include "tasks/Task.h"
 #include "tasks/ConcurrentTask.h"
 
@@ -24,7 +26,7 @@ class QSortFilterProxyModel;
 class ResourceFolderModel : public QAbstractListModel {
     Q_OBJECT
    public:
-    ResourceFolderModel(QDir, QObject* parent = nullptr);
+    ResourceFolderModel(QDir, BaseInstance* instance, QObject* parent = nullptr, bool create_dir = true);
     ~ResourceFolderModel() override;
 
     /** Starts watching the paths for changes.
@@ -125,6 +127,8 @@ class ResourceFolderModel : public QAbstractListModel {
         [[nodiscard]] bool lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const override;
     };
 
+    QString instDirPath() const;
+
    public slots:
     void enableInteraction(bool enabled);
     void disableInteraction(bool disabled) { enableInteraction(!disabled); }
@@ -187,6 +191,7 @@ class ResourceFolderModel : public QAbstractListModel {
     bool m_can_interact = true;
 
     QDir m_dir;
+    BaseInstance* m_instance;
     QFileSystemWatcher m_watcher;
     bool m_is_watching = false;
 

launcher/minecraft/mod/ResourcePackFolderModel.cpp

@@ -36,12 +36,17 @@
 
 #include "ResourcePackFolderModel.h"
 
+#include <QIcon>
+#include <QStyle>
+
+#include "Application.h"
 #include "Version.h"
 
 #include "minecraft/mod/tasks/BasicFolderLoadTask.h"
 #include "minecraft/mod/tasks/LocalResourcePackParseTask.h"
 
-ResourcePackFolderModel::ResourcePackFolderModel(const QString& dir) : ResourceFolderModel(QDir(dir))
+ResourcePackFolderModel::ResourcePackFolderModel(const QString& dir, BaseInstance* instance)
+    : ResourceFolderModel(QDir(dir), instance)
 {
     m_column_sort_keys = { SortType::ENABLED, SortType::NAME, SortType::PACK_FORMAT, SortType::DATE };
 }
@@ -78,12 +83,29 @@ QVariant ResourcePackFolderModel::data(const QModelIndex& index, int role) const
                 default:
                     return {};
             }
+        case Qt::DecorationRole: {
+            if (column == NAME_COLUMN && (at(row)->isSymLinkUnder(instDirPath()) || at(row)->isMoreThanOneHardLink()))
+                return APPLICATION->getThemedIcon("status-yellow");
 
+            return {};
+        }
         case Qt::ToolTipRole: {
             if (column == PackFormatColumn) {
                 //: The string being explained by this is in the format: ID (Lower version - Upper version)
                 return tr("The resource pack format ID, as well as the Minecraft versions it was designed for.");
             }
+            if (column == NAME_COLUMN) {
+                if (at(row)->isSymLinkUnder(instDirPath())) {
+                    return 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());;
+                }
+                if (at(row)->isMoreThanOneHardLink()) {
+                    return m_resources[row]->internal_id() +
+                        tr("\nWarning: This resource is hard linked elsewhere. Editing it will also change the original.");
+                }
+            }
             return m_resources[row]->internal_id();
         }
         case Qt::CheckStateRole:

launcher/minecraft/mod/ResourcePackFolderModel.h

@@ -17,7 +17,7 @@ public:
         NUM_COLUMNS
     };
 
-    explicit ResourcePackFolderModel(const QString &dir);
+    explicit ResourcePackFolderModel(const QString &dir, BaseInstance* instance);
 
     [[nodiscard]] QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 

launcher/minecraft/mod/ShaderPackFolderModel.h

@@ -6,5 +6,7 @@ class ShaderPackFolderModel : public ResourceFolderModel {
     Q_OBJECT
 
    public:
-    explicit ShaderPackFolderModel(const QString& dir) : ResourceFolderModel(QDir(dir)) {}
+    explicit ShaderPackFolderModel(const QString& dir, BaseInstance* instance)
+        : ResourceFolderModel(QDir(dir), instance)
+    {}
 };

launcher/minecraft/mod/TexturePackFolderModel.cpp

@@ -39,7 +39,9 @@
 #include "minecraft/mod/tasks/BasicFolderLoadTask.h"
 #include "minecraft/mod/tasks/LocalTexturePackParseTask.h"
 
-TexturePackFolderModel::TexturePackFolderModel(const QString &dir) : ResourceFolderModel(QDir(dir)) {}
+TexturePackFolderModel::TexturePackFolderModel(const QString& dir, BaseInstance* instance)
+    : ResourceFolderModel(QDir(dir), instance)
+{}
 
 Task* TexturePackFolderModel::createUpdateTask()
 {

launcher/minecraft/mod/TexturePackFolderModel.h

@@ -43,7 +43,7 @@ class TexturePackFolderModel : public ResourceFolderModel
     Q_OBJECT
 
 public:
-    explicit TexturePackFolderModel(const QString &dir);
+    explicit TexturePackFolderModel(const QString &dir, BaseInstance* instance);
     [[nodiscard]] Task* createUpdateTask() override;
     [[nodiscard]] Task* createParseTask(Resource&) override;
 };

launcher/minecraft/mod/tasks/LocalModParseTask.cpp

@@ -3,6 +3,7 @@
 #include <quazip/quazip.h>
 #include <quazip/quazipfile.h>
 #include <toml++/toml.h>
+#include <qdcss.h>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
@@ -241,7 +242,7 @@ ModDetails ReadQuiltModInfo(QByteArray contents)
     return details;
 }
 
-ModDetails ReadForgeInfo(QByteArray contents)
+ModDetails ReadForgeInfo(QString fileName)
 {
     ModDetails details;
     // Read the data
@@ -249,7 +250,7 @@ ModDetails ReadForgeInfo(QByteArray contents)
     details.mod_id = "Forge";
     details.homeurl = "http://www.minecraftforge.net/forum/";
     INIFile ini;
-    if (!ini.loadFile(contents))
+    if (!ini.loadFile(fileName))
         return details;
 
     QString major = ini.get("forge.major.number", "0").toString();
@@ -285,6 +286,32 @@ ModDetails ReadLiteModInfo(QByteArray contents)
     return details;
 }
 
+// https://git.sleeping.town/unascribed/NilLoader/src/commit/d7fc87b255fc31019ff90f80d45894927fac6efc/src/main/java/nilloader/api/NilMetadata.java#L64
+ModDetails ReadNilModInfo(QByteArray contents, QString fname)
+{
+    ModDetails details;
+
+    QDCSS cssData = QDCSS(contents);
+    auto name = cssData.get("@nilmod.name");
+    auto desc = cssData.get("@nilmod.description");
+    auto authors = cssData.get("@nilmod.authors");
+
+    if (name->has_value()) {
+        details.name = name->value();
+    }
+    if (desc->has_value()) {
+        details.description = desc->value();
+    }
+    if (authors->has_value()) {
+        details.authors.append(authors->value());
+    }
+    details.version = cssData.get("@nilmod.version")->value_or("?");
+
+    details.mod_id = fname.remove(".nilmod.css");
+
+    return details;
+}
+
 bool process(Mod& mod, ProcessingLevel level)
 {
     switch (mod.type()) {
@@ -395,12 +422,38 @@ bool processZIP(Mod& mod, ProcessingLevel level)
             return false;
         }
 
-        details = ReadForgeInfo(file.readAll());
+        details = ReadForgeInfo(file.getFileName());
         file.close();
         zip.close();
 
         mod.setDetails(details);
         return true;
+    } else if (zip.setCurrentFile("META-INF/nil/mappings.json")) {
+        // nilloader uses the filename of the metadata file for the modid, so we can't know the exact filename
+        // thankfully, there is a good file to use as a canary so we don't look for nil meta all the time
+
+        QString foundNilMeta;
+        for (auto& fname : zip.getFileNameList()) {
+            // nilmods can shade nilloader to be able to run as a standalone agent - which includes nilloader's own meta file
+            if (fname.endsWith(".nilmod.css") && fname != "nilloader.nilmod.css") {
+                foundNilMeta = fname;
+                break;
+            }
+        }
+
+        if (zip.setCurrentFile(foundNilMeta)) {
+            if (!file.open(QIODevice::ReadOnly)) {
+                zip.close();
+                return false;
+            }
+
+            details = ReadNilModInfo(file.readAll(), foundNilMeta);
+            file.close();
+            zip.close();
+
+            mod.setDetails(details);
+            return true;
+        }
     }
 
     zip.close();

launcher/minecraft/services/CapeChange.cpp

@@ -54,9 +54,14 @@ void CapeChange::setCape(QString& cape) {
     setStatus(tr("Equipping cape"));
 
     m_reply = shared_qobject_ptr<QNetworkReply>(rep);
-    connect(rep, &QNetworkReply::uploadProgress, this, &Task::setProgress);
+    connect(rep, &QNetworkReply::uploadProgress, this, &CapeChange::setProgress);
-    connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) // QNetworkReply::errorOccurred added in 5.15
-    connect(rep, SIGNAL(finished()), this, SLOT(downloadFinished()));
+    connect(rep, &QNetworkReply::errorOccurred, this, &CapeChange::downloadError);
+#else
+    connect(rep, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &CapeChange::downloadError);
+#endif
+    connect(rep, &QNetworkReply::sslErrors, this, &CapeChange::sslErrors);
+    connect(rep, &QNetworkReply::finished, this, &CapeChange::downloadFinished);
 }
 
 void CapeChange::clearCape() {
@@ -68,13 +73,14 @@ void CapeChange::clearCape() {
     setStatus(tr("Removing cape"));
 
     m_reply = shared_qobject_ptr<QNetworkReply>(rep);
-    connect(rep, &QNetworkReply::uploadProgress, this, &Task::setProgress);
+    connect(rep, &QNetworkReply::uploadProgress, this, &CapeChange::setProgress);
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) // QNetworkReply::errorOccurred added in 5.15
-    connect(rep, SIGNAL(errorOccurred(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+    connect(rep, &QNetworkReply::errorOccurred, this, &CapeChange::downloadError);
 #else
-    connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+    connect(rep, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &CapeChange::downloadError);
 #endif
-    connect(rep, SIGNAL(finished()), this, SLOT(downloadFinished()));
+    connect(rep, &QNetworkReply::sslErrors, this, &CapeChange::sslErrors);
+    connect(rep, &QNetworkReply::finished, this, &CapeChange::downloadFinished);
 }
 
 
@@ -95,6 +101,17 @@ void CapeChange::downloadError(QNetworkReply::NetworkError error)
     emitFailed(m_reply->errorString());
 }
 
+void CapeChange::sslErrors(const QList<QSslError>& errors)
+{
+    int i = 1;
+    for (auto error : errors) {
+        qCritical() << "Cape change SSL Error #" << i << " : " << error.errorString();
+        auto cert = error.certificate();
+        qCritical() << "Certificate in question:\n" << cert.toText();
+        i++;
+    }
+}
+
 void CapeChange::downloadFinished()
 {
     // if the download failed

launcher/minecraft/services/CapeChange.h

@@ -27,6 +27,7 @@ protected:
 
 public slots:
     void downloadError(QNetworkReply::NetworkError);
+    void sslErrors(const QList<QSslError>& errors);
     void downloadFinished();
 };
 

launcher/minecraft/services/SkinDelete.cpp

@@ -53,13 +53,14 @@ void SkinDelete::executeTask()
     m_reply = shared_qobject_ptr<QNetworkReply>(rep);
 
     setStatus(tr("Deleting skin"));
-    connect(rep, &QNetworkReply::uploadProgress, this, &Task::setProgress);
+    connect(rep, &QNetworkReply::uploadProgress, this, &SkinDelete::setProgress);
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) // QNetworkReply::errorOccurred added in 5.15
-    connect(rep, SIGNAL(errorOccurred(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+    connect(rep, &QNetworkReply::errorOccurred, this, &SkinDelete::downloadError);
 #else
-    connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+    connect(rep, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &SkinDelete::downloadError);
 #endif
-    connect(rep, SIGNAL(finished()), this, SLOT(downloadFinished()));
+    connect(rep, &QNetworkReply::sslErrors, this, &SkinDelete::sslErrors);
+    connect(rep, &QNetworkReply::finished, this, &SkinDelete::downloadFinished);
 }
 
 void SkinDelete::downloadError(QNetworkReply::NetworkError error)
@@ -69,6 +70,17 @@ void SkinDelete::downloadError(QNetworkReply::NetworkError error)
     emitFailed(m_reply->errorString());
 }
 
+void SkinDelete::sslErrors(const QList<QSslError>& errors)
+{
+    int i = 1;
+    for (auto error : errors) {
+        qCritical() << "Skin Delete SSL Error #" << i << " : " << error.errorString();
+        auto cert = error.certificate();
+        qCritical() << "Certificate in question:\n" << cert.toText();
+        i++;
+    }
+}
+
 void SkinDelete::downloadFinished()
 {
     // if the download failed

launcher/minecraft/services/SkinDelete.h

@@ -22,5 +22,6 @@ protected:
 
 public slots:
     void downloadError(QNetworkReply::NetworkError);
+    void sslErrors(const QList<QSslError>& errors);
     void downloadFinished();
 };

launcher/minecraft/services/SkinUpload.cpp

@@ -78,13 +78,14 @@ void SkinUpload::executeTask()
     m_reply = shared_qobject_ptr<QNetworkReply>(rep);
 
     setStatus(tr("Uploading skin"));
-    connect(rep, &QNetworkReply::uploadProgress, this, &Task::setProgress);
+    connect(rep, &QNetworkReply::uploadProgress, this, &SkinUpload::setProgress);
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) // QNetworkReply::errorOccurred added in 5.15
-    connect(rep, SIGNAL(errorOccurred(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+    connect(rep, &QNetworkReply::errorOccurred, this, &SkinUpload::downloadError);
 #else
-    connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
+    connect(rep, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &SkinUpload::downloadError);
 #endif
-    connect(rep, SIGNAL(finished()), this, SLOT(downloadFinished()));
+    connect(rep, &QNetworkReply::sslErrors, this, &SkinUpload::sslErrors);
+    connect(rep, &QNetworkReply::finished, this, &SkinUpload::downloadFinished);
 }
 
 void SkinUpload::downloadError(QNetworkReply::NetworkError error)
@@ -94,6 +95,17 @@ void SkinUpload::downloadError(QNetworkReply::NetworkError error)
     emitFailed(m_reply->errorString());
 }
 
+void SkinUpload::sslErrors(const QList<QSslError>& errors)
+{
+    int i = 1;
+    for (auto error : errors) {
+        qCritical() << "Skin Upload SSL Error #" << i << " : " << error.errorString();
+        auto cert = error.certificate();
+        qCritical() << "Certificate in question:\n" << cert.toText();
+        i++;
+    }
+}
+
 void SkinUpload::downloadFinished()
 {
     // if the download failed

launcher/minecraft/services/SkinUpload.h

@@ -32,6 +32,7 @@ protected:
 public slots:
 
     void downloadError(QNetworkReply::NetworkError);
+    void sslErrors(const QList<QSslError>& errors);
 
     void downloadFinished();
 };

launcher/minecraft/update/AssetUpdateTask.cpp

@@ -45,6 +45,7 @@ void AssetUpdateTask::executeTask()
     connect(downloadJob.get(), &NetJob::failed, this, &AssetUpdateTask::assetIndexFailed);
     connect(downloadJob.get(), &NetJob::aborted, this, [this]{ emitFailed(tr("Aborted")); });
     connect(downloadJob.get(), &NetJob::progress, this, &AssetUpdateTask::progress);
+    connect(downloadJob.get(), &NetJob::stepProgress, this, &AssetUpdateTask::propogateStepProgress);
 
     qDebug() << m_inst->name() << ": Starting asset index download";
     downloadJob->start();
@@ -83,6 +84,7 @@ void AssetUpdateTask::assetIndexFinished()
         connect(downloadJob.get(), &NetJob::failed, this, &AssetUpdateTask::assetsFailed);
         connect(downloadJob.get(), &NetJob::aborted, this, [this]{ emitFailed(tr("Aborted")); });
         connect(downloadJob.get(), &NetJob::progress, this, &AssetUpdateTask::progress);
+        connect(downloadJob.get(), &NetJob::stepProgress, this, &AssetUpdateTask::propogateStepProgress);
         downloadJob->start();
         return;
     }

launcher/minecraft/update/FMLLibrariesTask.cpp

@@ -75,6 +75,7 @@ void FMLLibrariesTask::executeTask()
     connect(dljob.get(), &NetJob::failed, this, &FMLLibrariesTask::fmllibsFailed);
     connect(dljob.get(), &NetJob::aborted, this, [this]{ emitFailed(tr("Aborted")); });
     connect(dljob.get(), &NetJob::progress, this, &FMLLibrariesTask::progress);
+    connect(dljob.get(), &NetJob::stepProgress, this, &FMLLibrariesTask::propogateStepProgress);
     downloadJob.reset(dljob);
     downloadJob->start();
 }

launcher/minecraft/update/LibrariesTask.cpp

@@ -70,6 +70,8 @@ void LibrariesTask::executeTask()
     connect(downloadJob.get(), &NetJob::failed, this, &LibrariesTask::jarlibFailed);
     connect(downloadJob.get(), &NetJob::aborted, this, [this]{ emitFailed(tr("Aborted")); });
     connect(downloadJob.get(), &NetJob::progress, this, &LibrariesTask::progress);
+    connect(downloadJob.get(), &NetJob::stepProgress, this, &LibrariesTask::propogateStepProgress);
+
     downloadJob->start();
 }
 

launcher/modplatform/ModIndex.h

@@ -23,6 +23,7 @@
 #include <QString>
 #include <QVariant>
 #include <QVector>
+#include <memory>
 
 class QIODevice;
 
@@ -30,7 +31,7 @@ namespace ModPlatform {
 
 enum class ResourceProvider { MODRINTH, FLAME };
 
-enum class ResourceType { MOD, RESOURCE_PACK };
+enum class ResourceType { MOD, RESOURCE_PACK, SHADER_PACK };
 
 class ProviderCapabilities {
    public:
@@ -83,6 +84,8 @@ struct ExtraPackData {
 };
 
 struct IndexedPack {
+    using Ptr = std::shared_ptr<IndexedPack>;
+
     QVariant addonId;
     ResourceProvider provider;
     QString name;

launcher/modplatform/atlauncher/ATLPackInstallTask.cpp

@@ -683,6 +683,7 @@ void PackInstallTask::installConfigs()
         abortable = true;
         setProgress(current, total);
     });
+    connect(jobPtr.get(), &NetJob::stepProgress, this, &PackInstallTask::propogateStepProgress);
     connect(jobPtr.get(), &NetJob::aborted, [&]{
         abortable = false;
         jobPtr.reset();
@@ -846,9 +847,11 @@ void PackInstallTask::downloadMods()
     });
     connect(jobPtr.get(), &NetJob::progress, [&](qint64 current, qint64 total)
     {
+        setDetails(tr("%1 out of %2 complete").arg(current).arg(total));
         abortable = true;
         setProgress(current, total);
     });
+    connect(jobPtr.get(), &NetJob::stepProgress, this, &PackInstallTask::propogateStepProgress);
     connect(jobPtr.get(), &NetJob::aborted, [&]
     {
         abortable = false;

launcher/modplatform/flame/FileResolvingTask.cpp

@@ -35,7 +35,29 @@ void Flame::FileResolvingTask::executeTask()
     QByteArray data = Json::toText(object);
     auto dl = Net::Upload::makeByteArray(QUrl("https://api.curseforge.com/v1/mods/files"), result.get(), data);
     m_dljob->addNetAction(dl);
-    connect(m_dljob.get(), &NetJob::finished, this, &Flame::FileResolvingTask::netJobFinished);
+
+    auto step_progress = std::make_shared<TaskStepProgress>();
+    connect(m_dljob.get(), &NetJob::finished, this, [this, step_progress]() {
+        step_progress->state = TaskStepState::Succeeded;
+        stepProgress(*step_progress);
+        netJobFinished();
+    });
+    connect(m_dljob.get(), &NetJob::failed, this, [this, step_progress](QString reason) {
+        step_progress->state = TaskStepState::Failed;
+        stepProgress(*step_progress);
+        emitFailed(reason);
+    });
+    connect(m_dljob.get(), &NetJob::stepProgress, this, &FileResolvingTask::propogateStepProgress);
+    connect(m_dljob.get(), &NetJob::progress, this, [this, step_progress](qint64 current, qint64 total) {
+        qDebug() << "Resolve slug progress" << current << total;
+        step_progress->update(current, total);
+        stepProgress(*step_progress);
+    });
+    connect(m_dljob.get(), &NetJob::status, this, [this, step_progress](QString status) {
+        step_progress->status = status;
+        stepProgress(*step_progress);
+    });
+
     m_dljob->start();
 }
 
@@ -44,7 +66,7 @@ void Flame::FileResolvingTask::netJobFinished()
     setProgress(1, 3);
     // job to check modrinth for blocked projects
     m_checkJob.reset(new NetJob("Modrinth check", m_network));
-    blockedProjects = QMap<File *,QByteArray *>();
+    blockedProjects = QMap<File*, std::shared_ptr<QByteArray>>();
 
     QJsonDocument doc;
     QJsonArray array;
@@ -71,8 +93,8 @@ void Flame::FileResolvingTask::netJobFinished()
             auto hash = out.hash;
             if(!hash.isEmpty()) {
                 auto url = QString("https://api.modrinth.com/v2/version_file/%1?algorithm=sha1").arg(hash);
-                auto output = new QByteArray();
+                auto output = std::make_shared<QByteArray>();
-                auto dl = Net::Download::makeByteArray(QUrl(url), output);
+                auto dl = Net::Download::makeByteArray(QUrl(url), output.get());
                 QObject::connect(dl.get(), &Net::Download::succeeded, [&out]() {
                     out.resolved = true;
                 });
@@ -82,7 +104,27 @@ void Flame::FileResolvingTask::netJobFinished()
             }
         }
     }
-    connect(m_checkJob.get(), &NetJob::finished, this, &Flame::FileResolvingTask::modrinthCheckFinished);
+    auto step_progress = std::make_shared<TaskStepProgress>();
+    connect(m_checkJob.get(), &NetJob::finished, this, [this, step_progress]() {
+        step_progress->state = TaskStepState::Succeeded;
+        stepProgress(*step_progress);
+        modrinthCheckFinished();
+    });
+    connect(m_checkJob.get(), &NetJob::failed, this, [this, step_progress](QString reason) {
+        step_progress->state = TaskStepState::Failed;
+        stepProgress(*step_progress);
+        emitFailed(reason);
+    });
+    connect(m_checkJob.get(), &NetJob::stepProgress, this, &FileResolvingTask::propogateStepProgress);
+    connect(m_checkJob.get(), &NetJob::progress, this, [this, step_progress](qint64 current, qint64 total) {
+        qDebug() << "Resolve slug progress" << current << total;
+        step_progress->update(current, total);
+        stepProgress(*step_progress);
+    });
+    connect(m_checkJob.get(), &NetJob::status, this, [this, step_progress](QString status) {
+        step_progress->status = status;
+        stepProgress(*step_progress);
+    });
 
     m_checkJob->start();
 }
@@ -95,7 +137,6 @@ void Flame::FileResolvingTask::modrinthCheckFinished() {
         auto &out = *it;
         auto bytes = blockedProjects[out];
         if (!out->resolved) {
-            delete bytes;
             continue;
         }
 
@@ -112,11 +153,9 @@ void Flame::FileResolvingTask::modrinthCheckFinished() {
         } else {
             out->resolved = false;
         }
-
-        delete bytes;
     }
     //copy to an output list and filter out projects found on modrinth
-    auto block = new QList<File *>();
+    auto block = std::make_shared<QList<File*>>();
     auto it = blockedProjects.keys();
     std::copy_if(it.begin(), it.end(), std::back_inserter(*block), [](File *f) {
         return !f->resolved;
@@ -124,32 +163,48 @@ void Flame::FileResolvingTask::modrinthCheckFinished() {
     //Display not found mods early
     if (!block->empty()) {
         //blocked mods found, we need the slug for displaying.... we need another job :D !
-        auto slugJob = new NetJob("Slug Job", m_network);
+        m_slugJob.reset(new NetJob("Slug Job", m_network));
-        auto slugs = QVector<QByteArray>(block->size());
+        int index = 0;
-        auto index = 0;
+        for (auto mod : *block) {
-        for (auto fileInfo: *block) {
+            auto projectId = mod->projectId;
-            auto projectId = fileInfo->projectId;
+            auto output = std::make_shared<QByteArray>();
-            slugs[index] = QByteArray();
             auto url = QString("https://api.curseforge.com/v1/mods/%1").arg(projectId);
-            auto dl = Net::Download::makeByteArray(url, &slugs[index]);
+            auto dl = Net::Download::makeByteArray(url, output.get());
-            slugJob->addNetAction(dl);
+            qDebug() << "Fetching url slug for file:" << mod->fileName;
-            index++;
+            QObject::connect(dl.get(), &Net::Download::succeeded, [block, index, output]() {
-        }
+                auto mod = block->at(index);  // use the shared_ptr so it is captured and only freed when we are done
-        connect(slugJob, &NetJob::succeeded, this, [slugs, this, slugJob, block]() {
+                auto json = QJsonDocument::fromJson(*output);
-            slugJob->deleteLater();
-            auto index = 0;
-            for (const auto &slugResult: slugs) {
-                auto json = QJsonDocument::fromJson(slugResult);
                 auto base = Json::requireString(Json::requireObject(Json::requireObject(Json::requireObject(json),"data"),"links"),
                         "websiteUrl");
-                auto mod = block->at(index);
                 auto link = QString("%1/download/%2").arg(base, QString::number(mod->fileId));
                 mod->websiteUrl = link;
+            });
+            m_slugJob->addNetAction(dl);
             index++;
         }
+        auto step_progress = std::make_shared<TaskStepProgress>();
+        connect(m_slugJob.get(), &NetJob::succeeded, this, [this, step_progress]() {
+            step_progress->state = TaskStepState::Succeeded;
+            stepProgress(*step_progress);
             emitSucceeded();
         });
-        slugJob->start();
+        connect(m_slugJob.get(), &NetJob::failed, this, [this, step_progress](QString reason) {
+            step_progress->state = TaskStepState::Failed;
+            stepProgress(*step_progress);
+            emitFailed(reason);
+        });
+        connect(m_slugJob.get(), &NetJob::stepProgress, this, &FileResolvingTask::propogateStepProgress);
+        connect(m_slugJob.get(), &NetJob::progress, this, [this, step_progress](qint64 current, qint64 total) {
+            qDebug() << "Resolve slug progress" << current << total;
+            step_progress->update(current, total);
+            stepProgress(*step_progress);
+        });
+        connect(m_slugJob.get(), &NetJob::status, this, [this, step_progress](QString status) {
+            step_progress->status = status;
+            stepProgress(*step_progress);
+        });
+
+        m_slugJob->start();
     } else {
         emitSucceeded();
     }

launcher/modplatform/flame/FileResolvingTask.h

@@ -1,41 +1,37 @@
 #pragma once
 
-#include "tasks/Task.h"
-#include "net/NetJob.h"
 #include "PackManifest.h"
+#include "net/NetJob.h"
+#include "tasks/Task.h"
 
-namespace Flame
+namespace Flame {
-{
+class FileResolvingTask : public Task {
-class FileResolvingTask : public Task
-{
     Q_OBJECT
-public:
+   public:
-    explicit FileResolvingTask(const shared_qobject_ptr<QNetworkAccessManager>& network, Flame::Manifest &toProcess);
+    explicit FileResolvingTask(const shared_qobject_ptr<QNetworkAccessManager>& network, Flame::Manifest& toProcess);
-    virtual ~FileResolvingTask() {};
+    virtual ~FileResolvingTask(){};
 
     bool canAbort() const override { return true; }
     bool abort() override;
 
-    const Flame::Manifest &getResults() const
+    const Flame::Manifest& getResults() const { return m_toProcess; }
-    {
-        return m_toProcess;
-    }
 
-protected:
+   protected:
     virtual void executeTask() override;
 
-protected slots:
+   protected slots:
     void netJobFinished();
 
-private: /* data */
+   private: /* data */
     shared_qobject_ptr<QNetworkAccessManager> m_network;
     Flame::Manifest m_toProcess;
     std::shared_ptr<QByteArray> result;
     NetJob::Ptr m_dljob;
     NetJob::Ptr m_checkJob;
+    NetJob::Ptr m_slugJob;
 
     void modrinthCheckFinished();
 
-    QMap<File *, QByteArray *> blockedProjects;
+    QMap<File*, std::shared_ptr<QByteArray>> blockedProjects;
 };
-}
+}  // namespace Flame

launcher/modplatform/flame/FlameAPI.cpp

@@ -38,14 +38,14 @@ auto FlameAPI::getModFileChangelog(int modId, int fileId) -> QString
     QEventLoop lock;
     QString changelog;
 
-    auto* netJob = new NetJob(QString("Flame::FileChangelog"), APPLICATION->network());
+    auto netJob = makeShared<NetJob>(QString("Flame::FileChangelog"), APPLICATION->network());
-    auto* response = new QByteArray();
+    auto response = std::make_shared<QByteArray>();
     netJob->addNetAction(Net::Download::makeByteArray(
         QString("https://api.curseforge.com/v1/mods/%1/files/%2/changelog")
             .arg(QString::fromStdString(std::to_string(modId)), QString::fromStdString(std::to_string(fileId))),
-        response));
+        response.get()));
 
-    QObject::connect(netJob, &NetJob::succeeded, [netJob, response, &changelog] {
+    QObject::connect(netJob.get(), &NetJob::succeeded, [&netJob, response, &changelog] {
         QJsonParseError parse_error{};
         QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
         if (parse_error.error != QJsonParseError::NoError) {
@@ -60,10 +60,7 @@ auto FlameAPI::getModFileChangelog(int modId, int fileId) -> QString
         changelog = Json::ensureString(doc.object(), "data");
     });
 
-    QObject::connect(netJob, &NetJob::finished, [response, &lock] {
+    QObject::connect(netJob.get(), &NetJob::finished, [&lock] { lock.quit(); });
-        delete response;
-        lock.quit();
-    });
 
     netJob->start();
     lock.exec();
@@ -76,13 +73,12 @@ auto FlameAPI::getModDescription(int modId) -> QString
     QEventLoop lock;
     QString description;
 
-    auto* netJob = new NetJob(QString("Flame::ModDescription"), APPLICATION->network());
+    auto netJob = makeShared<NetJob>(QString("Flame::ModDescription"), APPLICATION->network());
-    auto* response = new QByteArray();
+    auto response = std::make_shared<QByteArray>();
     netJob->addNetAction(Net::Download::makeByteArray(
-        QString("https://api.curseforge.com/v1/mods/%1/description")
+        QString("https://api.curseforge.com/v1/mods/%1/description").arg(QString::number(modId)), response.get()));
-            .arg(QString::number(modId)), response));
 
-    QObject::connect(netJob, &NetJob::succeeded, [netJob, response, &description] {
+    QObject::connect(netJob.get(), &NetJob::succeeded, [&netJob, response, &description] {
         QJsonParseError parse_error{};
         QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
         if (parse_error.error != QJsonParseError::NoError) {
@@ -97,10 +93,7 @@ auto FlameAPI::getModDescription(int modId) -> QString
         description = Json::ensureString(doc.object(), "data");
     });
 
-    QObject::connect(netJob, &NetJob::finished, [response, &lock] {
+    QObject::connect(netJob.get(), &NetJob::finished, [&lock] { lock.quit(); });
-        delete response;
-        lock.quit();
-    });
 
     netJob->start();
     lock.exec();
@@ -118,13 +111,13 @@ auto FlameAPI::getLatestVersion(VersionSearchArgs&& args) -> ModPlatform::Indexe
 
     QEventLoop loop;
 
-    auto netJob = new NetJob(QString("Flame::GetLatestVersion(%1)").arg(args.pack.name), APPLICATION->network());
+    auto netJob = makeShared<NetJob>(QString("Flame::GetLatestVersion(%1)").arg(args.pack.name), APPLICATION->network());
-    auto response = new QByteArray();
+    auto response = std::make_shared<QByteArray>();
     ModPlatform::IndexedVersion ver;
 
-    netJob->addNetAction(Net::Download::makeByteArray(versions_url, response));
+    netJob->addNetAction(Net::Download::makeByteArray(versions_url, response.get()));
 
-    QObject::connect(netJob, &NetJob::succeeded, [response, args, &ver] {
+    QObject::connect(netJob.get(), &NetJob::succeeded, [response, args, &ver] {
         QJsonParseError parse_error{};
         QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
         if (parse_error.error != QJsonParseError::NoError) {
@@ -158,11 +151,7 @@ auto FlameAPI::getLatestVersion(VersionSearchArgs&& args) -> ModPlatform::Indexe
         }
     });
 
-    QObject::connect(netJob, &NetJob::finished, [response, netJob, &loop] {
+    QObject::connect(netJob.get(), &NetJob::finished, [&loop] { loop.quit(); });
-        netJob->deleteLater();
-        delete response;
-        loop.quit();
-    });
 
     netJob->start();
 

launcher/modplatform/flame/FlameAPI.h

@@ -27,6 +27,8 @@ class FlameAPI : public NetworkResourceAPI {
             default:
             case ModPlatform::ResourceType::MOD:
                 return 6;
+            case ModPlatform::ResourceType::RESOURCE_PACK:
+                return 12;
         }
     }
 

launcher/modplatform/flame/FlameInstanceCreationTask.cpp

@@ -35,6 +35,7 @@
 
 #include "FlameInstanceCreationTask.h"
 
+#include "modplatform/flame/FileResolvingTask.h"
 #include "modplatform/flame/FlameAPI.h"
 #include "modplatform/flame/PackManifest.h"
 
@@ -382,7 +383,8 @@ bool FlameCreationTask::createInstance()
     });
     connect(m_mod_id_resolver.get(), &Flame::FileResolvingTask::progress, this, &FlameCreationTask::setProgress);
     connect(m_mod_id_resolver.get(), &Flame::FileResolvingTask::status, this, &FlameCreationTask::setStatus);
-
+    connect(m_mod_id_resolver.get(), &Flame::FileResolvingTask::stepProgress, this, &FlameCreationTask::propogateStepProgress);
+    connect(m_mod_id_resolver.get(), &Flame::FileResolvingTask::details, this, &FlameCreationTask::setDetails);
     m_mod_id_resolver->start();
 
     loop.exec();
@@ -452,7 +454,7 @@ void FlameCreationTask::idResolverSucceeded(QEventLoop& loop)
 
 void FlameCreationTask::setupDownloadJob(QEventLoop& loop)
 {
-    m_files_job.reset(new NetJob(tr("Mod download"), APPLICATION->network()));
+    m_files_job.reset(new NetJob(tr("Mod Download Flame"), APPLICATION->network()));
     for (const auto& result : m_mod_id_resolver->getResults().files) {
         QString filename = result.fileName;
         if (!result.required) {
@@ -496,7 +498,11 @@ void FlameCreationTask::setupDownloadJob(QEventLoop& loop)
         m_files_job.reset();
         setError(reason);
     });
-    connect(m_files_job.get(), &NetJob::progress, this, &FlameCreationTask::setProgress);
+    connect(m_files_job.get(), &NetJob::progress, this, [this](qint64 current, qint64 total){
+        setDetails(tr("%1 out of %2 complete").arg(current).arg(total));
+        setProgress(current, total);
+    });
+    connect(m_files_job.get(), &NetJob::stepProgress, this, &FlameCreationTask::propogateStepProgress);
     connect(m_files_job.get(), &NetJob::finished, &loop, &QEventLoop::quit);
 
     setStatus(tr("Downloading mods..."));

launcher/modplatform/helpers/HashUtils.cpp

@@ -79,7 +79,7 @@ void FlameHasher::executeTask()
     // CF-specific
     auto should_filter_out = [](char c) { return (c == 9 || c == 10 || c == 13 || c == 32); };
 
-    std::ifstream file_stream(StringUtils::toStdString(m_path), std::ifstream::binary);
+    std::ifstream file_stream(StringUtils::toStdString(m_path).c_str(), std::ifstream::binary);
     // TODO: This is very heavy work, but apparently QtConcurrent can't use move semantics, so we can't boop this to another thread.
     // How do we make this non-blocking then?
     m_hash = QString::number(MurmurHash2(std::move(file_stream), 4 * MiB, should_filter_out));

launcher/modplatform/helpers/NetworkResourceAPI.cpp

@@ -24,7 +24,7 @@ Task::Ptr NetworkResourceAPI::searchProjects(SearchArgs&& args, SearchCallbacks&
 
     netJob->addNetAction(Net::Download::makeByteArray(QUrl(search_url), response));
 
-    QObject::connect(netJob.get(), &NetJob::succeeded, [=]{
+    QObject::connect(netJob.get(), &NetJob::succeeded, [this, response, callbacks]{
         QJsonParseError parse_error{};
         QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
         if (parse_error.error != QJsonParseError::NoError) {
@@ -40,16 +40,20 @@ Task::Ptr NetworkResourceAPI::searchProjects(SearchArgs&& args, SearchCallbacks&
         callbacks.on_succeed(doc);
     });
 
-    QObject::connect(netJob.get(), &NetJob::failed, [=](QString reason){
+    QObject::connect(netJob.get(), &NetJob::failed, [&netJob, callbacks](QString reason){
         int network_error_code = -1;
         if (auto* failed_action = netJob->getFailedActions().at(0); failed_action && failed_action->m_reply)
             network_error_code = failed_action->m_reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 
        callbacks.on_fail(reason, network_error_code); 
     });
-    QObject::connect(netJob.get(), &NetJob::aborted, [=]{
+    QObject::connect(netJob.get(), &NetJob::aborted, [callbacks]{
        callbacks.on_abort(); 
     });
+    QObject::connect(netJob.get(), &NetJob::finished, [response] {
+        delete response;
+    });
+
 
     return netJob;
 }
@@ -88,7 +92,7 @@ Task::Ptr NetworkResourceAPI::getProjectVersions(VersionSearchArgs&& args, Versi
 
     netJob->addNetAction(Net::Download::makeByteArray(versions_url, response));
 
-    QObject::connect(netJob.get(), &NetJob::succeeded, [=] {
+    QObject::connect(netJob.get(), &NetJob::succeeded, [response, callbacks, args] {
         QJsonParseError parse_error{};
         QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
         if (parse_error.error != QJsonParseError::NoError) {

launcher/modplatform/legacy_ftb/PackInstallTask.cpp

@@ -81,6 +81,7 @@ void PackInstallTask::downloadPack()
     connect(netJobContainer.get(), &NetJob::succeeded, this, &PackInstallTask::onDownloadSucceeded);
     connect(netJobContainer.get(), &NetJob::failed, this, &PackInstallTask::onDownloadFailed);
     connect(netJobContainer.get(), &NetJob::progress, this, &PackInstallTask::onDownloadProgress);
+    connect(netJobContainer.get(), &NetJob::stepProgress, this, &PackInstallTask::propogateStepProgress);
     connect(netJobContainer.get(), &NetJob::aborted, this, &PackInstallTask::onDownloadAborted);
 
     netJobContainer->start();

launcher/modplatform/modpacksch/FTBPackInstallTask.cpp

@@ -1,387 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-/*
- *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 flowln <flowlnlnln@gmail.com>
- *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
- *
- *  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/>.
- *
- * This file incorporates work covered by the following copyright and
- * permission notice:
- *
- *      Copyright 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
- *      Copyright 2020-2021 Petr Mrazek <peterix@gmail.com>
- *
- *      Licensed under the Apache License, Version 2.0 (the "License");
- *      you may not use this file except in compliance with the License.
- *      You may obtain a copy of the License at
- *
- *          http://www.apache.org/licenses/LICENSE-2.0
- *
- *      Unless required by applicable law or agreed to in writing, software
- *      distributed under the License is distributed on an "AS IS" BASIS,
- *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *      See the License for the specific language governing permissions and
- *      limitations under the License.
- */
-
-#include "FTBPackInstallTask.h"
-
-#include "FileSystem.h"
-#include "Json.h"
-#include "minecraft/MinecraftInstance.h"
-#include "minecraft/PackProfile.h"
-#include "modplatform/flame/PackManifest.h"
-#include "net/ChecksumValidator.h"
-#include "settings/INISettingsObject.h"
-
-#include "Application.h"
-#include "BuildConfig.h"
-#include "ui/dialogs/BlockedModsDialog.h"
-
-namespace ModpacksCH {
-
-PackInstallTask::PackInstallTask(Modpack pack, QString version, QWidget* parent)
-    : m_pack(std::move(pack)), m_version_name(std::move(version)), m_parent(parent)
-{}
-
-bool PackInstallTask::abort()
-{
-    if (!canAbort())
-        return false;
-
-    bool aborted = true;
-
-    if (m_net_job)
-        aborted &= m_net_job->abort();
-    if (m_mod_id_resolver_task)
-        aborted &= m_mod_id_resolver_task->abort();
-
-    return aborted ? InstanceTask::abort() : false;
-}
-
-void PackInstallTask::executeTask()
-{
-    setStatus(tr("Getting the manifest..."));
-    setAbortable(false);
-
-    // Find pack version
-    auto version_it = std::find_if(m_pack.versions.constBegin(), m_pack.versions.constEnd(),
-                                   [this](ModpacksCH::VersionInfo const& a) { return a.name == m_version_name; });
-
-    if (version_it == m_pack.versions.constEnd()) {
-        emitFailed(tr("Failed to find pack version %1").arg(m_version_name));
-        return;
-    }
-
-    auto version = *version_it;
-
-    auto netJob = makeShared<NetJob>("ModpacksCH::VersionFetch", APPLICATION->network());
-
-    auto searchUrl = QString(BuildConfig.MODPACKSCH_API_BASE_URL + "public/modpack/%1/%2").arg(m_pack.id).arg(version.id);
-    netJob->addNetAction(Net::Download::makeByteArray(QUrl(searchUrl), &m_response));
-
-    QObject::connect(netJob.get(), &NetJob::succeeded, this, &PackInstallTask::onManifestDownloadSucceeded);
-    QObject::connect(netJob.get(), &NetJob::failed, this, &PackInstallTask::onManifestDownloadFailed);
-    QObject::connect(netJob.get(), &NetJob::aborted, this, &PackInstallTask::abort);
-    QObject::connect(netJob.get(), &NetJob::progress, this, &PackInstallTask::setProgress);
-
-    m_net_job = netJob;
-
-    setAbortable(true);
-    netJob->start();
-}
-
-void PackInstallTask::onManifestDownloadSucceeded()
-{
-    m_net_job.reset();
-
-    QJsonParseError parse_error{};
-    QJsonDocument doc = QJsonDocument::fromJson(m_response, &parse_error);
-    if (parse_error.error != QJsonParseError::NoError) {
-        qWarning() << "Error while parsing JSON response from ModpacksCH at " << parse_error.offset
-                   << " reason: " << parse_error.errorString();
-        qWarning() << m_response;
-        return;
-    }
-
-    ModpacksCH::Version version;
-    try {
-        auto obj = Json::requireObject(doc);
-        ModpacksCH::loadVersion(version, obj);
-    } catch (const JSONValidationError& e) {
-        emitFailed(tr("Could not understand pack manifest:\n") + e.cause());
-        return;
-    }
-
-    m_version = version;
-
-    resolveMods();
-}
-
-void PackInstallTask::resolveMods()
-{
-    setStatus(tr("Resolving mods..."));
-    setAbortable(false);
-    setProgress(0, 100);
-
-    m_file_id_map.clear();
-
-    Flame::Manifest manifest;
-    int index = 0;
-
-    for (auto const& file : m_version.files) {
-        if (!file.serverOnly && file.url.isEmpty()) {
-            if (file.curseforge.file_id <= 0) {
-                emitFailed(tr("Invalid manifest: There's no information available to download the file '%1'!").arg(file.name));
-                return;
-            }
-
-            Flame::File flame_file;
-            flame_file.projectId = file.curseforge.project_id;
-            flame_file.fileId = file.curseforge.file_id;
-            flame_file.hash = file.sha1;
-
-            manifest.files.insert(flame_file.fileId, flame_file);
-            m_file_id_map.append(flame_file.fileId);
-        } else {
-            m_file_id_map.append(-1);
-        }
-
-        index++;
-    }
-
-    m_mod_id_resolver_task.reset(new Flame::FileResolvingTask(APPLICATION->network(), manifest));
-
-    connect(m_mod_id_resolver_task.get(), &Flame::FileResolvingTask::succeeded, this, &PackInstallTask::onResolveModsSucceeded);
-    connect(m_mod_id_resolver_task.get(), &Flame::FileResolvingTask::failed, this, &PackInstallTask::onResolveModsFailed);
-    connect(m_mod_id_resolver_task.get(), &Flame::FileResolvingTask::aborted, this, &PackInstallTask::abort);
-    connect(m_mod_id_resolver_task.get(), &Flame::FileResolvingTask::progress, this, &PackInstallTask::setProgress);
-
-    setAbortable(true);
-
-    m_mod_id_resolver_task->start();
-}
-
-void PackInstallTask::onResolveModsSucceeded()
-{
-    auto anyBlocked = false;
-
-    Flame::Manifest results = m_mod_id_resolver_task->getResults();
-    for (int index = 0; index < m_file_id_map.size(); index++) {
-        auto const file_id = m_file_id_map.at(index);
-        if (file_id < 0)
-            continue;
-
-        Flame::File results_file = results.files[file_id];
-        VersionFile& local_file = m_version.files[index];
-
-        // First check for blocked mods
-        if (!results_file.resolved || results_file.url.isEmpty()) {
-            BlockedMod blocked_mod;
-            blocked_mod.name = local_file.name;
-            blocked_mod.websiteUrl = results_file.websiteUrl;
-            blocked_mod.hash = results_file.hash;
-            blocked_mod.matched = false;
-            blocked_mod.localPath = "";
-            blocked_mod.targetFolder = results_file.targetFolder;
-
-            m_blocked_mods.append(blocked_mod);
-
-            anyBlocked = true;
-        } else {
-            local_file.url = results_file.url.toString();
-        }
-    }
-
-    m_mod_id_resolver_task.reset();
-
-    if (anyBlocked) {
-        qDebug() << "Blocked files found, displaying file list";
-
-        BlockedModsDialog message_dialog(m_parent, tr("Blocked files found"),
-                                         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."),
-                                         m_blocked_mods);
-
-        message_dialog.setModal(true);
-
-        if (message_dialog.exec() == QDialog::Accepted) {
-            qDebug() << "Post dialog blocked mods list: " << m_blocked_mods;
-            createInstance();
-        } else {
-            abort();
-        }
-
-    } else {
-        createInstance();
-    }
-}
-
-void PackInstallTask::createInstance()
-{
-    setAbortable(false);
-
-    setStatus(tr("Creating the instance..."));
-    QCoreApplication::processEvents();
-
-    auto instanceConfigPath = FS::PathCombine(m_stagingPath, "instance.cfg");
-    auto instanceSettings = std::make_shared<INISettingsObject>(instanceConfigPath);
-
-    MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
-    auto components = instance.getPackProfile();
-    components->buildingFromScratch();
-
-    for (auto target : m_version.targets) {
-        if (target.type == "game" && target.name == "minecraft") {
-            components->setComponentVersion("net.minecraft", target.version, true);
-            break;
-        }
-    }
-
-    for (auto target : m_version.targets) {
-        if (target.type != "modloader")
-            continue;
-
-        if (target.name == "forge") {
-            components->setComponentVersion("net.minecraftforge", target.version);
-        } else if (target.name == "fabric") {
-            components->setComponentVersion("net.fabricmc.fabric-loader", target.version);
-        }
-    }
-
-    // install any jar mods
-    QDir jarModsDir(FS::PathCombine(m_stagingPath, "minecraft", "jarmods"));
-    if (jarModsDir.exists()) {
-        QStringList jarMods;
-
-        for (const auto& info : jarModsDir.entryInfoList(QDir::NoDotAndDotDot | QDir::Files)) {
-            jarMods.push_back(info.absoluteFilePath());
-        }
-
-        components->installJarMods(jarMods);
-    }
-
-    components->saveNow();
-
-    instance.setName(name());
-    instance.setIconKey(m_instIcon);
-    instance.setManagedPack("modpacksch", QString::number(m_pack.id), m_pack.name, QString::number(m_version.id), m_version.name);
-
-    instance.saveNow();
-
-    onCreateInstanceSucceeded();
-}
-
-void PackInstallTask::onCreateInstanceSucceeded()
-{
-    downloadPack();
-}
-
-void PackInstallTask::downloadPack()
-{
-    setStatus(tr("Downloading mods..."));
-    setAbortable(false);
-
-    auto jobPtr = makeShared<NetJob>(tr("Mod download"), APPLICATION->network());
-    for (auto const& file : m_version.files) {
-        if (file.serverOnly || file.url.isEmpty())
-            continue;
-
-        auto path = FS::PathCombine(m_stagingPath, ".minecraft", file.path, file.name);
-        qDebug() << "Will try to download" << file.url << "to" << path;
-
-        QFileInfo file_info(file.name);
-
-        auto dl = Net::Download::makeFile(file.url, path);
-        if (!file.sha1.isEmpty()) {
-            auto rawSha1 = QByteArray::fromHex(file.sha1.toLatin1());
-            dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, rawSha1));
-        }
-
-        jobPtr->addNetAction(dl);
-    }
-
-    connect(jobPtr.get(), &NetJob::succeeded, this, &PackInstallTask::onModDownloadSucceeded);
-    connect(jobPtr.get(), &NetJob::failed, this, &PackInstallTask::onModDownloadFailed);
-    connect(jobPtr.get(), &NetJob::aborted, this, &PackInstallTask::abort);
-    connect(jobPtr.get(), &NetJob::progress, this, &PackInstallTask::setProgress);
-
-    m_net_job = jobPtr;
-
-    setAbortable(true);
-    jobPtr->start();
-}
-
-void PackInstallTask::onModDownloadSucceeded()
-{
-    m_net_job.reset();
-    if (!m_blocked_mods.isEmpty()) {
-        copyBlockedMods();
-    }
-    emitSucceeded();
-}
-
-void PackInstallTask::onManifestDownloadFailed(QString reason)
-{
-    m_net_job.reset();
-    emitFailed(reason);
-}
-void PackInstallTask::onResolveModsFailed(QString reason)
-{
-    m_net_job.reset();
-    emitFailed(reason);
-}
-void PackInstallTask::onCreateInstanceFailed(QString reason)
-{
-    emitFailed(reason);
-}
-void PackInstallTask::onModDownloadFailed(QString reason)
-{
-    m_net_job.reset();
-    emitFailed(reason);
-}
-
-/// @brief copy the matched blocked mods to the instance staging area
-void PackInstallTask::copyBlockedMods()
-{
-    setStatus(tr("Copying Blocked Mods..."));
-    setAbortable(false);
-    int i = 0;
-    int total = m_blocked_mods.length();
-    setProgress(i, total);
-    for (auto const& mod : m_blocked_mods) {
-        if (!mod.matched) {
-            qDebug() << mod.name << "was not matched to a local file, skipping copy";
-            continue;
-        }
-
-        auto dest_path = FS::PathCombine(m_stagingPath, ".minecraft", mod.targetFolder, mod.name);
-
-        setStatus(tr("Copying Blocked Mods (%1 out of %2 are done)").arg(QString::number(i), QString::number(total)));
-
-        qDebug() << "Will try to copy" << mod.localPath << "to" << dest_path;
-
-        if (!FS::copy(mod.localPath, dest_path)()) {
-            qDebug() << "Copy of" << mod.localPath << "to" << dest_path << "Failed";
-        }
-
-        i++;
-        setProgress(i, total);
-    }
-
-    setAbortable(true);
-}
-
-}  // namespace ModpacksCH

launcher/modplatform/modpacksch/FTBPackInstallTask.h

@@ -1,101 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-only
-/*
- *  Prism Launcher - Minecraft Launcher
- *  Copyright (C) 2022 flowln <flowlnlnln@gmail.com>
- *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
- *
- *  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/>.
- *
- * This file incorporates work covered by the following copyright and
- * permission notice:
- *
- *      Copyright 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
- *      Copyright 2020-2021 Petr Mrazek <peterix@gmail.com>
- *
- *      Licensed under the Apache License, Version 2.0 (the "License");
- *      you may not use this file except in compliance with the License.
- *      You may obtain a copy of the License at
- *
- *          http://www.apache.org/licenses/LICENSE-2.0
- *
- *      Unless required by applicable law or agreed to in writing, software
- *      distributed under the License is distributed on an "AS IS" BASIS,
- *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *      See the License for the specific language governing permissions and
- *      limitations under the License.
- */
-
-#pragma once
-
-#include "FTBPackManifest.h"
-
-#include "InstanceTask.h"
-#include "QObjectPtr.h"
-#include "modplatform/flame/FileResolvingTask.h"
-#include "net/NetJob.h"
-#include "ui/dialogs/BlockedModsDialog.h"
-
-#include <QWidget>
-
-namespace ModpacksCH {
-
-class PackInstallTask final : public InstanceTask
-{
-    Q_OBJECT
-
-public:
-    explicit PackInstallTask(Modpack pack, QString version, QWidget* parent = nullptr);
-    ~PackInstallTask() override = default;
-
-    bool abort() override;
-
-protected:
-    void executeTask() override;
-
-private slots:
-    void onManifestDownloadSucceeded();
-    void onResolveModsSucceeded();
-    void onCreateInstanceSucceeded();
-    void onModDownloadSucceeded();
-
-    void onManifestDownloadFailed(QString reason);
-    void onResolveModsFailed(QString reason);
-    void onCreateInstanceFailed(QString reason);
-    void onModDownloadFailed(QString reason);
-
-private:
-    void resolveMods();
-    void createInstance();
-    void downloadPack();
-    void copyBlockedMods();
-
-private:
-    NetJob::Ptr m_net_job = nullptr;
-    shared_qobject_ptr<Flame::FileResolvingTask> m_mod_id_resolver_task = nullptr;
-
-    QList<int> m_file_id_map;
-
-    QByteArray m_response;
-
-    Modpack m_pack;
-    QString m_version_name;
-    Version m_version;
-
-    QMap<QString, QString> m_files_to_copy;
-    QList<BlockedMod> m_blocked_mods;
-
-    //FIXME: nuke
-    QWidget* m_parent;
-};
-
-}