Fix optimize_surface_rules breaking mods that provide custom BiomeManagers

Blocks may legitimately not have a block entity for some states

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -4,51 +4,75 @@ body:
   - type: markdown
     attributes:
       value: >-
-        **Note: This issue tracker is not intended for support requests!** If you need help with crashes or other issues, then
+        **Need help?** Ask on [Discord](https://discord.gg/rN9Y7caguP) instead of opening an issue.
-        you should [ask on our Discord server](https://discord.gg/rN9Y7caguP) instead. Unless you are certain that you
-        have found a defect, and you are able to point to where the problem is, you should not open an issue.
-        <br><br>
-        Additionally, please make sure you have done the following:
         
-        - **Have you ensured that all of your mods (including ModernFix) are up-to-date?** The latest version of ModernFix
+        **Issues that do not meet the requirements below (or are otherwise impossible to address with the given info) will be closed without investigation.**
-        can always be found [on Modrinth](https://modrinth.com/mod/modernfix).
+  - type: checkboxes
-        
+    id: confirmations
-        - **Have you used the [search tool](https://github.com/embeddedt/ModernFix/issues) to check whether your issue
+    attributes:
-        has already been reported?** If it has been, then consider adding more information to the existing issue instead.
+      label: Checklist
-        
+      options:
-        - **Have you determined the minimum set of instructions to reproduce the issue?** If your problem only occurs
+        - label: I am reporting a defect, not asking for help
-        with other mods installed, then you should narrow down exactly which mods are causing the issue. Please do not
+          required: true
-        provide your entire list of mods to us and expect that we will be able to figure out the problem.
+        - label: I have searched existing issues and this has not been reported
+          required: true
+        - label: I have reduced my mod list to the minimum required to reproduce this issue (see below)
+          required: true
   - type: textarea
     id: description
     attributes:
       label: Bug Description
       description: >-
-        Use this section to describe the issue you are experiencing in as much depth as possible. The description should
+        Describe the issue in detail. Be sure to include what you expected to happen and what actually happened.
-        explain what behavior you were expecting, and why you believe the issue to be a bug. If the issue you are reporting
+    validations:
-        only occurs with specific mods installed, then provide the name and version of each mod.
+      required: true
+  - type: textarea
+    id: minimal-mods
+    attributes:
+      label: Minimal Mod List
+      description: >-
+        List ONLY the mods required to reproduce this issue. Maintainers have debugging tools that help them
+        locate problems quickly, but these generally don't work well in modpacks or large mod sets.
+        A minimal list should typically contain fewer than 10 mods.
 
-        **Hint:** If you have any screenshots, videos, or other information that you feel is necessary to
+        Reports with large mod lists will likely be closed without investigation, unless the problem is very clear.
-        explain the issue, you can attach them here.
+
+        If you don't know which mods are causing your problem, use binary search:
+
+        1. Remove half your mods
+
+        2. Test if the issue still occurs
+
+        3. If yes, remove half again. If no, restore the last removed half and repeat from step 1.
+
+        4. Repeat until only the necessary mods remain
+      placeholder: "- ModernFix 5.x.x\n- SomeMod 1.2.3"
+    validations:
+      required: true
   - type: textarea
     id: description-reproduction-steps
     attributes:
       label: Reproduction Steps
       description: >-
-        Provide as much information as possible on how to reproduce this bug. Make sure your instructions are as clear and
+        Provide clear steps to reproduce the bug. Each step should be a single concrete action.
-        concise as possible, because other people will need to be able to follow your guide in order to re-create the issue.
+
-        
+        Maintainers are busy and need to be able to quickly replicate your problem. Your reproduction steps should be
-        **Hint:**  A common way to fill this section out is to write a step-by-step guide.
+        clear enough for someone who is unfamiliar with your mods to follow in 5 minutes or less (not counting time
+        to launch the game).
+
+        Providing vague steps is likely to result in the issue being closed.
+
+      placeholder: "1. \n2. \n3. "
     validations:
       required: true
   - type: textarea
-    id: log-file
+    id: diagnostic-info
     attributes:
-      label: Log File
+      label: Diagnostic Info
       description: >-
-        **Hint:** You can usually find the log files within the folder `.minecraft/logs`. Most often, you will want the `latest.log`
+        Drag and drop `latest.log` from `.minecraft/logs/` for the session where the issue occurred.
-        file, since that file belongs to the last played session of the game.
+        Do not paste log text inline. Issues without a valid `latest.log` will be closed.
-      placeholder: >-
+
-        Drag-and-drop the log file here.
+        If a crash occurred, also attach the relevant file from `.minecraft/crash-reports/`.
     validations:
       required: true

.github/workflows/gradle.yml

@@ -11,31 +11,124 @@ on:
 jobs:
   build:
     runs-on: ubuntu-22.04
+    permissions:
+      issues: write
+    concurrency:
+      group: release-${{ github.ref }}
+      cancel-in-progress: true
     steps:
       - name: Checkout Repository
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - name: Set up JDK 17
+      - name: Set up JDK 21
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: 17
+          java-version: 21
           check-latest: true
+      - name: Check if release branch
+        id: check_branch
+        if: github.event_name == 'push'
+        run: |
+          if [[ "${{ github.ref }}" =~ ^refs/heads/[0-9]+\. ]]; then
+            echo "is_release=true" >> $GITHUB_OUTPUT
+          else
+            echo "is_release=false" >> $GITHUB_OUTPUT
+          fi
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v3
+        uses: gradle/actions/setup-gradle@v4
         with:
-          cache-read-only: ${{ !startsWith(github.ref, 'refs/heads/1.') }}
+          cache-read-only: ${{ steps.check_branch.outputs.is_release != 'true' }}
           gradle-home-cache-cleanup: true
-      - name: Setup project Loom cache
+      - name: Remove tags for release on other versions
-        uses: actions/cache@v4
+        if: steps.check_branch.outputs.is_release == 'true'
-        with:
+        run: ./scripts/tagcleaner.sh
-          path: |
-            .gradle/loom-cache
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/gradle.properties', '**/*.gradle*', '**/gradle-wrapper.properties') }}
-          restore-keys: ${{ runner.os }}-gradle-
       - name: Build ModernFix using Gradle
         run: ./gradlew build
+      - name: Run mixin audit
+        run: timeout 60 xvfb-run ./gradlew runAuditClient
+      - name: Publish mod to CurseForge & Modrinth
+        if: steps.check_branch.outputs.is_release == 'true'
+        run: ./gradlew publishMods copyJarToBin
+        env:
+          CURSEFORGE_TOKEN: ${{ secrets.CURSEFORGE_TOKEN }}
+          MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
+      - name: Capture mod version
+        if: steps.check_branch.outputs.is_release == 'true'
+        run: |
+          echo "MOD_VERSION=$(./gradlew properties -q | grep '^version:' | awk '{print $2}')" >> $GITHUB_ENV
+          echo "MC_VERSION=$(grep '^minecraft_version=' gradle.properties | cut -d= -f2)" >> $GITHUB_ENV
+      - name: Comment on fixed issues
+        if: steps.check_branch.outputs.is_release == 'true'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { execSync } = require('child_process');
+
+            const branch = context.ref.replace('refs/heads/', '');
+            const { data: runs } = await github.rest.actions.listWorkflowRuns({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              workflow_id: 'gradle.yml',
+              branch,
+              status: 'success',
+              per_page: 1
+            });
+
+            const logArgs = runs.workflow_runs.length > 0
+              ? `${runs.workflow_runs[0].head_sha}..${context.sha}`
+              : `-1 ${context.sha}`;
+            const log = execSync(`git log ${logArgs} --format=%s%n%b`, { encoding: 'utf8' });
+
+            const issueNumbers = new Set();
+            const pattern = /(?:fix(?:es|ed)?|close[sd]?|resolve[sd]?)\s+#(\d+)/gi;
+            let match;
+            while ((match = pattern.exec(log)) !== null) {
+              issueNumbers.add(parseInt(match[1]));
+            }
+
+            if (issueNumbers.size === 0) {
+              console.log('No fixed issues found in commits');
+              return;
+            }
+
+            const MARKER = '<!-- modernfix-fix-tracker -->';
+            const modVersion = process.env.MOD_VERSION;
+            const mcVersion = process.env.MC_VERSION;
+            const newLine = `- ${modVersion} for Minecraft ${mcVersion}`;
+
+            for (const issueNumber of issueNumbers) {
+              try {
+                const { data: comments } = await github.rest.issues.listComments({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issueNumber,
+                  per_page: 100
+                });
+
+                const existing = comments.find(c => c.body.includes(MARKER));
+                if (existing) {
+                  await github.rest.issues.updateComment({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    comment_id: existing.id,
+                    body: existing.body + `\n${newLine}`
+                  });
+                  console.log(`Updated comment on issue #${issueNumber}`);
+                } else {
+                  await github.rest.issues.createComment({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issueNumber,
+                    body: `${MARKER}\nThe fix for this issue has been released in the following versions of ModernFix:\n${newLine}`
+                  });
+                  console.log(`Created comment on issue #${issueNumber}`);
+                }
+              } catch (e) {
+                console.log(`Could not comment on #${issueNumber}: ${e.message}`);
+              }
+            }
       - name: Upload Artifacts to GitHub
         uses: actions/upload-artifact@v4
         with:

.github/workflows/release.yml

@@ -1,41 +0,0 @@
-name: Release ModernFix Artifacts
-
-on:
-  release:
-    types:
-      - published
-
-jobs:
-  release:
-    if: github.repository_owner == 'embeddedt'
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: 17
-          check-latest: true
-      - name: Remove tags for release on other versions
-        run: ./scripts/tagcleaner.sh
-      - name: Build and publish mod to CurseForge & Modrinth
-        run: ./gradlew publishToModSites copyJarToBin
-        env:
-          CURSEFORGE_TOKEN: ${{ secrets.CURSEFORGE_TOKEN }}
-          MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }}
-      - name: Upload assets to GitHub
-        uses: AButler/upload-release-assets@v3.0
-        with:
-          files: 'bin/*'
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Add changelog to release
-        uses: irongut/EditRelease@v1.2.0
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          id: ${{ github.event.release.id }}
-          replacebody: true
-          files: "CHANGELOG.md"

CONTRIBUTING.md

@@ -2,16 +2,15 @@ ModernFix is a standard Minecraft-style Gradle project powered by Architectury L
 run the `build` task (e.g. via `./gradlew build`). You can also use `./gradlew forge:build` or `./gradlew fabric:build`
 to build for just one loader (e.g. when debugging and wanting to rebuild quickly).
 
-You must use Java 17 to develop ModernFix as the toolchain requires it. Nonetheless, the 1.16 mod JARs will work on
+You must use Java 21 to develop ModernFix as the toolchain requires it. Nonetheless, the built 1.20.1 JAR is still
-a Minecraft instance with Java 8.
+compatible with Java 17.
 
 ## Submitting pull requests
 
 Code or documentation contributions are welcome. Please keep the following points in mind:
 
-* This project supports many Minecraft versions. Ideally, contributions should be made to the oldest relevant MC version.
+* This project supports many Minecraft versions. Ideally, contributions should be made to the oldest relevant MC version (currently 1.20)
-For instance, a PR optimizing new worldgen should be made to 1.18 (not 1.19 or 1.20) while a PR optimizing something
+  and then they will be ported forward.
-like recipes should be made to 1.16 (the oldest supported version).
 
   This somewhat unconventional policy ensures that all supported versions are treated equal when it comes to development,
 rather than the onus being on other modders and players to backport changes that are needed. Changes to older versions are

annotation-processor/build.gradle

@@ -1,7 +1,6 @@
 plugins {
-    id 'com.github.johnrengelman.shadow'
+    id 'com.gradleup.shadow' version '8.3.9'
     id 'java-library'
-    id 'com.diffplug.spotless'
 }
 
 repositories {
@@ -31,7 +30,6 @@ dependencies {
 }
 
 tasks.withType(JavaCompile) {
-    options.compilerArgs += '--enable-preview'
     options.release = 17
 }
 
@@ -44,6 +42,7 @@ shadowJar {
     // shadowJar bug
     include '*.jar'
     include 'META-INF/services/javax.annotation.processing.Processor'
+    include 'META-INF/gradle/incremental.annotation.processors'
     include 'org/spongepowered/asm/mixin/Mixin.class'
     include 'org/fury_phoenix/**/*'
     include {it.getName() == 'OnlyIn.class'}
@@ -52,9 +51,4 @@ shadowJar {
     include {it.getName() == 'EnvType.class'}
 }
 
-spotless {
-    java {
-        removeUnusedImports()
-    }
-}
 version = '1.1.4'

annotation-processor/src/main/java/org/fury_phoenix/mixinAp/annotation/ClientMixinValidator.java

@@ -90,24 +90,19 @@ public class ClientMixinValidator {
     }
 
     private boolean targetsClient(Object classTarget) {
-        return switch (classTarget) {
+        if (classTarget instanceof TypeElement te) {
-            case TypeElement te ->
+            return isClientMarked(te);
-                isClientMarked(te);
+        } else if (classTarget instanceof TypeMirror tm) {
-            case TypeMirror tm -> {
+            var el = types.asElement(tm);
-                var el = types.asElement(tm);
+            return el != null ? targetsClient(el) : warn("TypeMirror of " + tm);
-                yield el != null ? targetsClient(el) : warn("TypeMirror of " + tm);
+        } else if (classTarget instanceof String s) {
-            }
+            var te = elemUtils.getTypeElement(toSourceString(s.split("\\$")[0]));
-            // If you're using a dollar sign in class names you are insane
+            return te != null ? targetsClient(te) : warn(s);
-            case String s -> {
+        } else {
-                var te =
+            throw new IllegalArgumentException("Unhandled type: "
-                elemUtils.getTypeElement(toSourceString(s.split("\\$")[0]));
-                yield te != null ? targetsClient(te) : warn(s);
-            }
-            default ->
-                throw new IllegalArgumentException("Unhandled type: "
                 + classTarget.getClass() + "\n" + "Stringified contents: "
                 + classTarget.toString());
-        };
+        }
     }
 
     private boolean isClientMarked(TypeElement te) {

annotation-processor/src/main/java/org/fury_phoenix/mixinAp/annotation/MixinProcessor.java

@@ -16,7 +16,6 @@ import javax.annotation.processing.Processor;
 import javax.annotation.processing.RoundEnvironment;
 import javax.annotation.processing.SupportedAnnotationTypes;
 import javax.annotation.processing.SupportedOptions;
-import javax.annotation.processing.SupportedSourceVersion;
 import javax.lang.model.SourceVersion;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.TypeElement;
@@ -26,7 +25,6 @@ import org.fury_phoenix.mixinAp.config.MixinConfig;
 
 @SupportedAnnotationTypes({"org.spongepowered.asm.mixin.Mixin", "org.embeddedt.modernfix.annotation.ClientOnlyMixin"})
 @SupportedOptions({"rootProject.name", "project.name", "org.fury_phoenix.mixinAp.validator.debug"})
-@SupportedSourceVersion(SourceVersion.RELEASE_17)
 @AutoService(Processor.class)
 public class MixinProcessor extends AbstractProcessor {
 
@@ -38,6 +36,11 @@ public class MixinProcessor extends AbstractProcessor {
 
     private final Map<String, List<String>> mixinConfigList = new HashMap<>();
 
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+        return SourceVersion.latest();
+    }
+
     @Override
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
         try {
@@ -77,7 +80,7 @@ public class MixinProcessor extends AbstractProcessor {
             List<String> mixins =
             annotatedMixins.stream()
             .map(TypeElement.class::cast)
-            .map(TypeElement::toString)
+            .map(e -> processingEnv.getElementUtils().getBinaryName(e).toString())
             .collect(Collectors.toList());
 
             mixinConfigList.putIfAbsent(aliases.get(annotation.getSimpleName().toString()), mixins);

annotation-processor/src/main/java/org/fury_phoenix/mixinAp/config/MixinConfig.java

@@ -17,7 +17,7 @@ public record MixinConfig(
     @SerializedName("package")
     String packageName,
     String plugin,
-    String compatabilityLevel,
+    String compatibilityLevel,
     @SerializedName("mixins")
     List<String> commonMixins,
     @SerializedName("client")
@@ -25,7 +25,7 @@ public record MixinConfig(
     InjectorOptions injectors, OverwriteOptions overwrites
     ) {
     public MixinConfig(String packageName, List<String> commonMixins, List<String> clientMixins) {
-        this(true, "0.8", packageName, "org.embeddedt.modernfix.core.ModernFixMixinPlugin", "JAVA_8",
+        this(true, "0.8", packageName, "org.embeddedt.modernfix.core.ModernFixMixinPlugin", "JAVA_17",
         commonMixins, clientMixins, InjectorOptions.DEFAULT, OverwriteOptions.DEFAULT);
     }
     public record InjectorOptions(int defaultRequire) {

annotation-processor/src/main/resources/META-INF/gradle/incremental.annotation.processors

@@ -0,0 +1 @@
+org.fury_phoenix.mixinAp.annotation.MixinProcessor,aggregating

annotations/build.gradle

@@ -1,6 +0,0 @@
-plugins {
-    id 'modernfix.common-conventions'
-    id 'java-library'
-}
-
-version = '1.1.0'

annotations/build.gradle.kts

@@ -0,0 +1,10 @@
+plugins {
+    id("java")
+}
+
+version = "1.1.0"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

annotations/src/main/java/org/embeddedt/modernfix/annotation/FeatureLevel.java

@@ -0,0 +1,9 @@
+package org.embeddedt.modernfix.annotation;
+
+public enum FeatureLevel {
+    GA, BETA;
+
+    public boolean isAtLeast(FeatureLevel required) {
+        return this.ordinal() >= required.ordinal();
+    }
+}

annotations/src/main/java/org/embeddedt/modernfix/annotation/RequiresFeatureLevel.java

@@ -0,0 +1,12 @@
+package org.embeddedt.modernfix.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.TYPE, ElementType.PACKAGE})
+public @interface RequiresFeatureLevel {
+    FeatureLevel value() default FeatureLevel.GA;
+}

annotations/src/main/java/org/embeddedt/modernfix/annotation/RequiresMod.java

@@ -6,7 +6,7 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 @Retention(RetentionPolicy.CLASS)
-@Target(ElementType.TYPE)
+@Target({ElementType.TYPE, ElementType.PACKAGE})
 public @interface RequiresMod {
     String value() default "";
 }

build.gradle

@@ -1,67 +0,0 @@
-plugins {
-    id "architectury-plugin" version "3.4-SNAPSHOT"
-    id "dev.architectury.loom" version "1.6-SNAPSHOT" apply false
-    id "maven-publish"
-    id 'com.matthewprenger.cursegradle' version '1.4.0' apply false
-    id 'com.palantir.git-version' version '1.0.0'
-    id 'org.ajoberstar.grgit' version '5.2.0'
-    id 'se.bjurr.gitchangelog.git-changelog-gradle-plugin' version '1.79.0'
-    id "com.modrinth.minotaur" version "2.+" apply false
-    id("com.diffplug.spotless") version "6.18.0" apply false
-    id 'modernfix.common-conventions' apply false
-}
-
-architectury {
-    minecraft = rootProject.minecraft_version
-}
-
-ext.archives_base_name = 'modernfix'
-
-apply plugin: 'modernfix.common-conventions'
-
-tasks.withType(JavaCompile).configureEach {
-    // ensure that the encoding is set to UTF-8, no matter what the system default is
-    // this fixes some edge cases with special characters not displaying correctly
-    // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
-    // If Javadoc is generated, this must be specified in that task too.
-    options.encoding = "UTF-8"
-
-    // The Minecraft launcher currently installs Java 8 for users, so your mod probably wants to target Java 8 too
-    // JDK 9 introduced a new way of specifying this that will make sure no newer classes or methods are used.
-    // We'll use that if it's available, but otherwise we'll use the older option.
-    def targetVersion = 8
-    /*
-    if (JavaVersion.current().isJava9Compatible()) {
-        options.release = targetVersion
-    }
-     */
-}
-
-tasks.register('generateChangelog', se.bjurr.gitchangelog.plugin.gradle.GitChangelogTask) {
-    def details = versionDetails();
-    def theVersionRef
-    if (details.commitDistance > 0) {
-        theVersionRef = details.lastTag;
-    } else {
-        def secondLastTagCmd = "git describe --abbrev=0 " + details.lastTag + "^"
-        def secondLastTag = secondLastTagCmd.execute().text.trim()
-        theVersionRef = secondLastTag;
-    }
-
-    fromRef = theVersionRef
-
-    file = new File("${rootDir}/CHANGELOG.md");
-    templateContent = new File("${rootDir}/gradle/changelog.mustache").getText('UTF-8').replace("[[modernFixVersionRef]]", theVersionRef);
-    toCommit = "HEAD";
-}
-
-tasks.register('checkCleanTag') {
-    doLast {
-        def details = versionDetails()
-        if (!details.isCleanTag || versionDetails().commitDistance != 0) {
-            throw new GradleException('Not a clean tree.')
-        }
-    }
-}
-
-println "ModernFix: " + version

build.gradle.kts

@@ -0,0 +1,210 @@
+plugins {
+    id("net.neoforged.moddev.legacyforge") version("2.0.134")
+    id("me.modmuss50.mod-publish-plugin") version("1.1.0")
+}
+
+val minecraft_version = rootProject.properties["minecraft_version"].toString()
+
+group = "org.embeddedt"
+
+val gitVersion = providers.of(GitVersionSource::class) {
+    parameters {
+        minecraftVersion.set(minecraft_version)
+        projectDir.set(rootProject.layout.projectDirectory)
+    }
+}
+
+version = gitVersion.get()
+
+base.archivesName = "modernfix-forge"
+
+legacyForge {
+    enable {
+        forgeVersion = rootProject.properties["forge_version"].toString()
+        isDisableRecompilation = System.getenv("CI") == "true"
+    }
+
+    rootProject.properties["parchment_version"]?.let { parchmentVer ->
+        parchment {
+            minecraftVersion = minecraft_version
+            mappingsVersion = parchmentVer.toString()
+        }
+    }
+
+    runs {
+        create("client") {
+            client()
+        }
+        create("server") {
+            server()
+        }
+        create("auditClient") {
+            client()
+            jvmArguments.addAll("-Dmodernfix.auditAndExit=true", "-Djava.awt.headless=true")
+        }
+    }
+
+    mods {
+        create("modernfix") {
+            sourceSet(sourceSets.main.get())
+        }
+    }
+}
+
+mixin {
+    add(sourceSets.main.get(), "modernfix.refmap.json")
+    config("modernfix-modernfix.mixins.json")
+}
+
+tasks.named<Jar>("jar") {
+    manifest.attributes(mapOf(
+        "MixinConfigs" to "modernfix-modernfix.mixins.json",
+        "Specification-Version" to "1",
+        "Implementation-Title" to project.name,
+        "Implementation-Version" to version
+    ))
+}
+
+java {
+    val curSourceCompatLevel = JavaVersion.VERSION_17
+    sourceCompatibility = curSourceCompatLevel
+    targetCompatibility = curSourceCompatLevel
+}
+
+repositories {
+    exclusiveContent {
+        forRepository {
+            maven {
+                // location of the maven that hosts JEI files
+                name = "Progwml6 maven"
+                url = uri("https://dvs1.progwml6.com/files/maven/")
+            }
+        }
+        forRepository {
+            maven {
+                name = "ModMaven"
+                url = uri("https://modmaven.dev")
+            }
+        }
+        filter {
+            includeGroup("mezz.jei")
+        }
+    }
+    exclusiveContent {
+        forRepository {
+            maven("https://cursemaven.com")
+        }
+        filter {
+            includeGroup("curse.maven")
+        }
+    }
+}
+
+val embed by configurations.creating {
+    isCanBeConsumed = false
+    isCanBeResolved = true
+    isTransitive = true
+}
+
+dependencies {
+    implementation(project(":annotations"))
+    embed(project(":annotations"))
+    "additionalRuntimeClasspath"(project(":annotations"))
+    annotationProcessor(project(path = ":annotation-processor", configuration = "shadow"))
+
+    val mixinextrasVersion = rootProject.properties["mixinextras_version"].toString()
+    implementation("io.github.llamalad7:mixinextras-common:${mixinextrasVersion}")
+    annotationProcessor("net.fabricmc:sponge-mixin:0.12.5+mixin.0.8.5")
+    annotationProcessor("io.github.llamalad7:mixinextras-common:${mixinextrasVersion}")
+    implementation("io.github.llamalad7:mixinextras-forge:${mixinextrasVersion}")
+    "jarJar"("io.github.llamalad7:mixinextras-forge:${mixinextrasVersion}")
+
+    val jei_version = rootProject.properties["jei_version"].toString()
+    modCompileOnly("mezz.jei:jei-${minecraft_version}-forge:${jei_version}")
+    modCompileOnly("curse.maven:spark-361579:${rootProject.properties["spark_version"].toString()}")
+    modCompileOnly("curse.maven:ctm-267602:${rootProject.properties["ctm_version"].toString()}")
+    modCompileOnly("curse.maven:ldlib-626676:${rootProject.properties["ldlib_version"].toString()}")
+    modCompileOnly("curse.maven:supermartijncore-454372:4455391")
+    modCompileOnly("curse.maven:patchouli-306770:6164575")
+    modCompileOnly("curse.maven:cofhcore-69162:5374122")
+    modCompileOnly("curse.maven:resourcefullib-570073:5659871")
+    modCompileOnly("curse.maven:kubejs-238086:5853326")
+    modCompileOnly("curse.maven:terrablender-563928:6290448")
+}
+
+tasks.named<Jar>("jar") {
+    from(embed.map { if (it.isDirectory) it else zipTree(it) })
+}
+
+// For the AP
+tasks.withType<JavaCompile>().configureEach {
+    if (!name.lowercase().contains("test")) {
+        options.compilerArgs.addAll(
+            listOf(
+                "-ArootProject.name=${rootProject.name}",
+                "-Aproject.name=${project.name}"
+            )
+        )
+    }
+}
+
+sourceSets {
+    main {
+        resources.srcDir(
+            layout.buildDirectory.dir("generated/sources/annotationProcessor/java/main/resources")
+        )
+    }
+}
+
+tasks.named<ProcessResources>("processResources") {
+    dependsOn(tasks.named("compileJava"))
+
+    inputs.property("version", project.version)
+
+    filesMatching("META-INF/mods.toml") {
+        expand("version" to project.version)
+    }
+}
+
+val finalJarTask = "reobfJar"
+
+tasks.register<Copy>("copyJarNameConsistent") {
+    from(tasks.named<Jar>(finalJarTask).get().outputs.files)
+    into(project.file("build/libs"))
+    rename { _ -> "modernfix-" + project.name + "-latest.jar" }
+}
+
+tasks.register<Copy>("copyJarToBin") {
+    from(tasks.named<Jar>(finalJarTask).get().outputs.files)
+    into(rootProject.file("bin"))
+    mustRunAfter(tasks.named("copyJarNameConsistent"))
+}
+
+tasks.named("build") {
+    dependsOn("copyJarToBin", "copyJarNameConsistent")
+}
+
+publishMods {
+    file.set(tasks.named<Jar>(finalJarTask).flatMap { it.archiveFile })
+    displayName.set(tasks.named<Jar>(finalJarTask).flatMap { it.archiveFileName })
+    changelog = "Please check the [GitHub wiki](https://github.com/embeddedt/ModernFix/wiki/Changelog) for major changes."
+    type = STABLE
+
+    modLoaders.add("forge")
+
+    curseforge {
+        projectId = "790626"
+        projectSlug = "modernfix"
+        accessToken = providers.environmentVariable("CURSEFORGE_TOKEN")
+        minecraftVersions.add(minecraft_version)
+    }
+    modrinth {
+        projectId = "nmDcB62a"
+        accessToken = providers.environmentVariable("MODRINTH_TOKEN")
+        minecraftVersions.add(minecraft_version)
+    }
+}
+
+tasks.named("publishMods") {
+    dependsOn(finalJarTask)
+}

buildSrc/build.gradle

@@ -1,3 +0,0 @@
-plugins {
-    id 'groovy-gradle-plugin'
-}

buildSrc/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    mavenCentral()
+}

buildSrc/src/main/groovy/modernfix.common-conventions.gradle

@@ -1,137 +0,0 @@
-plugins {
-    id 'java'
-    id 'architectury-plugin'
-    id 'maven-publish'
-    id 'com.diffplug.spotless'
-}
-
-spotless {
-    java {
-        removeUnusedImports()
-    }
-}
-
-architectury {
-    compileOnly()
-}
-
-group = 'org.embeddedt'
-// extract base version from tag, generate other metadata ourselves
-def details = versionDetails()
-def plusIndex = details.lastTag.indexOf("+")
-if(plusIndex == -1) {
-    plusIndex = details.lastTag.length()
-}
-def baseVersion = details.lastTag.substring(0, plusIndex)
-def dirtyMarker = grgit.status().clean ? "" : ".dirty"
-def commitHashMarker = details.commitDistance > 0 ? ("." + details.gitHash.substring(0, Math.min(4, details.gitHash.length()))) : ""
-def preMarker = (details.commitDistance > 0 || !details.isCleanTag) ? ("-beta." + details.commitDistance) : ""
-if(preMarker.length() > 0) {
-    // bump to next patch release
-    def versionParts = baseVersion.tokenize(".")
-    baseVersion = "${versionParts[0]}.${versionParts[1]}.${versionParts[2].toInteger() + 1}"
-}
-def versionString = "${baseVersion}${preMarker}+mc${minecraft_version}${commitHashMarker}${dirtyMarker}"
-version = versionString
-archivesBaseName = rootProject.archives_base_name + '-' + project.name
-
-sourceCompatibility = targetCompatibility = JavaVersion.VERSION_1_8
-
-repositories {
-    exclusiveContent {
-        forRepository {
-            maven {
-                url "https://modmaven.dev"
-            }
-        }
-        filter {
-            includeGroup "appeng"
-            includeGroup "vazkii.patchouli"
-            includeGroup "mezz.jei"
-        }
-    }
-    exclusiveContent {
-        forRepository {
-            maven {
-                url "https://cursemaven.com"
-            }
-        }
-        filter {
-            includeGroup "curse.maven"
-        }
-    }
-    exclusiveContent {
-        forRepository {
-            maven {
-                name = 'ParchmentMC'
-                url = 'https://maven.parchmentmc.org'
-            }
-        }
-        filter {
-            includeGroup "org.parchmentmc.data"
-        }
-    }
-    exclusiveContent {
-        forRepository {
-            maven {
-                url = 'https://maven.architectury.dev'
-            }
-        }
-        filter {
-            includeGroup "me.shedaniel"
-        }
-    }
-    exclusiveContent {
-        forRepository {
-            maven {
-                url = 'https://maven.saps.dev/minecraft'
-            }
-        }
-        filter {
-            includeGroup "dev.latvian.mods"
-        }
-    }
-    exclusiveContent {
-        forRepository {
-            maven {
-                name = "Fuzs Mod Resources"
-                url = "https://raw.githubusercontent.com/Fuzss/modresources/main/maven/"
-            }
-        }
-        filter {
-            includeGroup "fuzs"
-        }
-    }
-    exclusiveContent {
-        forRepository {
-            maven {
-                name = "Fabric maven"
-                url = "https://maven.fabricmc.net/"
-            }
-        }
-        filter {
-            includeGroup "net.fabricmc"
-        }
-    }
-    exclusiveContent {
-        forRepository {
-            maven {
-                name = "Mod Menu"
-                url = "https://maven.terraformersmc.com/releases/"
-            }
-        }
-        filter {
-            includeGroup "com.terraformersmc"
-        }
-    }
-    exclusiveContent {
-        forRepository {
-            maven {
-                url "https://maven.tterrag.com"
-            }
-        }
-        filter {
-            includeGroup "team.chisel.ctm"
-        }
-    }
-}

buildSrc/src/main/groovy/modernfix.mod-common-conventions.gradle

@@ -1,41 +0,0 @@
-plugins {
-    id 'modernfix.common-conventions'
-    id 'dev.architectury.loom'
-}
-
-loom {
-    silentMojangMappingsLicense()
-    accessWidenerPath = file("${rootDir}/common/src/main/resources/modernfix.accesswidener")
-}
-
-dependencies {
-    minecraft "com.mojang:minecraft:${rootProject.minecraft_version}"
-    mappings loom.layered() {
-        officialMojangMappings()
-        if(rootProject.hasProperty("parchment_version")) {
-            parchment("org.parchmentmc.data:parchment-${minecraft_version}:${parchment_version}@zip")
-        }
-    }
-    implementation project(":annotations")
-    annotationProcessor project(path: ":annotation-processor", configuration: 'shadow')
-}
-
-project.sourceSets {
-    main.resources.srcDirs += [layout.buildDirectory.dir("generated/sources/annotationProcessor/java/main/resources")]
-}
-// hack to shut up gradle about the hack to include generated resources
-tasks {
-    processResources {
-        dependsOn compileJava
-    }
-}
-
-tasks.withType(JavaCompile) {
-    options.fork = true
-    options.forkOptions.jvmArgs << '--enable-preview'
-    configure(options) {
-        if (!name.toLowerCase().contains('test')) {
-        options.compilerArgs << "-ArootProject.name=${rootProject.name}" << "-Aproject.name=${project.name}"
-        }
-    }
-}

buildSrc/src/main/groovy/modernfix.platform-conventions.gradle

@@ -1,69 +0,0 @@
-plugins {
-    id 'com.matthewprenger.cursegradle'
-    id 'com.modrinth.minotaur'
-}
-
-loom {
-    mods {
-        main { // to match the default mod generated for Forge
-            sourceSet project.sourceSets.main
-            sourceSet project(':common').sourceSets.main
-        }
-    }
-    runs {
-        client {
-            vmArgs "-Xmx1G"
-            vmArgs "-Xms1G"
-            property("mixin.debug.export", "true")
-        }
-    }
-}
-
-def copyJarNameConsistent = tasks.register('copyJarNameConsistent', Copy) {
-    from remapJar // shortcut for createJar.outputs.files
-    into project.file("build/libs")
-    rename { name -> "modernfix-" + project.name + "-latest.jar" }
-}
-
-def copyJarToBin = tasks.register('copyJarToBin', Copy) {
-    from remapJar // shortcut for createJar.outputs.files
-    into rootProject.file("bin")
-    mustRunAfter "copyJarNameConsistent"
-}
-
-tasks.build.dependsOn(copyJarToBin, copyJarNameConsistent)
-
-def isBeta = project.version.toString().contains("beta")
-
-curseforge {
-    if (System.getenv("CURSEFORGE_TOKEN") != null) {
-        apiKey = System.getenv("CURSEFORGE_TOKEN")
-        project {
-            id = "790626"
-            changelog = file("${rootDir}/CHANGELOG.md")
-            changelogType = "markdown"
-            releaseType = isBeta ? "beta" : "release"
-            addGameVersion project.name.capitalize()
-            gameVersionStrings.addAll(supported_minecraft_versions.tokenize(","))
-            mainArtifact remapJar
-        }
-    }
-}
-
-modrinth {
-    token = System.getenv("MODRINTH_TOKEN")
-    projectId = "modernfix" // This can be the project ID or the slug. Either will work!
-    versionType = isBeta ? "beta" : "release" // This is the default -- can also be `beta` or `alpha`
-    uploadFile = remapJar
-    gameVersions = supported_minecraft_versions.tokenize(",")
-    loaders = [project.name]
-    changelog.set(provider { file("${rootDir}/CHANGELOG.md").getText('UTF-8') })
-}
-
-tasks.curseforge.dependsOn(rootProject.generateChangelog)
-tasks.modrinth.dependsOn(rootProject.generateChangelog)
-
-tasks.register('publishToModSites') {
-    publishToModSites.dependsOn(tasks.modrinth)
-    publishToModSites.dependsOn(tasks.curseforge)
-}

buildSrc/src/main/kotlin/GitVersionSource.kt

@@ -0,0 +1,61 @@
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.ValueSource
+import org.gradle.api.provider.ValueSourceParameters
+import org.gradle.process.ExecOperations
+import java.io.ByteArrayOutputStream
+import java.io.File
+import javax.inject.Inject
+
+abstract class GitVersionSource : ValueSource<String, GitVersionSource.Parameters> {
+
+    interface Parameters : ValueSourceParameters {
+        val minecraftVersion: Property<String>
+        val projectDir: DirectoryProperty
+    }
+
+    @get:Inject
+    abstract val execOperations: ExecOperations
+
+    override fun obtain(): String {
+        val minecraftVersion = parameters.minecraftVersion.get()
+        val workDir = parameters.projectDir.get().asFile
+
+        val releaseLine = workDir.resolve("release_line.txt").readText().trim()
+
+        val patch = try {
+            // Find the most recent first-parent commit that touched release_line.txt
+            val lineStartCommit = git(workDir,
+                "log", "--first-parent",
+                "-n", "1",
+                "--format=%H",
+                "--",
+                "release_line.txt"
+            ).trim()
+
+            if (lineStartCommit.isEmpty()) {
+                // count all first-parent commits as a safe fallback
+                git(workDir, "rev-list", "--count", "--first-parent", "HEAD")
+                    .trim().toIntOrNull() ?: 0
+            } else {
+                git(workDir, "rev-list", "--count", "--first-parent", "$lineStartCommit..HEAD")
+                    .trim().toIntOrNull() ?: 0
+            }
+        } catch (_: Exception) {
+            // Git is unavailable or this is not a git repository
+            999
+        }
+
+        return "$releaseLine.$patch+mc$minecraftVersion"
+    }
+
+    private fun git(workDir: File, vararg args: String): String {
+        val output = ByteArrayOutputStream()
+        execOperations.exec {
+            commandLine("git", *args)
+            standardOutput = output
+            workingDir(workDir)
+        }
+        return output.toString(Charsets.UTF_8)
+    }
+}

common/build.gradle

@@ -1,37 +0,0 @@
-plugins {
-    id "modernfix.mod-common-conventions"
-}
-
-architectury {
-    common(rootProject.enabled_platforms.split(","))
-}
-
-dependencies {
-    // We depend on fabric loader here to use the fabric @Environment annotations and get the mixin dependencies
-    // Do NOT use other classes from fabric loader
-    modImplementation "net.fabricmc:fabric-loader:${rootProject.fabric_loader_version}"
-    implementation(annotationProcessor("io.github.llamalad7:mixinextras-common:${rootProject.mixinextras_version}"))
-
-    modCompileOnly("dev.latvian.mods:kubejs:${kubejs_version}") {
-        transitive = false
-    }
-    // Remove the next line if you don't want to depend on the API
-    // modApi "me.shedaniel:architectury:${rootProject.architectury_version}"
-}
-
-// don't need remapped common jar
-tasks.named('remapJar') { enabled = false }
-
-publishing {
-    publications {
-        mavenCommon(MavenPublication) {
-            artifactId = rootProject.archives_base_name
-            from components.java
-        }
-    }
-
-    // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
-    repositories {
-        // Add repositories to publish to here.
-    }
-}

common/src/main/java/org/embeddedt/modernfix/FileWalker.java

@@ -1,21 +0,0 @@
-package org.embeddedt.modernfix;
-
-import com.google.common.cache.CacheLoader;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-public class FileWalker extends CacheLoader<Pair<Path, Integer>, List<Path>> {
-    public static final FileWalker INSTANCE = new FileWalker();
-
-    @Override
-    public List<Path> load(Pair<Path, Integer> key) throws Exception {
-        try(Stream<Path> stream = Files.walk(key.getLeft(), key.getRight())) {
-            return stream.collect(Collectors.toList());
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/ModernFixClient.java

@@ -1,205 +0,0 @@
-package org.embeddedt.modernfix;
-
-import com.mojang.datafixers.util.Pair;
-import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
-import net.minecraft.client.Minecraft;
-import net.minecraft.network.syncher.EntityDataAccessor;
-import net.minecraft.network.syncher.SynchedEntityData;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.world.entity.Entity;
-import org.embeddedt.modernfix.api.constants.IntegrationConstants;
-import org.embeddedt.modernfix.api.entrypoint.ModernFixClientIntegration;
-import org.embeddedt.modernfix.core.ModernFixMixinPlugin;
-import org.embeddedt.modernfix.packet.EntityIDSyncPacket;
-import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
-import org.embeddedt.modernfix.util.ClassInfoManager;
-import org.embeddedt.modernfix.world.IntegratedWatchdog;
-
-import java.lang.management.ManagementFactory;
-import java.lang.reflect.Field;
-import java.util.*;
-import java.util.concurrent.CopyOnWriteArrayList;
-
-public class ModernFixClient {
-    public static ModernFixClient INSTANCE;
-    public static long worldLoadStartTime = -1;
-    private static int numRenderTicks;
-
-    public static float gameStartTimeSeconds = -1;
-
-    public static boolean recipesUpdated, tagsUpdated = false;
-
-    public String brandingString = null;
-
-    /**
-     * The list of loaded client integrations.
-     */
-    public static List<ModernFixClientIntegration> CLIENT_INTEGRATIONS = new CopyOnWriteArrayList<>();
-
-    public ModernFixClient() {
-        INSTANCE = this;
-        // clear reserve as it's not needed
-        Minecraft.reserve = new byte[0];
-        if(ModernFixMixinPlugin.instance.isOptionEnabled("feature.branding.F3Screen")) {
-            brandingString = ModernFix.NAME + " " + ModernFixPlatformHooks.INSTANCE.getVersionString();
-        }
-        for(String className : ModernFixPlatformHooks.INSTANCE.getCustomModOptions().get(IntegrationConstants.CLIENT_INTEGRATION_CLASS)) {
-            try {
-                CLIENT_INTEGRATIONS.add((ModernFixClientIntegration)Class.forName(className).getDeclaredConstructor().newInstance());
-            } catch(ReflectiveOperationException | ClassCastException e) {
-                ModernFix.LOGGER.error("Could not instantiate integration {}", className, e);
-            }
-        }
-
-        if(ModernFixMixinPlugin.instance.isOptionEnabled("perf.dynamic_resources.FireIntegrationHook")) {
-            for(ModernFixClientIntegration integration : ModernFixClient.CLIENT_INTEGRATIONS) {
-                integration.onDynamicResourcesStatusChange(true);
-            }
-        }
-    }
-
-    public void resetWorldLoadStateMachine() {
-        numRenderTicks = 0;
-        worldLoadStartTime = -1;
-        recipesUpdated = false;
-        tagsUpdated = false;
-    }
-
-    public void onGameLaunchFinish() {
-        if(gameStartTimeSeconds >= 0)
-            return;
-        gameStartTimeSeconds = ManagementFactory.getRuntimeMXBean().getUptime() / 1000f;
-        if(ModernFixMixinPlugin.instance.isOptionEnabled("feature.measure_time.GameLoad"))
-            ModernFix.LOGGER.warn("Game took " + gameStartTimeSeconds + " seconds to start");
-        ModernFixPlatformHooks.INSTANCE.onLaunchComplete();
-        ClassInfoManager.clear();
-    }
-
-    public void onRecipesUpdated() {
-        recipesUpdated = true;
-    }
-
-    public void onTagsUpdated() {
-        tagsUpdated = true;
-    }
-
-    public void onRenderTickEnd() {
-        if(recipesUpdated
-                && tagsUpdated
-                && worldLoadStartTime != -1
-                && Minecraft.getInstance().player != null
-                && numRenderTicks++ >= 10) {
-            float timeSpentLoading = ((float)(System.nanoTime() - worldLoadStartTime) / 1000000000f);
-            if(ModernFixMixinPlugin.instance.isOptionEnabled("feature.measure_time.WorldLoad")) {
-                ModernFix.LOGGER.warn("Time from main menu to in-game was " + timeSpentLoading + " seconds");
-                ModernFix.LOGGER.warn("Total time to load game and open world was " + (timeSpentLoading + gameStartTimeSeconds) + " seconds");
-            }
-            resetWorldLoadStateMachine();
-        }
-    }
-
-    /**
-     * Check if the IDs match and remap them if not.
-     * @return true if ID remap was needed
-     */
-    private static boolean compareAndSwitchIds(Class<? extends Entity> eClass, String fieldName, EntityDataAccessor<?> accessor, int newId) {
-        if(accessor.id != newId) {
-            ModernFix.LOGGER.warn("Corrected ID mismatch on {} field {}. Client had {} but server wants {}.",
-                    eClass,
-                    fieldName,
-                    accessor.id,
-                    newId);
-            accessor.id = newId;
-            return true;
-        } else {
-            ModernFix.LOGGER.debug("{} {} ID fine: {}", eClass, fieldName, newId);
-            return false;
-        }
-    }
-
-    /**
-     * Horrendous hack to allow tracking every synced entity data manager.
-     *
-     * This is to ensure we can perform ID fixup on already constructed managers.
-     */
-    public static final Set<SynchedEntityData> allEntityDatas = Collections.newSetFromMap(new WeakHashMap<>());
-
-    private static final Field entriesArrayField;
-    static {
-        Field field;
-        try {
-            field = SynchedEntityData.class.getDeclaredField("entriesArray");
-            field.setAccessible(true);
-        } catch(ReflectiveOperationException e) {
-            field = null;
-        }
-        entriesArrayField = field;
-    }
-
-    /**
-     * Extremely hacky method to detect and correct mismatched entity data parameter IDs on the client and server.
-     *
-     * The technique is far from ideal, but it should detect reliably and also not break already constructed entities.
-     */
-    public static void handleEntityIDSync(EntityIDSyncPacket packet) {
-        Map<Class<? extends Entity>, List<Pair<String, Integer>>> info = packet.getFieldInfo();
-        boolean fixNeeded = false;
-        for(Map.Entry<Class<? extends Entity>, List<Pair<String, Integer>>> entry : info.entrySet()) {
-            Class<? extends Entity> eClass = entry.getKey();
-            for(Pair<String, Integer> field : entry.getValue()) {
-                String fieldName = field.getFirst();
-                int newId = field.getSecond();
-                try {
-                    Field f = eClass.getDeclaredField(fieldName);
-                    f.setAccessible(true);
-                    EntityDataAccessor<?> accessor = (EntityDataAccessor<?>)f.get(null);
-                    if(compareAndSwitchIds(eClass, fieldName, accessor, newId))
-                        fixNeeded = true;
-                } catch(NoSuchFieldException e) {
-                    ModernFix.LOGGER.warn("Couldn't find field on {}: {}", eClass, fieldName);
-                } catch(ReflectiveOperationException e) {
-                    throw new RuntimeException("Unexpected exception", e);
-                }
-            }
-        }
-        /* Now the ID mappings on synced entity data instances are probably all wrong. Fix that. */
-        List<SynchedEntityData> dataEntries;
-        synchronized (allEntityDatas) {
-            if(fixNeeded) {
-                dataEntries = new ArrayList<>(allEntityDatas);
-                for(SynchedEntityData manager : dataEntries) {
-                    Int2ObjectOpenHashMap<SynchedEntityData.DataItem<?>> fixedMap = new Int2ObjectOpenHashMap<>();
-                    List<SynchedEntityData.DataItem<?>> items = new ArrayList<>(manager.itemsById.values());
-                    for(SynchedEntityData.DataItem<?> item : items) {
-                        fixedMap.put(item.getAccessor().id, item);
-                    }
-                    manager.lock.writeLock().lock();
-                    try {
-                        manager.itemsById.replaceAll((id, parameter) -> fixedMap.get((int)id));
-                        if(entriesArrayField != null) {
-                            try {
-                                SynchedEntityData.DataItem<?>[] dataArray = new SynchedEntityData.DataItem[items.size()];
-                                for(int i = 0; i < dataArray.length; i++) {
-                                    dataArray[i] = fixedMap.get(i);
-                                }
-                                entriesArrayField.set(manager, dataArray);
-                            } catch(ReflectiveOperationException e) {
-                                ModernFix.LOGGER.error(e);
-                            }
-                        }
-                    } finally {
-                        manager.lock.writeLock().unlock();
-                    }
-                }
-            }
-            allEntityDatas.clear();
-        }
-    }
-
-    public void onServerStarted(MinecraftServer server) {
-        if(!ModernFixMixinPlugin.instance.isOptionEnabled("feature.integrated_server_watchdog.IntegratedWatchdog"))
-            return;
-        IntegratedWatchdog watchdog = new IntegratedWatchdog(server);
-        watchdog.start();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/chunk/SafeBlockGetter.java

@@ -1,68 +0,0 @@
-package org.embeddedt.modernfix.chunk;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.BlockGetter;
-import net.minecraft.world.level.block.Blocks;
-import net.minecraft.world.level.block.entity.BlockEntity;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.chunk.ChunkAccess;
-import net.minecraft.world.level.chunk.ChunkStatus;
-import net.minecraft.world.level.material.FluidState;
-import net.minecraft.world.level.material.Fluids;
-import org.jetbrains.annotations.Nullable;
-
-public class SafeBlockGetter implements BlockGetter {
-    private final ServerLevel wrapped;
-    private final Thread mainThread;
-
-    public SafeBlockGetter(ServerLevel wrapped) {
-        this.wrapped = wrapped;
-        this.mainThread = Thread.currentThread();
-    }
-
-    public boolean shouldUse() {
-        return Thread.currentThread() != this.mainThread;
-    }
-
-    @Nullable
-    private BlockGetter getChunkSafe(BlockPos pos) {
-        // can safely call getChunkForLighting off-thread
-        BlockGetter access = this.wrapped.getChunkSource().getChunkForLighting(pos.getX() >> 4, pos.getZ() >> 4);
-        if(!(access instanceof ChunkAccess))
-            return null;
-        ChunkAccess chunk = (ChunkAccess)access;
-        if(!chunk.getStatus().isOrAfter(ChunkStatus.FULL))
-            return null;
-        return chunk;
-    }
-
-    @Override
-    public int getMaxBuildHeight() {
-        return this.wrapped.getMaxBuildHeight();
-    }
-
-    @Override
-    public int getMaxLightLevel() {
-        return this.wrapped.getMaxLightLevel();
-    }
-
-    @Nullable
-    @Override
-    public BlockEntity getBlockEntity(BlockPos pos) {
-        BlockGetter g = getChunkSafe(pos);
-        return g == null ? null : g.getBlockEntity(pos);
-    }
-
-    @Override
-    public BlockState getBlockState(BlockPos pos) {
-        BlockGetter g = getChunkSafe(pos);
-        return g == null ? Blocks.AIR.defaultBlockState() : g.getBlockState(pos);
-    }
-
-    @Override
-    public FluidState getFluidState(BlockPos pos) {
-        BlockGetter g = getChunkSafe(pos);
-        return g == null ? Fluids.EMPTY.defaultFluidState() : g.getFluidState(pos);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/command/ModernFixCommands.java

@@ -1,56 +0,0 @@
-package org.embeddedt.modernfix.command;
-
-import com.mojang.brigadier.CommandDispatcher;
-import net.minecraft.commands.CommandSourceStack;
-import net.minecraft.network.chat.TextComponent;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.server.packs.resources.Resource;
-import net.minecraft.server.packs.resources.ResourceManager;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.structure.CachingStructureManager;
-
-import java.util.Collection;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import static net.minecraft.commands.Commands.*;
-
-public class ModernFixCommands {
-    public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
-        dispatcher.register(literal("modernfix")
-                        .then(literal("upgradeStructures")
-                        .requires(source -> source.hasPermission(3))
-                        .executes(context -> {
-                            ServerLevel level = context.getSource().getLevel();
-                            if(level == null) {
-                                context.getSource().sendFailure(new TextComponent("Couldn't find server level"));
-                                return 0;
-                            }
-
-                            ResourceManager manager = level.getServer().resources.getResourceManager();
-                            Collection<ResourceLocation> structures = manager.listResources("structures", p -> p.endsWith(".nbt"));
-                            int upgradedNum = 0;
-                            Pattern pathPattern = Pattern.compile("^structures/(.*)\\.nbt$");
-                            for(ResourceLocation found : structures) {
-                                upgradedNum++;
-                                Matcher matcher = pathPattern.matcher(found.getPath());
-                                if(!matcher.matches())
-                                    continue;
-                                ResourceLocation structureLocation = new ResourceLocation(found.getNamespace(), matcher.group(1));
-                                try(Resource resource = manager.getResource(found)) {
-                                    CachingStructureManager.readStructureTag(structureLocation, level.getServer().getFixerUpper(), resource.getInputStream());
-                                    context.getSource().sendSuccess(new TextComponent("checked " + structureLocation + " (" + upgradedNum + "/" + structures.size() + ")"), false);
-                                } catch(Throwable e) {
-                                    ModernFix.LOGGER.error("Couldn't upgrade structure " + found, e);
-                                    context.getSource().sendFailure(new TextComponent("error reading " + structureLocation + " (" + upgradedNum + "/" + structures.size() + ")"));
-                                }
-                            }
-
-                            context.getSource().sendSuccess(new TextComponent("All structures upgraded"), false);
-
-                            return 1;
-                        }))
-        );
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/chunk_deadlock/BlockStateBaseMixin.java

@@ -1,22 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.chunk_deadlock;
-
-import net.minecraft.world.level.BlockGetter;
-import net.minecraft.world.level.block.state.BlockBehaviour;
-import org.embeddedt.modernfix.chunk.SafeBlockGetter;
-import org.embeddedt.modernfix.duck.ISafeBlockGetter;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyVariable;
-
-@Mixin(value = BlockBehaviour.BlockStateBase.class, priority = 100)
-public class BlockStateBaseMixin {
-    @ModifyVariable(method = "getOffset", at = @At("HEAD"), argsOnly = true, index = 1)
-    private BlockGetter useSafeGetter(BlockGetter g) {
-        if(g instanceof ISafeBlockGetter) {
-            SafeBlockGetter replacement = ((ISafeBlockGetter) g).mfix$getSafeBlockGetter();
-            if(replacement.shouldUse())
-                return replacement;
-        }
-        return g;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/chunk_deadlock/ServerLevelMixin.java

@@ -1,18 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.chunk_deadlock;
-
-import net.minecraft.server.level.ServerLevel;
-import org.embeddedt.modernfix.chunk.SafeBlockGetter;
-import org.embeddedt.modernfix.duck.ISafeBlockGetter;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Unique;
-
-@Mixin(ServerLevel.class)
-public class ServerLevelMixin implements ISafeBlockGetter {
-    @Unique
-    private final SafeBlockGetter mfix$safeBlockGetter = new SafeBlockGetter((ServerLevel)(Object)this);
-
-    @Override
-    public SafeBlockGetter mfix$getSafeBlockGetter() {
-        return mfix$safeBlockGetter;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/concurrency/MinecraftMixin.java

@@ -1,36 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.concurrency;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.util.thread.BlockableEventLoop;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-
-import java.util.function.BooleanSupplier;
-
-@Mixin(Minecraft.class)
-@ClientOnlyMixin
-public abstract class MinecraftMixin<R extends Runnable> extends BlockableEventLoop<R> {
-
-    protected MinecraftMixin(String p_i50403_1_) {
-        super(p_i50403_1_);
-    }
-
-    @Override
-    public void managedBlock(BooleanSupplier pIsDone) {
-        if(!this.isSameThread()) {
-            ModernFix.LOGGER.warn("A mod is calling Minecraft.managedBlock from the wrong thread. This is most likely related to one of our parallelizations.");
-            ModernFix.LOGGER.warn("ModernFix will work around this, however ideally the issue should be patched in the other mod.");
-            ModernFix.LOGGER.warn("Stacktrace", new IllegalThreadStateException());
-            while(!pIsDone.getAsBoolean()) {
-                try {
-                    Thread.sleep(100);
-                } catch(InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                }
-            }
-        } else {
-            super.managedBlock(pIsDone);
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/concurrency/RenderTypeEqualsStrategyMixin.java

@@ -1,19 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.concurrency;
-
-import net.minecraft.client.renderer.RenderType;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-import java.util.Objects;
-
-@Mixin(targets = { "net/minecraft/client/renderer/RenderType$CompositeRenderType$EqualsStrategy"})
-@ClientOnlyMixin
-public class RenderTypeEqualsStrategyMixin {
-    @Redirect(method = "equals(Lnet/minecraft/client/renderer/RenderType$CompositeRenderType;Lnet/minecraft/client/renderer/RenderType$CompositeRenderType;)Z", at = @At(value = "INVOKE", target = "Ljava/util/Objects;equals(Ljava/lang/Object;Ljava/lang/Object;)Z", ordinal = 0))
-    private boolean alsoCheckName(Object a, Object b, RenderType.CompositeRenderType type1, RenderType.CompositeRenderType type2) {
-        boolean supposedlyEqual = Objects.equals(a, b);
-        return supposedlyEqual && Objects.equals(type1.name, type2.name);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/concurrency/RenderTypeMixin.java

@@ -1,27 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.concurrency;
-
-import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
-import net.minecraft.client.renderer.RenderType;
-import com.mojang.blaze3d.vertex.VertexFormat;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Overwrite;
-import org.spongepowered.asm.mixin.Shadow;
-
-@Mixin(RenderType.CompositeRenderType.class)
-@ClientOnlyMixin
-public class RenderTypeMixin {
-    @Shadow @Final private static ObjectOpenCustomHashSet<RenderType.CompositeRenderType> INSTANCES;
-
-    /**
-     * @author embeddedt
-     * @reason synchronize, can be accessed by multiple mods during modloading
-     */
-    @Overwrite
-    private static RenderType.CompositeRenderType memoize(String name, VertexFormat format, int drawMode, int bufferSize, boolean useDelegate, boolean needsSorting, RenderType.CompositeState renderState) {
-        synchronized (INSTANCES){
-            return INSTANCES.addOrGet(new RenderType.CompositeRenderType(name, format, drawMode, bufferSize, useDelegate, needsSorting, renderState));
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/concurrency/StaticTagHelperMixin.java

@@ -1,28 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.concurrency;
-
-import net.minecraft.tags.StaticTagHelper;
-import net.minecraft.tags.TagCollection;
-import net.minecraft.tags.TagContainer;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Mutable;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.function.Function;
-
-@Mixin(StaticTagHelper.class)
-public class StaticTagHelperMixin<T> {
-    @SuppressWarnings("rawtypes")
-    @Shadow @Mutable
-    @Final private List wrappers;
-
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void useCOWArrayList(Function<TagContainer, TagCollection<T>> function, CallbackInfo ci) {
-        this.wrappers = new CopyOnWriteArrayList<>();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/item_cache_flag/ItemStackMixin.java

@@ -1,40 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.item_cache_flag;
-
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import org.objectweb.asm.Opcodes;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Overwrite;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-/**
- * Remove emptyCacheFlag from ItemStack, as Mojang did in 1.20 due to <a href="https://bugs.mojang.com/browse/MC-258939">MC-258939</a>.
- */
-@Mixin(ItemStack.class)
-public class ItemStackMixin {
-    @Shadow @Final @Deprecated private Item item;
-
-    /**
-     * @author embeddedt, Mojang
-     * @reason avoid getItem()
-     */
-    @Redirect(method = "isEmpty", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/item/ItemStack;getItem()Lnet/minecraft/world/item/Item;"))
-    private Item getItemDirect(ItemStack stack) {
-        return this.item;
-    }
-
-    @Redirect(method = "*", at = @At(value = "FIELD", opcode = Opcodes.GETFIELD, target = "Lnet/minecraft/world/item/ItemStack;emptyCacheFlag:Z"))
-    private boolean checkEmptyDirect(ItemStack stack) {
-        return stack.isEmpty();
-    }
-
-    /**
-     * @author embeddedt, Mojang
-     * @reason flag is no longer used
-     */
-    @Overwrite
-    private void updateEmptyCacheFlag() {}
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/mc218112/SynchedEntityDataMixin_Client.java

@@ -1,48 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.mc218112;
-
-import net.minecraft.network.syncher.SynchedEntityData;
-import net.minecraft.world.entity.Entity;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Overwrite;
-import org.spongepowered.asm.mixin.Shadow;
-
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.locks.ReadWriteLock;
-
-@Mixin(SynchedEntityData.class)
-@ClientOnlyMixin
-public abstract class SynchedEntityDataMixin_Client {
-    @Shadow @Final private ReadWriteLock lock;
-
-    @Shadow private boolean isDirty;
-
-    @Shadow protected abstract <T> void assignValue(SynchedEntityData.DataItem<T> target, SynchedEntityData.DataItem<?> source);
-
-    @Shadow @Final private Entity entity;
-
-    @Shadow @Final private Map<Integer, SynchedEntityData.DataItem<?>> itemsById;
-
-    /**
-     * @author embeddedt
-     * @reason always unlock
-     */
-    @Overwrite
-    public void assignValues(List<SynchedEntityData.DataItem<?>> entries) {
-        this.lock.writeLock().lock();
-        try {
-            for(SynchedEntityData.DataItem<?> dataentry : entries) {
-                SynchedEntityData.DataItem<?> dataentry1 = this.itemsById.get(dataentry.getAccessor().getId());
-                if (dataentry1 != null) {
-                    this.assignValue(dataentry1, dataentry);
-                    this.entity.onSyncedDataUpdated(dataentry.getAccessor());
-                }
-            }
-        } finally {
-            this.lock.writeLock().unlock();
-        }
-        this.isDirty = true;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/packet_leak/SCustomPayloadPlayPacketMixin.java

@@ -1,39 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.packet_leak;
-
-import net.minecraft.network.protocol.game.ClientGamePacketListener;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.protocol.game.ClientboundCustomPayloadPacket;
-import net.minecraft.resources.ResourceLocation;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.Redirect;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(ClientboundCustomPayloadPacket.class)
-@ClientOnlyMixin
-public class SCustomPayloadPlayPacketMixin {
-    @Shadow private FriendlyByteBuf data;
-
-    private boolean needsRelease;
-
-    @Inject(method = "<init>(Lnet/minecraft/resources/ResourceLocation;Lnet/minecraft/network/FriendlyByteBuf;)V", at = @At("RETURN"))
-    private void markNotOwned(ResourceLocation pIdentifier, FriendlyByteBuf pData, CallbackInfo ci) {
-        this.needsRelease = false;
-    }
-
-    @Inject(method = "read", at = @At("RETURN"))
-    private void markOwned(FriendlyByteBuf p_148837_1_, CallbackInfo ci) {
-        this.needsRelease = true;
-    }
-
-    @Redirect(method = "handle(Lnet/minecraft/network/protocol/game/ClientGamePacketListener;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/protocol/game/ClientGamePacketListener;handleCustomPayload(Lnet/minecraft/network/protocol/game/ClientboundCustomPayloadPacket;)V"))
-    private void handleAndFree(ClientGamePacketListener instance, ClientboundCustomPayloadPacket sCustomPayloadPlayPacket) {
-        /* in 1.16, this method creates a copy inside it, but does not handle freeing correctly. fixing that breaks mods though */
-        instance.handleCustomPayload(sCustomPayloadPlayPacket);
-        if(this.needsRelease)
-            this.data.release(); /* free our own copy of the data if needed */
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java

@@ -1,61 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.paper_chunk_patches;
-
-import com.mojang.datafixers.util.Either;
-import net.minecraft.server.level.ChunkHolder;
-import net.minecraft.world.level.chunk.ChunkAccess;
-import net.minecraft.world.level.chunk.ChunkStatus;
-import org.embeddedt.modernfix.duck.IPaperChunkHolder;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-
-@Mixin(ChunkHolder.class)
-public abstract class ChunkHolderMixin implements IPaperChunkHolder {
-
-    @Shadow public abstract CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> getFutureIfPresentUnchecked(ChunkStatus arg);
-
-    @Shadow @Final private static List<ChunkStatus> CHUNK_STATUSES;
-
-    public ChunkStatus mfix$getChunkHolderStatus() {
-        for (ChunkStatus curr = ChunkStatus.FULL, next = curr.getParent(); curr != next; curr = next, next = next.getParent()) {
-            CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> future = this.getFutureIfPresentUnchecked(curr);
-            Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure> either = future.getNow(null);
-            if (either == null || !either.left().isPresent()) {
-                continue;
-            }
-            return curr;
-        }
-
-        return null;
-    }
-
-    public ChunkAccess mfix$getAvailableChunkNow() {
-        // TODO can we just getStatusFuture(EMPTY)?
-        for (ChunkStatus curr = ChunkStatus.FULL, next = curr.getParent(); curr != next; curr = next, next = next.getParent()) {
-            CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> future = this.getFutureIfPresentUnchecked(curr);
-            Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure> either = future.getNow(null);
-            if (either == null || !either.left().isPresent()) {
-                continue;
-            }
-            return either.left().get();
-        }
-        return null;
-    }
-
-    private static ChunkStatus mfix$getNextStatus(ChunkStatus status) {
-        if (status == ChunkStatus.FULL) {
-            return status;
-        }
-        return CHUNK_STATUSES.get(status.getIndex() + 1);
-    }
-
-    @Override
-    public boolean mfix$canAdvanceStatus() {
-        ChunkStatus status = mfix$getChunkHolderStatus();
-        ChunkAccess chunk = mfix$getAvailableChunkNow();
-        return chunk != null && (status == null || chunk.getStatus().isOrAfter(mfix$getNextStatus(status)));
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java

@@ -1,66 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.bugfix.paper_chunk_patches;
-
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ChunkHolder;
-import net.minecraft.server.level.ChunkMap;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.util.thread.BlockableEventLoop;
-import org.embeddedt.modernfix.duck.IPaperChunkHolder;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-import org.spongepowered.asm.mixin.injection.Redirect;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.function.Function;
-
-
-@Mixin(ChunkMap.class)
-public class ChunkMapMixin {
-    @Shadow @Final private BlockableEventLoop<Runnable> mainThreadExecutor;
-
-    @Shadow @Final private ServerLevel level;
-    private Executor mainInvokingExecutor;
-
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void setup(CallbackInfo ci) {
-        MinecraftServer server = this.level.getServer();
-        this.mainInvokingExecutor = (runnable) -> {
-            if(server.isSameThread())
-                runnable.run();
-            else
-                this.mainThreadExecutor.execute(runnable);
-        };
-    }
-
-
-    /* https://github.com/PaperMC/Paper/blob/ver/1.17.1/patches/server/0752-Fix-chunks-refusing-to-unload-at-low-TPS.patch */
-    @ModifyArg(method = "unpackTicks", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenApplyAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;"), index = 1)
-    private Executor useMainThreadExecutor(Executor executor) {
-        return this.mainThreadExecutor;
-    }
-
-    /* https://github.com/PaperMC/Paper/blob/master/patches/removed/1.19.2-legacy-chunksystem/0482-Improve-Chunk-Status-Transition-Speed.patch */
-    @ModifyArg(method = "getEntityTickingRangeFuture", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenApplyAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;"), index = 1)
-    private Executor useMainInvokingExecutor(Executor executor) {
-        return this.mainInvokingExecutor;
-    }
-
-    @SuppressWarnings({"rawtypes", "unchecked"})
-    @Redirect(method = "scheduleChunkGeneration", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenComposeAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;"))
-    private CompletableFuture skipWorkerIfPossible(CompletableFuture inputFuture, Function function, Executor executor, ChunkHolder holder) {
-        Executor targetExecutor = (runnable) -> {
-            if(((IPaperChunkHolder)holder).mfix$canAdvanceStatus()) {
-                this.mainInvokingExecutor.execute(runnable);
-                return;
-            }
-            executor.execute(runnable);
-        };
-        return inputFuture.thenComposeAsync(function, targetExecutor);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/core/MinecraftServerMixin.java

@@ -1,24 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.core;
-
-import net.minecraft.Util;
-import net.minecraft.server.MinecraftServer;
-import org.embeddedt.modernfix.duck.ITimeTrackingServer;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(MinecraftServer.class)
-public class MinecraftServerMixin implements ITimeTrackingServer {
-    private long mfix$lastTickStartTime = -1L;
-
-    @Override
-    public long mfix$getLastTickStartTime() {
-        return mfix$lastTickStartTime;
-    }
-
-    @Inject(method = "runServer", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/MinecraftServer;tickServer(Ljava/util/function/BooleanSupplier;)V"))
-    private void trackTickTime(CallbackInfo ci) {
-        mfix$lastTickStartTime = Util.getMillis();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/core/SynchedEntityDataMixin.java

@@ -1,26 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.core;
-
-import net.minecraft.network.syncher.SynchedEntityData;
-import net.minecraft.world.entity.Entity;
-import org.embeddedt.modernfix.ModernFixClient;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(SynchedEntityData.class)
-@ClientOnlyMixin
-public class SynchedEntityDataMixin {
-    /**
-     * Store this in our set of all entity data objects.
-     *
-     * Not an ideal solution, but it should guarantee compatibility with mods.
-     */
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void storeInSet(Entity arg, CallbackInfo ci) {
-        synchronized (ModernFixClient.allEntityDatas) {
-            ModernFixClient.allEntityDatas.add((SynchedEntityData)(Object)this);
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/devenv/MinecraftMixin.java

@@ -1,19 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.devenv;
-
-import com.mojang.authlib.minecraft.OfflineSocialInteractions;
-import com.mojang.authlib.minecraft.SocialInteractionsService;
-import net.minecraft.client.Minecraft;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(Minecraft.class)
-@ClientOnlyMixin
-public class MinecraftMixin {
-    @Inject(method = "createSocialInteractions", at = @At("HEAD"), cancellable = true)
-    private void noSocialInteraction(CallbackInfoReturnable<SocialInteractionsService> cir) {
-        cir.setReturnValue(new OfflineSocialInteractions());
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/devenv/NarratorMixin.java

@@ -1,18 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.devenv;
-
-import com.mojang.text2speech.Narrator;
-import com.mojang.text2speech.NarratorDummy;
-import net.minecraft.client.gui.chat.NarratorChatListener;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(NarratorChatListener.class)
-@ClientOnlyMixin
-public class NarratorMixin {
-    @Redirect(method = "<init>", at = @At(value = "INVOKE", target = "Lcom/mojang/text2speech/Narrator;getNarrator()Lcom/mojang/text2speech/Narrator;", remap = false))
-    private Narrator useDummyNarrator() {
-        return new NarratorDummy();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/feature/direct_stack_trace/CrashReportMixin.java

@@ -1,22 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.feature.direct_stack_trace;
-
-import net.minecraft.CrashReport;
-import net.minecraft.CrashReportCategory;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(CrashReport.class)
-public class CrashReportMixin {
-    @Shadow @Final private Throwable exception;
-
-    @Inject(method = "addCategory(Ljava/lang/String;I)Lnet/minecraft/CrashReportCategory;", at = @At(value = "INVOKE", target = "Ljava/io/PrintStream;println(Ljava/lang/String;)V"))
-    private void dumpStacktrace(String s, int i, CallbackInfoReturnable<CrashReportCategory> cir) {
-        new Exception("ModernFix crash stacktrace").printStackTrace();
-        if(this.exception != null)
-            this.exception.printStackTrace();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/feature/measure_time/MinecraftMixin.java

@@ -1,47 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.feature.measure_time;
-
-import com.mojang.datafixers.util.Function4;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.screens.Overlay;
-import net.minecraft.server.packs.resources.ResourceManager;
-import net.minecraft.world.level.DataPackConfig;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.world.level.storage.WorldData;
-import net.minecraft.world.level.storage.LevelStorageSource;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.ModernFixClient;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.jetbrains.annotations.Nullable;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.function.Function;
-
-@Mixin(Minecraft.class)
-@ClientOnlyMixin
-public class MinecraftMixin {
-    @Shadow @Nullable public Overlay overlay;
-    private long datapackReloadStartTime;
-
-    @Inject(method = "makeServerStem", at = @At(value = "HEAD"))
-    private void recordReloadStart(RegistryAccess.RegistryHolder p_238189_1_, Function<LevelStorageSource.LevelStorageAccess, DataPackConfig> p_238189_2_, Function4<LevelStorageSource.LevelStorageAccess, RegistryAccess.RegistryHolder, ResourceManager, DataPackConfig, WorldData> p_238189_3_, boolean p_238189_4_, LevelStorageSource.LevelStorageAccess p_238189_5_, CallbackInfoReturnable<Minecraft.ServerStem> cir) {
-        datapackReloadStartTime = System.nanoTime();
-    }
-
-    @Inject(method = "makeServerStem", at = @At(value = "RETURN"))
-    private void recordReloadEnd(RegistryAccess.RegistryHolder p_238189_1_, Function<LevelStorageSource.LevelStorageAccess, DataPackConfig> p_238189_2_, Function4<LevelStorageSource.LevelStorageAccess, RegistryAccess.RegistryHolder, ResourceManager, DataPackConfig, WorldData> p_238189_3_, boolean p_238189_4_, LevelStorageSource.LevelStorageAccess p_238189_5_, CallbackInfoReturnable<Minecraft.ServerStem> cir) {
-        float timeSpentReloading = ((float)(System.nanoTime() - datapackReloadStartTime) / 1000000000f);
-        ModernFix.LOGGER.warn("Datapack reload took " + timeSpentReloading + " seconds.");
-    }
-
-    @Inject(method = "tick", at = @At("HEAD"))
-    private void onClientTick(CallbackInfo ci) {
-        if(this.overlay == null && ModernFixClient.INSTANCE != null) {
-            ModernFixClient.INSTANCE.onGameLaunchFinish();
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/feature/measure_time/ProfiledReloadInstanceMixin.java

@@ -1,23 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.feature.measure_time;
-
-import net.minecraft.server.packs.resources.PreparableReloadListener;
-import net.minecraft.server.packs.resources.ProfiledReloadInstance;
-import org.embeddedt.modernfix.util.NamedPreparableResourceListener;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyVariable;
-
-import java.util.ArrayList;
-import java.util.List;
-
-@Mixin(ProfiledReloadInstance.class)
-public class ProfiledReloadInstanceMixin {
-    @ModifyVariable(method = "<init>", at = @At("HEAD"), argsOnly = true, ordinal = 0)
-    private static List<PreparableReloadListener> getWrappedListeners(List<PreparableReloadListener> listeners) {
-        List<PreparableReloadListener> newList = new ArrayList<>(listeners.size());
-        for(PreparableReloadListener listener : listeners) {
-            newList.add(new NamedPreparableResourceListener(listener));
-        }
-        return newList;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/feature/measure_time/SimpleReloadableResourceManagerMixin.java

@@ -1,21 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.feature.measure_time;
-
-import net.minecraft.server.packs.resources.SimpleReloadableResourceManager;
-import org.apache.logging.log4j.Logger;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(SimpleReloadableResourceManager.class)
-public class SimpleReloadableResourceManagerMixin {
-    // TODO maybe expose as a mixin config
-    private static final boolean ENABLE_DEBUG_RELOADER = Boolean.getBoolean("modernfix.debugReloader");
-    /**
-     * @author embeddedt
-     * @reason add ability to use this feature in modpacks
-     */
-    @Redirect(method = "createReload", at = @At(value = "INVOKE", target = "Lorg/apache/logging/log4j/Logger;isDebugEnabled()Z", remap = false))
-    private boolean enableDebugReloader(Logger logger) {
-        return logger.isDebugEnabled() || ENABLE_DEBUG_RELOADER;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/feature/stalled_chunk_load_detection/ServerChunkCacheMixin.java

@@ -1,66 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.feature.stalled_chunk_load_detection;
-
-import com.mojang.datafixers.util.Either;
-import net.minecraft.server.level.ChunkHolder;
-import net.minecraft.server.level.ServerChunkCache;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.ChunkAccess;
-import net.minecraft.world.level.chunk.ChunkStatus;
-import net.minecraft.world.level.chunk.EmptyLevelChunk;
-import org.embeddedt.modernfix.ModernFix;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import java.util.concurrent.*;
-
-@Mixin(value = ServerChunkCache.class, priority = 1100)
-public abstract class ServerChunkCacheMixin {
-    @Shadow @Final private Thread mainThread;
-    @Shadow @Final public ServerLevel level;
-
-    @Shadow protected abstract CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> getChunkFutureMainThread(int k, int l, ChunkStatus arg, boolean bl);
-
-    @Shadow @Final private ServerChunkCache.MainThreadExecutor mainThreadProcessor;
-    private final boolean debugDeadServerAccess = Boolean.getBoolean("modernfix.debugBadChunkloading");
-
-    @Inject(method = "getChunk", at = @At("HEAD"), cancellable = true)
-    private void bailIfServerDead(int chunkX, int chunkZ, ChunkStatus requiredStatus, boolean load, CallbackInfoReturnable<ChunkAccess> cir) {
-        if(!this.level.getServer().isRunning() && !this.mainThread.isAlive()) {
-            ModernFix.LOGGER.fatal("A mod is accessing chunks from a stopped server (this will also cause memory leaks)");
-            if(debugDeadServerAccess) {
-                new Exception().printStackTrace();
-            }
-            cir.setReturnValue(new EmptyLevelChunk(this.level, new ChunkPos(chunkX, chunkZ)));
-        } else if(Thread.currentThread() != this.mainThread) {
-            CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> future = CompletableFuture.supplyAsync(() -> this.getChunkFutureMainThread(chunkX, chunkZ, requiredStatus, false), this.mainThreadProcessor).join();
-            if(!future.isDone()) {
-                // Wait at least 500 milliseconds before printing anything
-                Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure> resultingChunk = null;
-                try {
-                    resultingChunk = future.get(500, TimeUnit.MILLISECONDS);
-                } catch(InterruptedException | ExecutionException | TimeoutException ignored) {
-                }
-                if(resultingChunk != null && resultingChunk.left().isPresent()) {
-                    cir.setReturnValue(resultingChunk.left().get());
-                    return;
-                }
-                if(debugDeadServerAccess)
-                    ModernFix.LOGGER.warn("Async loading of a chunk was requested, this might not be desirable", new Exception());
-                try {
-                    resultingChunk = future.get(10, TimeUnit.SECONDS);
-                    if(resultingChunk.left().isPresent()) {
-                        cir.setReturnValue(resultingChunk.left().get());
-                        return;
-                    }
-                } catch(InterruptedException | ExecutionException | TimeoutException e) {
-                    ModernFix.LOGGER.error("Async chunk load took way too long, this needs to be reported to the appropriate mod.", e);
-                }
-                //cir.setReturnValue(new EmptyLevelChunk(this.level, new ChunkPos(chunkX, chunkZ)));
-            }
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/biome_zoomer/FuzzyOffsetBiomeZoomerMixin.java

@@ -1,57 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.biome_zoomer;
-
-import net.minecraft.world.level.biome.Biome;
-import net.minecraft.world.level.biome.BiomeManager;
-import net.minecraft.world.level.biome.FuzzyOffsetBiomeZoomer;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Overwrite;
-import org.spongepowered.asm.mixin.Shadow;
-
-@Mixin(FuzzyOffsetBiomeZoomer.class)
-public abstract class FuzzyOffsetBiomeZoomerMixin {
-    @Shadow protected static double getFiddledDistance(long seed, int x, int y, int z, double scaleX, double scaleY, double scaleZ) {
-        throw new AssertionError();
-    }
-
-    /**
-     * @author embeddedt
-     * @reason use the modern logic that doesn't allocate an array of 8 doubles every time
-     */
-    @Overwrite
-    public Biome getBiome(long seed, int xIn, int yIn, int zIn, BiomeManager.NoiseBiomeSource biomeReader) {
-        int i = xIn - 2;
-        int j = yIn - 2;
-        int k = zIn - 2;
-        int l = i >> 2;
-        int i1 = j >> 2;
-        int j1 = k >> 2;
-        double d0 = (double)(i & 3) / 4.0D;
-        double d1 = (double)(j & 3) / 4.0D;
-        double d2 = (double)(k & 3) / 4.0D;
-        int k1 = 0;
-        double d3 = Double.POSITIVE_INFINITY;
-
-        for(int l1 = 0; l1 < 8; ++l1) {
-            boolean flag = (l1 & 4) == 0;
-            boolean flag1 = (l1 & 2) == 0;
-            boolean flag2 = (l1 & 1) == 0;
-            int i2 = flag ? l : l + 1;
-            int j2 = flag1 ? i1 : i1 + 1;
-            int k2 = flag2 ? j1 : j1 + 1;
-            double d4 = flag ? d0 : d0 - 1.0D;
-            double d5 = flag1 ? d1 : d1 - 1.0D;
-            double d6 = flag2 ? d2 : d2 - 1.0D;
-            double d7 = getFiddledDistance(seed, i2, j2, k2, d4, d5, d6);
-            if (d3 > d7) {
-                k1 = l1;
-                d3 = d7;
-            }
-        }
-
-        int l2 = (k1 & 4) == 0 ? l : l + 1;
-        int i3 = (k1 & 2) == 0 ? i1 : i1 + 1;
-        int j3 = (k1 & 1) == 0 ? j1 : j1 + 1;
-        return biomeReader.getNoiseBiome(l2, i3, j3);
-    }
-
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/boost_worker_count/UtilMixin.java

@@ -1,25 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.boost_worker_count;
-
-import net.minecraft.Util;
-import org.embeddedt.modernfix.ModernFix;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.Constant;
-import org.spongepowered.asm.mixin.injection.ModifyConstant;
-
-@Mixin(Util.class)
-public class UtilMixin {
-    @ModifyConstant(method = "makeExecutor", constant = @Constant(intValue = 7))
-    private static int useHigherThreadCount(int old) {
-        String requestedMax = System.getProperty("max.bg.threads");
-        if(requestedMax != null) {
-            try {
-                int newMax = Integer.parseInt(requestedMax);
-                if(newMax >= 1 && newMax <= 255)
-                    return newMax;
-            } catch(NumberFormatException e) {
-                ModernFix.LOGGER.error("max.bg.threads is not a number");
-            }
-        }
-        return 255;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_model_materials/BlockModelMixin.java

@@ -1,110 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.cache_model_materials;
-
-import com.mojang.datafixers.util.Either;
-import net.minecraft.client.renderer.block.model.BlockModel;
-import net.minecraft.client.resources.model.Material;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.embeddedt.modernfix.duck.ICachedMaterialsModel;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Mutable;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.Set;
-
-@Mixin(BlockModel.class)
-@ClientOnlyMixin
-public class BlockModelMixin {
-    @Shadow @Final @Mutable public Map<String, Either<Material, String>> textureMap;
-
-    /**
-     * @author embeddedt
-     * @reason detect changes to the texture map, and clear the material cache as needed
-     */
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void useTrackingTextureMap(CallbackInfo ci) {
-        Map<String, Either<Material, String>> backingMap = this.textureMap;
-        ICachedMaterialsModel cacheHolder = (ICachedMaterialsModel)this;
-        this.textureMap = new Map<String, Either<Material, String>>() {
-            @Override
-            public int size() {
-                return backingMap.size();
-            }
-
-            @Override
-            public boolean isEmpty() {
-                return backingMap.isEmpty();
-            }
-
-            @Override
-            public boolean containsKey(Object o) {
-                return backingMap.containsKey(o);
-            }
-
-            @Override
-            public boolean containsValue(Object o) {
-                return backingMap.containsValue(o);
-            }
-
-            @Override
-            public Either<Material, String> get(Object o) {
-                return backingMap.get(o);
-            }
-
-            @Nullable
-            @Override
-            public Either<Material, String> put(String s, Either<Material, String> materialStringEither) {
-                Either<Material, String> old = backingMap.put(s, materialStringEither);
-                cacheHolder.clearMaterialsCache();
-                return old;
-            }
-
-            @Override
-            public Either<Material, String> remove(Object o) {
-                Either<Material, String> e = backingMap.remove(o);
-                cacheHolder.clearMaterialsCache();
-                return e;
-            }
-
-            @Override
-            public void putAll(@NotNull Map<? extends String, ? extends Either<Material, String>> map) {
-                backingMap.putAll(map);
-                cacheHolder.clearMaterialsCache();
-            }
-
-            @Override
-            public void clear() {
-                backingMap.clear();
-                cacheHolder.clearMaterialsCache();
-            }
-
-            @NotNull
-            @Override
-            public Set<String> keySet() {
-                cacheHolder.clearMaterialsCache();
-                return backingMap.keySet();
-            }
-
-            @NotNull
-            @Override
-            public Collection<Either<Material, String>> values() {
-                cacheHolder.clearMaterialsCache();
-                return backingMap.values();
-            }
-
-            @NotNull
-            @Override
-            public Set<Entry<String, Either<Material, String>>> entrySet() {
-                cacheHolder.clearMaterialsCache();
-                return backingMap.entrySet();
-            }
-        };
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_model_materials/MultipartMixin.java

@@ -1,28 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.cache_model_materials;
-
-import net.minecraft.client.renderer.block.model.multipart.MultiPart;
-import net.minecraft.resources.ResourceLocation;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Collection;
-
-@Mixin(MultiPart.class)
-@ClientOnlyMixin
-public class MultipartMixin {
-    private Collection<ResourceLocation> dependencyCache = null;
-    @Inject(method = "getDependencies", at = @At("HEAD"), cancellable = true)
-    private void useDependencyCache(CallbackInfoReturnable<Collection<ResourceLocation>> cir) {
-        if(dependencyCache != null)
-            cir.setReturnValue(dependencyCache);
-    }
-
-    @Inject(method = "getDependencies", at = @At("RETURN"))
-    private void storeDependencyCache(CallbackInfoReturnable<Collection<ResourceLocation>> cir) {
-        if(dependencyCache == null)
-            dependencyCache = cir.getReturnValue();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_model_materials/VanillaModelMixin.java

@@ -1,43 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.cache_model_materials;
-
-import com.mojang.datafixers.util.Pair;
-import net.minecraft.client.renderer.block.model.BlockModel;
-import net.minecraft.client.resources.model.UnbakedModel;
-import net.minecraft.client.resources.model.Material;
-import net.minecraft.resources.ResourceLocation;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.embeddedt.modernfix.duck.ICachedMaterialsModel;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
-import java.util.function.Function;
-
-/* only cache BlockModel to prevent issues with CTM on Fabric */
-@Mixin(value = {BlockModel.class})
-@ClientOnlyMixin
-public class VanillaModelMixin implements ICachedMaterialsModel {
-    private Collection<Material> materialsCache = null;
-
-    @Inject(method = "getMaterials", at = @At("HEAD"), cancellable = true)
-    private void useCachedMaterials(Function<ResourceLocation, UnbakedModel> pModelGetter, Set<Pair<String, String>> pMissingTextureErrors, CallbackInfoReturnable<Collection<Material>> cir) {
-        if(materialsCache != null) {
-            cir.setReturnValue(materialsCache);
-        }
-    }
-
-    @Inject(method = "getMaterials", at = @At("RETURN"))
-    private void storeCachedMaterials(Function<ResourceLocation, UnbakedModel> pModelGetter, Set<Pair<String, String>> pMissingTextureErrors, CallbackInfoReturnable<Collection<Material>> cir) {
-        if(materialsCache == null)
-            materialsCache = Collections.unmodifiableCollection(cir.getReturnValue());
-    }
-
-    @Override
-    public void clearMaterialsCache() {
-        materialsCache = null;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_strongholds/ChunkGeneratorMixin.java

@@ -1,66 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.cache_strongholds;
-
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.ChunkGenerator;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.duck.IServerLevel;
-import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
-import org.embeddedt.modernfix.world.StrongholdLocationCache;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.List;
-
-@Mixin(ChunkGenerator.class)
-public class ChunkGeneratorMixin {
-    @Shadow @Final private List<ChunkPos> strongholdPositions;
-
-    @Inject(method = "generateStrongholds", at = @At(value = "INVOKE", target = "Lcom/google/common/collect/Lists;newArrayList()Ljava/util/ArrayList;", ordinal = 0, remap = false), cancellable = true)
-    private void useCachedDataIfAvailable(CallbackInfo ci) {
-        ServerLevel level = searchLevel();
-        if(level == null) {
-            ModernFix.LOGGER.error("Can't find server level for " + this);
-            return;
-        }
-        StrongholdLocationCache cache = ((IServerLevel)level).mfix$getStrongholdCache();
-        List<ChunkPos> positions = cache.getChunkPosList();
-        if(positions.isEmpty())
-            return;
-        ModernFix.LOGGER.debug("Loaded stronghold cache for dimension {} with {} positions", level.dimension().location(), positions.size());
-        this.strongholdPositions.addAll(positions);
-        ci.cancel();
-    }
-
-    private ServerLevel searchLevel() {
-        MinecraftServer server = ModernFixPlatformHooks.INSTANCE.getCurrentServer();
-        if(server != null) {
-            ServerLevel ourLevel = null;
-            for (ServerLevel level : server.getAllLevels()) {
-                if (level.getChunkSource().getGenerator() == ((ChunkGenerator) (Object) this)) {
-                    ourLevel = level;
-                    break;
-                }
-            }
-            return ourLevel;
-        } else
-            return null;
-    }
-
-    @Inject(method = "generateStrongholds", at = @At("TAIL"))
-    private void saveCachedData(CallbackInfo ci) {
-        if(this.strongholdPositions.size() > 0) {
-            ServerLevel level = searchLevel();
-            if(level != null) {
-                StrongholdLocationCache cache = ((IServerLevel)level).mfix$getStrongholdCache();
-                cache.setChunkPosList(this.strongholdPositions);
-                ModernFix.LOGGER.debug("Saved stronghold cache for dimension {}", level.dimension().location());
-            }
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_strongholds/ServerLevelMixin.java

@@ -1,49 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.cache_strongholds;
-
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.server.level.progress.ChunkProgressListener;
-import net.minecraft.util.profiling.ProfilerFiller;
-import net.minecraft.world.level.CustomSpawner;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.chunk.ChunkGenerator;
-import net.minecraft.world.level.dimension.DimensionType;
-import net.minecraft.world.level.storage.DimensionDataStorage;
-import net.minecraft.world.level.storage.LevelStorageSource;
-import net.minecraft.world.level.storage.ServerLevelData;
-import net.minecraft.world.level.storage.WritableLevelData;
-import org.embeddedt.modernfix.duck.IServerLevel;
-import org.embeddedt.modernfix.world.StrongholdLocationCache;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.List;
-import java.util.concurrent.Executor;
-import java.util.function.Supplier;
-
-@Mixin(ServerLevel.class)
-public abstract class ServerLevelMixin extends Level implements IServerLevel {
-    protected ServerLevelMixin(WritableLevelData arg, ResourceKey<Level> arg2, DimensionType arg3, Supplier<ProfilerFiller> supplier, boolean bl, boolean bl2, long l) {
-        super(arg, arg2, arg3, supplier, bl, bl2, l);
-    }
-
-    @Shadow public abstract DimensionDataStorage getDataStorage();
-
-    private StrongholdLocationCache mfix$strongholdCache;
-
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void addStrongholdCache(MinecraftServer minecraftServer, Executor executor, LevelStorageSource.LevelStorageAccess arg,
-                                ServerLevelData arg2, ResourceKey<Level> arg3, DimensionType arg4, ChunkProgressListener arg5,
-                                ChunkGenerator arg6, boolean bl, long l, List<CustomSpawner> list, boolean bl2, CallbackInfo ci) {
-        mfix$strongholdCache = this.getDataStorage().computeIfAbsent(() -> new StrongholdLocationCache((ServerLevel)(Object)this), StrongholdLocationCache.getFileId(this.dimensionType()));
-    }
-
-    @Override
-    public StrongholdLocationCache mfix$getStrongholdCache() {
-        return mfix$strongholdCache;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_upgraded_structures/StructureManagerMixin.java

@@ -1,25 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.cache_upgraded_structures;
-
-import com.mojang.datafixers.DataFixer;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.levelgen.structure.templatesystem.StructureManager;
-import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplate;
-import org.embeddedt.modernfix.structure.CachingStructureManager;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-import java.io.IOException;
-import java.io.InputStream;
-
-@Mixin(StructureManager.class)
-public class StructureManagerMixin {
-    @Shadow @Final private DataFixer fixerUpper;
-
-    @Redirect(method = "loadFromResource", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/levelgen/structure/templatesystem/StructureManager;readStructure(Ljava/io/InputStream;)Lnet/minecraft/world/level/levelgen/structure/templatesystem/StructureTemplate;"))
-    private StructureTemplate readViaCache(StructureManager manager, InputStream stream, ResourceLocation arg) throws IOException {
-        return CachingStructureManager.readStructure(arg, this.fixerUpper, stream);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/compress_biome_container/MixinBiomeContainer.java

@@ -1,148 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.compress_biome_container;
-
-import it.unimi.dsi.fastutil.objects.Reference2ShortMap;
-import it.unimi.dsi.fastutil.objects.Reference2ShortOpenHashMap;
-import net.minecraft.util.BitStorage;
-import net.minecraft.core.IdMap;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.util.Mth;
-import net.minecraft.world.level.biome.Biome;
-import net.minecraft.world.level.chunk.ChunkBiomeContainer;
-import net.minecraft.world.level.biome.BiomeSource;
-import org.spongepowered.asm.mixin.*;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(ChunkBiomeContainer.class)
-public class MixinBiomeContainer {
-    @Mutable
-    @Shadow
-    @Final
-    private Biome[] biomes;
-
-    @Shadow
-    @Final
-    private IdMap<Biome> biomeRegistry;
-
-    @Shadow
-    @Final
-    private static int WIDTH_BITS;
-
-    private Biome[] palette;
-    private BitStorage intArray;
-
-    @Inject(method = "<init>(Lnet/minecraft/core/IdMap;[I)V", at = @At("RETURN"), require = 0)
-    private void reinit1(IdMap p_i241970_1_, int[] p_i241970_2_, CallbackInfo ci) {
-        this.createCompact();
-    }
-
-    @Inject(method = "<init>(Lnet/minecraft/core/IdMap;[Lnet/minecraft/world/level/biome/Biome;)V", at = @At("RETURN"))
-    private void reinit2(IdMap p_i241971_1_, Biome[] p_i241971_2_, CallbackInfo ci) {
-        this.createCompact();
-    }
-
-    @Inject(method = "<init>(Lnet/minecraft/core/IdMap;Lnet/minecraft/world/level/ChunkPos;Lnet/minecraft/world/level/biome/BiomeSource;)V", at = @At("RETURN"))
-    private void reinit3(IdMap p_i241968_1_, ChunkPos p_i241968_2_, BiomeSource p_i241968_3_, CallbackInfo ci) {
-        this.createCompact();
-    }
-
-    @Inject(method = "<init>(Lnet/minecraft/core/IdMap;Lnet/minecraft/world/level/ChunkPos;Lnet/minecraft/world/level/biome/BiomeSource;[I)V", at = @At("RETURN"))
-    private void reinit4(IdMap p_i241969_1_, ChunkPos p_i241969_2_, BiomeSource p_i241969_3_, int[] p_i241969_4_, CallbackInfo ci) {
-        this.createCompact();
-    }
-
-    private void createCompact() {
-        if (this.intArray != null || this.biomes[0] == null) {
-            return;
-        }
-
-        Reference2ShortOpenHashMap<Biome> paletteTable = this.createPalette();
-        Biome[] paletteIndexed = new Biome[paletteTable.size()];
-
-        for (Reference2ShortMap.Entry<Biome> entry : paletteTable.reference2ShortEntrySet()) {
-            paletteIndexed[entry.getShortValue()] = entry.getKey();
-        }
-
-        int packedIntSize = Math.max(2, Mth.ceillog2(paletteTable.size()));
-        BitStorage integerArray = new BitStorage(packedIntSize, ChunkBiomeContainer.BIOMES_SIZE);
-
-        Biome prevBiome = null;
-        short prevId = -1;
-
-        for (int i = 0; i < this.biomes.length; i++) {
-            Biome biome = this.biomes[i];
-            short id;
-
-            if (prevBiome == biome) {
-                id = prevId;
-            } else {
-                id = paletteTable.getShort(biome);
-
-                if (id < 0) {
-                    throw new IllegalStateException("Palette is missing entry: " + biome);
-                }
-
-                prevId = id;
-                prevBiome = biome;
-            }
-
-            integerArray.set(i, id);
-        }
-
-        this.palette = paletteIndexed;
-        this.intArray = integerArray;
-        this.biomes = null;
-    }
-
-    private Reference2ShortOpenHashMap<Biome> createPalette() {
-        Reference2ShortOpenHashMap<Biome> map = new Reference2ShortOpenHashMap<>();
-        map.defaultReturnValue(Short.MIN_VALUE);
-
-        Biome prevObj = null;
-        short id = 0;
-
-        for (Biome obj : this.biomes) {
-            if (obj == prevObj) {
-                continue;
-            }
-
-            if (map.getShort(obj) < 0) {
-                map.put(obj, id++);
-            }
-
-            prevObj = obj;
-        }
-
-        return map;
-    }
-
-    /**
-     * @author JellySquid
-     * @reason Use paletted lookup
-     */
-    @Overwrite
-    public int[] writeBiomes() {
-        int size = this.intArray.getSize();
-        int[] array = new int[size];
-
-        for(int i = 0; i < size; ++i) {
-            array[i] = this.biomeRegistry.getId(this.palette[this.intArray.get(i)]);
-        }
-
-        return array;
-    }
-
-    /**
-     * @author JellySquid
-     * @reason Use paletted lookup
-     */
-    @Overwrite
-    public Biome getNoiseBiome(int biomeX, int biomeY, int biomeZ) {
-        int x = biomeX & ChunkBiomeContainer.HORIZONTAL_MASK;
-        int y = Mth.clamp(biomeY, 0, ChunkBiomeContainer.VERTICAL_MASK);
-        int z = biomeZ & ChunkBiomeContainer.HORIZONTAL_MASK;
-
-        return this.palette[this.intArray.get(y << WIDTH_BITS + WIDTH_BITS | z << WIDTH_BITS | x)];
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/deduplicate_location/MixinResourceLocation.java

@@ -1,30 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.deduplicate_location;
-
-import net.minecraft.resources.ResourceLocation;
-import org.embeddedt.modernfix.dedup.IdentifierCaches;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Mutable;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(ResourceLocation.class)
-public class MixinResourceLocation {
-    @Mutable
-    @Shadow
-    @Final
-    protected String namespace;
-
-    @Mutable
-    @Shadow
-    @Final
-    protected String path;
-
-    @Inject(method = "<init>([Ljava/lang/String;)V", at = @At("RETURN"))
-    private void reinit(String[] id, CallbackInfo ci) {
-        this.namespace = IdentifierCaches.NAMESPACES.deduplicate(this.namespace);
-        this.path = IdentifierCaches.PATH.deduplicate(this.path);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_resources/BlockElementFaceDeserializerMixin.java

@@ -1,23 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.dynamic_resources;
-
-import com.google.gson.JsonDeserializationContext;
-import com.google.gson.JsonElement;
-import net.minecraft.client.renderer.block.model.BlockElementFace;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.embeddedt.modernfix.dynamicresources.UVController;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-import java.lang.reflect.Type;
-
-@Mixin(BlockElementFace.Deserializer.class)
-@ClientOnlyMixin
-public class BlockElementFaceDeserializerMixin {
-
-    @Redirect(method = "deserialize(Lcom/google/gson/JsonElement;Ljava/lang/reflect/Type;Lcom/google/gson/JsonDeserializationContext;)Lnet/minecraft/client/renderer/block/model/BlockElementFace;",
-            at = @At(value = "INVOKE", target = "Lcom/google/gson/JsonDeserializationContext;deserialize(Lcom/google/gson/JsonElement;Ljava/lang/reflect/Type;)Ljava/lang/Object;", ordinal = 0, remap = false))
-    private Object skipUvsForInitialLoad(JsonDeserializationContext context, JsonElement element, Type type) {
-        return UVController.useDummyUv.get() ? UVController.dummyUv : context.deserialize(element, type);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_resources/ModelManagerMixin.java

@@ -1,28 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.dynamic_resources;
-
-import net.minecraft.client.resources.model.BakedModel;
-import net.minecraft.client.resources.model.ModelManager;
-import net.minecraft.resources.ResourceLocation;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Mixin(ModelManager.class)
-@ClientOnlyMixin
-public class ModelManagerMixin {
-    @Shadow private Map<ResourceLocation, BakedModel> bakedRegistry;
-
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void injectDummyBakedRegistry(CallbackInfo ci) {
-        if(this.bakedRegistry == null) {
-            // Create a dummy baked registry. This prevents NPEs when mods query block models too early
-            this.bakedRegistry = new HashMap<>();
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_sounds/SoundBufferLibraryMixin.java

@@ -1,47 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.dynamic_sounds;
-
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.RemovalCause;
-import com.google.common.cache.RemovalNotification;
-import com.mojang.blaze3d.audio.SoundBuffer;
-import net.minecraft.client.sounds.SoundBufferLibrary;
-import net.minecraft.resources.ResourceLocation;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.embeddedt.modernfix.dynamicresources.DynamicSoundHelpers;
-import org.embeddedt.modernfix.ModernFix;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Mutable;
-import org.spongepowered.asm.mixin.Shadow;
-
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.Map;
-
-@Mixin(SoundBufferLibrary.class)
-@ClientOnlyMixin
-public abstract class SoundBufferLibraryMixin {
-
-    private static final boolean debugDynamicSoundLoading = Boolean.getBoolean("modernfix.debugDynamicSoundLoading");
-
-    @Shadow @Final @Mutable
-    private Map<ResourceLocation, CompletableFuture<SoundBuffer>> cache = CacheBuilder.newBuilder()
-        .expireAfterAccess(DynamicSoundHelpers.MAX_SOUND_LIFETIME_SECS, TimeUnit.SECONDS)
-        .concurrencyLevel(1)
-        // Excessive use of type hinting due to it assuming Object as the broadest correct type
-        .<ResourceLocation, CompletableFuture<SoundBuffer>>removalListener(this::onSoundRemoval)
-        .build()
-        .asMap();
-
-    private <K extends ResourceLocation, V extends CompletableFuture<SoundBuffer>> void onSoundRemoval(RemovalNotification<K, V> notification) {
-        if(notification.getCause() == RemovalCause.REPLACED && notification.getValue() == cache.get(notification.getKey()))
-            return;
-        notification.getValue().thenAccept(SoundBuffer::discardAlBuffer);
-        if(!debugDynamicSoundLoading)
-            return;
-        K k = notification.getKey();
-        if(k == null)
-            return;
-        ModernFix.LOGGER.warn("Evicted sound {}", k);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/faster_font_loading/LegacyUnicodeBitmapsProviderMixin.java

@@ -1,71 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.faster_font_loading;
-
-import com.mojang.blaze3d.platform.NativeImage;
-import net.minecraft.client.gui.font.providers.LegacyUnicodeBitmapsProvider;
-import net.minecraft.resources.ResourceLocation;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.Redirect;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Map;
-
-/**
- * Objective: avoid recomputing locations many times, as well as loading all the font sheets in the constructor
- * only to do it again later.
- */
-@Mixin(LegacyUnicodeBitmapsProvider.class)
-@ClientOnlyMixin
-public abstract class LegacyUnicodeBitmapsProviderMixin {
-    @Shadow protected abstract ResourceLocation getSheetLocation(int i);
-
-    @Shadow @Final private Map<ResourceLocation, NativeImage> textures;
-    private final ResourceLocation[] glyphLocations = new ResourceLocation[256];
-
-    private ResourceLocation currentCharIdx;
-
-    @Redirect(method = "<init>", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/font/providers/LegacyUnicodeBitmapsProvider;getSheetLocation(I)Lnet/minecraft/resources/ResourceLocation;"))
-    private ResourceLocation storeCurrentCharIdx(LegacyUnicodeBitmapsProvider provider, int i) {
-        ResourceLocation location = getSheetLocation(i);
-        currentCharIdx = location;
-        return location;
-    }
-
-    @Redirect(method = "<init>", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/platform/NativeImage;read(Lcom/mojang/blaze3d/platform/NativeImage$Format;Ljava/io/InputStream;)Lcom/mojang/blaze3d/platform/NativeImage;"))
-    private NativeImage storeLoadedFontSheet(NativeImage.Format format, InputStream stream) throws IOException {
-        NativeImage image = NativeImage.read(format, stream);
-        textures.put(currentCharIdx, image);
-        return image;
-    }
-
-    @Redirect(method = "<init>", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/platform/NativeImage;close()V"))
-    private void skipCloseNativeImage(NativeImage image) {
-        /* we can't close here, as the image has been stored for use later */
-    }
-
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void clearLocation(CallbackInfo ci) {
-        currentCharIdx = null;
-    }
-
-    @Inject(method = "getSheetLocation", at = @At("HEAD"), cancellable = true)
-    private void useCachedLocation(int idx, CallbackInfoReturnable<ResourceLocation> cir) {
-        int cachedIdx = idx / 256;
-        if(cachedIdx >= 0 && cachedIdx < glyphLocations.length && glyphLocations[cachedIdx] != null)
-            cir.setReturnValue(glyphLocations[cachedIdx]);
-    }
-
-    @Inject(method = "getSheetLocation", at = @At("RETURN"))
-    private void saveCachedLocation(int idx, CallbackInfoReturnable<ResourceLocation> cir) {
-        int cachedIdx = idx / 256;
-        if(cachedIdx >= 0 && cachedIdx < glyphLocations.length)
-            glyphLocations[cachedIdx] = cir.getReturnValue();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/faster_texture_loading/TextureAtlasMixin.java

@@ -1,123 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.faster_texture_loading;
-
-import com.mojang.blaze3d.platform.NativeImage;
-import com.mojang.datafixers.util.Pair;
-import net.minecraft.client.renderer.texture.MissingTextureAtlasSprite;
-import net.minecraft.client.renderer.texture.TextureAtlas;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.client.resources.metadata.animation.AnimationMetadataSection;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.resources.Resource;
-import net.minecraft.server.packs.resources.ResourceManager;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.Redirect;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.io.IOException;
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-
-@Mixin(value = TextureAtlas.class, priority = 600)
-@ClientOnlyMixin
-public abstract class TextureAtlasMixin {
-    @Shadow protected abstract ResourceLocation getResourceLocation(ResourceLocation location);
-
-    @Shadow protected abstract Collection<TextureAtlasSprite.Info> getBasicSpriteInfos(ResourceManager resourceManager, Set<ResourceLocation> spriteLocations);
-
-    private Map<ResourceLocation, Pair<Resource, NativeImage>> loadedImages = new ConcurrentHashMap<>();
-    private boolean usingFasterLoad;
-    private Collection<TextureAtlasSprite.Info> storedResults;
-    /**
-     * @author embeddedt
-     * @reason simplify texture loading by loading whole image once, avoid slow PngInfo code
-     */
-    @Inject(method = "getBasicSpriteInfos", at = @At("HEAD"))
-    private void loadImages(ResourceManager manager, Set<ResourceLocation> imageLocations, CallbackInfoReturnable<Collection<TextureAtlasSprite.Info>> cir) {
-        usingFasterLoad = ModernFixPlatformHooks.INSTANCE.isLoadingNormally();
-    }
-
-    @Redirect(method = "getBasicSpriteInfos", at = @At(value = "INVOKE", target = "Ljava/util/Set;iterator()Ljava/util/Iterator;", ordinal = 0))
-    private Iterator<?> skipIteration(Set<?> instance, ResourceManager manager, Set<ResourceLocation> imageLocations) {
-        // bail if Forge is erroring to avoid AT crashes
-        if(!usingFasterLoad)
-            return instance.iterator();
-        List<CompletableFuture<?>> futures = new ArrayList<>();
-        ConcurrentLinkedQueue<TextureAtlasSprite.Info> results = new ConcurrentLinkedQueue<>();
-        for(ResourceLocation location : imageLocations) {
-            if(MissingTextureAtlasSprite.getLocation().equals(location))
-                continue;
-            futures.add(CompletableFuture.runAsync(() -> {
-                try {
-                    ResourceLocation fileLocation = this.getResourceLocation(location);
-                    Resource resource = manager.getResource(fileLocation);
-                    NativeImage image = NativeImage.read(resource.getInputStream());
-                    AnimationMetadataSection animData = resource.getMetadata(AnimationMetadataSection.SERIALIZER);
-                    if (animData == null) {
-                        animData = AnimationMetadataSection.EMPTY;
-                    }
-                    Pair<Integer, Integer> dimensions = animData.getFrameSize(image.getWidth(), image.getHeight());
-                    loadedImages.put(location, Pair.of(resource, image));
-                    results.add(new TextureAtlasSprite.Info(location, dimensions.getFirst(), dimensions.getSecond(), animData));
-                } catch(IOException e) {
-                    ModernFix.LOGGER.error("Using missing texture, unable to load {} : {}", location, e);
-                } catch(RuntimeException e) {
-                    ModernFix.LOGGER.error("Unable to parse metadata from {} : {}", location, e);
-                }
-            }, ModernFix.resourceReloadExecutor()));
-        }
-        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
-        storedResults = results;
-        return Collections.emptyIterator();
-    }
-
-    @Inject(method = "getBasicSpriteInfos", at = @At("RETURN"))
-    private void injectFastSprites(ResourceManager resourceManager, Set<ResourceLocation> spriteLocations, CallbackInfoReturnable<Collection<TextureAtlasSprite.Info>> cir) {
-        if(usingFasterLoad)
-            cir.getReturnValue().addAll(storedResults);
-    }
-
-    @Inject(method = "prepareToStitch", at = @At("HEAD"))
-    private void initMap(CallbackInfoReturnable<TextureAtlas.Preparations> cir) {
-        loadedImages = new ConcurrentHashMap<>();
-    }
-
-    @Inject(method = "prepareToStitch", at = @At("RETURN"))
-    private void clearLoadedImages(CallbackInfoReturnable<TextureAtlas.Preparations> cir) {
-        loadedImages = Collections.emptyMap();
-        storedResults = null;
-    }
-
-    @Inject(method = "load(Lnet/minecraft/server/packs/resources/ResourceManager;Lnet/minecraft/client/renderer/texture/TextureAtlasSprite$Info;IIIII)Lnet/minecraft/client/renderer/texture/TextureAtlasSprite;",
-        at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/texture/TextureAtlas;getResourceLocation(Lnet/minecraft/resources/ResourceLocation;)Lnet/minecraft/resources/ResourceLocation;"), cancellable = true)
-    private void loadFromExisting(ResourceManager resourceManager, TextureAtlasSprite.Info spriteInfo, int width, int height, int mipmapLevel, int originX, int originY, CallbackInfoReturnable<TextureAtlasSprite> cir) {
-        if(!usingFasterLoad)
-            return;
-        Pair<Resource, NativeImage> pair = loadedImages.get(spriteInfo.name());
-        if(pair == null) {
-            ModernFix.LOGGER.error("Texture {} was not loaded in early stage", spriteInfo.name());
-            cir.setReturnValue(null);
-        } else {
-            TextureAtlasSprite sprite = null;
-            try {
-                sprite = ModernFixPlatformHooks.INSTANCE.loadTextureAtlasSprite((TextureAtlas)(Object)this, resourceManager, spriteInfo, pair.getFirst(), width, height, originX, originY, mipmapLevel, pair.getSecond());
-            } catch(RuntimeException e) {
-                ModernFix.LOGGER.error("Error loading texture {}: {}", spriteInfo.name(), e);
-            } finally {
-                try {
-                    pair.getFirst().close();
-                } catch(IOException ignored) {
-                    // not much we can do
-                }
-            }
-            cir.setReturnValue(sprite);
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/fix_loop_spin_waiting/BlockableEventLoopMixin.java

@@ -1,23 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.fix_loop_spin_waiting;
-
-import net.minecraft.util.thread.BlockableEventLoop;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Overwrite;
-
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.locks.LockSupport;
-
-// This should fix https://bugs.mojang.com/browse/MC-183518
-@Mixin(value = BlockableEventLoop.class, priority = 500)
-public class BlockableEventLoopMixin {
-    private static final long MFIX$TICK_WAIT_TIME = TimeUnit.MILLISECONDS.toNanos(2);
-
-    /**
-     * @author embeddedt
-     * @reason yielding the thread is pretty pointless if we're about to park anyway
-     */
-    @Overwrite
-    protected void waitForTasks() {
-        LockSupport.parkNanos("waiting for tasks", MFIX$TICK_WAIT_TIME);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/mojang_registry_size/ResourceKeyMixin.java

@@ -1,28 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.mojang_registry_size;
-
-import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Map;
-
-@Mixin(ResourceKey.class)
-public class ResourceKeyMixin<T> {
-    private static final Map<ResourceLocation, Map<ResourceLocation, ResourceKey<?>>> INTERNING_MAP = new Object2ObjectOpenHashMap<>();
-    @Inject(method = "create(Lnet/minecraft/resources/ResourceLocation;Lnet/minecraft/resources/ResourceLocation;)Lnet/minecraft/resources/ResourceKey;", at = @At("HEAD"), cancellable = true)
-    private static <T> void createEfficient(ResourceLocation parent, ResourceLocation location, CallbackInfoReturnable<ResourceKey<T>> cir) {
-        synchronized (ResourceKey.class) {
-            Map<ResourceLocation, ResourceKey<?>> keys = INTERNING_MAP.computeIfAbsent(parent, k -> new Object2ObjectOpenHashMap<>());
-            ResourceKey<?> key = keys.get(location);
-            if(key == null) {
-                key = new ResourceKey<>(parent, location);
-                keys.put(location, key);
-            }
-            cir.setReturnValue((ResourceKey<T>)key);
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/nbt_memory_usage/CompoundTag1Mixin.java

@@ -1,20 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.nbt_memory_usage;
-
-import net.minecraft.nbt.Tag;
-import org.embeddedt.modernfix.util.CanonizingStringMap;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyVariable;
-
-import java.util.Map;
-
-@Mixin(targets = "net/minecraft/nbt/CompoundTag$1")
-public class CompoundTag1Mixin {
-    @ModifyVariable(method = "load(Ljava/io/DataInput;ILnet/minecraft/nbt/NbtAccounter;)Lnet/minecraft/nbt/CompoundTag;", at = @At(value = "INVOKE_ASSIGN", target = "Lcom/google/common/collect/Maps;newHashMap()Ljava/util/HashMap;", remap = false))
-    private Map<String, Tag> modifyMap(Map<String, Tag> map) {
-        CanonizingStringMap<Tag> newMap =  new CanonizingStringMap<>();
-        if(map != null)
-            newMap.putAll(map);
-        return newMap;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/nbt_memory_usage/CompoundTagMixin.java

@@ -1,40 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.nbt_memory_usage;
-
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.Tag;
-import org.embeddedt.modernfix.util.CanonizingStringMap;
-import org.spongepowered.asm.mixin.*;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Map;
-
-@Mixin(CompoundTag.class)
-public class CompoundTagMixin {
-    @Shadow @Final
-    private Map<String, Tag> tags;
-
-    /**
-     * Ensure that the default backing map is a CanonizingStringMap.
-     */
-    @ModifyArg(method = "<init>()V", at = @At(value = "INVOKE", target = "Lnet/minecraft/nbt/CompoundTag;<init>(Ljava/util/Map;)V"), index = 0)
-    private static Map<String, Tag> useCanonizingStringMap(Map<String, Tag> incoming) {
-        CanonizingStringMap<Tag> newMap = new CanonizingStringMap<>();
-        if(incoming != null)
-            newMap.putAll(incoming);
-        return newMap;
-    }
-
-    /**
-     * @author embeddedt
-     * @reason use more efficient method when copying canonizing string map
-     */
-    @Inject(method = "copy()Lnet/minecraft/nbt/Tag;", at = @At("HEAD"), cancellable = true)
-    public void copyEfficient(CallbackInfoReturnable<Tag> cir) {
-        if(this.tags instanceof CanonizingStringMap) {
-            cir.setReturnValue(new CompoundTag(CanonizingStringMap.deepCopy((CanonizingStringMap<Tag>)this.tags, Tag::copy)));
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/nuke_empty_chunk_sections/MixinChunk.java

@@ -1,35 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.nuke_empty_chunk_sections;
-
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.UpgradeData;
-import net.minecraft.world.level.TickList;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.chunk.ChunkBiomeContainer;
-import net.minecraft.world.level.chunk.LevelChunk;
-import net.minecraft.world.level.chunk.LevelChunkSection;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.function.Consumer;
-
-@Mixin(LevelChunk.class)
-public class MixinChunk {
-    @Shadow @Final private LevelChunkSection[] sections;
-
-    @Inject(method = "<init>(Lnet/minecraft/world/level/Level;Lnet/minecraft/world/level/ChunkPos;Lnet/minecraft/world/level/chunk/ChunkBiomeContainer;Lnet/minecraft/world/level/chunk/UpgradeData;Lnet/minecraft/world/level/TickList;Lnet/minecraft/world/level/TickList;J[Lnet/minecraft/world/level/chunk/LevelChunkSection;Ljava/util/function/Consumer;)V",
-            at = @At("RETURN"))
-    private void reinit(Level world, ChunkPos pos, ChunkBiomeContainer container, UpgradeData data,
-                        TickList list1, TickList list2, long inhabited,
-                        LevelChunkSection[] oldSections, Consumer consumer, CallbackInfo ci) {
-        /* taken from Hydrogen */
-        for(int i = 0; i < this.sections.length; i++) {
-            if(LevelChunkSection.isEmpty(this.sections[i])) {
-                this.sections[i] = null;
-            }
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/reduce_blockstate_cache_rebuilds/BlockStateBaseMixin.java

@@ -1,61 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.reduce_blockstate_cache_rebuilds;
-
-import net.minecraft.world.level.block.state.BlockBehaviour;
-import org.embeddedt.modernfix.duck.IBlockState;
-import org.objectweb.asm.Opcodes;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-
-@Mixin(BlockBehaviour.BlockStateBase.class)
-public abstract class BlockStateBaseMixin implements IBlockState {
-    @Shadow public abstract void initCache();
-
-    @Shadow private BlockBehaviour.BlockStateBase.Cache cache;
-
-    private volatile boolean cacheInvalid = false;
-    private static boolean buildingCache = false;
-    @Override
-    public void clearCache() {
-        cacheInvalid = true;
-    }
-
-    @Override
-    public boolean isCacheInvalid() {
-        return cacheInvalid;
-    }
-
-    private void mfix$generateCache() {
-        if(cacheInvalid) {
-            // Ensure that only one block's cache is built at a time
-            synchronized (BlockBehaviour.BlockStateBase.class) {
-                if(cacheInvalid) {
-                    // Ensure that if we end up in here recursively, we just use the original cache
-                    if(!buildingCache) {
-                        buildingCache = true;
-                        try {
-                            this.initCache();
-                            cacheInvalid = false;
-                        } finally {
-                            buildingCache = false;
-                        }
-                    }
-                }
-
-            }
-        }
-    }
-
-    @Redirect(method = "*", at = @At(
-            value = "FIELD",
-            opcode = Opcodes.GETFIELD,
-            target = "Lnet/minecraft/world/level/block/state/BlockBehaviour$BlockStateBase;cache:Lnet/minecraft/world/level/block/state/BlockBehaviour$BlockStateBase$Cache;",
-            ordinal = 0
-    ))
-    private BlockBehaviour.BlockStateBase.Cache dynamicCacheGen(BlockBehaviour.BlockStateBase base) {
-        mfix$generateCache();
-        return this.cache;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/reduce_blockstate_cache_rebuilds/BlocksMixin.java

@@ -1,18 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.reduce_blockstate_cache_rebuilds;
-
-import net.minecraft.world.level.block.Blocks;
-import org.embeddedt.modernfix.blockstate.BlockStateCacheHandler;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-
-import java.util.function.Consumer;
-
-@Mixin(value = Blocks.class, priority = 1100)
-public class BlocksMixin {
-    @ModifyArg(method = "rebuildCache", at = @At(value = "INVOKE", target = "Lnet/minecraft/core/IdMapper;forEach(Ljava/util/function/Consumer;)V"), index = 0)
-    private static Consumer getEmptyConsumer(Consumer original) {
-        BlockStateCacheHandler.rebuildParallel(true);
-        return o -> {};
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/remove_spawn_chunks/MinecraftServerMixin.java

@@ -1,24 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.remove_spawn_chunks;
-
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerChunkCache;
-import net.minecraft.server.level.TicketType;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.ChunkStatus;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(value = MinecraftServer.class, priority = 1100)
-public class MinecraftServerMixin {
-    @Redirect(method = "prepareLevels", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerChunkCache;addRegionTicket(Lnet/minecraft/server/level/TicketType;Lnet/minecraft/world/level/ChunkPos;ILjava/lang/Object;)V"))
-    private void addSpawnChunkTicket(ServerChunkCache cache, TicketType<?> type, ChunkPos pos, int distance, Object o) {
-        // load first chunk
-        cache.getChunk(pos.x, pos.z, ChunkStatus.FULL, true);
-    }
-
-    @Redirect(method = "prepareLevels", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerChunkCache;getTickingGenerated()I"), require = 0)
-    private int getGenerated(ServerChunkCache cache) {
-        return 441;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/remove_spawn_chunks/ServerChunkCacheAccessor.java

@@ -1,12 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.remove_spawn_chunks;
-
-import net.minecraft.server.level.DistanceManager;
-import net.minecraft.server.level.ServerChunkCache;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(ServerChunkCache.class)
-public interface ServerChunkCacheAccessor {
-    @Accessor("distanceManager")
-    DistanceManager getDistanceManager();
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/resourcepacks/ReloadableResourceManagerMixin.java

@@ -1,18 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.resourcepacks;
-
-import net.minecraft.server.packs.resources.SimpleReloadableResourceManager;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.resources.PackResourcesCacheEngine;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(SimpleReloadableResourceManager.class)
-public class ReloadableResourceManagerMixin {
-    @Inject(method = "createReload", at = @At("HEAD"))
-    private void invalidateResourceCaches(CallbackInfoReturnable<?> cir) {
-        ModernFix.LOGGER.info("Invalidating pack caches");
-        PackResourcesCacheEngine.invalidate();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/reuse_datapacks/MinecraftMixin.java

@@ -1,83 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.reuse_datapacks;
-
-import com.google.common.collect.ImmutableList;
-import net.minecraft.client.Minecraft;
-import net.minecraft.commands.Commands;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.ServerResources;
-import net.minecraft.server.packs.PackResources;
-import net.minecraft.server.packs.repository.Pack;
-import net.minecraft.server.packs.repository.PackRepository;
-import net.minecraft.world.level.DataPackConfig;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.embeddedt.modernfix.duck.reuse_datapacks.ICachingResourceClient;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.Redirect;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-
-@Mixin(Minecraft.class)
-@ClientOnlyMixin
-public abstract class MinecraftMixin implements ICachingResourceClient {
-    @Shadow public abstract boolean isLocalServer();
-
-    private ServerResources cachedResources;
-    private List<String> cachedDataPackConfig;
-
-    private List<String> loadingDataPackConfig;
-
-    @Redirect(method = "makeServerStem", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/MinecraftServer;configurePackRepository(Lnet/minecraft/server/packs/repository/PackRepository;Lnet/minecraft/world/level/DataPackConfig;Z)Lnet/minecraft/world/level/DataPackConfig;"))
-    private DataPackConfig saveLoadingConfig(PackRepository repo, DataPackConfig inCodec, boolean vanillaOnly) {
-        DataPackConfig config = MinecraftServer.configurePackRepository(repo, inCodec, vanillaOnly);
-        loadingDataPackConfig = repo.getSelectedPacks().stream().map(Pack::getId).collect(ImmutableList.toImmutableList());
-        return config;
-    }
-
-    @Redirect(method = "makeServerStem", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/ServerResources;loadResources(Ljava/util/List;Lnet/minecraft/commands/Commands$CommandSelection;ILjava/util/concurrent/Executor;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;"))
-    private CompletableFuture<ServerResources> useCachedResources(List<PackResources> list, Commands.CommandSelection arg, int i, Executor executor, Executor executor2) {
-        if(cachedResources != null) {
-            if(cachedResources.getResourceManager().getNamespaces().size() > 0) {
-                if (cachedDataPackConfig.equals(loadingDataPackConfig)) {
-                    ModernFix.LOGGER.warn("Reusing loaded server resources from previous world");
-                    return CompletableFuture.completedFuture(cachedResources);
-                } else {
-                    ModernFix.LOGGER.warn("Discarding cached server resources, datapack configs have changed");
-                    ModernFix.LOGGER.warn("Old: {}", "[" + String.join(", ", cachedDataPackConfig) + "]");
-                    ModernFix.LOGGER.warn("New: {}", "[" + String.join(", ", loadingDataPackConfig) + "]");
-                    cachedResources.close();
-                    cachedResources = null;
-                    cachedDataPackConfig = null;
-                }
-            } else {
-                ModernFix.LOGGER.error("Cached server resources were closed somehow, that shouldn't happen");
-                cachedResources = null;
-            }
-        }
-        return ServerResources.loadResources(list, arg, i, executor, executor2);
-    }
-
-
-    @Override
-    public void setCachedResources(ServerResources r) {
-        cachedResources = r;
-    }
-
-    @Override
-    public void setCachedDataPackConfig(Collection<String> c) {
-        cachedDataPackConfig = ImmutableList.copyOf(c);
-    }
-
-    @Inject(method = "setLevel", at = @At("HEAD"))
-    private void clearResourcesIfNotLocal(CallbackInfo ci) {
-        if(!this.isLocalServer())
-            cachedResources = null;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/reuse_datapacks/MinecraftServerMixin.java

@@ -1,29 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.reuse_datapacks;
-
-import com.google.common.collect.ImmutableList;
-import net.minecraft.client.Minecraft;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.ServerResources;
-import net.minecraft.server.packs.repository.Pack;
-import net.minecraft.server.packs.repository.PackRepository;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.embeddedt.modernfix.duck.reuse_datapacks.ICachingResourceClient;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Redirect;
-
-@Mixin(MinecraftServer.class)
-@ClientOnlyMixin
-public class MinecraftServerMixin {
-
-    @Shadow @Final private PackRepository packRepository;
-
-    @Redirect(method = "stopServer", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/ServerResources;close()V"))
-    private void saveResources(ServerResources resources) {
-        ICachingResourceClient client = ((ICachingResourceClient) Minecraft.getInstance());
-        client.setCachedDataPackConfig(this.packRepository.getSelectedPacks().stream().map(Pack::getId).collect(ImmutableList.toImmutableList()));
-        client.setCachedResources(resources);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/thread_priorities/IntegratedServerMixin.java

@@ -1,28 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.perf.thread_priorities;
-
-import com.mojang.authlib.GameProfileRepository;
-import com.mojang.authlib.minecraft.MinecraftSessionService;
-import net.minecraft.client.Minecraft;
-import net.minecraft.server.ServerResources;
-import net.minecraft.server.packs.repository.PackRepository;
-import net.minecraft.client.server.IntegratedServer;
-import net.minecraft.server.players.GameProfileCache;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.server.level.progress.ChunkProgressListenerFactory;
-import net.minecraft.world.level.storage.WorldData;
-import net.minecraft.world.level.storage.LevelStorageSource;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(IntegratedServer.class)
-@ClientOnlyMixin
-public class IntegratedServerMixin {
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void adjustServerPriority(Thread pServerThread, Minecraft pMinecraft, RegistryAccess.RegistryHolder pRegistryHolder, LevelStorageSource.LevelStorageAccess pStorageSource, PackRepository pPackRepository, ServerResources pResources, WorldData pWorldData, MinecraftSessionService pSessionService, GameProfileRepository pProfileRepository, GameProfileCache pProfileCache, ChunkProgressListenerFactory pProgressListenerfactory, CallbackInfo ci) {
-        int pri = 4; //ModernFixConfig.INTEGRATED_SERVER_PRIORITY.get();
-        pServerThread.setPriority(pri);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/common/mixin/safety/LivingEntityRendererMixin.java

@@ -1,28 +0,0 @@
-package org.embeddedt.modernfix.common.mixin.safety;
-
-import net.minecraft.client.renderer.entity.LivingEntityRenderer;
-import net.minecraft.client.renderer.entity.layers.RenderLayer;
-import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Mutable;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import java.util.Collections;
-import java.util.List;
-
-@Mixin(LivingEntityRenderer.class)
-@ClientOnlyMixin
-public class LivingEntityRendererMixin {
-    @Shadow @Final @Mutable
-    protected List<RenderLayer<?, ?>> layers;
-
-    @Inject(method = "<init>", at = @At("RETURN"))
-    private void synchronizeLayerList(CallbackInfo ci) {
-        /* allows buggy mods to call addLayer concurrently, order is not deterministic but can't fix that */
-        this.layers = Collections.synchronizedList(layers);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/dedup/DeduplicationCache.java

@@ -1,56 +0,0 @@
-package org.embeddedt.modernfix.dedup;
-
-import it.unimi.dsi.fastutil.Hash;
-import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
-
-import java.util.Objects;
-
-public class DeduplicationCache<T> {
-    private final ObjectOpenCustomHashSet<T> pool;
-
-    private int attemptedInsertions = 0;
-    private int deduplicated = 0;
-
-    public DeduplicationCache(Hash.Strategy<T> strategy) {
-        this.pool = new ObjectOpenCustomHashSet<>(strategy);
-    }
-
-    public DeduplicationCache() {
-        this.pool = new ObjectOpenCustomHashSet<>(new Hash.Strategy<T>() {
-            @Override
-            public int hashCode(T o) {
-                return Objects.hashCode(o);
-            }
-
-            @Override
-            public boolean equals(T a, T b) {
-                return Objects.equals(a, b);
-            }
-        });
-    }
-
-    public synchronized T deduplicate(T item) {
-        this.attemptedInsertions++;
-
-        T result = this.pool.addOrGet(item);
-
-        if (result != item) {
-            this.deduplicated++;
-        }
-
-        return result;
-    }
-
-    public synchronized void clearCache() {
-        this.attemptedInsertions = 0;
-        this.deduplicated = 0;
-
-        this.pool.clear();
-    }
-
-    @Override
-    public synchronized String toString() {
-        return String.format("DeduplicationCache ( %d/%d de-duplicated, %d pooled )",
-                this.deduplicated, this.attemptedInsertions, this.pool.size());
-    }
-}

common/src/main/java/org/embeddedt/modernfix/dedup/IdentifierCaches.java

@@ -1,16 +0,0 @@
-package org.embeddedt.modernfix.dedup;
-
-
-import org.embeddedt.modernfix.ModernFix;
-
-public class IdentifierCaches {
-    public static final DeduplicationCache<String> NAMESPACES = new DeduplicationCache<>();
-    public static final DeduplicationCache<String> PATH = new DeduplicationCache<>();
-    public static final DeduplicationCache<String> PROPERTY = new DeduplicationCache<>();
-
-    public static void printDebug() {
-        ModernFix.LOGGER.info("[[[ Identifier de-duplication statistics ]]]");
-        ModernFix.LOGGER.info("Namespace cache: {}", NAMESPACES);
-        ModernFix.LOGGER.info("Path cache: {}", PATH);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/dfu/DFUBlaster.java

@@ -1,68 +0,0 @@
-package org.embeddedt.modernfix.dfu;
-
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-import com.mojang.datafixers.RewriteResult;
-import com.mojang.datafixers.TypeRewriteRule;
-import com.mojang.datafixers.functions.PointFreeRule;
-import com.mojang.datafixers.types.Type;
-import com.mojang.datafixers.util.Pair;
-import org.apache.commons.lang3.tuple.Triple;
-import org.embeddedt.modernfix.ModernFix;
-import sun.misc.Unsafe;
-
-import java.lang.reflect.Field;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-import java.util.function.IntFunction;
-
-public class DFUBlaster {
-    private static final Cache<Pair<IntFunction<RewriteResult<?, ?>>, Integer>, RewriteResult<?, ?>> hmapApplyCache = CacheBuilder.newBuilder()
-            .expireAfterAccess(3, TimeUnit.MINUTES)
-            .build();
-    private static final Cache<Triple<Type<?>, TypeRewriteRule, PointFreeRule>, Optional<? extends RewriteResult<?, ?>>> rewriteCache = CacheBuilder.newBuilder()
-            .expireAfterAccess(3, TimeUnit.MINUTES)
-            .build();
-    public static void blastMaps() {
-        try {
-            Class<?> FOLD_CLASS = Class.forName("com.mojang.datafixers.functions.Fold");
-            Field hmapField = FOLD_CLASS.getDeclaredField("HMAP_APPLY_CACHE");
-            hmapField.setAccessible(true);
-            final Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
-            theUnsafe.setAccessible(true);
-            Unsafe unsafe = (Unsafe)theUnsafe.get(null);
-            Object base = unsafe.staticFieldBase(hmapField);
-            long offset = unsafe.staticFieldOffset(hmapField);
-            unsafe.putObject(base, offset, hmapApplyCache.asMap());
-            Field rewriteCacheField = Type.class.getDeclaredField("REWRITE_CACHE");
-            rewriteCacheField.setAccessible(true);
-            base = unsafe.staticFieldBase(rewriteCacheField);
-            offset = unsafe.staticFieldOffset(rewriteCacheField);
-            unsafe.putObject(base, offset, rewriteCache.asMap());
-            new CleanerThread().start();
-        } catch(Throwable e) {
-            ModernFix.LOGGER.error("Could not replace DFU map", e);
-        }
-    }
-
-    static class CleanerThread extends Thread {
-        CleanerThread() {
-            this.setName("DFU cleaning thread");
-            this.setPriority(1);
-            this.setDaemon(true);
-        }
-
-        @Override
-        public void run() {
-            while(true) {
-                try {
-                    Thread.sleep(15000);
-                } catch(InterruptedException e){
-                    return;
-                }
-                rewriteCache.cleanUp();
-                hmapApplyCache.cleanUp();
-            }
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/duck/ICachedIngredientJS.java

@@ -1,14 +0,0 @@
-package org.embeddedt.modernfix.duck;
-
-import dev.latvian.kubejs.item.ItemStackJS;
-
-import java.util.Set;
-
-public interface ICachedIngredientJS {
-    /**
-     * Returns a cached list of item stacks for the given ingredient. The user must not attempt to modify any contents
-     * of these stacks.
-     * @return cached set of stacks
-     */
-    Set<ItemStackJS> getCachedStacks();
-}

common/src/main/java/org/embeddedt/modernfix/duck/ICachedMaterialsModel.java

@@ -1,5 +0,0 @@
-package org.embeddedt.modernfix.duck;
-
-public interface ICachedMaterialsModel {
-    public void clearMaterialsCache();
-}

common/src/main/java/org/embeddedt/modernfix/duck/ILevelSave.java

@@ -1,7 +0,0 @@
-package org.embeddedt.modernfix.duck;
-
-import net.minecraft.world.level.storage.LevelStorageSource;
-
-public interface ILevelSave {
-    public void runWorldPersistenceHooks(LevelStorageSource format);
-}

common/src/main/java/org/embeddedt/modernfix/duck/IPaperChunkHolder.java

@@ -1,5 +0,0 @@
-package org.embeddedt.modernfix.duck;
-
-public interface IPaperChunkHolder {
-    boolean mfix$canAdvanceStatus();
-}

common/src/main/java/org/embeddedt/modernfix/duck/ISafeBlockGetter.java

@@ -1,7 +0,0 @@
-package org.embeddedt.modernfix.duck;
-
-import org.embeddedt.modernfix.chunk.SafeBlockGetter;
-
-public interface ISafeBlockGetter {
-    SafeBlockGetter mfix$getSafeBlockGetter();
-}

common/src/main/java/org/embeddedt/modernfix/duck/IServerLevel.java

@@ -1,7 +0,0 @@
-package org.embeddedt.modernfix.duck;
-
-import org.embeddedt.modernfix.world.StrongholdLocationCache;
-
-public interface IServerLevel {
-    StrongholdLocationCache mfix$getStrongholdCache();
-}

common/src/main/java/org/embeddedt/modernfix/duck/reuse_datapacks/ICachingResourceClient.java

@@ -1,10 +0,0 @@
-package org.embeddedt.modernfix.duck.reuse_datapacks;
-
-import net.minecraft.server.ServerResources;
-
-import java.util.Collection;
-
-public interface ICachingResourceClient {
-    void setCachedResources(ServerResources r);
-    void setCachedDataPackConfig(Collection<String> c);
-}

common/src/main/java/org/embeddedt/modernfix/dynamicresources/DynamicSoundHelpers.java

@@ -1,8 +0,0 @@
-package org.embeddedt.modernfix.dynamicresources;
-
-public class DynamicSoundHelpers {
-	/**
-	 * The duration until a sound is eligible for eviction if unused.
-	 */
-	public static final int MAX_SOUND_LIFETIME_SECS = 300;
-}

common/src/main/java/org/embeddedt/modernfix/dynamicresources/ModelBakeryHelpers.java

@@ -1,411 +0,0 @@
-package org.embeddedt.modernfix.dynamicresources;
-
-import com.google.common.base.Splitter;
-import com.google.common.base.Stopwatch;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Sets;
-import com.google.gson.*;
-import com.google.gson.stream.JsonReader;
-import com.mojang.datafixers.util.Pair;
-import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
-import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
-import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
-import it.unimi.dsi.fastutil.objects.ReferenceSet;
-import net.minecraft.client.renderer.block.model.BlockModel;
-import net.minecraft.client.resources.model.*;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.PackResources;
-import net.minecraft.server.packs.PackType;
-import net.minecraft.server.packs.resources.FallbackResourceManager;
-import net.minecraft.server.packs.resources.Resource;
-import net.minecraft.server.packs.resources.ResourceManager;
-import net.minecraft.server.packs.resources.SimpleReloadableResourceManager;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.block.state.StateDefinition;
-import net.minecraft.world.level.block.state.properties.Property;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.api.entrypoint.ModernFixClientIntegration;
-import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-import static net.minecraft.client.resources.model.ModelBakery.BLOCK_ENTITY_MARKER;
-import static net.minecraft.client.resources.model.ModelBakery.GENERATION_MARKER;
-
-public class ModelBakeryHelpers {
-    /**
-     * The maximum number of baked models kept in memory at once.
-     */
-    public static final int MAX_BAKED_MODEL_COUNT = 10000;
-    /**
-     * The maximum number of unbaked models kept in memory at once.
-     */
-    public static final int MAX_UNBAKED_MODEL_COUNT = 10000;
-    /**
-     * The time in seconds after which a model becomes eligible for eviction if not used.
-     */
-    public static final int MAX_MODEL_LIFETIME_SECS = 300;
-
-    /**
-     * These folders will have all textures stitched onto the atlas when dynamic resources is enabled.
-     */
-    public static String[] getExtraTextureFolders() {
-        return new String[] {
-                "attachment",
-                "bettergrass",
-                "block",
-                "blocks",
-                "cape",
-                "entity/bed",
-                "entity/chest",
-                "item",
-                "items",
-                "model",
-                "models",
-                "part",
-                "pipe",
-                "ropebridge",
-                "runes",
-                "solid_block",
-                "spell_effect",
-                "spell_projectile"
-        };
-    }
-
-    private static JsonElement parseStream(InputStream stream) {
-        JsonParser parser = new JsonParser();
-        JsonReader jsonReader = new JsonReader(new InputStreamReader(stream, StandardCharsets.UTF_8));
-        jsonReader.setLenient(true);
-        return parser.parse(jsonReader);
-    }
-
-    private static void gatherAdditionalViaManualScan(List<PackResources> untrustedPacks, Set<ResourceLocation> knownLocations,
-                                               Collection<ResourceLocation> uncertainLocations, String filePrefix) {
-        if(untrustedPacks.size() > 0) {
-            /* Now make a fallback resource manager and use it on the remaining packs to see if they actually contain these files */
-            FallbackResourceManager frm = new FallbackResourceManager(PackType.CLIENT_RESOURCES, "dummy");
-            for (int i = untrustedPacks.size() - 1; i >= 0; i--) {
-                frm.add(untrustedPacks.get(i));
-            }
-            for (ResourceLocation blockstate : uncertainLocations) {
-                if (knownLocations.contains(blockstate))
-                    continue; // don't check ones we know exist
-                ResourceLocation fileLocation = new ResourceLocation(blockstate.getNamespace(), filePrefix + blockstate.getPath() + ".json");
-                try (Resource resource = frm.getResource(fileLocation)) {
-                    knownLocations.add(blockstate);
-                } catch (IOException | RuntimeException ignored) {
-                }
-            }
-        }
-    }
-
-    private static final int ERROR_THRESHOLD = 200;
-
-    private static void logOrSuppressError(Object2IntOpenHashMap<String> suppressionMap, String type, ResourceLocation location, Throwable e) {
-        int numErrors;
-        synchronized (suppressionMap) {
-            numErrors = suppressionMap.computeInt(location.getNamespace(), (k, oldVal) -> (oldVal == null ? 1 : oldVal + 1));
-        }
-        if(numErrors <= ERROR_THRESHOLD)
-            ModernFix.LOGGER.error("Error reading {} {}: {}", type, location, e);
-    }
-
-    /**
-     * Some mods (cough, EBE) inject their custom resource pack into the namespaced resource managers, but not into the
-     * main list contained inside the parent resource manager, so we need to scan each of the namespaced managers as
-     * well.
-     */
-    private static void checkFallbacks(SimpleReloadableResourceManager manager, List<PackResources> resourcePackList) {
-        ReferenceSet<PackResources> knownPacks = new ReferenceOpenHashSet<>(resourcePackList);
-        Map<String, FallbackResourceManager> namespacedMap = manager.namespacedPacks;
-        namespacedMap.values().stream().flatMap(FallbackResourceManager::listPacks).forEach(pack -> {
-            if(knownPacks.add(pack)) {
-                /* the pack was not previously known, add to our list */
-                ModernFix.LOGGER.debug("Injecting unlisted pack '{}': {}", pack.getName(), pack.getClass().getName());
-                resourcePackList.add(pack);
-            }
-        });
-    }
-
-    public static void gatherModelMaterials(ResourceManager manager, Predicate<PackResources> isTrustedPack,
-                                            Set<Material> materialSet, Set<ResourceLocation> blockStateFiles,
-                                            Set<ResourceLocation> modelFiles, UnbakedModel missingModel,
-                                            Function<JsonElement, BlockModel> modelDeserializer,
-                                            Function<ResourceLocation, UnbakedModel> bakeryModelGetter) {
-        if(!ModernFixPlatformHooks.INSTANCE.isLoadingNormally())
-            return;
-        Stopwatch stopwatch = Stopwatch.createStarted();
-        final Object2IntOpenHashMap<String> blockstateErrors = new Object2IntOpenHashMap<>();
-        /*
-         * First, gather all vanilla packs, and use listResources on them. This will allow us to (hopefully) avoid
-         * scanning most packs a lot.
-         */
-        List<PackResources> allPackResources = new ArrayList<>(manager.listPacks().collect(Collectors.toList()));
-        if(manager instanceof SimpleReloadableResourceManager) {
-            checkFallbacks((SimpleReloadableResourceManager)manager, allPackResources);
-        }
-        Collections.reverse(allPackResources);
-        ObjectOpenHashSet<ResourceLocation> allAvailableModels = new ObjectOpenHashSet<>(), allAvailableStates = new ObjectOpenHashSet<>();
-        /* try to fix CME in some runtime packs by forcing generation */
-        for(PackResources pack : allPackResources) {
-            try(InputStream stream = pack.getResource(PackType.CLIENT_RESOURCES, new ResourceLocation("modernfix", "dummy.json"))) {
-            } catch(Exception ignored) {
-            }
-        }
-        allPackResources.removeIf(pack -> {
-            for(String namespace : pack.getNamespaces(PackType.CLIENT_RESOURCES)) {
-                Collection<ResourceLocation> allBlockstates = pack.getResources(PackType.CLIENT_RESOURCES, namespace, "blockstates", Integer.MAX_VALUE, p -> p.endsWith(".json"));
-                for(ResourceLocation blockstate : allBlockstates) {
-                    allAvailableStates.add(new ResourceLocation(blockstate.getNamespace(), blockstate.getPath().replaceFirst("blockstates/", "").replace(".json", "")));
-                }
-                Collection<ResourceLocation> allModels = pack.getResources(PackType.CLIENT_RESOURCES, namespace, "models", Integer.MAX_VALUE, p -> p.endsWith(".json"));
-                for(ResourceLocation blockstate : allModels) {
-                    allAvailableModels.add(new ResourceLocation(blockstate.getNamespace(), blockstate.getPath().replaceFirst("models/", "").replace(".json", "")));
-                }
-            }
-            if(!isTrustedPack.test(pack)) {
-                ModernFix.LOGGER.debug("Pack with class {} needs manual scan", pack.getClass().getName());
-                return false;
-            }
-            return true;
-        });
-
-        gatherAdditionalViaManualScan(allPackResources, allAvailableStates, blockStateFiles, "blockstates/");
-        // We now have a list of all blockstates known to exist. Delete anything that we don't have
-        blockStateFiles.retainAll(allAvailableStates);
-        allAvailableStates.clear();
-        allAvailableStates.trim();
-
-        ConcurrentLinkedQueue<Pair<ResourceLocation, JsonElement>> blockStateLoadedFiles = new ConcurrentLinkedQueue<>();
-        List<CompletableFuture<Void>> blockStateData = new ArrayList<>();
-        for(ResourceLocation blockstate : blockStateFiles) {
-            ResourceLocation fileLocation = new ResourceLocation(blockstate.getNamespace(), "blockstates/" + blockstate.getPath() + ".json");
-            List<Resource> resources;
-            try {
-                resources = manager.getResources(fileLocation);
-                if(resources.isEmpty())
-                    continue;
-            } catch(IOException e) {
-                logOrSuppressError(blockstateErrors, "blockstate", blockstate, e);
-                continue;
-            }
-            blockStateData.add(CompletableFuture.runAsync(() -> {
-                try {
-                    for(Resource resource : resources) {
-                        try {
-                            blockStateLoadedFiles.add(Pair.of(blockstate, parseStream(resource.getInputStream())));
-                        } catch(JsonParseException e) {
-                            logOrSuppressError(blockstateErrors, "blockstate", blockstate, e);
-                        } finally {
-                            resource.close();
-                        }
-                    }
-                } catch(IOException e) {
-                    logOrSuppressError(blockstateErrors, "blockstate", blockstate, e);
-                }
-            }, ModernFix.resourceReloadExecutor()));
-        }
-        blockStateFiles = null;
-        CompletableFuture.allOf(blockStateData.toArray(new CompletableFuture[0])).join();
-        for(Pair<ResourceLocation, JsonElement> pair : blockStateLoadedFiles) {
-            if(pair.getSecond() != null) {
-                try {
-                    JsonObject obj = pair.getSecond().getAsJsonObject();
-                    if(obj.has("variants")) {
-                        JsonObject eachVariant = obj.getAsJsonObject("variants");
-                        for(Map.Entry<String, JsonElement> entry : eachVariant.entrySet()) {
-                            JsonElement variantData = entry.getValue();
-                            List<JsonObject> variantModels;
-                            if(variantData.isJsonArray()) {
-                                variantModels = new ArrayList<>();
-                                for(JsonElement model : variantData.getAsJsonArray()) {
-                                    variantModels.add(model.getAsJsonObject());
-                                }
-                            } else
-                                variantModels = Collections.singletonList(variantData.getAsJsonObject());
-                            for(JsonObject variant : variantModels) {
-                                modelFiles.add(new ResourceLocation(variant.get("model").getAsString()));
-                            }
-                        }
-
-                    } else {
-                        JsonArray multipartData = obj.get("multipart").getAsJsonArray();
-                        for(JsonElement element : multipartData) {
-                            JsonObject self = element.getAsJsonObject();
-                            JsonElement apply = self.get("apply");
-                            List<JsonObject> applyObjects;
-                            if(apply.isJsonArray()) {
-                                applyObjects = new ArrayList<>();
-                                for(JsonElement e : apply.getAsJsonArray()) {
-                                    applyObjects.add(e.getAsJsonObject());
-                                }
-                            } else
-                                applyObjects = Collections.singletonList(apply.getAsJsonObject());
-                            for(JsonObject applyEntry : applyObjects) {
-                                modelFiles.add(new ResourceLocation(applyEntry.get("model").getAsString()));
-                            }
-                        }
-
-                    }
-                } catch(RuntimeException e) {
-                    logOrSuppressError(blockstateErrors, "blockstate", pair.getFirst(), e);
-                }
-
-            }
-        }
-        blockstateErrors.object2IntEntrySet().forEach(entry -> {
-            if(entry.getIntValue() > ERROR_THRESHOLD) {
-                ModernFix.LOGGER.error("Suppressed additional {} blockstate errors for domain {}", entry.getIntValue(), entry.getKey());
-            }
-        });
-        blockstateErrors.clear();
-        blockStateData = null;
-        blockStateLoadedFiles.clear();
-
-        modelFiles.addAll(allAvailableModels);
-        /* figure out which models we should actually load */
-        gatherAdditionalViaManualScan(allPackResources, allAvailableModels, modelFiles, "models/");
-        modelFiles.retainAll(allAvailableModels);
-        allAvailableModels.clear();
-        allAvailableModels.trim();
-
-        Map<ResourceLocation, BlockModel> basicModels = new HashMap<>();
-        basicModels.put(ModelBakery.MISSING_MODEL_LOCATION, (BlockModel)missingModel);
-        basicModels.put(new ResourceLocation("builtin/generated"), GENERATION_MARKER);
-        basicModels.put(new ResourceLocation("builtin/entity"), BLOCK_ENTITY_MARKER);
-        Set<Pair<String, String>> errorSet = Sets.newLinkedHashSet();
-        while(modelFiles.size() > 0) {
-            List<CompletableFuture<Pair<ResourceLocation, JsonElement>>> modelBytes = new ArrayList<>();
-            for(ResourceLocation model : modelFiles) {
-                if(basicModels.containsKey(model))
-                    continue;
-                ResourceLocation fileLocation = new ResourceLocation(model.getNamespace(), "models/" + model.getPath() + ".json");
-                modelBytes.add(CompletableFuture.supplyAsync(() -> {
-                    try(Resource resource = manager.getResource(fileLocation)) {
-                        return Pair.of(model, parseStream(resource.getInputStream()));
-                    } catch(IOException | JsonParseException e) {
-                        logOrSuppressError(blockstateErrors, "model", fileLocation, e);
-                        return Pair.of(fileLocation, null);
-                    }
-                }, ModernFix.resourceReloadExecutor()));
-            }
-            modelFiles.clear();
-            CompletableFuture.allOf(modelBytes.toArray(new CompletableFuture[0])).join();
-            UVController.useDummyUv.set(Boolean.TRUE);
-            for(CompletableFuture<Pair<ResourceLocation, JsonElement>> future : modelBytes) {
-                Pair<ResourceLocation, JsonElement> pair = future.join();
-                try {
-                    if(pair.getSecond() != null) {
-
-                        BlockModel model = modelDeserializer.apply(pair.getSecond());
-                        model.name = pair.getFirst().toString();
-                        modelFiles.addAll(model.getDependencies());
-                        basicModels.put(pair.getFirst(), model);
-                        continue;
-                    }
-                } catch(Throwable e) {
-                    logOrSuppressError(blockstateErrors, "model", pair.getFirst(), e);
-                }
-                basicModels.put(pair.getFirst(), (BlockModel)missingModel);
-            }
-            UVController.useDummyUv.set(Boolean.FALSE);
-        }
-        blockstateErrors.object2IntEntrySet().forEach(entry -> {
-            if(entry.getIntValue() > ERROR_THRESHOLD) {
-                ModernFix.LOGGER.error("Suppressed additional {} model errors for domain {}", entry.getIntValue(), entry.getKey());
-            }
-        });
-        blockstateErrors.clear();
-        modelFiles = null;
-        Function<ResourceLocation, UnbakedModel> modelGetter = loc -> {
-            UnbakedModel m = basicModels.get(loc);
-            /* fallback to vanilla loader if missing */
-            return m != null ? m : bakeryModelGetter.apply(loc);
-        };
-        for(BlockModel model : basicModels.values()) {
-            try {
-                materialSet.addAll(model.getMaterials(modelGetter, errorSet));
-            } catch(Throwable e) {
-                ModernFix.LOGGER.error("Model {} threw error while getting materials", model.name, e);
-            }
-        }
-        //errorSet.stream().filter(pair -> !pair.getSecond().equals(MISSING_MODEL_LOCATION_STRING)).forEach(pair -> LOGGER.warn("Unable to resolve texture reference: {} in {}", pair.getFirst(), pair.getSecond()));
-        stopwatch.stop();
-        ModernFix.LOGGER.info("Resolving model textures took " + stopwatch);
-    }
-
-    private static <T extends Comparable<T>, V extends T> BlockState setPropertyGeneric(BlockState state, Property<T> prop, Object o) {
-        return state.setValue(prop, (V)o);
-    }
-
-    private static <T extends Comparable<T>> T getValueHelper(Property<T> property, String value) {
-        return property.getValue(value).orElse(null);
-    }
-
-    private static final Splitter COMMA_SPLITTER = Splitter.on(',');
-    private static final Splitter EQUAL_SPLITTER = Splitter.on('=').limit(2);
-
-    public static ImmutableList<BlockState> getBlockStatesForMRL(StateDefinition<Block, BlockState> stateDefinition, ModelResourceLocation location) {
-        if(Objects.equals(location.getVariant(), "inventory"))
-            return ImmutableList.of();
-        Set<Property<?>> fixedProperties = new HashSet<>();
-        BlockState fixedState = stateDefinition.any();
-        for(String s : COMMA_SPLITTER.split(location.getVariant())) {
-            Iterator<String> iterator = EQUAL_SPLITTER.split(s).iterator();
-            if (iterator.hasNext()) {
-                String s1 = iterator.next();
-                Property<?> property = stateDefinition.getProperty(s1);
-                if (property != null && iterator.hasNext()) {
-                    String s2 = iterator.next();
-                    Object value = getValueHelper(property, s2);
-                    if (value == null) {
-                        throw new RuntimeException("Unknown value: '" + s2 + "' for blockstate property: '" + s1 + "' " + property.getPossibleValues());
-                    }
-                    fixedState = setPropertyGeneric(fixedState, property, value);
-                    fixedProperties.add(property);
-                } else if (!s1.isEmpty()) {
-                    throw new RuntimeException("Unknown blockstate property: '" + s1 + "'");
-                }
-            }
-        }
-        // check if there is only one possible state
-        if(fixedProperties.size() == stateDefinition.getProperties().size()) {
-            return ImmutableList.of(fixedState);
-        }
-        // generate all possible blockstates from the remaining properties
-        ArrayList<Property<?>> anyProperties = new ArrayList<>(stateDefinition.getProperties());
-        anyProperties.removeAll(fixedProperties);
-        ArrayList<BlockState> finalList = new ArrayList<>();
-        finalList.add(fixedState);
-        for(Property<?> property : anyProperties) {
-            ArrayList<BlockState> newPermutations = new ArrayList<>();
-            for(BlockState state : finalList) {
-                for(Comparable<?> value : property.getPossibleValues()) {
-                    newPermutations.add(setPropertyGeneric(state, property, value));
-                }
-            }
-            finalList = newPermutations;
-        }
-        return ImmutableList.copyOf(finalList);
-    }
-
-    public static ModernFixClientIntegration bakedModelWrapper(BiFunction<ResourceLocation, Pair<UnbakedModel, BakedModel>, BakedModel> consumer) {
-        return new ModernFixClientIntegration() {
-            @Override
-            public BakedModel onBakedModelLoad(ResourceLocation location, UnbakedModel baseModel, BakedModel originalModel, ModelState state, ModelBakery bakery) {
-                return consumer.apply(location, Pair.of(baseModel, originalModel));
-            }
-        };
-    }
-}

common/src/main/java/org/embeddedt/modernfix/dynamicresources/UVController.java

@@ -1,8 +0,0 @@
-package org.embeddedt.modernfix.dynamicresources;
-
-import net.minecraft.client.renderer.block.model.BlockFaceUV;
-
-public class UVController {
-    public static final ThreadLocal<Boolean> useDummyUv = ThreadLocal.withInitial(() -> Boolean.FALSE);
-    public static final BlockFaceUV dummyUv = new BlockFaceUV(new float[4], 0);
-}

common/src/main/java/org/embeddedt/modernfix/entity/EntityDataIDSyncHandler.java

@@ -1,57 +0,0 @@
-package org.embeddedt.modernfix.entity;
-
-import com.mojang.datafixers.util.Pair;
-import net.minecraft.network.syncher.EntityDataAccessor;
-import net.minecraft.network.syncher.SynchedEntityData;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.entity.Entity;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.packet.EntityIDSyncPacket;
-import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public class EntityDataIDSyncHandler {
-    private static Map<Class<? extends Entity>, List<Pair<String, Integer>>> fieldsToSyncMap;
-
-    @SuppressWarnings("unchecked")
-    public static void onDatapackSyncEvent(ServerPlayer targetPlayer) {
-        if(targetPlayer != null) {
-            /* Compute the current set of serializer IDs in use and send them */
-            if(fieldsToSyncMap == null) {
-                fieldsToSyncMap = new HashMap<>();
-                Map<Class<? extends Entity>, Integer> entityPoolMap = SynchedEntityData.ENTITY_ID_POOL;
-                List<Field> fieldsToSync = new ArrayList<>();
-                for(Class<? extends Entity> eClass : entityPoolMap.keySet()) {
-                    fieldsToSync.clear();
-                    try {
-                        Field[] classFields = eClass.getDeclaredFields();
-                        for(Field field : classFields) {
-                            if(!Modifier.isStatic(field.getModifiers()))
-                                continue;
-                            field.setAccessible(true);
-                            Object o = field.get(null);
-                            if(o != null && EntityDataAccessor.class.isAssignableFrom(o.getClass())) {
-                                fieldsToSync.add(field);
-                            }
-                        }
-                        for(Field field : fieldsToSync) {
-                            int id = ((EntityDataAccessor<?>)field.get(null)).id;
-                            fieldsToSyncMap.computeIfAbsent(eClass, k -> new ArrayList<>()).add(Pair.of(field.getName(), id));
-                        }
-                    } catch(Throwable e) {
-                        ModernFix.LOGGER.error("Skipping entity ID sync for {}: {}", eClass.getName(), e);
-                    }
-                }
-            }
-            EntityIDSyncPacket packet = new EntityIDSyncPacket(fieldsToSyncMap);
-            ModernFix.LOGGER.debug("Sending ID correction packet to client with " + fieldsToSyncMap.size() + " classes");
-            ModernFixPlatformHooks.INSTANCE.sendPacket(targetPlayer, packet);
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/jei/async/IAsyncJeiStarter.java

@@ -1,8 +0,0 @@
-package org.embeddedt.modernfix.jei.async;
-
-public interface IAsyncJeiStarter {
-    static void checkForLoadInterruption() {
-        if(((JEIReloadThread)Thread.currentThread()).isStopRequested())
-            throw new JEILoadingInterruptedException();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/jei/async/JEILoadingInterruptedException.java

@@ -1,4 +0,0 @@
-package org.embeddedt.modernfix.jei.async;
-
-public class JEILoadingInterruptedException extends Error {
-}

common/src/main/java/org/embeddedt/modernfix/jei/async/JEIReloadThread.java

@@ -1,18 +0,0 @@
-package org.embeddedt.modernfix.jei.async;
-
-public class JEIReloadThread extends Thread {
-    private volatile boolean stopRequested;
-
-    public JEIReloadThread(Runnable runnable, String s) {
-        super(runnable, s);
-        this.stopRequested = false;
-    }
-
-    public void requestStop() {
-        stopRequested = true;
-    }
-
-    public boolean isStopRequested() {
-        return stopRequested;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/packet/EntityIDSyncPacket.java

@@ -1,78 +0,0 @@
-package org.embeddedt.modernfix.packet;
-
-import com.mojang.datafixers.util.Pair;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.syncher.EntityDataAccessor;
-import net.minecraft.world.entity.Entity;
-import org.embeddedt.modernfix.ModernFix;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.*;
-
-public class EntityIDSyncPacket {
-    private Map<Class<? extends Entity>, List<Pair<String, Integer>>> map;
-
-    public EntityIDSyncPacket(Map<Class<? extends Entity>, List<Pair<String, Integer>>> map) {
-        this.map = map;
-    }
-
-    public Map<Class<? extends Entity>, List<Pair<String, Integer>>> getFieldInfo() {
-        return this.map;
-    }
-
-    public EntityIDSyncPacket() {
-        this.map = new HashMap<>();
-    }
-
-    public void serialize(FriendlyByteBuf buf) {
-        buf.writeVarInt(map.keySet().size());
-        for(Map.Entry<Class<? extends Entity>, List<Pair<String, Integer>>> entry : map.entrySet()) {
-            buf.writeUtf(entry.getKey().getName());
-            buf.writeVarInt(entry.getValue().size());
-            for(Pair<String, Integer> field : entry.getValue()) {
-                buf.writeUtf(field.getFirst());
-                buf.writeVarInt(field.getSecond());
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    public static EntityIDSyncPacket deserialize(FriendlyByteBuf buf) {
-        EntityIDSyncPacket self = new EntityIDSyncPacket();
-        int numEntityClasses = buf.readVarInt();
-        for(int i = 0; i < numEntityClasses; i++) {
-            String clzName = buf.readUtf();
-            try {
-                Class<?> clz;
-                try {
-                    clz = Class.forName(clzName);
-                } catch(ClassNotFoundException e) {
-                    ModernFix.LOGGER.warn("Entity class not found: {}", clzName);
-                    break;
-                }
-                if(!Entity.class.isAssignableFrom(clz)) {
-                    ModernFix.LOGGER.error("Not an entity: " + clzName);
-                    break;
-                }
-                int numFields = buf.readVarInt();
-                for(int j = 0; j < numFields; j++) {
-                    String fieldName = buf.readUtf();
-                    int id = buf.readVarInt();
-                    Field f = clz.getDeclaredField(fieldName);
-                    if(!Modifier.isStatic(f.getModifiers()))
-                        continue;
-                    f.setAccessible(true);
-                    if(!EntityDataAccessor.class.isAssignableFrom(f.get(null).getClass())) {
-                        ModernFix.LOGGER.error("Not a data accessor field: " + clz + "." + fieldName);
-                        continue;
-                    }
-                    self.map.computeIfAbsent((Class<? extends Entity>)clz, k -> new ArrayList<>()).add(Pair.of(fieldName, id));
-                }
-            } catch(ReflectiveOperationException e) {
-                ModernFix.LOGGER.error("Error deserializing packet", e);
-            }
-        }
-        return self;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/resources/CachedResourcePath.java

@@ -1,108 +0,0 @@
-package org.embeddedt.modernfix.resources;
-
-import com.google.common.base.Splitter;
-import com.google.common.collect.Interner;
-import com.google.common.collect.Interners;
-import org.embeddedt.modernfix.util.FileUtil;
-
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collection;
-
-public class CachedResourcePath {
-    private final String[] pathComponents;
-
-    public static final Interner<String> PATH_COMPONENT_INTERNER = Interners.newStrongInterner();
-    private static final Splitter SLASH_SPLITTER = Splitter.on('/');
-    public static final String[] NO_PREFIX = new String[0];
-
-    public CachedResourcePath(String[] prefix, Path path) {
-        this(prefix, path, path.getNameCount(), true);
-    }
-
-    public CachedResourcePath(String s) {
-        // normalize so we can guarantee there are no empty sections
-        this(NO_PREFIX, SLASH_SPLITTER.splitToList(FileUtil.normalize(s)), false);
-    }
-
-    public <T> CachedResourcePath(String[] prefixElements, Collection<T> collection, boolean intern) {
-        this(prefixElements, collection, collection.size(), intern);
-    }
-
-    public <T> CachedResourcePath(String[] prefixElements, Iterable<T> path, int count, boolean intern) {
-        String[] components = new String[prefixElements.length + count];
-        int i = 0;
-        while(i < prefixElements.length) {
-            components[i] = intern ? PATH_COMPONENT_INTERNER.intern(prefixElements[i]) : prefixElements[i];
-            i++;
-        }
-        for(Object component : path) {
-            String s = component.toString();
-            if(s.length() == 0)
-                continue;
-            components[i] = intern ? PATH_COMPONENT_INTERNER.intern(s) : s;
-            i++;
-        }
-        pathComponents = components;
-    }
-
-    public CachedResourcePath(String[] prefixElements, CachedResourcePath other) {
-        String[] components = new String[prefixElements.length + other.pathComponents.length];
-        int i = 0;
-        while(i < prefixElements.length) {
-            components[i] = PATH_COMPONENT_INTERNER.intern(prefixElements[i]);
-            i++;
-        }
-        System.arraycopy(other.pathComponents, 0, components, i, other.pathComponents.length);
-        pathComponents = components;
-    }
-
-    /**
-     * DOES NOT INTERN!
-     */
-    public CachedResourcePath(String[] pathComponents) {
-        for(String s : pathComponents) {
-            if(s.length() == 0) {
-                // reconstruct the whole array skipping blanks. inefficient, but should not be the common case
-                pathComponents = Arrays.stream(pathComponents).filter(comp -> comp.length() > 0).toArray(String[]::new);
-                break;
-            }
-        }
-        this.pathComponents = pathComponents;
-    }
-
-    @Override
-    public int hashCode() {
-        return Arrays.hashCode(pathComponents);
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        CachedResourcePath that = (CachedResourcePath) o;
-        return Arrays.equals(pathComponents, that.pathComponents);
-    }
-
-    public String getFileName() {
-        return pathComponents[pathComponents.length - 1];
-    }
-
-    public int getNameCount() {
-        return pathComponents.length;
-    }
-
-    public String getNameAt(int i) {
-        return pathComponents[i];
-    }
-
-    public String getFullPath(int startIndex) {
-        StringBuilder sb = new StringBuilder();
-        for(int i = startIndex; i < pathComponents.length; i++) {
-            sb.append(pathComponents[i]);
-            if(i != (pathComponents.length - 1))
-                sb.append('/');
-        }
-        return sb.toString();
-    }
-}

common/src/main/java/org/embeddedt/modernfix/resources/PackResourcesCacheEngine.java

@@ -1,184 +0,0 @@
-package org.embeddedt.modernfix.resources;
-
-import com.google.common.base.Joiner;
-import com.google.common.base.Stopwatch;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.mojang.datafixers.util.Pair;
-import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.PackType;
-import org.embeddedt.modernfix.ModernFix;
-import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
-import org.embeddedt.modernfix.util.PackTypeHelper;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.*;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-/**
- * The core of the resource pack cache system.
- *
- * Using a dedicated set and also separate lists is important; testing without this showed a huge performance
- * drop.
- */
-public class PackResourcesCacheEngine {
-    private static final Joiner SLASH_JOINER = Joiner.on('/');
-
-    private final Map<PackType, Set<String>> namespacesByType;
-    private final Set<CachedResourcePath> containedPaths;
-    private final EnumMap<PackType, Map<String, List<CachedResourcePath>>> resourceListings;
-    private volatile boolean cacheGenerationFlag = false;
-    private List<Runnable> cacheGenerationTasks = new ArrayList<>();
-    private Path debugPath;
-
-    public PackResourcesCacheEngine(Function<PackType, Set<String>> namespacesRetriever, BiFunction<PackType, String, Path> basePathRetriever) {
-        this.namespacesByType = new EnumMap<>(PackType.class);
-        for(PackType type : PackType.values()) {
-            if(!PackTypeHelper.isVanillaPackType(type))
-                continue;
-            this.namespacesByType.put(type, namespacesRetriever.apply(type));
-        }
-        this.containedPaths = new ObjectOpenHashSet<>();
-        this.resourceListings = new EnumMap<>(PackType.class);
-        // used for log message
-        this.debugPath = basePathRetriever.apply(PackType.CLIENT_RESOURCES, "minecraft").toAbsolutePath();
-        for(PackType type : PackType.values()) {
-            Collection<String> namespaces = PackTypeHelper.isVanillaPackType(type) ? this.namespacesByType.get(type) : namespacesRetriever.apply(type);
-            Collection<Pair<String, Path>> namespacedRoots = namespaces.stream().map(s -> Pair.of(s, basePathRetriever.apply(type, s).toAbsolutePath())).collect(Collectors.toList());
-            cacheGenerationTasks.add(() -> {
-                ImmutableMap.Builder<String, List<CachedResourcePath>> packTypedMap = ImmutableMap.builder();
-                for(Pair<String, Path> pair : namespacedRoots) {
-                    try {
-                        ImmutableList.Builder<CachedResourcePath> namespacedList = ImmutableList.builder();
-                        String namespace = pair.getFirst();
-                        Path root = pair.getSecond();
-                        String[] prefix = new String[] { type.getDirectory(), namespace };
-                        try (Stream<Path> stream = Files.walk(root)) {
-                            stream
-                                    .map(path -> root.relativize(path.toAbsolutePath()))
-                                    .filter(PackResourcesCacheEngine::isValidCachedResourcePath)
-                                    .forEach(path -> {
-                                        CachedResourcePath cachedPath = new CachedResourcePath(prefix, path);
-                                        synchronized (this.containedPaths) {
-                                            this.containedPaths.add(cachedPath);
-                                        }
-                                        if(!cachedPath.getFileName().endsWith(".mcmeta"))
-                                            namespacedList.add(cachedPath);
-                                    });
-                        }
-                        packTypedMap.put(namespace, namespacedList.build());
-                    } catch(IOException ignored) {
-                    }
-                }
-                synchronized (this.resourceListings) {
-                    this.resourceListings.put(type, packTypedMap.build());
-                }
-            });
-        }
-        cacheGenerationTasks.add(() -> {
-            ((ObjectOpenHashSet<CachedResourcePath>)this.containedPaths).trim();
-        });
-    }
-
-    private static boolean isValidCachedResourcePath(Path path) {
-        if(path.getFileName() == null || path.getNameCount() == 0) {
-            return false;
-        }
-        String str = SLASH_JOINER.join(path);
-        if(str.length() == 0)
-            return false;
-        for(int i = 0; i < str.length(); i++) {
-            if(!ResourceLocation.validPathChar(str.charAt(i))) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    public Set<String> getNamespaces(PackType type) {
-        if(PackTypeHelper.isVanillaPackType(type))
-            return this.namespacesByType.get(type);
-        else
-            return null;
-    }
-
-    private void doGenerateCache() {
-        Stopwatch watch = Stopwatch.createStarted();
-        for(Runnable r : this.cacheGenerationTasks) {
-            r.run();
-        }
-        watch.stop();
-        ModernFix.LOGGER.debug("Generated cache for {} in {}", debugPath, watch);
-        debugPath = null;
-        cacheGenerationTasks = ImmutableList.of();
-    }
-
-    private void awaitLoad() {
-        if(!this.cacheGenerationFlag) {
-            synchronized (this) {
-                if(!this.cacheGenerationFlag) {
-                    this.doGenerateCache();
-                    this.cacheGenerationFlag = true;
-                }
-            }
-        }
-    }
-
-    public boolean hasResource(String path) {
-        awaitLoad();
-        return this.containedPaths.contains(new CachedResourcePath(path));
-    }
-
-    public boolean hasResource(String[] paths) {
-        awaitLoad();
-        return this.containedPaths.contains(new CachedResourcePath(paths));
-    }
-
-    public Collection<ResourceLocation> getResources(PackType type, String resourceNamespace, String pathIn, int maxDepth, Predicate<String> filter) {
-        if(!PackTypeHelper.isVanillaPackType(type))
-            throw new IllegalArgumentException("Only vanilla PackTypes are supported");
-        awaitLoad();
-        List<CachedResourcePath> paths = resourceListings.get(type).getOrDefault(resourceNamespace, Collections.emptyList());
-        if(paths.isEmpty())
-            return Collections.emptyList();
-        String testPath = pathIn.endsWith("/") ? pathIn : (pathIn + "/");
-        ArrayList<ResourceLocation> resources = new ArrayList<>();
-        for(CachedResourcePath cachePath : paths) {
-            if((cachePath.getNameCount() - 2) > maxDepth)
-                continue;
-            String fullPath = cachePath.getFullPath(2);
-            if(!fullPath.startsWith(testPath))
-                continue;
-            if(!filter.test(cachePath.getFileName()))
-                continue;
-            ResourceLocation foundResource = new ResourceLocation(resourceNamespace, fullPath);
-            resources.add(foundResource);
-        }
-        return resources;
-    }
-
-    private static final WeakHashMap<ICachingResourcePack, Boolean> cachingPacks = new WeakHashMap<>();
-    public static void track(ICachingResourcePack pack) {
-        synchronized (cachingPacks) {
-            cachingPacks.put(pack, Boolean.TRUE);
-        }
-    }
-
-    public static void invalidate() {
-        if(!ModernFixPlatformHooks.INSTANCE.isDevEnv())
-            return;
-        synchronized (cachingPacks) {
-            cachingPacks.keySet().forEach(pack -> {
-                if(pack != null)
-                    pack.invalidateCache();
-            });
-        }
-    }
-}

common/src/main/java/org/embeddedt/modernfix/screen/ModernFixConfigScreen.java

@@ -1,60 +0,0 @@
-package org.embeddedt.modernfix.screen;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.Util;
-import net.minecraft.client.gui.components.Button;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.network.chat.*;
-import org.jetbrains.annotations.Nullable;
-
-public class ModernFixConfigScreen extends Screen {
-    private OptionList optionList;
-    private Screen lastScreen;
-
-    public boolean madeChanges = false;
-    private Button doneButton, wikiButton;
-    private double lastScrollAmount = 0;
-
-    public ModernFixConfigScreen(Screen lastScreen) {
-        super(new TranslatableComponent("modernfix.config"));
-        this.lastScreen = lastScreen;
-    }
-
-    @Override
-    protected void init() {
-        this.optionList = new OptionList(this, this.minecraft);
-        this.optionList.setScrollAmount(lastScrollAmount);
-        this.children.add(this.optionList);
-        this.wikiButton = new Button(this.width / 2 - 155, this.height - 29, 150, 20, new TranslatableComponent("modernfix.config.wiki"), (arg) -> {
-            Util.getPlatform().openUri("https://github.com/embeddedt/ModernFix/wiki/Summary-of-Patches");
-        });
-        this.doneButton = new Button(this.width / 2 - 155 + 160, this.height - 29, 150, 20, CommonComponents.GUI_DONE, (arg) -> {
-            this.onClose();
-        });
-        this.addButton(this.wikiButton);
-        this.addButton(this.doneButton);
-    }
-
-    @Override
-    public void onClose() {
-        this.minecraft.setScreen(lastScreen);
-    }
-
-    @Override
-    public void render(PoseStack poseStack, int mouseX, int mouseY, float partialTicks) {
-        this.renderBackground(poseStack);
-        this.optionList.render(poseStack, mouseX, mouseY, partialTicks);
-        drawCenteredString(poseStack, this.font, this.title, this.width / 2, 8, 16777215);
-        this.doneButton.setMessage(madeChanges ? new TranslatableComponent("modernfix.config.done_restart") : CommonComponents.GUI_DONE);
-        super.render(poseStack, mouseX, mouseY, partialTicks);
-    }
-
-    @Override
-    public void renderComponentHoverEffect(PoseStack matrixStack, @Nullable Style style, int mouseX, int mouseY) {
-        super.renderComponentHoverEffect(matrixStack, style, mouseX, mouseY);
-    }
-
-    public void setLastScrollAmount(double d) {
-        this.lastScrollAmount = d;
-    }
-}

common/src/main/java/org/embeddedt/modernfix/screen/ModernFixOptionInfoScreen.java

@@ -1,51 +0,0 @@
-package org.embeddedt.modernfix.screen;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.gui.Font;
-import net.minecraft.client.gui.components.Button;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.network.chat.CommonComponents;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.TextComponent;
-import net.minecraft.network.chat.TranslatableComponent;
-import net.minecraft.util.FormattedCharSequence;
-
-public class ModernFixOptionInfoScreen extends Screen {
-    private final Screen lastScreen;
-    private final Component description;
-
-    public ModernFixOptionInfoScreen(Screen lastScreen, String optionName) {
-        super(new TextComponent(optionName));
-
-        this.lastScreen = lastScreen;
-        this.description = new TranslatableComponent("modernfix.option." + optionName);
-    }
-
-    @Override
-    protected void init() {
-        super.init();
-        this.addButton(new Button(this.width / 2 - 100, this.height - 29, 200, 20, CommonComponents.GUI_DONE, (button) -> {
-            this.onClose();
-        }));
-    }
-
-    @Override
-    public void onClose() {
-        this.minecraft.setScreen(lastScreen);
-    }
-
-    private void drawMultilineString(PoseStack mStack, Font fr, Component str, int x, int y) {
-        for(FormattedCharSequence s : fr.split(str, this.width - 50)) {
-            fr.drawShadow(mStack, s, (float)x, (float)y, 16777215);
-            y += fr.lineHeight;
-        }
-    }
-
-    @Override
-    public void render(PoseStack poseStack, int mouseX, int mouseY, float partialTicks) {
-        this.renderBackground(poseStack);
-        drawCenteredString(poseStack, this.font, this.title, this.width / 2, 8, 16777215);
-        this.drawMultilineString(poseStack, this.minecraft.font, description, 10, 50);
-        super.render(poseStack, mouseX, mouseY, partialTicks);
-    }
-}

common/src/main/java/org/embeddedt/modernfix/searchtree/DummySearchTree.java

@@ -1,37 +0,0 @@
-package org.embeddedt.modernfix.searchtree;
-
-import net.minecraft.client.searchtree.MutableSearchTree;
-import net.minecraft.client.searchtree.ReloadableIdSearchTree;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Stream;
-
-/**
- * Dummy search tree that stores nothing and returns nothing on searches.
- */
-public class DummySearchTree<T> extends ReloadableIdSearchTree<T> implements MutableSearchTree<T> {
-    public DummySearchTree() {
-        super(t -> Stream.empty());
-    }
-
-    @Override
-    public void add(T pObj) {
-
-    }
-
-    @Override
-    public void clear() {
-
-    }
-
-    @Override
-    public void refresh() {
-
-    }
-
-    @Override
-    public List<T> search(String pSearchText) {
-        return Collections.emptyList();
-    }
-}