Add back coremods support.

Fox2Code · Fox2Code · commit 28b13635b421 · 2025-06-17T11:08:07.000+02:00
diff --git a/loader/src/main/java/com/fox2code/foxloader/patching/PreLoader.java b/loader/src/main/java/com/fox2code/foxloader/patching/PreLoader.java
@@ -27,9 +27,11 @@
 import com.fox2code.foxloader.dependencies.DependencyHelper;
 import com.fox2code.foxloader.launcher.FileInfo;
 import com.fox2code.foxloader.launcher.FoxLauncher;
+import com.fox2code.foxloader.loader.ModLoaderInit;
 import com.fox2code.foxloader.patching.game.GamePatches;
 import com.fox2code.foxloader.patching.mixin.MixinModLoader;
 import com.fox2code.foxloader.utils.Platform;
+import com.fox2code.foxloader.utils.io.IOUtils;
 import com.fox2code.rebuild.ClassDataProvider;
 import org.objectweb.asm.tree.ClassNode;
 import org.spongepowered.asm.mixin.transformer.IMixinTransformer;
@@ -43,15 +45,21 @@
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.net.URLConnection;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.LinkedList;
 import java.util.Objects;
 
 public final class PreLoader {
+    private static final File coremods = new File(FoxLauncher.getGameDir(), "coremods");
     private static final File tmpRoot = new File(FoxLauncher.getGameDir(), ".foxloader");
     private static final File tmpDir = new File(tmpRoot,
             File.separator + "internal" + File.separator + "patched");
     private static final File patchedFile = new File(tmpDir,
             "ReIndev-v" + BuildConfig.REINDEV_VERSION + "-fl" + BuildConfig.FOXLOADER_VERSION + ".jar");
+    private static final File patchedHash = new File(tmpDir,
+            "ReIndev-v" + BuildConfig.REINDEV_VERSION + "-fl" + BuildConfig.FOXLOADER_VERSION + ".hash");
     private static File devPatchedFile = null;
     // Use reference to allow memory to be freed on demand
     private static Reference<ClassDataProvider> classDataProviderReference;
@@ -70,16 +78,55 @@ public static void initializePatching() {
         IMixinTransformer mixinTransformer = MixinModLoader.initializeMixin(FoxLauncher.isClient());
         FoxLauncher.getFoxClassLoader().installWrappedExtensions(
                 patchingLoaderExtensions = new PatchingLoaderExtensions(mixinTransformer));
+        LinkedList<File> coreMods = new LinkedList<>();
+        if (coremods.isDirectory() || coremods.mkdirs()) {
+            coreMods.addAll(Arrays.asList(Objects.requireNonNull(coremods.listFiles(
+                    (dir, name) -> name.endsWith(".zip") || name.endsWith(".jar")))));
+        }
         if (!FoxLauncher.DEVELOPING_FOXLOADER && !FoxLauncher.DEV_MODE) {
+            PreLoaderMetaJarHash preLoaderMetaJarHash = new PreLoaderMetaJarHash();
+            preLoaderMetaJarHash.addString(BuildConfig.REINDEV_VERSION);
+            preLoaderMetaJarHash.addString(ModLoaderInit.FOXLOADER_TRUE_SHA_256);
             try {
-                if (!patchedFile.exists()) {
+                LinkedList<FileInfo> coreModsInfos = new LinkedList<>();
+                for (File coreMod : coreMods) {
+                    FileInfo fileInfo = new FileInfo(coreMod);
+                    coreModsInfos.add(fileInfo);
+                    preLoaderMetaJarHash.addString(fileInfo.sha256);
+                }
+                preLoaderMetaJarHash.freeze();
+                final String currentHash = preLoaderMetaJarHash.getHash();
+                String previousHashAndSize = "";
+                String jarSize = "";
+                if (patchedFile.exists() && patchedHash.exists()) {
+                    try {
+                        previousHashAndSize = new String(Files.readAllBytes(
+                                patchedHash.toPath()), StandardCharsets.UTF_8);
+                        jarSize = String.format("%08X", patchedFile.length());
+                    } catch (Exception ignored) {}
+                }
+
+                if (jarSize.isEmpty() || !previousHashAndSize.equals(currentHash + jarSize)) {
+                    if (tmpDir.isDirectory()) {
+                        for (File child : Objects.requireNonNull(tmpDir.listFiles())) {
+                            IOUtils.deleteFile(child);
+                        }
+                    }
                     File file = DependencyHelper.loadDependencyAsFile(DependencyHelper.reIndevDependencySlim);
-                    GamePatches.patchSlimJar(file, patchedFile);
+                    GamePatches.patchSlimJarWithCoreMods(file, coreMods, patchedFile);
+                    jarSize = String.format("%08X", patchedFile.length());
+                    Files.write(patchedHash.toPath(), (currentHash + jarSize).getBytes(StandardCharsets.UTF_8));
                 }
                 FoxLauncher.getFoxClassLoader().setPatchedSlimInfo(new FileInfo(patchedFile));
+                for (FileInfo coreMod : coreModsInfos) {
+                    FoxLauncher.getFoxClassLoader().addFileToClassLoader(coreMod);
+                }
             } catch (IOException e) {
                 throw new RuntimeException("Failed to patch ReIndev", e);
             }
+        } else if (!coreMods.isEmpty()) {
+            ModLoaderInit.getModLoaderLogger().warning(
+                    "Core mods are not supported inside a development environment!");
         }
     }
 
diff --git a/loader/src/main/java/com/fox2code/foxloader/patching/PreLoaderMetaJarHash.java b/loader/src/main/java/com/fox2code/foxloader/patching/PreLoaderMetaJarHash.java
@@ -0,0 +1,82 @@
+/*
+ * MIT License
+ * 
+ * Copyright (c) 2023-2025 Fox2Code
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.fox2code.foxloader.patching;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+final class PreLoaderMetaJarHash {
+    private final MessageDigest digest;
+    private final ByteArrayOutputStream baos;
+    private final DataOutputStream dos;
+    private byte[] cache;
+
+    public PreLoaderMetaJarHash() {
+        try {
+            this.digest = MessageDigest.getInstance("SHA-256");
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException(e);
+        }
+        this.baos = new ByteArrayOutputStream();
+        this.dos = new DataOutputStream(this.baos);
+    }
+
+    public void addString(String text) {
+        if (this.cache != null)
+            throw new IllegalStateException("Hash has been frozen");
+        try {
+            this.dos.writeUTF(text);
+            this.dos.writeByte(0);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public byte[] makeHash() {
+        if (this.cache != null) return this.cache;
+        byte[] result = this.digest.digest(this.baos.toByteArray());
+        if (result.length != 32) {
+            throw new AssertionError(
+                    "Result hash is not the result hash of a SHA-256 hash " +
+                            "(got " + result.length + ", expected 32)");
+        }
+        return result;
+    }
+
+    public String getHash() {
+        byte[] hash = makeHash();
+        StringBuilder builder = new StringBuilder();
+        for (byte b : hash) {
+            builder.append(String.format("%02X", b));
+        }
+        return builder.toString();
+    }
+
+    public void freeze() {
+        this.cache = this.makeHash();
+    }
+}
diff --git a/patching/src/main/java/com/fox2code/foxloader/patching/game/GamePatches.java b/patching/src/main/java/com/fox2code/foxloader/patching/game/GamePatches.java
@@ -24,6 +24,7 @@
 package com.fox2code.foxloader.patching.game;
 
 import com.fox2code.foxloader.patching.TransformerUtils;
+import com.fox2code.foxloader.utils.io.IOUtils;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.tree.ClassNode;
@@ -33,6 +34,7 @@
 import java.util.*;
 import java.util.function.Function;
 import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
 import java.util.zip.ZipInputStream;
 import java.util.zip.ZipOutputStream;
 
@@ -115,7 +117,7 @@ public static void patchSlimJarDev(File slimJar, File patchedJar) throws IOExcep
         }
         boolean failedRename = false;
         try {
-            patchSlimJarImpl(slimJar, patchedJar, true);
+            patchSlimJarImpl(slimJar, null, patchedJar, true);
         } finally {
             if (!patchedJar.renameTo(patchedJar)) {
                 failedRename = true;
@@ -127,10 +129,20 @@ public static void patchSlimJarDev(File slimJar, File patchedJar) throws IOExcep
     }
 
     public static void patchSlimJar(File slimJar, File patchedJar) throws IOException {
-        patchSlimJarImpl(slimJar, patchedJar, false);
+        patchSlimJarImpl(slimJar, null, patchedJar, false);
     }
 
-    private static void patchSlimJarImpl(File slimJar, File patchedJar, boolean check) throws IOException {
+    public static void patchSlimJarWithCoreMods(File slimJar, List<File> coreMods, File patchedJar) throws IOException {
+        if (coreMods == null || coreMods.isEmpty()) {
+            patchSlimJar(slimJar, patchedJar);
+            return;
+        }
+        try (JarSourceSet jarSourceSet = new JarSourceSet(coreMods)) {
+            patchSlimJarImpl(slimJar, jarSourceSet, patchedJar, false);
+        }
+    }
+
+    private static void patchSlimJarImpl(File slimJar,JarSourceSet jarSourceSet, File patchedJar, boolean check) throws IOException {
         HashSet<String> classesToPatch = new HashSet<>(gameClassPatches.keySet());
         try(ZipInputStream zipInputStream = new ZipInputStream(Files.newInputStream(slimJar.toPath()));
             ZipOutputStream zipOutputStream = new ZipOutputStream(Files.newOutputStream(patchedJar.toPath()))) {
@@ -139,27 +151,18 @@ private static void patchSlimJarImpl(File slimJar, File patchedJar, boolean chec
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(131072);
             while ((zipEntry = zipInputStream.getNextEntry()) != null) {
                 String path = zipEntry.getName();
-                if (path.endsWith(".class")) {
-                    byteArrayOutputStream.reset();
-                    copy(zipInputStream, byteArrayOutputStream);
-                    ClassReader classReader = new ClassReader(byteArrayOutputStream.toByteArray());
-                    ClassNode classNode = new ClassNode();
-                    classReader.accept(classNode, ClassReader.SKIP_FRAMES);
-                    classesToPatch.remove(classNode.name);
-                    classNode = patchClassNode(classNode);
-                    if (classNode != null) {
-                        zipOutputStream.putNextEntry(new ZipEntry(zipEntry.getName()));
-                        ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
-                        classNode.accept(classWriter);
-                        byte[] compiled = classWriter.toByteArray();
-                        zipOutputStream.write(compiled);
-                        zipOutputStream.closeEntry();
-                        if (check) TransformerUtils.checkBytecodeValidity(compiled);
-                    }
-                } else {
-                    zipOutputStream.putNextEntry(new ZipEntry(zipEntry.getName()));
-                    copy(zipInputStream, zipOutputStream);
-                    zipOutputStream.closeEntry();
+                InputStream jarSourceInputStream = jarSourceSet != null ?
+                        jarSourceSet.getInputStreamParsed(path) : null;
+                patchAndInsert(byteArrayOutputStream, classesToPatch, zipOutputStream,
+                        jarSourceInputStream == null ? zipInputStream : jarSourceInputStream,
+                        path, check, jarSourceInputStream != null);
+            }
+            if (jarSourceSet != null) {
+                while ((zipEntry = jarSourceSet.nextExtraZipEntry()) != null) {
+                    String path = zipEntry.getName();
+                    InputStream inputStream = jarSourceSet.getInputStreamOfCurrentEntry();
+                    patchAndInsert(byteArrayOutputStream, classesToPatch, zipOutputStream,
+                            inputStream, path, check, true);
                 }
             }
             zipOutputStream.finish();
@@ -169,13 +172,104 @@ private static void patchSlimJarImpl(File slimJar, File patchedJar, boolean chec
         }
     }
 
-    // Utils port for game patches
-    static void copy(InputStream inputStream, OutputStream outputStream) throws IOException {
-        byte[] byteChunk = new byte[4096];
-        int n;
+    private static void patchAndInsert(
+            ByteArrayOutputStream byteArrayOutputStream, HashSet<String> classesToPatch,
+            ZipOutputStream zipOutputStream, InputStream inputStream,
+            String path, boolean check, boolean closeInput) throws IOException {
+        if (path.endsWith(".class")) {
+            byteArrayOutputStream.reset();
+            IOUtils.copy(inputStream, byteArrayOutputStream);
+            if (closeInput) {
+                inputStream.close();
+            }
+            ClassReader classReader = new ClassReader(byteArrayOutputStream.toByteArray());
+            ClassNode classNode = new ClassNode();
+            classReader.accept(classNode, ClassReader.SKIP_FRAMES);
+            classesToPatch.remove(classNode.name);
+            classNode = patchClassNode(classNode);
+            if (classNode != null) {
+                zipOutputStream.putNextEntry(new ZipEntry(path));
+                ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+                classNode.accept(classWriter);
+                byte[] compiled = classWriter.toByteArray();
+                zipOutputStream.write(compiled);
+                zipOutputStream.closeEntry();
+                if (check) TransformerUtils.checkBytecodeValidity(compiled);
+            }
+        } else {
+            zipOutputStream.putNextEntry(new ZipEntry(path));
+            IOUtils.copy(inputStream, zipOutputStream);
+            if (closeInput) {
+                inputStream.close();
+            }
+            zipOutputStream.closeEntry();
+        }
+    }
+
+    private static final class JarSourceSet implements Closeable {
+        private final List<ZipFile> zipFiles;
+        private final HashSet<String> parsedFiles;
+        private final Iterator<ZipFile> zipFileIterator;
+        private ZipFile currentZipFile;
+        private Enumeration<? extends ZipEntry> zipEntryEnumeration;
+        private ZipEntry currentZipEntry;
 
-        while ((n = inputStream.read(byteChunk)) > 0) {
-            outputStream.write(byteChunk, 0, n);
+        private JarSourceSet(List<File> files) throws IOException {
+            this.zipFiles = new ArrayList<>();
+            try {
+                for (File file : files) {
+                    this.zipFiles.add(new ZipFile(file));
+                }
+            } catch (IOException ioe) {
+                try {
+                    this.close();
+                } catch (IOException ignored) {}
+                throw ioe;
+            }
+            this.parsedFiles = new HashSet<>();
+            this.zipFileIterator = this.zipFiles.iterator();
+        }
+
+        public InputStream getInputStreamParsed(String path) throws IOException {
+            this.parsedFiles.add(path);
+            for (ZipFile zipFile : this.zipFiles) {
+                ZipEntry zipEntry = zipFile.getEntry(path);
+                if (zipEntry != null) {
+                    return zipFile.getInputStream(zipEntry);
+                }
+            }
+            return null;
+        }
+
+        public ZipEntry nextExtraZipEntry() {
+            while (true) {
+                while (this.zipEntryEnumeration == null ||
+                        !this.zipEntryEnumeration.hasMoreElements()) {
+                    if (!this.zipFileIterator.hasNext()) {
+                        return null;
+                    }
+                    this.currentZipFile = this.zipFileIterator.next();
+                    this.zipEntryEnumeration = this.currentZipFile.entries();
+                }
+                while (this.zipEntryEnumeration.hasMoreElements()) {
+                    ZipEntry zipEntry = this.zipEntryEnumeration.nextElement();
+                    if (this.parsedFiles.add(zipEntry.getName())) {
+                        return this.currentZipEntry = zipEntry;
+                    }
+                }
+            }
+        }
+
+        public InputStream getInputStreamOfCurrentEntry() throws IOException {
+            return this.currentZipFile.getInputStream(this.currentZipEntry);
+        }
+
+        @Override
+        public void close() throws IOException {
+            for (ZipFile zipFile : this.zipFiles) {
+                zipFile.close();
+            }
+            this.zipFiles.clear();
         }
     }
 }
diff --git a/patching/src/main/java/com/fox2code/foxloader/utils/io/IOUtils.java b/patching/src/main/java/com/fox2code/foxloader/utils/io/IOUtils.java
@@ -105,4 +105,10 @@ public static byte[] sha256Of(String text) {
         }
         return hash;
     }
+
+    public static void deleteFile(File file) throws IOException {
+        if (!file.exists()) return;
+        if (file.isDirectory()) throw new IOException("\"" + file.getPath() + "\" is a directory");
+        if (!file.delete()) throw new IOException("Failed to delete \"" + file.getPath() + "\"");
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -105,4 +105,10 @@ public static byte[] sha256Of(String text) {`
`105`	`105`	`}`
`106`	`106`	`return hash;`
`107`	`107`	`}`
	`108`	`+`
	`109`	`+ public static void deleteFile(File file) throws IOException {`
	`110`	`+ if (!file.exists()) return;`
	`111`	`+ if (file.isDirectory()) throw new IOException("\"" + file.getPath() + "\" is a directory");`
	`112`	`+ if (!file.delete()) throw new IOException("Failed to delete \"" + file.getPath() + "\"");`
	`113`	`+ }`
`108`	`114`	`}`