feat: enhance backup functionality with GUI scale support and exclude large directories

Author: KdGaming0

CHANGELOG.md

@@ -1 +0,0 @@
-- fix: bug that disabled fancy tab and hud in Skyblocker when selecting Skyhanni compact tab in welcome wizard

gradle.properties

@@ -4,7 +4,7 @@ org.gradle.parallel=true
 org.gradle.configuration-cache=false
 
 # Mod properties
-mod.version=4.0.0-alpha.1
+mod.version=4.0.0-alpha.3
 mod.group=com.github.kd_gaming1
 mod.id=packcore
 mod.name=Pack Core
@@ -15,7 +15,6 @@ deps.fabric_loader=0.18.4
 # Versioned dependencies
 deps.fabric_api=[VERSIONED]
 deps.uilib_version=[VERSIONED]
-deps.moulconfig_version=[VERSIONED]
 deps.midnightlib_version=[VERSIONED]
 deps.hm_api_version=[VERSIONED]
 deps.modmenu_version=[VERSIONED]

src/main/java/com/github/kd_gaming1/packcore/PackCore.java

@@ -35,7 +35,7 @@ public void onInitializeClient() {
         ClientCommandRegistrationCallback.EVENT.register((dispatcher, registryAccess) -> PackCoreCommands.register(dispatcher));
 
         ScreenEvents.BEFORE_INIT.register((client, screen, scaledWidth, scaledHeight) -> {
-            if (screen.getClass() != TitleScreen.class) return;
+            if (!(screen instanceof TitleScreen)) return;
 
             RamWarningHelper.onMainMenu();
 

src/main/java/com/github/kd_gaming1/packcore/PackCorePreLaunch.java

@@ -8,6 +8,7 @@
 import com.github.kd_gaming1.packcore.configpack.ConfigPackExtractor;
 import com.google.gson.JsonObject;
 import eu.midnightdust.lib.config.MidnightConfig;
+import net.fabricmc.loader.api.FabricLoader;
 import net.fabricmc.loader.api.entrypoint.PreLaunchEntrypoint;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -25,24 +26,25 @@ public class PackCorePreLaunch implements PreLaunchEntrypoint {
 
     @Override
     public void onPreLaunch() {
+        Path gameDir = FabricLoader.getInstance().getGameDir();
         Path packcoreDir = PackCore.PACKCORE_DIR;
-        Path configsDir  = packcoreDir.resolve("configs");
+        Path configsDir = packcoreDir.resolve("configs");
 
         MidnightConfig.init("packcore", PackCoreConfig.class);
 
         // Highest priority: restore a backup if one is pending
         if (!PackCoreConfig.pendingRestoreBackup.isBlank()) {
-            applyPendingRestore(packcoreDir);
+            applyPendingRestore(packcoreDir, gameDir);
             return;
         }
 
         // Next priority: the user explicitly chose a config from the wizard GUI
         if (!PackCoreConfig.pendingConfigPack.isBlank()) {
-            applyPendingConfig(packcoreDir, configsDir);
+            applyPendingConfig(gameDir, configsDir);
             return;
         }
 
-        // ── Normal path: auto-detect the best resolution match ─────────────────
+        // Normal path: auto-detect the best resolution + GUI scale match
         ScreenResolution.ScreenSize screen = ScreenResolution.detect();
 
         ConfigPackScanner scanner = new ConfigPackScanner();
@@ -60,38 +62,32 @@ public void onPreLaunch() {
             return;
         }
 
-        ConfigPackEntry selectedPack = findBestResolutionMatch(scannedPacks, screen.width(), screen.height());
+        ConfigPackEntry selectedPack = findBestMatch(scannedPacks, screen.width(), screen.height());
 
         if (selectedPack == null) {
             LOGGER.warn("No packs had valid resolution fields, aborting.");
             return;
         }
 
-        extractIfNeeded(selectedPack, packcoreDir);
+        extractIfNeeded(selectedPack, gameDir);
     }
 
-    // ── Pending (user-selected) config ────────────────────────────────────────
-
     /**
      * Applies the pack whose filename is stored in {@link PackCoreConfig#pendingConfigPack}.
-     * <p>
-     * Always uses {@link ConfigPackExtractor.OverwriteMode#REPLACE_EXISTING} because
-     * the user explicitly asked to switch, so we want a clean application of the new pack.
+     * Always uses REPLACE_EXISTING because the user explicitly asked to switch.
      * The pending flag is cleared regardless of success or failure.
      */
-    private void applyPendingConfig(Path packcoreDir, Path configsDir) {
+    private void applyPendingConfig(Path gameDir, Path configsDir) {
         String pendingFile = PackCoreConfig.pendingConfigPack;
         LOGGER.info("Pending config switch requested: {}", pendingFile);
 
-        // Locate the zip in the configs directory
         Path zipPath = configsDir.resolve(pendingFile);
         if (!Files.exists(zipPath)) {
             LOGGER.error("Pending config zip not found at: {}", zipPath);
             clearPending();
             return;
         }
 
-        // Re-scan so we get the ConfigPackEntry (with the parsed JsonObject)
         ConfigPackScanner scanner = new ConfigPackScanner();
         List<ConfigPackEntry> packs;
         try {
@@ -113,10 +109,9 @@ private void applyPendingConfig(Path packcoreDir, Path configsDir) {
             return;
         }
 
-        // Extract — fully replace
         try {
             ConfigPackExtractor.extractAll(
-                    entry.zipPath(), packcoreDir,
+                    entry.zipPath(), gameDir,
                     ConfigPackExtractor.OverwriteMode.REPLACE_EXISTING
             );
         } catch (IOException e) {
@@ -125,18 +120,18 @@ private void applyPendingConfig(Path packcoreDir, Path configsDir) {
             return;
         }
 
-        JsonObject config      = entry.config();
-        String     packVersion = config.has("version") ? config.get("version").getAsString() : "";
+        JsonObject config = entry.config();
+        String packVersion = config.has("version") ? config.get("version").getAsString() : "";
 
-        PackCoreConfig.lastAppliedVersion  = packVersion;
+        PackCoreConfig.lastAppliedVersion = packVersion;
         PackCoreConfig.lastAppliedPackFile = pendingFile;
-        PackCoreConfig.pendingConfigPack   = "";
+        PackCoreConfig.pendingConfigPack = "";
         MidnightConfig.write(MOD_ID);
 
         LOGGER.info("Successfully applied pending config: {} (version: {})", pendingFile, packVersion);
     }
 
-    private void applyPendingRestore(Path packcoreDir) {
+    private void applyPendingRestore(Path packcoreDir, Path gameDir) {
         String backupFile = PackCoreConfig.pendingRestoreBackup;
         Path backupPath = packcoreDir.resolve("backups").resolve(backupFile);
 
@@ -149,9 +144,10 @@ private void applyPendingRestore(Path packcoreDir) {
         }
 
         try {
-            // Backup files are relative to the game dir, so extract there
-            ConfigPackExtractor.extractAll(backupPath, packcoreDir.getParent(),
-                    ConfigPackExtractor.OverwriteMode.REPLACE_EXISTING);
+            ConfigPackExtractor.extractAll(
+                    backupPath, gameDir,
+                    ConfigPackExtractor.OverwriteMode.REPLACE_EXISTING
+            );
             LOGGER.info("Successfully restored backup: {}", backupFile);
         } catch (IOException e) {
             LOGGER.error("Failed to restore backup '{}': {}", backupFile, e.getMessage());
@@ -160,44 +156,50 @@ private void applyPendingRestore(Path packcoreDir) {
         clearPendingRestore();
     }
 
-    /** Clears {@code applyPendingRestore} and persists the change. */
     private static void clearPendingRestore() {
         PackCoreConfig.pendingRestoreBackup = "";
         MidnightConfig.write(MOD_ID);
     }
 
-    /** Clears {@code pendingConfigPack} and persists the change. */
     private static void clearPending() {
         PackCoreConfig.pendingConfigPack = "";
         MidnightConfig.write(MOD_ID);
     }
 
-    // ── Auto-detect helpers ───────────────────────────────────────────────────
-
     /**
-     * Extracts {@code selectedPack} if it is newer than the installed version,
-     * or if no version has been applied yet.
+     * Extracts {@code selectedPack} into the game directory if:
+     * <ul>
+     *   <li>No version has been applied yet, or</li>
+     *   <li>The selected pack's filename matches the last applied file AND its version is newer.</li>
+     * </ul>
+     * If the filenames differ, extraction is skipped to preserve what the user has installed.
      */
-    private void extractIfNeeded(ConfigPackEntry selectedPack, Path packcoreDir) {
-        JsonObject config           = selectedPack.config();
-        String     packVersion      = config.has("version") ? config.get("version").getAsString() : "";
-        String     installedVersion = PackCoreConfig.lastAppliedVersion;
+    private void extractIfNeeded(ConfigPackEntry selectedPack, Path gameDir) {
+        JsonObject config = selectedPack.config();
+        String packVersion = config.has("version") ? config.get("version").getAsString() : "";
+        String installedVersion = PackCoreConfig.lastAppliedVersion;
+        String installedPackFile = PackCoreConfig.lastAppliedPackFile;
+        String selectedPackFile = selectedPack.zipPath().getFileName().toString();
 
-        LOGGER.info("Best resolution match: {} (version: {})",
-                selectedPack.zipPath().getFileName(), packVersion);
+        LOGGER.info("Best match: {} (version: {})", selectedPackFile, packVersion);
 
         try {
             if (installedVersion.isEmpty()) {
                 LOGGER.info("No config applied yet — performing full extraction.");
                 ConfigPackExtractor.extractAll(
-                        selectedPack.zipPath(), packcoreDir,
+                        selectedPack.zipPath(), gameDir,
                         ConfigPackExtractor.OverwriteMode.REPLACE_EXISTING
                 );
+            } else if (!installedPackFile.equals(selectedPackFile)) {
+                // Selected pack differs from last applied — keep what's installed.
+                LOGGER.info("Selected pack '{}' differs from last applied '{}', skipping.",
+                        selectedPackFile, installedPackFile);
+                return;
             } else if (UpdateChecker.isNewerVersion(packVersion, installedVersion)) {
                 LOGGER.info("Newer config available ({} → {}), applying with SKIP_EXISTING.",
                         installedVersion, packVersion);
                 ConfigPackExtractor.extractAll(
-                        selectedPack.zipPath(), packcoreDir,
+                        selectedPack.zipPath(), gameDir,
                         ConfigPackExtractor.OverwriteMode.SKIP_EXISTING
                 );
             } else {
@@ -209,21 +211,22 @@ private void extractIfNeeded(ConfigPackEntry selectedPack, Path packcoreDir) {
             return;
         }
 
-        PackCoreConfig.lastAppliedVersion  = packVersion;
-        PackCoreConfig.lastAppliedPackFile = selectedPack.zipPath().getFileName().toString();
+        PackCoreConfig.lastAppliedVersion = packVersion;
+        PackCoreConfig.lastAppliedPackFile = selectedPackFile;
         MidnightConfig.write(MOD_ID);
 
         LOGGER.info("Successfully applied config version: {}", packVersion);
     }
 
     /**
      * Returns the pack whose target resolution is closest to the screen resolution
-     * using squared Euclidean distance.
+     * using squared Euclidean distance. When two packs tie on distance, the one
+     * with the higher guiScale wins.
      */
-    private ConfigPackEntry findBestResolutionMatch(List<ConfigPackEntry> packs,
-                                                    int screenWidth, int screenHeight) {
-        ConfigPackEntry selectedPack       = null;
-        long            bestDistanceSquared = Long.MAX_VALUE;
+    private ConfigPackEntry findBestMatch(List<ConfigPackEntry> packs, int screenWidth, int screenHeight) {
+        ConfigPackEntry best = null;
+        long bestDistSq = Long.MAX_VALUE;
+        int bestGuiScale = -1;
 
         for (ConfigPackEntry pack : packs) {
             JsonObject config = pack.config();
@@ -233,16 +236,18 @@ private ConfigPackEntry findBestResolutionMatch(List<ConfigPackEntry> packs,
                 continue;
             }
 
-            long widthDiff  = config.get("targetWidth").getAsInt()  - screenWidth;
+            long widthDiff = config.get("targetWidth").getAsInt() - screenWidth;
             long heightDiff = config.get("targetHeight").getAsInt() - screenHeight;
-            long distSq     = widthDiff * widthDiff + heightDiff * heightDiff;
+            long distSq = widthDiff * widthDiff + heightDiff * heightDiff;
+            int guiScale = config.has("guiScale") ? config.get("guiScale").getAsInt() : 0;
 
-            if (distSq < bestDistanceSquared) {
-                bestDistanceSquared = distSq;
-                selectedPack        = pack;
+            if (distSq < bestDistSq || (distSq == bestDistSq && guiScale > bestGuiScale)) {
+                bestDistSq = distSq;
+                bestGuiScale = guiScale;
+                best = pack;
             }
         }
 
-        return selectedPack;
+        return best;
     }
 }

src/main/java/com/github/kd_gaming1/packcore/command/PackCoreCommands.java

@@ -1,5 +1,7 @@
 package com.github.kd_gaming1.packcore.command;
 
+import com.github.kd_gaming1.packcore.gui.screen.WelcomeWizardScreen;
+import com.github.kd_gaming1.packcore.gui.screen.config.ConfigScreen;
 import com.github.kd_gaming1.packcore.integration.ItemBackgroundManager;
 import com.github.kd_gaming1.packcore.integration.PerformanceProfileService;
 import com.github.kd_gaming1.packcore.integration.StorageDesignManager;
@@ -85,6 +87,22 @@ public static void register(CommandDispatcher<FabricClientCommandSource> dispatc
                                     return 1;
                                 }))
                         )
+                        .then(literal("wizard")
+                                .executes(ctx -> {
+                                    Minecraft.getInstance().execute(() ->
+                                            Minecraft.getInstance().setScreen(new WelcomeWizardScreen(Minecraft.getInstance().screen))
+                                    );
+                                    return 1;
+                                })
+                        )
+                        .then(literal("modpack_config")
+                                .executes(ctx -> {
+                                    Minecraft.getInstance().execute(() ->
+                                            Minecraft.getInstance().setScreen(new ConfigScreen())
+                                    );
+                                    return 1;
+                                })
+                        )
         );
     }