Incomplete Nalim Impl

# Conflicts:
#	src/main/java/ac/grim/grimac/predictionengine/MovementCheckRunner.java
#	src/main/java/ac/grim/grimac/predictionengine/predictions/PredictionEngine.java
#	src/main/java/ac/grim/grimac/utils/nmsutil/JumpPower.java

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '30 15 * * 2'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'java' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
+          # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+      # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+      # If this step fails, then you should remove it and run the build manually (see below)
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v3
+
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 https://git.io/JvXDl
+
+      # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+      #    and modify them (or add more) to build your code if your project
+      #    uses a compiled language
+
+      #- run: |
+      #   make bootstrap
+      #   make release
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3

.github/workflows/gradle-publish.yml

@@ -0,0 +1,38 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will build a package using Gradle and then publish it to GitHub packages when a release is created
+# For more information see: https://github.com/actions/setup-java/blob/main/docs/advanced-usage.md#Publishing-using-gradle
+
+name: Gradle Package
+
+on:
+  [push, workflow_dispatch]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up JDK 17
+      uses: actions/setup-java@v4
+      with:
+        java-version: '17'
+        distribution: 'temurin'
+        server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
+        settings-path: ${{ github.workspace }} # location for the settings.xml file
+
+    - name: Build with Gradle
+      uses: gradle/actions/setup-gradle@v3
+      with:
+        arguments: build
+    - name: Upload a Build Artifact
+      uses: actions/upload-artifact@v4
+      with:
+        path: /home/runner/work/Grim/Grim/build/libs/**.jar

.github/workflows/gradle.yml

@@ -1,95 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
-
-name: Java CI with Gradle
-
-on:
-  push:
-    branches: [ "2.0" ]
-  pull_request:
-    branches: [ "2.0" ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          java-version: '21'
-          distribution: 'temurin'
-
-      # Configure Gradle for optimal use in GitHub Actions, including caching of downloaded dependencies.
-      # See: https://github.com/gradle/actions/blob/main/setup-gradle/README.md
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@dbbdc275be76ac10734476cc723d82dfe7ec6eda
-
-      - name: Build with Gradle Wrapper
-        run: ./gradlew build
-
-      - name: Get current datetime
-        id: datetime
-        run: echo "datetime=$(date +'%Y-%m-%d-%H%M%S')" >> $GITHUB_OUTPUT
-
-      - name: Delete previous dev release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          previous_release_id=$(curl -s -H "Authorization: token $GITHUB_TOKEN" \
-            "https://api.github.com/repos/${{ github.repository }}/releases/tags/dev" | jq -r .id)
-          if [ "$previous_release_id" != "null" ]; then
-            curl -X DELETE -H "Authorization: token $GITHUB_TOKEN" \
-              "https://api.github.com/repos/${{ github.repository }}/releases/$previous_release_id"
-            git push --delete origin dev || true
-          fi
-      - name: Create new dev release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: dev
-          release_name: Dev Build ${{ steps.datetime.outputs.datetime }}
-          body: |
-            This is an automated dev build of the master branch.
-            Build date: ${{ steps.datetime.outputs.datetime }}
-          draft: false
-          prerelease: true
-
-      - name: Find JAR file
-        id: find_jar
-        run: |
-          JAR_PATH=$(find ./build/libs -name "*.jar" | head -n 1)
-          echo "jar_path=$JAR_PATH" >> $GITHUB_OUTPUT
-          echo "jar_name=$(basename $JAR_PATH)" >> $GITHUB_OUTPUT
-      - name: Upload artifact
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ${{ steps.find_jar.outputs.jar_path }}
-          asset_name: GrimAC-${{ steps.datetime.outputs.datetime }}-dev.jar
-          asset_content_type: application/java-archive
-
-  dependency-submission:
-
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          java-version: '21'
-          distribution: 'temurin'

README.md

@@ -7,7 +7,7 @@ GrimAC is an open source Minecraft anticheat designed for 1.21 and supports 1.8-
 ### Compiling through terminal/command prompt
 1. git clone https://github.com/GrimAnticheat/Grim.git (or click the green code button, download ZIP, then unzip it.)
 2. cd Grim
-3. gradlew build
+3. ./gradlew build
 4. The final jar is located in build/libs
 
 ### API Information

build.gradle.kts

@@ -6,13 +6,39 @@ plugins {
     id("com.github.johnrengelman.shadow") version "8.1.1"
     id("io.freefair.lombok") version "8.6"
     id("net.minecrell.plugin-yml.bukkit") version "0.6.0"
+    id("com.diffplug.spotless") version "6.25.0"
+}
+
+spotless {
+    java {
+        endWithNewline()
+        indentWithSpaces(4)
+        removeUnusedImports()
+        trimTrailingWhitespace()
+        targetExclude("build/generated/**/*")
+    }
+
+    kotlinGradle {
+        endWithNewline()
+        indentWithSpaces(4)
+        trimTrailingWhitespace()
+    }
 }
 
 group = "ac.grim.grimac"
-version = "2.3.67"
+version = "2.3.68"
 description = "Libre simulation anticheat designed for 1.21 with 1.8-1.21 support, powered by PacketEvents 2.0."
-java.sourceCompatibility = JavaVersion.VERSION_1_8
-java.targetCompatibility = JavaVersion.VERSION_1_8
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(18))
+}
+
+// Set to false for debug builds
+// You cannot live reload classes if the jar relocates dependencies
+// Checks Project properties -> environment variable -> defaults true
+val relocate: Boolean = project.findProperty("relocate")?.toString()?.toBoolean()
+    ?: System.getenv("RELOCATE_JAR")?.toBoolean()
+    ?: true
 
 repositories {
     mavenLocal()
@@ -33,28 +59,43 @@ repositories {
     // FastUtil, Discord-Webhooks
 }
 
+// Add JMH configuration
+configurations {
+    create("jmh")
+    create("jmhAnnotationProcessor")
+}
+
+
 dependencies {
-    implementation("com.github.retrooper:packetevents-spigot:2.5.0-SNAPSHOT")
+    implementation("com.github.retrooper:packetevents-spigot:2.6.1-SNAPSHOT")
     implementation("co.aikar:acf-paper:0.5.1-SNAPSHOT")
     implementation("club.minnced:discord-webhooks:0.8.0") // Newer versions include kotlin-stdlib, which leads to incompatibility with plugins that use Kotlin
-    implementation("it.unimi.dsi:fastutil:8.5.13")
+    implementation("it.unimi.dsi:fastutil:8.5.15")
     implementation("github.scarsz:configuralize:1.4.0")
 
-    implementation("com.github.grimanticheat:grimapi:1193c4fa41")
-    // Used for local testing: implementation("ac.grim.grimac:grimapi:1.0")
+    //implementation("com.github.grimanticheat:grimapi:1193c4fa41")
+    // Used for local testing: implementation("ac.grim.grimac:GRIMAPI:1.0")
+    implementation("com.github.grimanticheat:grimapi:fc5634e444")
 
     implementation("org.jetbrains:annotations:24.1.0")
     compileOnly("org.geysermc.floodgate:api:2.0-SNAPSHOT")
     compileOnly("org.spigotmc:spigot-api:1.18.2-R0.1-SNAPSHOT")
-    compileOnly("com.viaversion:viaversion-api:4.9.4-SNAPSHOT")
+    compileOnly("com.viaversion:viaversion-api:5.0.4-SNAPSHOT")
     //
     compileOnly("io.netty:netty-all:4.1.85.Final")
+
+    // Replace jmhImplementation with the new configuration
+    "jmh"("org.openjdk.jmh:jmh-core:1.37")
+    "jmhAnnotationProcessor"("org.openjdk.jmh:jmh-generator-annprocess:1.37")
+
+    implementation(files("./nalim.jar"))
 }
 
 bukkit {
     name = "GrimAC"
     author = "GrimAC"
     main = "ac.grim.grimac.GrimAC"
+    website = "https://grim.ac/"
     apiVersion = "1.13"
     foliaSupported = true
 
@@ -115,11 +156,22 @@ bukkit {
             description = "Exempt from all checks"
             default = Permission.Default.FALSE
         }
+
+        register("grim.verbose") {
+            description = "Receive verbose alerts for violations. Requires grim.alerts"
+            default = Permission.Default.OP
+        }
+
+        register("grim.verbose.enable-on-join") {
+            description = "Enable verbose alerts on join. Requires grim.alerts and grim.alerts.enable-on-join"
+            default = Permission.Default.FALSE
+        }
     }
 }
 
 tasks.build {
     dependsOn(tasks.shadowJar)
+    dependsOn(tasks.spotlessApply)
 }
 
 tasks.withType<JavaCompile> {
@@ -130,24 +182,169 @@ publishing.publications.create<MavenPublication>("maven") {
     artifact(tasks["shadowJar"])
 }
 
+java {
+    sourceSets {
+        create("java18") {
+            java {
+                srcDirs("src/main/java18")
+            }
+            compileClasspath += main.get().output
+            runtimeClasspath += main.get().output
+            dependencies {
+                implementation(files("./nalim.jar")) // Add nalim.jar to java18 source set
+            }
+        }
+        create("jmh") {
+            java {
+                srcDir("src/jmh/java")
+            }
+            compileClasspath += sourceSets.main.get().output +
+                    sourceSets.getByName("java18").output +
+                    configurations["jmh"]
+            runtimeClasspath += sourceSets.main.get().output +
+                    sourceSets.getByName("java18").output +
+                    configurations["jmh"]
+        }
+    }
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(18))
+    }
+}
+
+tasks.withType<JavaCompile> {
+    if (name == "compileJava") {
+        options.compilerArgs.addAll(listOf("--add-exports","java.base/jdk.internal=ALL-UNNAMED",
+            "--add-exports", "java.base/jdk.internal.vm.annotation=ALL-UNNAMED"))
+    }
+    if (name == "compileJava18Java") {
+        options.compilerArgs.addAll(listOf("--add-modules", "jdk.incubator.vector", "-Xlint:unchecked"))
+        sourceCompatibility = "18"
+        targetCompatibility = "18"
+    }
+    if (name == "compileJava21Java") {
+        options.compilerArgs.addAll(listOf("--enable-preview", "--add-modules", "jdk.incubator.vector", "-Xlint:unchecked"))
+        sourceCompatibility = "21"
+        targetCompatibility = "21"
+    }
+    if (name == "compileJmhJava") {
+        options.compilerArgs.addAll(listOf("--add-modules", "jdk.incubator.vector"))
+        sourceCompatibility = "18"
+        targetCompatibility = "18"
+    }
+}
+
+tasks.withType<Jar> {
+    manifest {
+        attributes("Multi-Release" to "true")
+    }
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE // Important for multi-release JARs
+    from(sourceSets.main.get().output)
+    from(sourceSets.getByName("java18").output) {
+        into("META-INF/versions/18")
+    }
+}
+
 tasks.shadowJar {
     minimize()
     archiveFileName.set("${project.name}-${project.version}.jar")
-    relocate("io.github.retrooper.packetevents", "ac.grim.grimac.shaded.io.github.retrooper.packetevents")
-    relocate("com.github.retrooper.packetevents", "ac.grim.grimac.shaded.com.github.retrooper.packetevents")
-    relocate("co.aikar.commands", "ac.grim.grimac.shaded.acf")
-    relocate("co.aikar.locale", "ac.grim.grimac.shaded.locale")
-    relocate("club.minnced", "ac.grim.grimac.shaded.discord-webhooks")
-    relocate("github.scarsz.configuralize", "ac.grim.grimac.shaded.configuralize")
-    relocate("com.github.puregero", "ac.grim.grimac.shaded.com.github.puregero")
-    relocate("com.google.code.gson", "ac.grim.grimac.shaded.gson")
-    relocate("alexh", "ac.grim.grimac.shaded.maps")
-    relocate("it.unimi.dsi.fastutil", "ac.grim.grimac.shaded.fastutil")
-    relocate("net.kyori", "ac.grim.grimac.shaded.kyori")
-    relocate("okhttp3", "ac.grim.grimac.shaded.okhttp3")
-    relocate("okio", "ac.grim.grimac.shaded.okio")
-    relocate("org.yaml.snakeyaml", "ac.grim.grimac.shaded.snakeyaml")
-    relocate("org.json", "ac.grim.grimac.shaded.json")
-    relocate("org.intellij", "ac.grim.grimac.shaded.intellij")
-    relocate("org.jetbrains", "ac.grim.grimac.shaded.jetbrains")
+    if (relocate) {
+        relocate("io.github.retrooper.packetevents", "ac.grim.grimac.shaded.io.github.retrooper.packetevents")
+        relocate("com.github.retrooper.packetevents", "ac.grim.grimac.shaded.com.github.retrooper.packetevents")
+        relocate("co.aikar.commands", "ac.grim.grimac.shaded.acf")
+        relocate("co.aikar.locale", "ac.grim.grimac.shaded.locale")
+        relocate("club.minnced", "ac.grim.grimac.shaded.discord-webhooks")
+        relocate("github.scarsz.configuralize", "ac.grim.grimac.shaded.configuralize")
+        relocate("com.github.puregero", "ac.grim.grimac.shaded.com.github.puregero")
+        relocate("com.google.code.gson", "ac.grim.grimac.shaded.gson")
+        relocate("alexh", "ac.grim.grimac.shaded.maps")
+        relocate("it.unimi.dsi.fastutil", "ac.grim.grimac.shaded.fastutil")
+        relocate("net.kyori", "ac.grim.grimac.shaded.kyori")
+        relocate("okhttp3", "ac.grim.grimac.shaded.okhttp3")
+        relocate("okio", "ac.grim.grimac.shaded.okio")
+        relocate("org.yaml.snakeyaml", "ac.grim.grimac.shaded.snakeyaml")
+        relocate("org.json", "ac.grim.grimac.shaded.json")
+        relocate("org.intellij", "ac.grim.grimac.shaded.intellij")
+        relocate("org.jetbrains", "ac.grim.grimac.shaded.jetbrains")
+    }
 }
+
+tasks.register<Jar>("jmhJar") {
+    dependsOn("compileGeneratedJmh")
+
+    from(sourceSets["main"].output)
+    from(sourceSets["java18"].output)
+    from(sourceSets["jmh"].output)
+    from("${buildDir}/classes/java/jmh")
+    from(configurations["jmh"].map { if (it.isDirectory) it else zipTree(it) })
+
+    manifest {
+        attributes(
+            "Main-Class" to "org.openjdk.jmh.Main",
+            "Add-Opens" to "java.base/java.lang java.base/java.io java.base/java.util java.base/java.util.concurrent java.base/java.net",
+            "Add-Modules" to "jdk.incubator.vector"
+        )
+    }
+
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    archiveClassifier.set("benchmarks")
+}
+
+
+tasks.register<JavaCompile>("compileGeneratedJmh") {
+    dependsOn("compileJmhJava")
+
+    source = fileTree("${buildDir}/generated-sources/jmh")
+
+    classpath = sourceSets["jmh"].compileClasspath +
+            sourceSets["java18"].output +
+            sourceSets["java18"].compileClasspath +
+            sourceSets.main.get().output +
+            sourceSets.main.get().compileClasspath +
+            files("${buildDir}/classes/java/jmh")
+
+    destinationDirectory.set(file("${buildDir}/classes/java/jmh"))
+
+    sourceCompatibility = "18"
+    targetCompatibility = "18"
+    options.compilerArgs.addAll(listOf("--add-modules", "jdk.incubator.vector"))
+}
+
+tasks.register("jmh") {
+    dependsOn("jmhJar")
+    doLast {
+        val includes = System.getProperty("includes", "")
+
+        javaexec {
+            classpath = files(tasks.named("jmhJar").get().outputs.files)
+            mainClass.set("org.openjdk.jmh.Main")
+            jvmArgs = listOf("--enable-preview", "--add-modules", "jdk.incubator.vector", "-XX:+UnlockExperimentalVMOptions", "-XX:+EnableJVMCI", "-javaagent:nalim.jar")
+
+            // Initialize the args list with default settings
+            args = mutableListOf<String>().apply {
+                // Add any default arguments here if needed
+                if (includes.isNotEmpty()) {
+                    addAll(listOf(includes))
+                }
+            }
+        }
+    }
+}
+
+tasks.named<JavaCompile>("compileJmhJava") {
+    source = fileTree("src/jmh/java")
+    classpath = sourceSets["jmh"].compileClasspath +
+            sourceSets.main.get().output +
+            sourceSets["java18"].output
+    destinationDirectory.set(file("${buildDir}/classes/java/jmh"))
+
+    sourceCompatibility = "18"
+    targetCompatibility = "18"
+    options.compilerArgs.addAll(listOf("--add-modules", "jdk.incubator.vector"))
+}
+
+tasks.named("jmhJar") {
+    dependsOn("compileJmhJava")
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/java18/java/ac/grim/grimac/utils/vector/SIMDVector3D.java

@@ -0,0 +1,148 @@
+package ac.grim.grimac.utils.vector;
+
+import jdk.incubator.vector.*;
+
+public final class SIMDVector3D implements Vector3D {
+
+    private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_256;
+    private static final VectorMask<Double> LENGTH_3_ARRAY_MASK = SPECIES.indexInRange(0, 3);
+    private static final VectorShuffle<Double> CROSS_PRODUCT_SHUFFLE1 = VectorShuffle.fromArray(SPECIES, new int[]{1, 2, 0, 3}, 0);
+    private static final VectorShuffle<Double> CROSS_PRODUCT_SHUFFLE2 = VectorShuffle.fromArray(SPECIES, new int[]{2, 0, 1, 3}, 0);
+    private static final DoubleVector FOURTH_COMPONENT_ZERO = DoubleVector.zero(SPECIES).withLane(3, 1.0);
+
+    private DoubleVector vector;
+
+    public SIMDVector3D(double x, double y, double z) {
+        this.vector = DoubleVector.fromArray(SPECIES, new double[]{x, y, z, 0}, 0, LENGTH_3_ARRAY_MASK);
+    }
+
+    @Override
+    public double getX() {
+        return this.vector.lane(0);
+    }
+
+    @Override
+    public double getY() {
+        return this.vector.lane(1);
+    }
+
+    @Override
+    public double getZ() {
+        return this.vector.lane(2);
+    }
+
+    @Override
+    public Vector3D setX(double x) {
+        this.vector = this.vector.withLane(0, x);
+        return this;
+    }
+
+    @Override
+    public Vector3D setY(double y) {
+        this.vector = this.vector.withLane(1, y);
+        return this;
+    }
+
+    @Override
+    public Vector3D setZ(double z) {
+        this.vector = this.vector.withLane(2, z);
+        return this;
+    }
+
+    @Override
+    public double length() {
+        return Math.sqrt(lengthSquared());
+    }
+
+    @Override
+    public double lengthSquared() {
+        return this.vector.mul(this.vector).reduceLanes(VectorOperators.ADD);
+    }
+
+    @Override
+    public Vector3D multiply(double m) {
+        this.vector = this.vector.mul(m);
+        return this;
+    }
+
+    @Override
+    public Vector3D normalize() {
+//        DoubleVector squared = this.vector.mul(this.vector);
+//        double sum = squared.reduceLanes(VectorOperators.ADD);
+//        double length = Math.sqrt(sum);
+//        this.vector = this.vector.div(length);
+//        return this;
+        this.vector = this.vector.div(length());
+        return this;
+    }
+
+    @Override
+    public Vector3D crossProduct(Vector3D other) {
+        SIMDVector3D o = (SIMDVector3D) other;
+
+        DoubleVector tmp0 = this.vector.rearrange(CROSS_PRODUCT_SHUFFLE1);
+        DoubleVector tmp1 = o.vector.rearrange(CROSS_PRODUCT_SHUFFLE2);
+
+        DoubleVector tmp2 = tmp0.mul(o.vector);
+        DoubleVector tmp3 = tmp0.mul(tmp1);
+
+        DoubleVector tmp4 = tmp2.rearrange(CROSS_PRODUCT_SHUFFLE1);
+
+        this.vector = tmp3.sub(tmp4).blend(FOURTH_COMPONENT_ZERO, LENGTH_3_ARRAY_MASK.not());
+        return this;
+    }
+
+    @Override
+    public Vector3D add(Vector3D o) {
+        this.vector = this.vector.add(((SIMDVector3D) o).vector);
+        return this;
+    }
+
+    @Override
+    public Vector3D subtract(Vector3D o) {
+        this.vector = this.vector.sub(((SIMDVector3D) o).vector);
+        return this;
+    }
+
+    @Override
+    public Vector3D multiply(Vector3D o) {
+        this.vector = this.vector.mul(((SIMDVector3D) o).vector);
+        return this;
+    }
+
+    @Override
+    public double distance(Vector3D o) {
+        return Math.sqrt(distanceSquared(o));
+    }
+
+    @Override
+    public double distanceSquared(Vector3D o) {
+        DoubleVector diff = this.vector.sub(((SIMDVector3D) o).vector);
+        return diff.mul(diff).reduceLanes(VectorOperators.ADD);
+    }
+
+    @Override
+    public double dot(Vector3D o) {
+        return this.vector.mul(((SIMDVector3D) o).vector).reduceLanes(VectorOperators.ADD);
+    }
+
+
+    @Override
+    public Vector3D clone() {
+        // I think this makes a shallow clone if I do it like this?
+//        try {
+//            return (Vector3D) super.clone();
+//        } catch (CloneNotSupportedException e) {
+//            throw new Error(e);
+//        }
+        try {
+            SIMDVector3D cloned = (SIMDVector3D) super.clone();
+            // Create a new DoubleVector with the same values
+            cloned.vector = DoubleVector.fromArray(SPECIES,
+                    new double[]{this.getX(), this.getY(), this.getZ(), 0}, 0);
+            return cloned;
+        } catch (CloneNotSupportedException e) {
+            throw new Error(e);
+        }
+    }
+}

src/java18/java/ac/grim/grimac/utils/vector/VectorOperationsJava18.java

@@ -0,0 +1,10 @@
+package ac.grim.grimac.utils.vector;
+
+
+public class VectorOperationsJava18 implements VectorOperations {
+
+    @Override
+    public Vector3D newVector(double x, double y, double z) {
+        return new SIMDVector3D(x, y, z);
+    }
+}

src/jmh/java/ac/grim/grimac/benchmark/vector/Java21SIMDVector3DBenchmark.java

@@ -0,0 +1,114 @@
+//package ac.grim.grimac.benchmark.vector;
+//
+//import ac.grim.grimac.utils.vector.Java21SIMDVector3D;
+//import org.openjdk.jmh.annotations.*;
+//
+//import java.util.concurrent.TimeUnit;
+//
+//@BenchmarkMode(Mode.AverageTime)
+//@OutputTimeUnit(TimeUnit.NANOSECONDS)
+//@State(Scope.Thread)
+//@Warmup(iterations = 2, time = 1)
+//@Measurement(iterations = 3, time = 1)
+//@Fork(1)
+//public class Java21SIMDVector3DBenchmark {
+//
+//    private Java21SIMDVector3D vector1;
+//    private Java21SIMDVector3D vector2;
+//
+//    @Setup
+//    public void setup() {
+//        vector1 = new Java21SIMDVector3D(1.0, 2.0, 3.0);
+//        vector2 = new Java21SIMDVector3D(4.0, 5.0, 6.0);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkGetX() {
+//        return vector1.getX();
+//    }
+//
+//    @Benchmark
+//    public double benchmarkGetY() {
+//        return vector1.getY();
+//    }
+//
+//    @Benchmark
+//    public double benchmarkGetZ() {
+//        return vector1.getZ();
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkSetX() {
+//        return (Java21SIMDVector3D) vector1.setX(10.0);
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkSetY() {
+//        return (Java21SIMDVector3D) vector1.setY(20.0);
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkSetZ() {
+//        return (Java21SIMDVector3D) vector1.setZ(30.0);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkLength() {
+//        return vector1.length();
+//    }
+//
+//    @Benchmark
+//    public double benchmarkLengthSquared() {
+//        return vector1.lengthSquared();
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkMultiplyScalar() {
+//        return (Java21SIMDVector3D) vector1.multiply(2.0);
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkNormalize() {
+//        return (Java21SIMDVector3D) vector1.normalize();
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkCrossProduct() {
+//        return (Java21SIMDVector3D) vector1.crossProduct(vector2);
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkAdd() {
+//        return (Java21SIMDVector3D) vector1.add(vector2);
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkSubtract() {
+//        return (Java21SIMDVector3D) vector1.subtract(vector2);
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkMultiplyVector() {
+//        return (Java21SIMDVector3D) vector1.multiply(vector2);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkDistance() {
+//        return vector1.distance(vector2);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkDistanceSquared() {
+//        return vector1.distanceSquared(vector2);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkDotProduct() {
+//        return vector1.dot(vector2);
+//    }
+//
+//    @Benchmark
+//    public Java21SIMDVector3D benchmarkClone() {
+//        return (Java21SIMDVector3D) vector1.clone();
+//    }
+//}

src/jmh/java/ac/grim/grimac/benchmark/vector/NalimVector3DBenchmark.java

@@ -0,0 +1,114 @@
+package ac.grim.grimac.benchmark.vector;
+
+import ac.grim.grimac.utils.vector.NalimVector3D;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Thread)
+@Warmup(iterations = 2, time = 1)
+@Measurement(iterations = 3, time = 1)
+@Fork(1)
+public class NalimVector3DBenchmark {
+
+    private NalimVector3D vector1;
+    private NalimVector3D vector2;
+
+    @Setup
+    public void setup() {
+        vector1 = new NalimVector3D(1.0, 2.0, 3.0);
+        vector2 = new NalimVector3D(4.0, 5.0, 6.0);
+    }
+
+    @Benchmark
+    public double benchmarkGetX() {
+        return vector1.getX();
+    }
+
+    @Benchmark
+    public double benchmarkGetY() {
+        return vector1.getY();
+    }
+
+    @Benchmark
+    public double benchmarkGetZ() {
+        return vector1.getZ();
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkSetX() {
+        return (NalimVector3D) vector1.setX(10.0);
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkSetY() {
+        return (NalimVector3D) vector1.setY(20.0);
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkSetZ() {
+        return (NalimVector3D) vector1.setZ(30.0);
+    }
+
+    @Benchmark
+    public double benchmarkLength() {
+        return vector1.length();
+    }
+
+    @Benchmark
+    public double benchmarkLengthSquared() {
+        return vector1.lengthSquared();
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkMultiplyScalar() {
+        return (NalimVector3D) vector1.multiply(2.0);
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkNormalize() {
+        return (NalimVector3D) vector1.normalize();
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkCrossProduct() {
+        return (NalimVector3D) vector1.crossProduct(vector2);
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkAdd() {
+        return (NalimVector3D) vector1.add(vector2);
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkSubtract() {
+        return (NalimVector3D) vector1.subtract(vector2);
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkMultiplyVector() {
+        return (NalimVector3D) vector1.multiply(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDistance() {
+        return vector1.distance(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDistanceSquared() {
+        return vector1.distanceSquared(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDotProduct() {
+        return vector1.dot(vector2);
+    }
+
+    @Benchmark
+    public NalimVector3D benchmarkClone() {
+        return (NalimVector3D) vector1.clone();
+    }
+}

src/jmh/java/ac/grim/grimac/benchmark/vector/NativeVector3DBenchmark.java

@@ -0,0 +1,114 @@
+//package ac.grim.grimac.benchmark.vector;
+//
+//import ac.grim.grimac.utils.vector.NativeVector3D;
+//import org.openjdk.jmh.annotations.*;
+//
+//import java.util.concurrent.TimeUnit;
+//
+//@BenchmarkMode(Mode.AverageTime)
+//@OutputTimeUnit(TimeUnit.NANOSECONDS)
+//@State(Scope.Thread)
+//@Warmup(iterations = 2, time = 1)
+//@Measurement(iterations = 3, time = 1)
+//@Fork(1)
+//public class NativeVector3DBenchmark {
+//
+//    private NativeVector3D vector1;
+//    private NativeVector3D vector2;
+//
+//    @Setup
+//    public void setup() {
+//        vector1 = new NativeVector3D(1.0, 2.0, 3.0);
+//        vector2 = new NativeVector3D(4.0, 5.0, 6.0);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkGetX() {
+//        return vector1.getX();
+//    }
+//
+//    @Benchmark
+//    public double benchmarkGetY() {
+//        return vector1.getY();
+//    }
+//
+//    @Benchmark
+//    public double benchmarkGetZ() {
+//        return vector1.getZ();
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkSetX() {
+//        return (NativeVector3D) vector1.setX(10.0);
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkSetY() {
+//        return (NativeVector3D) vector1.setY(20.0);
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkSetZ() {
+//        return (NativeVector3D) vector1.setZ(30.0);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkLength() {
+//        return vector1.length();
+//    }
+//
+//    @Benchmark
+//    public double benchmarkLengthSquared() {
+//        return vector1.lengthSquared();
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkMultiplyScalar() {
+//        return (NativeVector3D) vector1.multiply(2.0);
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkNormalize() {
+//        return (NativeVector3D) vector1.normalize();
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkCrossProduct() {
+//        return (NativeVector3D) vector1.crossProduct(vector2);
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkAdd() {
+//        return (NativeVector3D) vector1.add(vector2);
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkSubtract() {
+//        return (NativeVector3D) vector1.subtract(vector2);
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkMultiplyVector() {
+//        return (NativeVector3D) vector1.multiply(vector2);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkDistance() {
+//        return vector1.distance(vector2);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkDistanceSquared() {
+//        return vector1.distanceSquared(vector2);
+//    }
+//
+//    @Benchmark
+//    public double benchmarkDotProduct() {
+//        return vector1.dot(vector2);
+//    }
+//
+//    @Benchmark
+//    public NativeVector3D benchmarkClone() {
+//        return (NativeVector3D) vector1.clone();
+//    }
+//}

src/jmh/java/ac/grim/grimac/benchmark/vector/SIMDVector3DBenchmark.java

@@ -0,0 +1,114 @@
+package ac.grim.grimac.benchmark.vector;
+
+import ac.grim.grimac.utils.vector.SIMDVector3D;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Thread)
+@Warmup(iterations = 2, time = 1)
+@Measurement(iterations = 3, time = 1)
+@Fork(1)
+public class SIMDVector3DBenchmark {
+
+    private SIMDVector3D vector1;
+    private SIMDVector3D vector2;
+
+    @Setup
+    public void setup() {
+        vector1 = new SIMDVector3D(1.0, 2.0, 3.0);
+        vector2 = new SIMDVector3D(4.0, 5.0, 6.0);
+    }
+
+    @Benchmark
+    public double benchmarkGetX() {
+        return vector1.getX();
+    }
+
+    @Benchmark
+    public double benchmarkGetY() {
+        return vector1.getY();
+    }
+
+    @Benchmark
+    public double benchmarkGetZ() {
+        return vector1.getZ();
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkSetX() {
+        return (SIMDVector3D) vector1.setX(10.0);
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkSetY() {
+        return (SIMDVector3D) vector1.setY(20.0);
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkSetZ() {
+        return (SIMDVector3D) vector1.setZ(30.0);
+    }
+
+    @Benchmark
+    public double benchmarkLength() {
+        return vector1.length();
+    }
+
+    @Benchmark
+    public double benchmarkLengthSquared() {
+        return vector1.lengthSquared();
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkMultiplyScalar() {
+        return (SIMDVector3D) vector1.multiply(2.0);
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkNormalize() {
+        return (SIMDVector3D) vector1.normalize();
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkCrossProduct() {
+        return (SIMDVector3D) vector1.crossProduct(vector2);
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkAdd() {
+        return (SIMDVector3D) vector1.add(vector2);
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkSubtract() {
+        return (SIMDVector3D) vector1.subtract(vector2);
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkMultiplyVector() {
+        return (SIMDVector3D) vector1.multiply(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDistance() {
+        return vector1.distance(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDistanceSquared() {
+        return vector1.distanceSquared(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDotProduct() {
+        return vector1.dot(vector2);
+    }
+
+    @Benchmark
+    public SIMDVector3D benchmarkClone() {
+        return (SIMDVector3D) vector1.clone();
+    }
+}

src/jmh/java/ac/grim/grimac/benchmark/vector/ScalarVector3DBenchmark.java

@@ -0,0 +1,114 @@
+package ac.grim.grimac.benchmark.vector;
+
+import ac.grim.grimac.utils.vector.ScalarVector3D;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Thread)
+@Warmup(iterations = 2, time = 1)
+@Measurement(iterations = 3, time = 1)
+@Fork(1)
+public class ScalarVector3DBenchmark {
+
+    private ScalarVector3D vector1;
+    private ScalarVector3D vector2;
+
+    @Setup
+    public void setup() {
+        vector1 = new ScalarVector3D(1.0, 2.0, 3.0);
+        vector2 = new ScalarVector3D(4.0, 5.0, 6.0);
+    }
+
+    @Benchmark
+    public double benchmarkGetX() {
+        return vector1.getX();
+    }
+
+    @Benchmark
+    public double benchmarkGetY() {
+        return vector1.getY();
+    }
+
+    @Benchmark
+    public double benchmarkGetZ() {
+        return vector1.getZ();
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkSetX() {
+        return (ScalarVector3D) vector1.setX(10.0);
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkSetY() {
+        return (ScalarVector3D) vector1.setY(20.0);
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkSetZ() {
+        return (ScalarVector3D) vector1.setZ(30.0);
+    }
+
+    @Benchmark
+    public double benchmarkLength() {
+        return vector1.length();
+    }
+
+    @Benchmark
+    public double benchmarkLengthSquared() {
+        return vector1.lengthSquared();
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkMultiplyScalar() {
+        return (ScalarVector3D) vector1.multiply(2.0);
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkNormalize() {
+        return (ScalarVector3D) vector1.normalize();
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkCrossProduct() {
+        return (ScalarVector3D) vector1.crossProduct(vector2);
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkAdd() {
+        return (ScalarVector3D) vector1.add(vector2);
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkSubtract() {
+        return (ScalarVector3D) vector1.subtract(vector2);
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkMultiplyVector() {
+        return (ScalarVector3D) vector1.multiply(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDistance() {
+        return vector1.distance(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDistanceSquared() {
+        return vector1.distanceSquared(vector2);
+    }
+
+    @Benchmark
+    public double benchmarkDotProduct() {
+        return vector1.dot(vector2);
+    }
+
+    @Benchmark
+    public ScalarVector3D benchmarkClone() {
+        return (ScalarVector3D) vector1.clone();
+    }
+}

src/main/java/ac/grim/grimac/GrimAPI.java

@@ -1,17 +1,16 @@
 package ac.grim.grimac;
 
-import ac.grim.grimac.api.GrimAbstractAPI;
 import ac.grim.grimac.manager.*;
+import ac.grim.grimac.manager.config.BaseConfigManager;
 import ac.grim.grimac.utils.anticheat.PlayerDataManager;
 import lombok.Getter;
-import org.bukkit.Bukkit;
-import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;
 
 @Getter
 public enum GrimAPI {
     INSTANCE;
 
+    private final BaseConfigManager configManager = new BaseConfigManager();
     private final AlertManagerImpl alertManager = new AlertManagerImpl();
     private final SpectateManager spectateManager = new SpectateManager();
     private final DiscordManager discordManager = new DiscordManager();
@@ -19,12 +18,10 @@ public enum GrimAPI {
     private final TickManager tickManager = new TickManager();
     private final GrimExternalAPI externalAPI = new GrimExternalAPI(this);
     private InitManager initManager;
-    private ConfigManager configManager;
     private JavaPlugin plugin;
 
     public void load(final JavaPlugin plugin) {
         this.plugin = plugin;
-        this.configManager = new ConfigManager();
         initManager = new InitManager();
         initManager.load();
     }
@@ -32,7 +29,6 @@ public enum GrimAPI {
     public void start(final JavaPlugin plugin) {
         this.plugin = plugin;
         initManager.start();
-        Bukkit.getServicesManager().register(GrimAbstractAPI.class, externalAPI, plugin, ServicePriority.Normal);
     }
 
     public void stop(final JavaPlugin plugin) {

src/main/java/ac/grim/grimac/GrimExternalAPI.java

@@ -1,25 +1,34 @@
 package ac.grim.grimac;
 
-import ac.grim.grimac.api.AbstractCheck;
 import ac.grim.grimac.api.GrimAbstractAPI;
 import ac.grim.grimac.api.GrimUser;
 import ac.grim.grimac.api.alerts.AlertManager;
+import ac.grim.grimac.api.config.ConfigManager;
+import ac.grim.grimac.api.events.GrimReloadEvent;
+import ac.grim.grimac.manager.config.ConfigManagerFileImpl;
 import ac.grim.grimac.manager.init.Initable;
 import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.LogUtil;
+import ac.grim.grimac.utils.common.ConfigReloadObserver;
 import com.github.retrooper.packetevents.netty.channel.ChannelHelper;
 import io.github.retrooper.packetevents.util.SpigotReflectionUtil;
+import io.github.retrooper.packetevents.util.folia.FoliaScheduler;
 import lombok.Getter;
+import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.ServicePriority;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
 //This is used for grim's external API. It has its own class just for organization.
-public class GrimExternalAPI implements GrimAbstractAPI, Initable {
+
+public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, Initable {
 
     private final GrimAPI api;
 
@@ -41,7 +50,8 @@ public class GrimExternalAPI implements GrimAbstractAPI, Initable {
     @Getter
     private final Map<String, Function<GrimUser, String>> variableReplacements = new ConcurrentHashMap<>();
 
-    @Getter private final Map<String, String> staticReplacements = new ConcurrentHashMap<>();
+    @Getter
+    private final Map<String, String> staticReplacements = new ConcurrentHashMap<>();
 
     public String replaceVariables(GrimUser user, String content, boolean colors) {
         if (colors) content = ChatColor.translateAlternateColorCodes('&', content);
@@ -56,12 +66,20 @@ public class GrimExternalAPI implements GrimAbstractAPI, Initable {
 
     @Override
     public void registerVariable(String string, Function<GrimUser, String> replacement) {
-        variableReplacements.put(string, replacement);
+        if (replacement == null) {
+            variableReplacements.remove(string);
+        } else {
+            variableReplacements.put(string, replacement);
+        }
     }
 
     @Override
     public void registerVariable(String variable, String replacement) {
-        staticReplacements.put(variable, replacement);
+        if (replacement == null) {
+            staticReplacements.remove(variable);
+        } else {
+            staticReplacements.put(variable, replacement);
+        }
     }
 
     @Override
@@ -70,34 +88,20 @@ public class GrimExternalAPI implements GrimAbstractAPI, Initable {
         return description.getVersion();
     }
 
+    private final Map<String, Function<Object, Object>> functions = new ConcurrentHashMap<>();
+
     @Override
     public void registerFunction(String key, Function<Object, Object> function) {
-
+        if (function == null) {
+            functions.remove(key);
+        } else {
+            functions.put(key, function);
+        }
     }
 
     @Override
     public Function<Object, Object> getFunction(String key) {
-        return null;
-    }
-
-    @Override
-    public void reload() {
-        GrimAPI.INSTANCE.getConfigManager().reload();
-        //Reload checks for all players
-        for (GrimPlayer grimPlayer : GrimAPI.INSTANCE.getPlayerDataManager().getEntries()) {
-            ChannelHelper.runInEventLoop(grimPlayer.user.getChannel(), () -> {
-                grimPlayer.onReload();
-                grimPlayer.updatePermissions();
-                grimPlayer.punishmentManager.reload();
-                for (AbstractCheck value : grimPlayer.checkManager.allChecks.values()) {
-                    value.reload();
-                }
-            });
-        }
-        //Restart
-        GrimAPI.INSTANCE.getDiscordManager().start();
-        GrimAPI.INSTANCE.getSpectateManager().start();
-        GrimAPI.INSTANCE.getExternalAPI().start();
+        return functions.get(key);
     }
 
     @Override
@@ -106,16 +110,106 @@ public class GrimExternalAPI implements GrimAbstractAPI, Initable {
     }
 
     @Override
-    public void start() {
-        variableReplacements.put("%player%", GrimUser::getName);
-        variableReplacements.put("%uuid%", user -> user.getUniqueId().toString());
-        variableReplacements.put("%ping%", user -> user.getTransactionPing() + "");
-        variableReplacements.put("%brand%", GrimUser::getBrand);
-        variableReplacements.put("%h_sensitivity%", user -> ((int) Math.round(user.getHorizontalSensitivity() * 200)) + "");
-        variableReplacements.put("%v_sensitivity%", user -> ((int) Math.round(user.getVerticalSensitivity() * 200)) + "");
-        variableReplacements.put("%fast_math%", user -> !user.isVanillaMath() + "");
-        variableReplacements.put("%tps%", user -> String.format("%.2f", SpigotReflectionUtil.getTPS()));
-        variableReplacements.put("%version%", GrimUser::getVersionName);
-        variableReplacements.put("%prefix%", user -> ChatColor.translateAlternateColorCodes('&', GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("prefix", "&bGrim &8»")));
+    public ConfigManager getConfigManager() {
+        return configManager;
     }
+
+    private ConfigManager configManager = null;
+    private final ConfigManagerFileImpl configManagerFile = new ConfigManagerFileImpl();
+    private boolean started = false;
+
+    // on load, load the config & register the service
+    public void load() {
+        reload(configManagerFile);
+        Bukkit.getServicesManager().register(GrimAbstractAPI.class, this, GrimAPI.INSTANCE.getPlugin(), ServicePriority.Normal);
+    }
+
+    // handles any config loading that's needed to be done after load
+    @Override
+    public void start() {
+        started = true;
+        try {
+            GrimAPI.INSTANCE.getConfigManager().start();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void reload(ConfigManager config) {
+        if (config.isLoadedAsync() && started) {
+            FoliaScheduler.getAsyncScheduler().runNow(GrimAPI.INSTANCE.getPlugin(),
+                    o -> successfulReload(config));
+        } else {
+            successfulReload(config);
+        }
+    }
+
+    @Override
+    public CompletableFuture<Boolean> reloadAsync(ConfigManager config) {
+        if (config.isLoadedAsync() && started) {
+            CompletableFuture<Boolean> future = new CompletableFuture<>();
+            FoliaScheduler.getAsyncScheduler().runNow(GrimAPI.INSTANCE.getPlugin(),
+                    o -> future.complete(successfulReload(config)));
+            return future;
+        }
+        return CompletableFuture.completedFuture(successfulReload(config));
+    }
+
+    private boolean successfulReload(ConfigManager config) {
+        try {
+            config.reload();
+            GrimAPI.INSTANCE.getConfigManager().load(config);
+            if (started) GrimAPI.INSTANCE.getConfigManager().start();
+            onReload(config);
+            if (started) FoliaScheduler.getAsyncScheduler().runNow(GrimAPI.INSTANCE.getPlugin(),
+                    o -> Bukkit.getPluginManager().callEvent(new GrimReloadEvent(true)));
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (started) FoliaScheduler.getAsyncScheduler().runNow(GrimAPI.INSTANCE.getPlugin(),
+                o -> Bukkit.getPluginManager().callEvent(new GrimReloadEvent(false)));
+        return false;
+    }
+
+    @Override
+    public void onReload(ConfigManager newConfig) {
+        if (newConfig == null) {
+            LogUtil.warn("ConfigManager not set. Using default config file manager.");
+            configManager = configManagerFile;
+        } else {
+            configManager = newConfig;
+        }
+        // Update variables
+        updateVariables();
+        // Restart
+        GrimAPI.INSTANCE.getDiscordManager().start();
+        GrimAPI.INSTANCE.getSpectateManager().start();
+        // Don't reload players if the plugin hasn't started yet
+        if (!started) return;
+        // Reload checks for all players
+        for (GrimPlayer grimPlayer : GrimAPI.INSTANCE.getPlayerDataManager().getEntries()) {
+            ChannelHelper.runInEventLoop(grimPlayer.user.getChannel(), () -> {
+                grimPlayer.updatePermissions();
+                grimPlayer.reload(configManager);
+            });
+        }
+    }
+
+    private void updateVariables() {
+        variableReplacements.putIfAbsent("%player%", GrimUser::getName);
+        variableReplacements.putIfAbsent("%uuid%", user -> user.getUniqueId().toString());
+        variableReplacements.putIfAbsent("%ping%", user -> user.getTransactionPing() + "");
+        variableReplacements.putIfAbsent("%brand%", GrimUser::getBrand);
+        variableReplacements.putIfAbsent("%h_sensitivity%", user -> ((int) Math.round(user.getHorizontalSensitivity() * 200)) + "");
+        variableReplacements.putIfAbsent("%v_sensitivity%", user -> ((int) Math.round(user.getVerticalSensitivity() * 200)) + "");
+        variableReplacements.putIfAbsent("%fast_math%", user -> !user.isVanillaMath() + "");
+        variableReplacements.putIfAbsent("%tps%", user -> String.format("%.2f", SpigotReflectionUtil.getTPS()));
+        variableReplacements.putIfAbsent("%version%", GrimUser::getVersionName);
+        // static variables
+        staticReplacements.putIfAbsent("%prefix%", ChatColor.translateAlternateColorCodes('&', GrimAPI.INSTANCE.getConfigManager().getPrefix()));
+        staticReplacements.putIfAbsent("%grim_version%", getGrimVersion());
+    }
+
 }

src/main/java/ac/grim/grimac/checks/Check.java

@@ -2,18 +2,22 @@ package ac.grim.grimac.checks;
 
 import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.api.AbstractCheck;
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.api.events.FlagEvent;
 import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.common.ConfigReloadObserver;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.packettype.PacketTypeCommon;
-import github.scarsz.configuralize.DynamicConfig;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
+import io.github.retrooper.packetevents.util.folia.FoliaScheduler;
 import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.Bukkit;
 
 // Class from https://github.com/Tecnio/AntiCheatBase/blob/master/src/main/java/me/tecnio/anticheat/check/Check.java
 @Getter
-public class Check implements AbstractCheck {
+public class Check implements AbstractCheck, ConfigReloadObserver {
     protected final GrimPlayer player;
 
     public double violations;
@@ -23,11 +27,13 @@ public class Check implements AbstractCheck {
     private String checkName;
     private String configName;
     private String alternativeName;
+    private String displayName;
     private String description;
 
     private boolean experimental;
     @Setter
     private boolean isEnabled;
+    private boolean exempted;
 
     @Override
     public boolean isExperimental() {
@@ -50,13 +56,21 @@ public class Check implements AbstractCheck {
             this.alternativeName = checkData.alternativeName();
             this.experimental = checkData.experimental();
             this.description = checkData.description();
+            this.displayName = this.checkName;
         }
-
+        //
         reload();
     }
 
     public boolean shouldModifyPackets() {
-        return isEnabled && !player.disableGrim && !player.noModifyPacketPermission;
+        return isEnabled && !player.disableGrim && !player.noModifyPacketPermission && !exempted;
+    }
+
+    public void updateExempted() {
+        if (player.bukkitPlayer == null || checkName == null) return;
+        FoliaScheduler.getEntityScheduler().run(player.bukkitPlayer, GrimAPI.INSTANCE.getPlugin(),
+                t -> exempted = player.bukkitPlayer.hasPermission("grim.exempt." + checkName.toLowerCase()),
+                () -> {});
     }
 
     public final boolean flagAndAlert(String verbose) {
@@ -72,7 +86,7 @@ public class Check implements AbstractCheck {
     }
 
     public final boolean flag() {
-        if (player.disableGrim || (experimental && !GrimAPI.INSTANCE.getConfigManager().isExperimentalChecks()))
+        if (player.disableGrim || (experimental && !player.isExperimentalChecks()) || exempted)
             return false; // Avoid calling event if disabled
 
         FlagEvent event = new FlagEvent(player, this);
@@ -98,21 +112,26 @@ public class Check implements AbstractCheck {
         violations = Math.max(0, violations - decay);
     }
 
-    public void reload() {
-        decay = getConfig().getDoubleElse(configName + ".decay", decay);
-        setbackVL = getConfig().getDoubleElse(configName + ".setbackvl", setbackVL);
+    @Override
+    public void reload(ConfigManager configuration) {
+        decay = configuration.getDoubleElse(configName + ".decay", decay);
+        setbackVL = configuration.getDoubleElse(configName + ".setbackvl", setbackVL);
+        displayName = configuration.getStringElse(configName + ".displayname", checkName);
 
         if (setbackVL == -1) setbackVL = Double.MAX_VALUE;
+        updateExempted();
+        onReload(configuration);
+    }
+
+    @Override
+    public void onReload(ConfigManager config) {
+
     }
 
     public boolean alert(String verbose) {
         return player.punishmentManager.handleAlert(player, verbose, this);
     }
 
-    public DynamicConfig getConfig() {
-        return GrimAPI.INSTANCE.getConfigManager().getConfig();
-    }
-
     public boolean setbackIfAboveSetbackVL() {
         if (getViolations() > setbackVL) {
             return player.getSetbackTeleportUtil().executeViolationSetback();
@@ -133,5 +152,42 @@ public class Check implements AbstractCheck {
                 packetType == PacketType.Play.Client.WINDOW_CONFIRMATION;
     }
 
-}
+    public boolean isFlying(PacketTypeCommon packetType) {
+        return WrapperPlayClientPlayerFlying.isFlying(packetType);
+    }
 
+    public boolean isUpdate(PacketTypeCommon packetType) {
+        return isFlying(packetType)
+                || packetType == PacketType.Play.Client.CLIENT_TICK_END
+                || isTransaction(packetType);
+    }
+
+    public boolean isTickPacket(PacketTypeCommon packetType) {
+        if (isTickPacketIncludingNonMovement(packetType)) {
+            if (isFlying(packetType)) {
+                return !player.packetStateData.lastPacketWasTeleport && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean isTickPacketIncludingNonMovement(PacketTypeCommon packetType) {
+        // On 1.21.2+ fall back to the TICK_END packet IF the player did not send a movement packet for their tick
+        // TickTimer checks to see if player did not send a tick end packet before new flying packet is sent
+        if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_2)
+                && !player.packetStateData.didSendMovementBeforeTickEnd) {
+            if (packetType == PacketType.Play.Client.CLIENT_TICK_END) {
+                return true;
+            }
+        }
+
+        return isFlying(packetType);
+    }
+
+    @Override
+    public void reload() {
+        reload(GrimAPI.INSTANCE.getConfigManager().getConfig());
+    }
+
+}

src/main/java/ac/grim/grimac/checks/impl/aim/AimModulo360.java

@@ -11,7 +11,8 @@ import ac.grim.grimac.utils.anticheat.update.RotationUpdate;
 // It works on clients who % 360 their rotation.
 @CheckData(name = "AimModulo360", decay = 0.005)
 public class AimModulo360 extends Check implements RotationCheck {
-    float lastDeltaYaw;
+
+    private float lastDeltaYaw;
 
     public AimModulo360(GrimPlayer playerData) {
         super(playerData);
@@ -19,12 +20,17 @@ public class AimModulo360 extends Check implements RotationCheck {
 
     @Override
     public void process(final RotationUpdate rotationUpdate) {
-        lastDeltaYaw = rotationUpdate.getDeltaXRot();
-        if (player.packetStateData.lastPacketWasTeleport) return;
+        if (player.packetStateData.lastPacketWasTeleport) {
+            lastDeltaYaw = rotationUpdate.getDeltaXRot();
+            return;
+        }
+
         if (player.xRot < 360 && player.xRot > -360 && Math.abs(rotationUpdate.getDeltaXRot()) > 320 && Math.abs(lastDeltaYaw) < 30) {
             flagAndAlert();
         } else {
             reward();
         }
+
+        lastDeltaYaw = rotationUpdate.getDeltaXRot();
     }
 }

src/main/java/ac/grim/grimac/checks/impl/aim/processor/AimProcessor.java

@@ -59,15 +59,15 @@ public class AimProcessor extends Check implements RotationCheck {
 
         if (this.xRotMode.size() > SIGNIFICANT_SAMPLES_THRESHOLD) {
             Pair<Double, Integer> modeX = this.xRotMode.getMode();
-            if (modeX.getSecond() > SIGNIFICANT_SAMPLES_THRESHOLD) {
-                this.modeX = modeX.getFirst();
+            if (modeX.second() > SIGNIFICANT_SAMPLES_THRESHOLD) {
+                this.modeX = modeX.first();
                 this.sensitivityX = convertToSensitivity(this.modeX);
             }
         }
         if (this.yRotMode.size() > SIGNIFICANT_SAMPLES_THRESHOLD) {
             Pair<Double, Integer> modeY = this.yRotMode.getMode();
-            if (modeY.getSecond() > SIGNIFICANT_SAMPLES_THRESHOLD) {
-                this.modeY = modeY.getFirst();
+            if (modeY.second() > SIGNIFICANT_SAMPLES_THRESHOLD) {
+                this.modeY = modeY.first();
                 this.sensitivityY = convertToSensitivity(this.modeY);
             }
         }
@@ -81,4 +81,4 @@ public class AimProcessor extends Check implements RotationCheck {
         double var9 = Math.cbrt(var11);
         return (var9 - 0.2f) / 0.6f;
     }
-}
+}

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsE.java

@@ -6,6 +6,7 @@ import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 @CheckData(name = "BadPacketsE")
@@ -23,10 +24,12 @@ public class BadPacketsE extends Check implements PacketCheck {
             noReminderTicks = 0;
         } else if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) {
             noReminderTicks++;
-        } else if (event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE) {
+        } else if (event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE
+                || (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_2) && player.compensatedEntities.getSelf().inVehicle())) {
             noReminderTicks = 0; // Exempt vehicles
         }
 
+
         if (noReminderTicks > 20) {
             flagAndAlert("ticks=" + noReminderTicks); // ban?  I don't know how this would false
         }

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsG.java

@@ -10,8 +10,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEn
 
 @CheckData(name = "BadPacketsG")
 public class BadPacketsG extends Check implements PacketCheck {
-    boolean wasTeleport;
-    boolean lastSneaking;
+    private boolean lastSneaking, respawn;
 
     public BadPacketsG(GrimPlayer player) {
         super(player);
@@ -19,13 +18,12 @@ public class BadPacketsG extends Check implements PacketCheck {
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        wasTeleport = player.packetStateData.lastPacketWasTeleport || wasTeleport;
-
         if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
             WrapperPlayClientEntityAction packet = new WrapperPlayClientEntityAction(event);
 
             if (packet.getAction() == WrapperPlayClientEntityAction.Action.START_SNEAKING) {
-                if (lastSneaking && !wasTeleport) {
+                // The player may send two START_SNEAKING packets if they respawned
+                if (lastSneaking && !respawn) {
                     if (flagAndAlert("state=true") && shouldModifyPackets()) {
                         event.setCancelled(true);
                         player.onPacketCancel();
@@ -33,8 +31,9 @@ public class BadPacketsG extends Check implements PacketCheck {
                 } else {
                     lastSneaking = true;
                 }
+                respawn = false;
             } else if (packet.getAction() == WrapperPlayClientEntityAction.Action.STOP_SNEAKING) {
-                if (!lastSneaking && !wasTeleport) {
+                if (!lastSneaking && !respawn) {
                     if (flagAndAlert("state=false") && shouldModifyPackets()) {
                         event.setCancelled(true);
                         player.onPacketCancel();
@@ -42,7 +41,13 @@ public class BadPacketsG extends Check implements PacketCheck {
                 } else {
                     lastSneaking = false;
                 }
+                respawn = false;
             }
         }
     }
+
+    public void handleRespawn() {
+        // Clients could potentially not send a STOP_SNEAKING packet when they die, so we need to track it
+        respawn = true;
+    }
 }

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsH.java

@@ -10,7 +10,6 @@ import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 @CheckData(name = "BadPacketsH")
 public class BadPacketsH extends Check implements PacketCheck {
@@ -44,7 +43,7 @@ public class BadPacketsH extends Check implements PacketCheck {
             if (player.getClientVersion().isOlderThan(ClientVersion.V_1_9)
                     && PacketEvents.getAPI().getServerManager().getVersion().isNewerThan(ServerVersion.V_1_8)) return;
 
-            if (!sentAnimation && flagAndAlert()) {
+            if (!sentAnimation && flagAndAlert() && shouldModifyPackets()) {
                 event.setCancelled(true);
                 player.onPacketCancel();
             }

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsO.java

@@ -39,7 +39,7 @@ public class BadPacketsO extends Check implements PacketCheck {
             boolean hasID = false;
 
             for (Pair<Long, Long> iterator : keepaliveMap) {
-                if (iterator.getFirst() == id) {
+                if (iterator.first() == id) {
                     hasID = true;
                     break;
                 }
@@ -55,7 +55,7 @@ public class BadPacketsO extends Check implements PacketCheck {
                 do {
                     data = keepaliveMap.poll();
                     if (data == null) break;
-                } while (data.getFirst() != id);
+                } while (data.first() != id);
             }
         }
     }

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsR.java

@@ -41,7 +41,8 @@ public class BadPacketsR extends Check implements PacketCheck {
         if ((event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION ||
                 event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION) && !player.compensatedEntities.getSelf().inVehicle()) {
             positions++;
-        } else if (event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE && player.compensatedEntities.getSelf().inVehicle()) {
+        } else if ((event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE || event.getPacketType() == PacketType.Play.Client.VEHICLE_MOVE)
+                && player.inVehicle()) {
             positions++;
         }
     }

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsU.java

@@ -6,7 +6,6 @@ import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.item.ItemStack;
-import com.github.retrooper.packetevents.protocol.item.type.ItemType;
 import com.github.retrooper.packetevents.protocol.item.type.ItemTypes;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsV.java

@@ -1,31 +0,0 @@
-package ac.grim.grimac.checks.impl.badpackets;
-
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
-import ac.grim.grimac.player.GrimPlayer;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
-import com.github.retrooper.packetevents.protocol.item.ItemStack;
-import com.github.retrooper.packetevents.protocol.packettype.PacketType;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
-
-@CheckData(name = "BadPacketsV", experimental = true)
-public class BadPacketsV extends Check implements PacketCheck {
-    public BadPacketsV(GrimPlayer player) {
-        super(player);
-    }
-
-    @Override
-    public void onPacketReceive(PacketReceiveEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
-            WrapperPlayClientInteractEntity interactEntity = new WrapperPlayClientInteractEntity(event);
-            if (interactEntity.getAction() != WrapperPlayClientInteractEntity.InteractAction.ATTACK) return;
-            if (!player.packetStateData.isSlowedByUsingItem()) return;
-            ItemStack itemInUse = player.getInventory().getItemInHand(player.packetStateData.eatingHand);
-            if (flagAndAlert("UseItem=" + itemInUse.getType().getName().getKey()) && shouldModifyPackets()) {
-                event.setCancelled(true);
-                player.onPacketCancel();
-            }
-        }
-    }
-}

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsX.java

@@ -1,45 +1,69 @@
 package ac.grim.grimac.checks.impl.badpackets;
 
+import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
-import ac.grim.grimac.utils.nmsutil.BlockBreakSpeed;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
 import com.github.retrooper.packetevents.protocol.item.type.ItemTypes;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.DiggingAction;
 import com.github.retrooper.packetevents.protocol.world.states.type.StateType;
 import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+import com.github.retrooper.packetevents.util.Vector3i;
 
-@CheckData(name = "BadPacketsX", experimental = true)
+@CheckData(name = "BadPacketsX")
 public class BadPacketsX extends Check implements PacketCheck {
     public BadPacketsX(GrimPlayer player) {
         super(player);
     }
 
+    private int lastTick;
+    private boolean didLastFlag;
+    private Vector3i lastBreakLoc;
+    private StateType lastBlockType;
+
     public final boolean noFireHitbox = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_15_2);
 
-    public final void handle(PacketReceiveEvent event, WrapperPlayClientPlayerDigging dig, StateType block) {
-        if (dig.getAction() != DiggingAction.START_DIGGING && dig.getAction() != DiggingAction.FINISHED_DIGGING)
+    public final void handle(BlockBreak blockBreak) {
+        if (blockBreak.action != DiggingAction.START_DIGGING && blockBreak.action != DiggingAction.FINISHED_DIGGING)
             return;
 
-        final boolean invalid;
+        final StateType block = blockBreak.block.getType();
 
-        if (dig.getAction() == DiggingAction.FINISHED_DIGGING) {
-            invalid = BlockBreakSpeed.getBlockDamage(player, dig.getBlockPosition()) >= 1 || block.getHardness() == -1.0f;
-        } else invalid = (block == StateTypes.LIGHT && !(player.getInventory().getHeldItem().is(ItemTypes.LIGHT) || player.getInventory().getOffHand().is(ItemTypes.LIGHT)))
+        // Fixes false from breaking kelp underwater
+        // The client sends two start digging packets to the server both in the same tick. BadPacketsX gets called twice, doesn't false the first time, but falses the second
+        // One ends up breaking the kelp, the other ends up doing nothing besides falsing this check because we think they're trying to mine water
+        // I am explicitly making this patch as narrow and specific as possible to potentially discover other blocks that exhibit similar behaviour
+        int newTick = GrimAPI.INSTANCE.getTickManager().currentTick;
+        if (lastTick == newTick
+                && lastBreakLoc.equals(blockBreak.position)
+                && !didLastFlag
+                && lastBlockType.getHardness() == 0.0F
+                && lastBlockType.getBlastResistance() == 0.0F
+                && block == StateTypes.WATER
+        ) return;
+        lastTick = newTick;
+        lastBreakLoc = blockBreak.position;
+        lastBlockType = block;
+
+        // the block does not have a hitbox
+        boolean invalid = (block == StateTypes.LIGHT && !(player.getInventory().getHeldItem().is(ItemTypes.LIGHT) || player.getInventory().getOffHand().is(ItemTypes.LIGHT)))
                 || block.isAir()
                 || block == StateTypes.WATER
                 || block == StateTypes.LAVA
                 || block == StateTypes.BUBBLE_COLUMN
                 || block == StateTypes.MOVING_PISTON
-                || (block == StateTypes.FIRE && noFireHitbox);
+                || block == StateTypes.FIRE && noFireHitbox
+                // or the client claims to have broken an unbreakable block
+                || block.getHardness() == -1.0f && blockBreak.action == DiggingAction.FINISHED_DIGGING;
 
-        if (invalid && flagAndAlert("block=" + block.getName() + ", type=" + dig.getAction()) && shouldModifyPackets()) {
-            event.setCancelled(true);
-            player.onPacketCancel();
+        if (invalid && flagAndAlert("block=" + block.getName() + ", type=" + blockBreak.action) && shouldModifyPackets()) {
+            didLastFlag = true;
+            blockBreak.cancel();
+        } else {
+            didLastFlag = false;
         }
     }
 }

src/main/java/ac/grim/grimac/checks/impl/badpackets/BadPacketsZ.java

@@ -4,16 +4,18 @@ import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import ac.grim.grimac.utils.anticheat.MessageUtil;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.DiggingAction;
 import com.github.retrooper.packetevents.util.Vector3i;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
 
 import static ac.grim.grimac.events.packets.patch.ResyncWorldUtil.resyncPosition;
 import static ac.grim.grimac.utils.nmsutil.BlockBreakSpeed.getBlockDamage;
 
-@CheckData(name = "BadPacketsZ", experimental = true)
+@CheckData(name = "BadPacketsZ")
 public class BadPacketsZ extends Check implements PacketCheck {
     public BadPacketsZ(final GrimPlayer player) {
         super(player);
@@ -21,7 +23,7 @@ public class BadPacketsZ extends Check implements PacketCheck {
 
     private boolean lastBlockWasInstantBreak = false;
     private Vector3i lastBlock, lastCancelledBlock, lastLastBlock = null;
-    private final int exemptedY = player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_8) ? 4095 : 255;
+    private final int exemptedY = player.getClientVersion().isOlderThan(ClientVersion.V_1_8) ? 255 : (PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_14) ? -1 : 4095);
 
     // The client sometimes sends a wierd cancel packet
     private boolean shouldExempt(final Vector3i pos) {
@@ -33,21 +35,13 @@ public class BadPacketsZ extends Check implements PacketCheck {
         if (player.getClientVersion().isOlderThan(ClientVersion.V_1_14_4) && pos.y != exemptedY)
             return false;
 
-        // the client only sends this packet if the last block was an instant break
-        if (getBlockDamage(player, lastBlock) < 1)
-            return false;
-
         // and if this block is not an instant break
         return player.getClientVersion().isOlderThan(ClientVersion.V_1_14_4) || getBlockDamage(player, pos) < 1;
     }
 
-    private String formatted(Vector3i vec) {
-        return vec == null ? "null" : vec.x + ", " + vec.y + ", " + vec.z;
-    }
-
-    public void handle(PacketReceiveEvent event, WrapperPlayClientPlayerDigging dig) {
-        if (dig.getAction() == DiggingAction.START_DIGGING) {
-            final Vector3i pos = dig.getBlockPosition();
+    public void handle(BlockBreak blockBreak) {
+        if (blockBreak.action == DiggingAction.START_DIGGING) {
+            final Vector3i pos = blockBreak.position;
 
             lastBlockWasInstantBreak = getBlockDamage(player, pos) >= 1;
             lastCancelledBlock = null;
@@ -55,11 +49,11 @@ public class BadPacketsZ extends Check implements PacketCheck {
             lastBlock = pos;
         }
 
-        if (dig.getAction() == DiggingAction.CANCELLED_DIGGING) {
-            final Vector3i pos = dig.getBlockPosition();
+        if (blockBreak.action == DiggingAction.CANCELLED_DIGGING) {
+            final Vector3i pos = blockBreak.position;
 
             if (shouldExempt(pos)) {
-                lastCancelledBlock = null;
+                lastCancelledBlock = pos;
                 lastLastBlock = null;
                 lastBlock = null;
                 return;
@@ -68,10 +62,9 @@ public class BadPacketsZ extends Check implements PacketCheck {
             if (!pos.equals(lastBlock)) {
                 // https://github.com/GrimAnticheat/Grim/issues/1512
                 if (player.getClientVersion().isOlderThan(ClientVersion.V_1_14_4) || (!lastBlockWasInstantBreak && pos.equals(lastCancelledBlock))) {
-                    if (flagAndAlert("action=CANCELLED_DIGGING" + ", last=" + formatted(lastBlock) + ", pos=" + formatted(pos))) {
+                    if (flagAndAlert("action=CANCELLED_DIGGING" + ", last=" + MessageUtil.toUnlabledString(lastBlock) + ", pos=" + MessageUtil.toUnlabledString(pos))) {
                         if (shouldModifyPackets()) {
-                            event.setCancelled(true);
-                            player.onPacketCancel();
+                            blockBreak.cancel();
                             resyncPosition(player, pos);
                         }
                     }
@@ -84,15 +77,14 @@ public class BadPacketsZ extends Check implements PacketCheck {
             return;
         }
 
-        if (dig.getAction() == DiggingAction.FINISHED_DIGGING) {
-            final Vector3i pos = dig.getBlockPosition();
+        if (blockBreak.action == DiggingAction.FINISHED_DIGGING) {
+            final Vector3i pos = blockBreak.position;
 
             // when a player looks away from the mined block, they send a cancel, and if they look at it again, they don't send another start. (thanks mojang!)
             if (!pos.equals(lastCancelledBlock) && (!lastBlockWasInstantBreak || player.getClientVersion().isOlderThan(ClientVersion.V_1_14_4)) && !pos.equals(lastBlock)) {
-                if (flagAndAlert("action=FINISHED_DIGGING" + ", last=" + formatted(lastBlock) + ", pos=" + formatted(pos))) {
+                if (flagAndAlert("action=FINISHED_DIGGING" + ", last=" + MessageUtil.toUnlabledString(lastBlock) + ", pos=" + MessageUtil.toUnlabledString(pos))) {
                     if (shouldModifyPackets()) {
-                        event.setCancelled(true);
-                        player.onPacketCancel();
+                        blockBreak.cancel();
                         resyncPosition(player, pos);
                     }
                 }

src/main/java/ac/grim/grimac/checks/impl/combat/MultiInteractA.java

@@ -0,0 +1,71 @@
+package ac.grim.grimac.checks.impl.combat;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
+
+import java.util.ArrayList;
+
+@CheckData(name = "MultiInteractA", experimental = true)
+public class MultiInteractA extends Check implements PostPredictionCheck {
+    public MultiInteractA(final GrimPlayer player) {
+        super(player);
+    }
+
+    private final ArrayList<String> flags = new ArrayList<>();
+    private int lastEntity;
+    private boolean lastSneaking;
+    private boolean hasInteracted = false;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            WrapperPlayClientInteractEntity packet = new WrapperPlayClientInteractEntity(event);
+            int entity = packet.getEntityId();
+            boolean sneaking = packet.isSneaking().orElse(false);
+
+            if (hasInteracted && entity != lastEntity) {
+                String verbose = "lastEntity=" + lastEntity + ", entity=" + entity
+                        + ", lastSneaking=" + lastSneaking + ", sneaking=" + sneaking;
+                if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+                    if (flagAndAlert(verbose) && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    flags.add(verbose);
+                }
+            }
+
+            lastEntity = entity;
+            lastSneaking = sneaking;
+            hasInteracted = true;
+        }
+
+        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType()) && player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8) && !player.packetStateData.lastPacketWasTeleport) {
+            hasInteracted = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        // we don't need to check pre-1.9 players here (no tick skipping)
+        if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+        hasInteracted = false;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/combat/MultiInteractB.java

@@ -0,0 +1,72 @@
+package ac.grim.grimac.checks.impl.combat;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.MessageUtil;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.util.Vector3f;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
+
+import java.util.ArrayList;
+
+@CheckData(name = "MultiInteractB", experimental = true)
+public class MultiInteractB extends Check implements PostPredictionCheck {
+    public MultiInteractB(final GrimPlayer player) {
+        super(player);
+    }
+
+    private final ArrayList<String> flags = new ArrayList<>();
+    private Vector3f lastPos;
+    private boolean hasInteracted = false;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            Vector3f pos = new WrapperPlayClientInteractEntity(event).getTarget().orElse(null);
+
+            if (pos == null) {
+                return;
+            }
+
+            if (hasInteracted && !pos.equals(lastPos)) {
+                String verbose = "pos=" + MessageUtil.toUnlabledString(pos) + ", lastPos=" + MessageUtil.toUnlabledString(lastPos);
+                if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+                    if (flagAndAlert(verbose) && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    flags.add(verbose);
+                }
+            }
+
+            lastPos = pos;
+            hasInteracted = true;
+        }
+
+        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType()) && player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8) && !player.packetStateData.lastPacketWasTeleport) {
+            hasInteracted = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        // we don't need to check pre-1.9 players here (no tick skipping)
+        if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+        hasInteracted = false;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/combat/Reach.java

@@ -15,18 +15,16 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package ac.grim.grimac.checks.impl.combat;
 
-import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
-import ac.grim.grimac.utils.data.HitData;
-import ac.grim.grimac.utils.data.Pair;
 import ac.grim.grimac.utils.data.packetentity.PacketEntity;
-import ac.grim.grimac.utils.nmsutil.BlockRayTrace;
 import ac.grim.grimac.utils.data.packetentity.dragon.PacketEntityEnderDragonPart;
 import ac.grim.grimac.utils.nmsutil.ReachUtils;
+import ac.grim.grimac.utils.vector.Vector3D;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.attribute.Attributes;
 import com.github.retrooper.packetevents.protocol.entity.type.EntityType;
@@ -34,32 +32,22 @@ import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
-import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
 import com.github.retrooper.packetevents.util.Vector3d;
-import com.github.retrooper.packetevents.util.Vector3i;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
-import org.bukkit.util.Vector;
-import org.jetbrains.annotations.Nullable;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+import ac.grim.grimac.utils.vector.Vector3D;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
+
+import static ac.grim.grimac.utils.vector.VectorFactory.newVector3D;
 
 // You may not copy the check unless you are licensed under GPL
 @CheckData(name = "Reach", configName = "Reach", setback = 10)
 public class Reach extends Check implements PacketCheck {
     // Only one flag per reach attack, per entity, per tick.
     // We store position because lastX isn't reliable on teleports.
-    private final Map<Integer, Vector3d> playerAttackQueue = new HashMap<>();
-    // Used to prevent falses in the wall hit check
-    private final Set<Vector3i> blocksChangedThisTick = new HashSet<>();
-
+    private final Int2ObjectMap<Vector3d> playerAttackQueue = new Int2ObjectOpenHashMap<>();
     private static final List<EntityType> blacklisted = Arrays.asList(
             EntityTypes.BOAT,
             EntityTypes.CHEST_BOAT,
@@ -97,7 +85,7 @@ public class Reach extends Check implements PacketCheck {
                 }
                 return;
             }
-            
+
             // Dead entities cause false flags (https://github.com/GrimAnticheat/Grim/issues/546)
             if (entity.isDead) return;
 
@@ -122,11 +110,8 @@ public class Reach extends Check implements PacketCheck {
         }
 
         // If the player set their look, or we know they have a new tick
-        final boolean isFlying = WrapperPlayClientPlayerFlying.isFlying(event.getPacketType());
-        if (isFlying ||
-                event.getPacketType() == PacketType.Play.Client.PONG ||
-                event.getPacketType() == PacketType.Play.Client.WINDOW_CONFIRMATION) {
-            tickBetterReachCheckWithAngle(isFlying);
+        if (isUpdate(event.getPacketType())) {
+            tickBetterReachCheckWithAngle();
         }
     }
 
@@ -158,9 +143,9 @@ public class Reach extends Check implements PacketCheck {
         }
     }
 
-    private void tickBetterReachCheckWithAngle(boolean isFlying) {
-        for (Map.Entry<Integer, Vector3d> attack : playerAttackQueue.entrySet()) {
-            PacketEntity reachEntity = player.compensatedEntities.entityMap.get(attack.getKey().intValue());
+    private void tickBetterReachCheckWithAngle() {
+        for (Int2ObjectMap.Entry<Vector3d> attack : playerAttackQueue.int2ObjectEntrySet()) {
+            PacketEntity reachEntity = player.compensatedEntities.entityMap.get(attack.getIntKey());
             if (reachEntity != null) {
                 String result = checkReach(reachEntity, attack.getValue(), false);
                 if (result != null) {
@@ -173,9 +158,6 @@ public class Reach extends Check implements PacketCheck {
             }
         }
         playerAttackQueue.clear();
-        // We can't use transactions for this because of this problem:
-        // transaction -> block changed applied -> 2nd transaction -> list cleared -> attack packet -> flying -> reach block hit checked, falses
-        if (isFlying) blocksChangedThisTick.clear();
     }
 
     private String checkReach(PacketEntity reachEntity, Vector3d from, boolean isPrediction) {
@@ -203,7 +185,7 @@ public class Reach extends Check implements PacketCheck {
         double minDistance = Double.MAX_VALUE;
 
         // https://bugs.mojang.com/browse/MC-67665
-        List<Vector> possibleLookDirs = new ArrayList<>(Collections.singletonList(ReachUtils.getLook(player, player.xRot, player.yRot)));
+        List<Vector3D> possibleLookDirs = new ArrayList<>(Collections.singletonList(ReachUtils.getLook(player, player.xRot, player.yRot)));
 
         // If we are a tick behind, we don't know their next look so don't bother doing this
         if (!isPrediction) {
@@ -222,12 +204,13 @@ public class Reach extends Check implements PacketCheck {
 
         // +3 would be 3 + 3 = 6, which is the pre-1.20.5 behaviour, preventing "Missed Hitbox"
         final double distance = player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_ENTITY_INTERACTION_RANGE) + 3;
-        for (Vector lookVec : possibleLookDirs) {
-            for (double eye : player.getPossibleEyeHeights()) {
-                Vector eyePos = new Vector(from.getX(), from.getY() + eye, from.getZ());
-                Vector endReachPos = eyePos.clone().add(new Vector(lookVec.getX() * distance, lookVec.getY() * distance, lookVec.getZ() * distance));
+        final double[] possibleEyeHeights = player.getPossibleEyeHeights();
+        for (Vector3D lookVec : possibleLookDirs) {
+            for (double eye : possibleEyeHeights) {
+                ac.grim.grimac.utils.vector.Vector3D eyePos = newVector3D(from.getX(), from.getY() + eye, from.getZ());
+                ac.grim.grimac.utils.vector.Vector3D endReachPos = eyePos.clone().add(newVector3D(lookVec.getX() * distance, lookVec.getY() * distance, lookVec.getZ() * distance));
 
-                Vector intercept = ReachUtils.calculateIntercept(targetBox, eyePos, endReachPos).getFirst();
+                Vector3D intercept = ReachUtils.calculateIntercept(targetBox, eyePos, endReachPos).first();
 
                 if (ReachUtils.isVecInside(targetBox, eyePos)) {
                     minDistance = 0;
@@ -240,26 +223,9 @@ public class Reach extends Check implements PacketCheck {
             }
         }
 
-        final boolean experimentalChecks = true; //GrimAPI.INSTANCE.getConfigManager().isExperimentalChecks(); // TODO fix for undraft
-        HitData foundHitData = null;
-        // If the entity is within range of the player (we'll flag anyway if not, so no point checking blocks in this case)
-        // Ignore when could be hitting through a moving shulker, piston blocks. They are just too glitchy/uncertain to check.
-        if (experimentalChecks && minDistance <= 3 && !player.compensatedWorld.isNearHardEntity(player.boundingBox.copy().expand(4))) {
-            final @Nullable Pair<Double, HitData> targetBlock = getTargetBlock(player, possibleLookDirs, from, minDistance);
-            // And if the target block is closer to the player than the entity box, they should hit the block instead
-            // So, this hit is invalid.
-            if (targetBlock != null && targetBlock.getFirst() < (minDistance * minDistance)) { // targetBlock is squared
-                minDistance = Double.MIN_VALUE;
-                foundHitData = targetBlock.getSecond();
-            }
-        }
-
         // if the entity is not exempt and the entity is alive
         if ((!blacklisted.contains(reachEntity.getType()) && reachEntity.isLivingEntity()) || reachEntity.getType() == EntityTypes.END_CRYSTAL) {
-            if (minDistance == Double.MIN_VALUE && foundHitData != null) {
-                cancelBuffer = 1;
-                return "Hit block block=" + foundHitData.getState().getType().getName();
-            } else if (minDistance == Double.MAX_VALUE) {
+            if (minDistance == Double.MAX_VALUE) {
                 cancelBuffer = 1;
                 return "Missed hitbox";
             } else if (minDistance > player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_ENTITY_INTERACTION_RANGE)) {
@@ -273,49 +239,9 @@ public class Reach extends Check implements PacketCheck {
         return null;
     }
 
-    public void handleBlockChange(Vector3i vector3i, WrappedBlockState state) {
-        if (blocksChangedThisTick.size() >= 40) return; // Don't let players freeze movement packets to grow this
-        // Only do this for nearby blocks
-        if (new Vector(vector3i.x, vector3i.y, vector3i.z).distanceSquared(new Vector(player.x, player.y, player.z)) > 6) return;
-        // Only do this if the state really had any world impact
-        if (state.equals(player.compensatedWorld.getWrappedBlockStateAt(vector3i))) return;
-        blocksChangedThisTick.add(vector3i);
-    }
-
-    // Returns a pair so we can check the block type in the flag
-    @Nullable
-    private Pair<Double, HitData> getTargetBlock(GrimPlayer player, List<Vector> possibleLookDirs, Vector3d from, double minDistance) {
-        // Check every possible look direction and every possible eye height
-        // IF *NONE* of them allow the player to hit the entity, this is an invalid hit
-        HitData bestHitData = null;
-        double min = Double.MAX_VALUE;
-        for (Vector lookVec : possibleLookDirs) {
-            for (double eye : player.getPossibleEyeHeights()) {
-                Vector eyes = new Vector(from.getX(), from.getY() + eye, from.getZ());
-                final double reach = player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_BLOCK_INTERACTION_RANGE);
-                final HitData hitResult = BlockRayTrace.getNearestReachHitResult(player, eyes, lookVec, minDistance, reach);
-                if (hitResult == null) {
-                    return null;
-                }
-
-                final double distance = eyes.distanceSquared(hitResult.getBlockHitLocation());
-                // Block changes are uncertain, can't check this tick
-                if (distance < (minDistance * minDistance) && blocksChangedThisTick.contains(hitResult.getPosition())) {
-                    return null;
-                }
-
-                bestHitData = hitResult;
-                min = Math.min(min, distance);
-            }
-        }
-
-        return bestHitData == null ? null : Pair.of(min, bestHitData);
-    }
-
     @Override
-    public void reload() {
-        super.reload();
-        this.cancelImpossibleHits = getConfig().getBooleanElse("Reach.block-impossible-hits", true);
-        this.threshold = getConfig().getDoubleElse("Reach.threshold", 0.0005);
+    public void onReload(ConfigManager config) {
+        this.cancelImpossibleHits = config.getBooleanElse("Reach.block-impossible-hits", true);
+        this.threshold = config.getDoubleElse("Reach.threshold", 0.0005);
     }
 }

src/main/java/ac/grim/grimac/checks/impl/crash/CrashB.java

@@ -18,7 +18,6 @@ public class CrashB extends Check implements PacketCheck {
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == PacketType.Play.Client.CREATIVE_INVENTORY_ACTION) {
             if (player.gamemode != GameMode.CREATIVE) {
-                player.getSetbackTeleportUtil().executeViolationSetback();
                 event.setCancelled(true);
                 player.onPacketCancel();
                 flagAndAlert(); // Could be transaction split, no need to setback though

src/main/java/ac/grim/grimac/checks/impl/exploit/ExploitC.java

@@ -0,0 +1,32 @@
+package ac.grim.grimac.checks.impl.exploit;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEditBook;
+
+@CheckData(name = "ExploitC")
+public class ExploitC extends Check implements PacketCheck {
+    public ExploitC(GrimPlayer playerData) {
+        super(playerData);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.EDIT_BOOK) {
+            final String title = new WrapperPlayClientEditBook(event).getTitle();
+
+            if (title == null) return; // book was not signed
+
+            if (title.length() > 15) {
+                if (flagAndAlert("title=" + title) && shouldModifyPackets()) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/groundspoof/NoFallA.java

@@ -43,7 +43,10 @@ public class NoFallA extends Check implements PacketCheck {
                 if (!isNearGround(wrapper.isOnGround())) { // If player isn't near ground
                     // 1.8 boats have a mind on their own... only flag if they're not near a boat or are on 1.9+
                     if (!GhostBlockDetector.isGhostBlock(player) && flagWithSetback()) alert("");
-                    if (shouldModifyPackets()) wrapper.setOnGround(false);
+                    if (shouldModifyPackets()) {
+                        wrapper.setOnGround(false);
+                        event.markForReEncode(true);
+                    }
                 }
             }
         }
@@ -59,10 +62,16 @@ public class NoFallA extends Check implements PacketCheck {
             // Also flip teleports because I don't trust vanilla's handling of teleports and ground
             if (flipPlayerGroundStatus) {
                 flipPlayerGroundStatus = false;
-                if (shouldModifyPackets()) wrapper.setOnGround(!wrapper.isOnGround());
+                if (shouldModifyPackets()) {
+                    wrapper.setOnGround(!wrapper.isOnGround());
+                    event.markForReEncode(true);
+                }
             }
             if (player.packetStateData.lastPacketWasTeleport) {
-                if (shouldModifyPackets()) wrapper.setOnGround(false);
+                if (shouldModifyPackets()) {
+                    wrapper.setOnGround(false);
+                    event.markForReEncode(true);
+                }
             }
         }
     }

src/main/java/ac/grim/grimac/checks/impl/misc/ClientBrand.java

@@ -9,6 +9,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPluginMessage;
 import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 
 public class ClientBrand extends Check implements PacketCheck {
@@ -38,6 +39,7 @@ public class ClientBrand extends Check implements PacketCheck {
                 System.arraycopy(data, 1, minusLength, 0, minusLength.length);
 
                 brand = new String(minusLength).replace(" (Velocity)", ""); //removes velocity's brand suffix
+                brand = ChatColor.stripColor(brand); //strip color codes from client brand
                 if (player.checkManager.getPrePredictionCheck(ExploitA.class).checkString(brand)) brand = "sent log4j";
                 if (!GrimAPI.INSTANCE.getConfigManager().isIgnoredClient(brand)) {
                     String message = GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("client-brand-format", "%prefix% &f%player% joined using %brand%");

src/main/java/ac/grim/grimac/checks/impl/misc/FastBreak.java

@@ -63,15 +63,15 @@ public class FastBreak extends Check implements PacketCheck {
 
             if (digging.getAction() == DiggingAction.START_DIGGING) {
                 WrappedBlockState block = player.compensatedWorld.getWrappedBlockStateAt(blockPosition);
-                
+
                 // Exempt all blocks that do not exist in the player version
                 if (WrappedBlockState.getDefaultState(player.getClientVersion(), block.getType()).getType() == StateTypes.AIR) {
                     return;
                 }
-            
+
                 startBreak = System.currentTimeMillis() - (targetBlock == null ? 50 : 0); // ???
                 targetBlock = blockPosition;
-                
+
                 maximumBlockDamage = BlockBreakSpeed.getBlockDamage(player, targetBlock);
 
                 double breakDelay = System.currentTimeMillis() - lastFinishBreak;

src/main/java/ac/grim/grimac/checks/impl/misc/GhostBlockMitigation.java

@@ -1,5 +1,6 @@
 package ac.grim.grimac.checks.impl.misc;
 
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.type.BlockPlaceCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.BlockPlace;
@@ -63,10 +64,9 @@ public class GhostBlockMitigation extends BlockPlaceCheck {
     }
 
     @Override
-    public void reload() {
-        super.reload();
-        allow = getConfig().getBooleanElse("exploit.allow-building-on-ghostblocks", true);
-        distance = getConfig().getIntElse("exploit.distance-to-check-for-ghostblocks", 2);
+    public void onReload(ConfigManager config) {
+        allow = config.getBooleanElse("exploit.allow-building-on-ghostblocks", true);
+        distance = config.getIntElse("exploit.distance-to-check-for-ghostblocks", 2);
 
         if (distance < 2 || distance > 4) distance = 2;
     }

src/main/java/ac/grim/grimac/checks/impl/misc/TransactionOrder.java

@@ -5,7 +5,6 @@ import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
-import java.util.ArrayList;
 
 @CheckData(name = "TransactionOrder", experimental = false)
 public class TransactionOrder extends Check implements PacketCheck {
@@ -14,4 +13,4 @@ public class TransactionOrder extends Check implements PacketCheck {
         super(player);
     }
 
-}
+}

src/main/java/ac/grim/grimac/checks/impl/movement/NegativeTimerCheck.java

@@ -1,12 +1,13 @@
 package ac.grim.grimac.checks.impl.movement;
 
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 
-@CheckData(name = "NegativeTimer", configName = "NegativeTimer", setback = 10, experimental = true)
+@CheckData(name = "NegativeTimer", configName = "NegativeTimer", setback = -1, experimental = true)
 public class NegativeTimerCheck extends TimerCheck implements PostPredictionCheck {
 
     public NegativeTimerCheck(GrimPlayer player) {
@@ -23,7 +24,7 @@ public class NegativeTimerCheck extends TimerCheck implements PostPredictionChec
 
         if (timerBalanceRealTime < lastMovementPlayerClock - clockDrift) {
             int lostMS = (int) ((System.nanoTime() - timerBalanceRealTime) / 1e6);
-            flagAndAlert("-" + lostMS);
+            if (flagAndAlert("-" + lostMS)) setbackIfAboveSetbackVL();
             timerBalanceRealTime += 50e6;
         }
     }
@@ -35,8 +36,7 @@ public class NegativeTimerCheck extends TimerCheck implements PostPredictionChec
     }
 
     @Override
-    public void reload() {
-        super.reload();
-        clockDrift = (long) (getConfig().getDoubleElse(getConfigName() + ".drift", 1200.0) * 1e6);
+    public void onReload(ConfigManager config) {
+        clockDrift = (long) (config.getDoubleElse(getConfigName() + ".drift", 1200.0) * 1e6);
     }
 }

src/main/java/ac/grim/grimac/checks/impl/movement/NoSlowA.java

@@ -1,5 +1,6 @@
 package ac.grim.grimac.checks.impl.movement;
 
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PostPredictionCheck;
@@ -33,8 +34,7 @@ public class NoSlowA extends Check implements PostPredictionCheck {
             }
 
             if (bestOffset > offsetToFlag) {
-                if (flaggedLastTick) {
-                    flagWithSetback();
+                if (flaggedLastTick && flagWithSetback()) {
                     alert("");
                 }
                 flaggedLastTick = true;
@@ -51,8 +51,7 @@ public class NoSlowA extends Check implements PostPredictionCheck {
     }
 
     @Override
-    public void reload() {
-        super.reload();
-        offsetToFlag = getConfig().getDoubleElse("NoSlowA.threshold", 0.001);
+    public void onReload(ConfigManager config) {
+        offsetToFlag = config.getDoubleElse("NoSlowA.threshold", 0.001);
     }
 }

src/main/java/ac/grim/grimac/checks/impl/movement/NoSlowB.java

@@ -35,4 +35,4 @@ public class NoSlowB extends Check implements PacketCheck {
             }
         }
     }
-}
+}

src/main/java/ac/grim/grimac/checks/impl/movement/NoSlowC.java

@@ -2,32 +2,17 @@ package ac.grim.grimac.checks.impl.movement;
 
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.checks.type.PostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
-import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
 @CheckData(name = "NoSlowC", setback = 5, experimental = true)
-public class NoSlowC extends Check implements PostPredictionCheck, PacketCheck {
+public class NoSlowC extends Check implements PostPredictionCheck {
     public NoSlowC(GrimPlayer player) {
         super(player);
     }
 
-    public boolean startedSprintingBeforeSlowMovement = false;
-
-    @Override
-    public void onPacketReceive(PacketReceiveEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
-            if (new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_SPRINTING) {
-                startedSprintingBeforeSlowMovement = false;
-            }
-        }
-    }
-
     @Override
     public void onPredictionComplete(final PredictionComplete predictionComplete) {
         if (!predictionComplete.isChecked()) return;
@@ -36,8 +21,7 @@ public class NoSlowC extends Check implements PostPredictionCheck, PacketCheck {
             ClientVersion client = player.getClientVersion();
 
             // https://bugs.mojang.com/browse/MC-152728
-            if (startedSprintingBeforeSlowMovement && client.isNewerThanOrEquals(ClientVersion.V_1_14_2)) {
-                reward();
+            if (client.isNewerThanOrEquals(ClientVersion.V_1_14_2)) {
                 return;
             }
 

src/main/java/ac/grim/grimac/checks/impl/movement/NoSlowD.java

@@ -2,42 +2,26 @@ package ac.grim.grimac.checks.impl.movement;
 
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.checks.type.PostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
-import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
 @CheckData(name = "NoSlowD", setback = 5, experimental = true)
-public class NoSlowD extends Check implements PostPredictionCheck, PacketCheck {
+public class NoSlowD extends Check implements PostPredictionCheck {
     public NoSlowD(GrimPlayer player) {
         super(player);
     }
 
-    public boolean startedSprintingBeforeUse = false;
     private boolean flaggedLastTick = false;
 
-    @Override
-    public void onPacketReceive(PacketReceiveEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
-            if (new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_SPRINTING) {
-                startedSprintingBeforeUse = false;
-            }
-        }
-    }
-
     @Override
     public void onPredictionComplete(final PredictionComplete predictionComplete) {
         if (!predictionComplete.isChecked()) return;
 
         if (player.packetStateData.isSlowedByUsingItem()) {
             // https://bugs.mojang.com/browse/MC-152728
-            if (startedSprintingBeforeUse && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_14_2)) {
-                reward();
-                flaggedLastTick = false;
+            if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_14_2)) {
                 return;
             }
 

src/main/java/ac/grim/grimac/checks/impl/movement/NoSlowE.java

@@ -2,7 +2,6 @@ package ac.grim.grimac.checks.impl.movement;
 
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.checks.type.PostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
@@ -13,7 +12,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEn
 import static com.github.retrooper.packetevents.protocol.potion.PotionTypes.BLINDNESS;
 
 @CheckData(name = "NoSlowE", setback = 5, experimental = true)
-public class NoSlowE extends Check implements PostPredictionCheck, PacketCheck {
+public class NoSlowE extends Check implements PostPredictionCheck {
     public NoSlowE(GrimPlayer player) {
         super(player);
     }

src/main/java/ac/grim/grimac/checks/impl/movement/SetbackBlocker.java

@@ -6,7 +6,6 @@ import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.util.Vector3d;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 public class SetbackBlocker extends Check implements PacketCheck {

src/main/java/ac/grim/grimac/checks/impl/movement/TickTimer.java

@@ -0,0 +1,34 @@
+package ac.grim.grimac.checks.impl.movement;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+
+
+@CheckData(name = "TickTimer", setback = 1)
+public class TickTimer extends Check implements PostPredictionCheck {
+
+    private boolean receivedTickEnd = true;
+    private int flyingPackets = 0;
+
+    public TickTimer(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (!player.supportsEndTick()) return;
+        if (isFlying(event.getPacketType()) && !player.packetStateData.lastPacketWasTeleport) {
+            if (!receivedTickEnd) flagAndAlert("type=flying, packets=" + flyingPackets);
+            receivedTickEnd = false;
+            flyingPackets++;
+        } else if (event.getPacketType() == PacketType.Play.Client.CLIENT_TICK_END) {
+            receivedTickEnd = true;
+            if (flyingPackets > 1) flagAndAlert("type=end, packets=" + flyingPackets);
+            flyingPackets = 0;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/movement/TimerCheck.java

@@ -1,5 +1,6 @@
 package ac.grim.grimac.checks.impl.movement;
 
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
@@ -7,7 +8,6 @@ import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.packettype.PacketTypeCommon;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 @CheckData(name = "Timer", configName = "TimerA", setback = 10)
 public class TimerCheck extends Check implements PacketCheck {
@@ -17,11 +17,11 @@ public class TimerCheck extends Check implements PacketCheck {
     long knownPlayerClockTime = (long) (System.nanoTime() - 6e10);
     long lastMovementPlayerClock = (long) (System.nanoTime() - 6e10);
 
-    // How long should the player be able to fall back behind their ping?
+    // How long should the player be able to fall back behind their ping? (nanos)
     // Default: 120 milliseconds
-    long clockDrift = (long) 120e6;
-
-    long limitAbuseOverPing = 1000;
+    long clockDrift;
+    // At what ping should we start to limit the balance advantage? (nanos)
+    long limitAbuseOverPing;
 
     boolean hasGottenMovementAfterTransaction = false;
 
@@ -72,35 +72,31 @@ public class TimerCheck extends Check implements PacketCheck {
         doCheck(event);
     }
 
-
     public void doCheck(final PacketReceiveEvent event) {
-        final double transactionPing = player.getTransactionPing();
-        // Limit using transaction ping if over 1000ms (default)
-        final boolean needsAdjustment = limitAbuseOverPing != -1 && transactionPing >= limitAbuseOverPing;
-        final boolean wouldFailNormal = timerBalanceRealTime > System.nanoTime();
-        final boolean failsAdjusted = needsAdjustment && (timerBalanceRealTime + ((transactionPing * 1e6) - clockDrift - 50e6)) > System.nanoTime();
-        if (wouldFailNormal || failsAdjusted) {
+        if (timerBalanceRealTime > System.nanoTime()) {
             if (flag()) {
                 // Cancel the packet
                 // Only cancel if not an adjustment setback
-                if (wouldFailNormal && shouldModifyPackets()) {
+                if (shouldModifyPackets()) {
                     event.setCancelled(true);
                     player.onPacketCancel();
                 }
 
                 if (isAboveSetbackVl()) player.getSetbackTeleportUtil().executeNonSimulatingSetback();
 
-                if (wouldFailNormal) {
-                    // Only alert if we would fail without adjusted limit
-                    alert("");
-                }
+                alert("");
             }
 
             // Reset the violation by 1 movement
             timerBalanceRealTime -= 50e6;
         }
 
-        timerBalanceRealTime = Math.max(timerBalanceRealTime, lastMovementPlayerClock - clockDrift);
+        // Limit using transaction ping if over 1000ms (default)
+        long playerClock = lastMovementPlayerClock;
+        if (System.nanoTime() - playerClock > limitAbuseOverPing) {
+            playerClock = System.nanoTime() - limitAbuseOverPing;
+        }
+        timerBalanceRealTime = Math.max(timerBalanceRealTime, playerClock - clockDrift);
     }
 
     public boolean checkForTransaction(PacketTypeCommon packetType) {
@@ -110,14 +106,12 @@ public class TimerCheck extends Check implements PacketCheck {
 
     public boolean shouldCountPacketForTimer(PacketTypeCommon packetType) {
         // If not flying, or this was a teleport, or this was a duplicate 1.17 mojang stupidity packet
-        return WrapperPlayClientPlayerFlying.isFlying(packetType) &&
-                !player.packetStateData.lastPacketWasTeleport && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate;
+        return isTickPacket(packetType);
     }
 
     @Override
-    public void reload() {
-        super.reload();
-        clockDrift = (long) (getConfig().getDoubleElse(getConfigName() + ".drift", 120.0) * 1e6);
-        limitAbuseOverPing = (long) (getConfig().getDoubleElse(getConfigName() + ".ping-abuse-limit-threshold", 1000));
+    public void onReload(ConfigManager config) {
+        clockDrift = (long) (config.getDoubleElse(getConfigName() + ".drift", 120.0) * 1e6);
+        limitAbuseOverPing = (long) (config.getDoubleElse(getConfigName() + ".ping-abuse-limit-threshold", 1000) * 1e6);
     }
 }

src/main/java/ac/grim/grimac/checks/impl/multiactions/MultiActionsA.java

@@ -0,0 +1,29 @@
+package ac.grim.grimac.checks.impl.multiactions;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.InteractionHand;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+
+@CheckData(name = "MultiActionsA", experimental = true)
+public class MultiActionsA extends Check implements PacketCheck {
+    public MultiActionsA(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.packetStateData.isSlowedByUsingItem() && (player.packetStateData.lastSlotSelected == player.packetStateData.getSlowedByUsingItemSlot() || player.packetStateData.eatingHand == InteractionHand.OFF_HAND) && event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            if (new WrapperPlayClientInteractEntity(event).getAction() == WrapperPlayClientInteractEntity.InteractAction.ATTACK) {
+                if (flagAndAlert() && shouldModifyPackets()) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/multiactions/MultiActionsB.java

@@ -0,0 +1,41 @@
+package ac.grim.grimac.checks.impl.multiactions;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.DiggingAction;
+import com.github.retrooper.packetevents.protocol.player.InteractionHand;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+
+import static ac.grim.grimac.events.packets.patch.ResyncWorldUtil.resyncPosition;
+
+@CheckData(name = "MultiActionsB", experimental = true)
+public class MultiActionsB extends Check implements PacketCheck {
+    public MultiActionsB(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.packetStateData.isSlowedByUsingItem() && (player.packetStateData.lastSlotSelected == player.packetStateData.getSlowedByUsingItemSlot() || player.packetStateData.eatingHand == InteractionHand.OFF_HAND) && event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING) {
+            // this is vanilla on 1.7
+            if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10)) {
+                return;
+            }
+
+            final WrapperPlayClientPlayerDigging packet = new WrapperPlayClientPlayerDigging(event);
+
+            if (packet.getAction() == DiggingAction.START_DIGGING || packet.getAction() == DiggingAction.CANCELLED_DIGGING || packet.getAction() == DiggingAction.FINISHED_DIGGING) {
+                if (flagAndAlert() && shouldModifyPackets()) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                    resyncPosition(player, packet.getBlockPosition());
+                }
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/multiactions/MultiActionsC.java

@@ -0,0 +1,31 @@
+package ac.grim.grimac.checks.impl.multiactions;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+
+@CheckData(name = "MultiActionsC", experimental = true)
+public class MultiActionsC extends Check implements PacketCheck {
+    public MultiActionsC(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW) {
+            String verbose = player.isSprinting && !player.isSwimming ? "sprinting" : "";
+
+            if (player.packetStateData.isSlowedByUsingItem()) {
+                verbose += (verbose.isEmpty() ? "" : ", ") + "using";
+            }
+
+            if (!verbose.isEmpty() && flagAndAlert(verbose) && shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/multiactions/MultiActionsD.java

@@ -0,0 +1,31 @@
+package ac.grim.grimac.checks.impl.multiactions;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+
+@CheckData(name = "MultiActionsD", experimental = true)
+public class MultiActionsD extends Check implements PacketCheck {
+    public MultiActionsD(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CLOSE_WINDOW) {
+            String verbose = player.isSprinting && !player.isSwimming ? "sprinting" : "";
+
+            if (player.packetStateData.isSlowedByUsingItem()) {
+                verbose += (verbose.isEmpty() ? "" : ", ") + "using";
+            }
+
+            if (!verbose.isEmpty() && flagAndAlert(verbose) && shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/multiactions/MultiActionsE.java

@@ -0,0 +1,32 @@
+package ac.grim.grimac.checks.impl.multiactions;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.InteractionHand;
+
+@CheckData(name = "MultiActionsE", experimental = true)
+public class MultiActionsE extends Check implements PacketCheck {
+    public MultiActionsE(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.packetStateData.isSlowedByUsingItem() && (player.packetStateData.lastSlotSelected == player.packetStateData.getSlowedByUsingItemSlot() || player.packetStateData.eatingHand == InteractionHand.OFF_HAND) && event.getPacketType() == PacketType.Play.Client.ANIMATION) {
+            // this is possible to false on 1.7
+            if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10)) {
+                return;
+            }
+
+            if (flagAndAlert() && shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/multiactions/MultiActionsF.java

@@ -0,0 +1,92 @@
+package ac.grim.grimac.checks.impl.multiactions;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockPlaceCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockPlace;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.DiggingAction;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static ac.grim.grimac.events.packets.patch.ResyncWorldUtil.resyncPosition;
+
+@CheckData(name = "MultiActionsF", experimental = true)
+public class MultiActionsF extends BlockPlaceCheck {
+    public MultiActionsF(GrimPlayer player) {
+        super(player);
+    }
+
+    private final List<String> flags = new ArrayList<>();
+    boolean entity, block;
+
+    @Override
+    public void onBlockPlace(BlockPlace place) {
+        block = true;
+        if (entity) {
+            if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+                if (flagAndAlert("place") && shouldModifyPackets() && shouldCancel()) {
+                    place.resync();
+                }
+            } else {
+                flags.add("place");
+            }
+        }
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            entity = true;
+            if (block) {
+                if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+                    if (flagAndAlert("entity") && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    flags.add("entity");
+                }
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING) {
+            WrapperPlayClientPlayerDigging packet = new WrapperPlayClientPlayerDigging(event);
+            if (packet.getAction() == DiggingAction.START_DIGGING || packet.getAction() == DiggingAction.FINISHED_DIGGING) {
+                block = true;
+                if (entity) {
+                    if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+                        if (flagAndAlert("dig") && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                            resyncPosition(player, packet.getBlockPosition());
+                        }
+                    } else {
+                        flags.add("dig");
+                    }
+                }
+            }
+        }
+
+        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType()) && !player.packetStateData.lastPacketWasTeleport && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate) {
+            block = entity = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (player.getClientVersion().isNewerThan(ClientVersion.V_1_8) && player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/post/PostCheck.java

@@ -15,11 +15,9 @@ import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.packettype.PacketTypeCommon;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerEntityAnimation;
 
 import java.util.ArrayDeque;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 
@@ -44,7 +42,7 @@ public class PostCheck extends Check implements PacketCheck, PostPredictionCheck
             // Okay, the user might be cheating, let's double check
             // 1.8 clients have the idle packet, and this shouldn't false on 1.8 clients
             // 1.9+ clients have predictions, which will determine if hidden tick skipping occurred
-            if (player.isTickingReliablyFor(3)) {
+            if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
                 for (String flag : flags) {
                     flagAndAlert(flag);
                 }
@@ -69,12 +67,7 @@ public class PostCheck extends Check implements PacketCheck, PostPredictionCheck
 
     @Override
     public void onPacketReceive(final PacketReceiveEvent event) {
-        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) {
-            // Don't count teleports or duplicates as movements
-            if (player.packetStateData.lastPacketWasTeleport || player.packetStateData.lastPacketWasOnePointSeventeenDuplicate) {
-                return;
-            }
-
+        if (isTickPacket(event.getPacketType())) { // Don't count teleports or duplicates as movements
             post.clear();
             sentFlying = true;
         } else {
@@ -87,6 +80,7 @@ public class PostCheck extends Check implements PacketCheck, PostPredictionCheck
                 post.clear();
                 sentFlying = false;
             } else if (PLAYER_ABILITIES.equals(packetType)
+                    || (HELD_ITEM_CHANGE.equals(packetType) && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_8))
                     || INTERACT_ENTITY.equals(packetType) || PLAYER_BLOCK_PLACEMENT.equals(packetType)
                     || USE_ITEM.equals(packetType) || PLAYER_DIGGING.equals(packetType)) {
                 if (sentFlying) post.add(event.getPacketType());

src/main/java/ac/grim/grimac/checks/impl/prediction/DebugHandler.java

@@ -9,7 +9,7 @@ import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
 import ac.grim.grimac.utils.lists.EvictingQueue;
 import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
-import org.bukkit.util.Vector;
+import ac.grim.grimac.utils.vector.Vector3D;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -45,8 +45,8 @@ public class DebugHandler extends Check implements PostPredictionCheck {
 
         ChatColor color = pickColor(offset, offset);
 
-        Vector predicted = player.predictedVelocity.vector;
-        Vector actually = player.actualMovement;
+        Vector3D predicted = player.predictedVelocity.vector;
+        Vector3D actually = player.actualMovement;
 
         ChatColor xColor = pickColor(Math.abs(predicted.getX() - actually.getX()), offset);
         ChatColor yColor = pickColor(Math.abs(predicted.getY() - actually.getY()), offset);

src/main/java/ac/grim/grimac/checks/impl/prediction/OffsetHandler.java

@@ -1,5 +1,6 @@
 package ac.grim.grimac.checks.impl.prediction;
 
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.api.events.CompletePredictionEvent;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
@@ -99,14 +100,12 @@ public class OffsetHandler extends Check implements PostPredictionCheck {
     }
 
     @Override
-    public void reload() {
-        super.reload();
-        setbackDecayMultiplier = getConfig().getDoubleElse("Simulation.setback-decay-multiplier", 0.999);
-        threshold = getConfig().getDoubleElse("Simulation.threshold", 0.001);
-        immediateSetbackThreshold = getConfig().getDoubleElse("Simulation.immediate-setback-threshold", 0.1);
-        maxAdvantage = getConfig().getDoubleElse("Simulation.max-advantage", 1);
-        maxCeiling = getConfig().getDoubleElse("Simulation.max-ceiling", 4);
-
+    public void onReload(ConfigManager config) {
+        setbackDecayMultiplier = config.getDoubleElse("Simulation.setback-decay-multiplier", 0.999);
+        threshold = config.getDoubleElse("Simulation.threshold", 0.001);
+        immediateSetbackThreshold = config.getDoubleElse("Simulation.immediate-setback-threshold", 0.1);
+        maxAdvantage = config.getDoubleElse("Simulation.max-advantage", 1);
+        maxCeiling = config.getDoubleElse("Simulation.max-ceiling", 4);
         if (maxAdvantage == -1) maxAdvantage = Double.MAX_VALUE;
         if (immediateSetbackThreshold == -1) immediateSetbackThreshold = Double.MAX_VALUE;
     }

src/main/java/ac/grim/grimac/checks/impl/scaffolding/AirLiquidPlace.java

@@ -1,5 +1,6 @@
 package ac.grim.grimac.checks.impl.scaffolding;
 
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.BlockPlaceCheck;
 import ac.grim.grimac.player.GrimPlayer;
@@ -29,8 +30,7 @@ public class AirLiquidPlace extends BlockPlaceCheck {
     }
 
     @Override
-    public void reload() {
-        super.reload();
-        this.cancelVL = getConfig().getIntElse(getConfigName() + ".cancelVL", 0);
+    public void onReload(ConfigManager config) {
+        this.cancelVL = config.getIntElse(getConfigName() + ".cancelVL", 0);
     }
 }

src/main/java/ac/grim/grimac/checks/impl/scaffolding/FarPlace.java

@@ -7,11 +7,11 @@ import ac.grim.grimac.utils.anticheat.update.BlockPlace;
 import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
 import ac.grim.grimac.utils.math.VectorUtils;
 import com.github.retrooper.packetevents.protocol.attribute.Attributes;
-import com.github.retrooper.packetevents.protocol.player.ClientVersion;
-import com.github.retrooper.packetevents.protocol.player.GameMode;
 import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
 import com.github.retrooper.packetevents.util.Vector3i;
-import org.bukkit.util.Vector;
+import ac.grim.grimac.utils.vector.Vector3D;
+
+import static ac.grim.grimac.utils.vector.VectorFactory.newVector3D;
 
 @CheckData(name = "FarPlace")
 public class FarPlace extends BlockPlaceCheck {
@@ -26,10 +26,11 @@ public class FarPlace extends BlockPlaceCheck {
         if (place.getMaterial() == StateTypes.SCAFFOLDING) return;
 
         double min = Double.MAX_VALUE;
-        for (double d : player.getPossibleEyeHeights()) {
+        final double[] possibleEyeHeights = player.getPossibleEyeHeights();
+        for (double d : possibleEyeHeights) {
             SimpleCollisionBox box = new SimpleCollisionBox(blockPos);
-            Vector eyes = new Vector(player.x, player.y + d, player.z);
-            Vector best = VectorUtils.cutBoxToVector(eyes, box);
+            Vector3D eyes = newVector3D(player.x, player.y + d, player.z);
+            Vector3D best = VectorUtils.cutBoxToVector(eyes, box);
             min = Math.min(min, eyes.distanceSquared(best));
         }
 

src/main/java/ac/grim/grimac/checks/impl/scaffolding/MultiPlace.java

@@ -0,0 +1,73 @@
+package ac.grim.grimac.checks.impl.scaffolding;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockPlaceCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.MessageUtil;
+import ac.grim.grimac.utils.anticheat.update.BlockPlace;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.world.BlockFace;
+import com.github.retrooper.packetevents.util.Vector3f;
+import com.github.retrooper.packetevents.util.Vector3i;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@CheckData(name = "MultiPlace", experimental = true)
+public class MultiPlace extends BlockPlaceCheck {
+    public MultiPlace(GrimPlayer player) {
+        super(player);
+    }
+
+    private final List<String> flags = new ArrayList<>();
+
+    private boolean hasPlaced;
+    private BlockFace lastFace;
+    private Vector3f lastCursor;
+    private Vector3i lastPos;
+
+    @Override
+    public void onBlockPlace(final BlockPlace place) {
+        final BlockFace face = place.getDirection();
+        final Vector3f cursor = place.getCursor();
+        final Vector3i pos = place.getPlacedAgainstBlockLocation();
+
+        if (hasPlaced && (face != lastFace || !cursor.equals(lastCursor) || !pos.equals(lastPos))) {
+            final String verbose = "face=" + face + ", lastFace=" + lastFace
+                    + ", cursor=" + MessageUtil.toUnlabledString(cursor) + ", lastCursor=" + MessageUtil.toUnlabledString(lastCursor)
+                    + ", pos=" + MessageUtil.toUnlabledString(pos) + ", lastPos=" + MessageUtil.toUnlabledString(lastPos);
+            if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+                if (flagAndAlert(verbose) && shouldModifyPackets() && shouldCancel()) {
+                    place.resync();
+                }
+            } else {
+                flags.add(verbose);
+            }
+        }
+
+        lastFace = face;
+        lastCursor = cursor;
+        lastPos = pos;
+        hasPlaced = true;
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (isTickPacket(event.getPacketType())) {
+            hasPlaced = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (player.getClientVersion().isNewerThan(ClientVersion.V_1_8) && player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/scaffolding/PositionPlace.java

@@ -8,7 +8,6 @@ import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
 
-import java.util.Collections;
 
 @CheckData(name = "PositionPlace")
 public class PositionPlace extends BlockPlaceCheck {
@@ -28,8 +27,13 @@ public class PositionPlace extends BlockPlaceCheck {
         // Each position represents the best case scenario to have clicked
         //
         // We will now calculate the most optimal position for the player's head to be in
-        double minEyeHeight = Collections.min(player.getPossibleEyeHeights());
-        double maxEyeHeight = Collections.max(player.getPossibleEyeHeights());
+        final double[] possibleEyeHeights = player.getPossibleEyeHeights();
+        double minEyeHeight = Double.MAX_VALUE;
+        double maxEyeHeight = Double.MIN_VALUE;
+        for (double height : possibleEyeHeights) {
+            minEyeHeight = Math.min(minEyeHeight, height);
+            maxEyeHeight = Math.max(maxEyeHeight, height);
+        }
         // I love the idle packet, why did you remove it mojang :(
         // Don't give 0.03 lenience if the player is a 1.8 player and we know they couldn't have 0.03'd because idle packet
         double movementThreshold = !player.packetStateData.didLastMovementIncludePosition || player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9) ? player.getMovementThreshold() : 0;
@@ -44,27 +48,21 @@ public class PositionPlace extends BlockPlaceCheck {
 
         // So now we have the player's possible eye positions
         // So then look at the face that the player has clicked
-        boolean flag = false;
-        switch (place.getDirection()) {
-            case NORTH: // Z- face
-                flag = eyePositions.minZ > combined.minZ;
-                break;
-            case SOUTH: // Z+ face
-                flag = eyePositions.maxZ < combined.maxZ;
-                break;
-            case EAST: // X+ face
-                flag = eyePositions.maxX < combined.maxX;
-                break;
-            case WEST: // X- face
-                flag = eyePositions.minX > combined.minX;
-                break;
-            case UP: // Y+ face
-                flag = eyePositions.maxY < combined.maxY;
-                break;
-            case DOWN: // Y- face
-                flag = eyePositions.minY > combined.minY;
-                break;
-        }
+        boolean flag = switch (place.getDirection()) {
+            case NORTH -> // Z- face
+                    eyePositions.minZ > combined.minZ;
+            case SOUTH -> // Z+ face
+                    eyePositions.maxZ < combined.maxZ;
+            case EAST -> // X+ face
+                    eyePositions.maxX < combined.maxX;
+            case WEST -> // X- face
+                    eyePositions.minX > combined.minX;
+            case UP -> // Y+ face
+                    eyePositions.maxY < combined.maxY;
+            case DOWN -> // Y- face
+                    eyePositions.minY > combined.minY;
+            default -> false;
+        };
 
         if (flag) {
             if (flagAndAlert() && shouldModifyPackets() && shouldCancel()) {

src/main/java/ac/grim/grimac/checks/impl/scaffolding/RotationPlace.java

@@ -8,6 +8,7 @@ import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
 import ac.grim.grimac.utils.data.Pair;
 import ac.grim.grimac.utils.nmsutil.Ray;
 import ac.grim.grimac.utils.nmsutil.ReachUtils;
+import ac.grim.grimac.utils.vector.Vector3D;
 import com.github.retrooper.packetevents.protocol.attribute.Attributes;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
@@ -15,7 +16,6 @@ import com.github.retrooper.packetevents.protocol.world.BlockFace;
 import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
 import com.github.retrooper.packetevents.util.Vector3d;
 import com.github.retrooper.packetevents.util.Vector3f;
-import org.bukkit.util.Vector;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -71,13 +71,19 @@ public class RotationPlace extends BlockPlaceCheck {
         SimpleCollisionBox box = new SimpleCollisionBox(place.getPlacedAgainstBlockLocation());
 
         List<Vector3f> possibleLookDirs = new ArrayList<>(Arrays.asList(
-                new Vector3f(player.lastXRot, player.yRot, 0),
-                new Vector3f(player.xRot, player.yRot, 0)
+                new Vector3f(player.xRot, player.yRot, 0),
+                new Vector3f(player.lastXRot, player.yRot, 0)
         ));
 
+        final double[] possibleEyeHeights = player.getPossibleEyeHeights();
+
         // Start checking if player is in the block
-        double minEyeHeight = Collections.min(player.getPossibleEyeHeights());
-        double maxEyeHeight = Collections.max(player.getPossibleEyeHeights());
+        double minEyeHeight = Double.MAX_VALUE;
+        double maxEyeHeight = Double.MIN_VALUE;
+        for (double height : possibleEyeHeights) {
+            minEyeHeight = Math.min(minEyeHeight, height);
+            maxEyeHeight = Math.max(maxEyeHeight, height);
+        }
 
         SimpleCollisionBox eyePositions = new SimpleCollisionBox(player.x, player.y + minEyeHeight, player.z, player.x, player.y + maxEyeHeight, player.z);
         eyePositions.expand(player.getMovementThreshold());
@@ -99,15 +105,15 @@ public class RotationPlace extends BlockPlaceCheck {
         }
 
         final double distance = player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_BLOCK_INTERACTION_RANGE);
-        for (double d : player.getPossibleEyeHeights()) {
+        for (double d : possibleEyeHeights) {
             for (Vector3f lookDir : possibleLookDirs) {
                 // x, y, z are correct for the block placement even after post tick because of code elsewhere
                 Vector3d starting = new Vector3d(player.x, player.y + d, player.z);
                 // xRot and yRot are a tick behind
                 Ray trace = new Ray(player, starting.getX(), starting.getY(), starting.getZ(), lookDir.getX(), lookDir.getY());
-                Pair<Vector, BlockFace> intercept = ReachUtils.calculateIntercept(box, trace.getOrigin(), trace.getPointAtDistance(distance));
+                Pair<Vector3D, BlockFace> intercept = ReachUtils.calculateIntercept(box, trace.getOrigin(), trace.getPointAtDistance(distance));
 
-                if (intercept.getFirst() != null) return true;
+                if (intercept.first() != null) return true;
             }
         }
 

src/main/java/ac/grim/grimac/checks/impl/velocity/ExplosionHandler.java

@@ -1,5 +1,6 @@
 package ac.grim.grimac.checks.impl.velocity;
 
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PostPredictionCheck;
@@ -18,13 +19,13 @@ import com.github.retrooper.packetevents.util.Vector3f;
 import com.github.retrooper.packetevents.util.Vector3i;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerExplosion;
 import lombok.Getter;
-import org.bukkit.Bukkit;
-import org.bukkit.util.Vector;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Deque;
 import java.util.LinkedList;
 
+import static ac.grim.grimac.utils.vector.VectorFactory.newVector3D;
+
 @CheckData(name = "AntiExplosion", configName = "Explosion", setback = 10)
 public class ExplosionHandler extends Check implements PostPredictionCheck {
     Deque<VelocityData> firstBreadMap = new LinkedList<>();
@@ -121,7 +122,7 @@ public class ExplosionHandler extends Check implements PostPredictionCheck {
     }
 
     public void addPlayerExplosion(int breadOne, Vector3f explosion) {
-        firstBreadMap.add(new VelocityData(-1, breadOne, player.getSetbackTeleportUtil().isSendingSetback, new Vector(explosion.getX(), explosion.getY(), explosion.getZ())));
+        firstBreadMap.add(new VelocityData(-1, breadOne, player.getSetbackTeleportUtil().isSendingSetback, newVector3D(explosion.getX(), explosion.getY(), explosion.getZ())));
     }
 
     public void setPointThree(boolean isPointThree) {
@@ -256,12 +257,10 @@ public class ExplosionHandler extends Check implements PostPredictionCheck {
     }
 
     @Override
-    public void reload() {
-        super.reload();
-
-        offsetToFlag = getConfig().getDoubleElse("Explosion.threshold", 0.00001);
-        setbackVL = getConfig().getDoubleElse("Explosion.setbackvl", 10);
-
+    public void onReload(ConfigManager config) {
+        offsetToFlag = config.getDoubleElse("Explosion.threshold", 0.00001);
+        setbackVL = config.getDoubleElse("Explosion.setbackvl", 10);
         if (setbackVL == -1) setbackVL = Double.MAX_VALUE;
     }
+
 }

src/main/java/ac/grim/grimac/checks/impl/velocity/KnockbackHandler.java

@@ -1,6 +1,7 @@
 package ac.grim.grimac.checks.impl.velocity;
 
 import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PostPredictionCheck;
@@ -14,12 +15,14 @@ import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.util.Vector3d;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerEntityVelocity;
 import lombok.Getter;
-import org.bukkit.util.Vector;
+import ac.grim.grimac.utils.vector.Vector3D;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Deque;
 import java.util.LinkedList;
 
+import static ac.grim.grimac.utils.vector.VectorFactory.newVector3D;
+
 // We are making a velocity sandwich between two pieces of transaction packets (bread)
 @CheckData(name = "AntiKB", alternativeName = "AntiKnockback", configName = "Knockback", setback = 10, decay = 0.025)
 public class KnockbackHandler extends Check implements PostPredictionCheck {
@@ -65,16 +68,17 @@ public class KnockbackHandler extends Check implements PostPredictionCheck {
             if (playerVelocity.getY() == -0.04) {
                 velocity.setVelocity(playerVelocity.add(new Vector3d(0, 1 / 8000D, 0)));
                 playerVelocity = velocity.getVelocity();
+                event.markForReEncode(true);
             }
 
             // Wrap velocity between two transactions
             player.sendTransaction();
-            addPlayerKnockback(entityId, player.lastTransactionSent.get(), new Vector(playerVelocity.getX(), playerVelocity.getY(), playerVelocity.getZ()));
+            addPlayerKnockback(entityId, player.lastTransactionSent.get(), newVector3D(playerVelocity.getX(), playerVelocity.getY(), playerVelocity.getZ()));
             event.getTasksAfterSend().add(player::sendTransaction);
         }
     }
 
-    @NotNull public Pair<VelocityData, Vector> getFutureKnockback() {
+    @NotNull public Pair<VelocityData, Vector3D> getFutureKnockback() {
         // Chronologically in the future
         if (firstBreadMap.size() > 0) {
             VelocityData data = firstBreadMap.peek();
@@ -96,7 +100,7 @@ public class KnockbackHandler extends Check implements PostPredictionCheck {
         return new Pair<>(null, null);
     }
 
-    private void addPlayerKnockback(int entityID, int breadOne, Vector knockback) {
+    private void addPlayerKnockback(int entityID, int breadOne, Vector3D knockback) {
         firstBreadMap.add(new VelocityData(entityID, breadOne, player.getSetbackTeleportUtil().isSendingSetback, knockback));
     }
 
@@ -240,15 +244,14 @@ public class KnockbackHandler extends Check implements PostPredictionCheck {
     }
 
     @Override
-    public void reload() {
-        super.reload();
-        offsetToFlag = getConfig().getDoubleElse("Knockback.threshold", 0.001);
-        maxAdv = getConfig().getDoubleElse("Knockback.max-advantage", 1);
-        immediate = getConfig().getDoubleElse("Knockback.immediate-setback-threshold", 0.1);
-        multiplier = getConfig().getDoubleElse("Knockback.setback-decay-multiplier", 0.999);
-        ceiling = getConfig().getDoubleElse("Knockback.max-ceiling", 4);
-
+    public void onReload(ConfigManager config) {
+        offsetToFlag = config.getDoubleElse("Knockback.threshold", 0.001);
+        maxAdv = config.getDoubleElse("Knockback.max-advantage", 1);
+        immediate = config.getDoubleElse("Knockback.immediate-setback-threshold", 0.1);
+        multiplier = config.getDoubleElse("Knockback.setback-decay-multiplier", 0.999);
+        ceiling = config.getDoubleElse("Knockback.max-ceiling", 4);
         if (maxAdv < 0) maxAdv = Double.MAX_VALUE;
         if (immediate < 0) immediate = Double.MAX_VALUE;
     }
+
 }

src/main/java/ac/grim/grimac/checks/type/BlockPlaceCheck.java

@@ -1,10 +1,12 @@
 package ac.grim.grimac.checks.type;
 
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.BlockPlace;
 import ac.grim.grimac.utils.collisions.HitboxData;
 import ac.grim.grimac.utils.collisions.datatypes.CollisionBox;
+import ac.grim.grimac.utils.collisions.datatypes.ComplexCollisionBox;
 import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
 import com.github.retrooper.packetevents.protocol.world.states.defaulttags.BlockTags;
 import com.github.retrooper.packetevents.protocol.world.states.type.StateType;
@@ -14,9 +16,10 @@ import com.github.retrooper.packetevents.util.Vector3i;
 import java.util.ArrayList;
 import java.util.List;
 
-public class BlockPlaceCheck extends Check implements RotationCheck {
+public class BlockPlaceCheck extends Check implements RotationCheck, PostPredictionCheck {
     private static final List<StateType> weirdBoxes = new ArrayList<>();
     private static final List<StateType> buggyBoxes = new ArrayList<>();
+    private final SimpleCollisionBox[] boxes = new SimpleCollisionBox[ComplexCollisionBox.DEFAULT_MAX_COLLISION_BOX_SIZE];
 
     protected int cancelVL;
 
@@ -33,9 +36,8 @@ public class BlockPlaceCheck extends Check implements RotationCheck {
     }
 
     @Override
-    public void reload() {
-        super.reload();
-        this.cancelVL = getConfig().getIntElse(getConfigName() + ".cancelVL", 5);
+    public void onReload(ConfigManager config) {
+        this.cancelVL = config.getIntElse(getConfigName() + ".cancelVL", 5);
     }
 
     protected boolean shouldCancel() {
@@ -69,11 +71,11 @@ public class BlockPlaceCheck extends Check implements RotationCheck {
         Vector3i clicked = place.getPlacedAgainstBlockLocation();
         CollisionBox placedOn = HitboxData.getBlockHitbox(player, place.getMaterial(), player.getClientVersion(), player.compensatedWorld.getWrappedBlockStateAt(clicked), clicked.getX(), clicked.getY(), clicked.getZ());
 
-        List<SimpleCollisionBox> boxes = new ArrayList<>();
-        placedOn.downCast(boxes);
+        int size = placedOn.downCast(boxes);
 
         SimpleCollisionBox combined = new SimpleCollisionBox(clicked.getX(), clicked.getY(), clicked.getZ());
-        for (SimpleCollisionBox box : boxes) {
+        for (int i = 0; i < size; i++) {
+            SimpleCollisionBox box = boxes[i];
             double minX = Math.max(box.minX, combined.minX);
             double minY = Math.max(box.minY, combined.minY);
             double minZ = Math.max(box.minZ, combined.minZ);

src/main/java/ac/grim/grimac/checks/type/PacketCheck.java

@@ -1,19 +1,10 @@
 package ac.grim.grimac.checks.type;
 
-
 import ac.grim.grimac.api.AbstractCheck;
-import ac.grim.grimac.utils.anticheat.update.PositionUpdate;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
 
 public interface PacketCheck extends AbstractCheck {
-
-    default void onPacketReceive(final PacketReceiveEvent event) {
-    }
-
-    default void onPacketSend(final PacketSendEvent event) {
-    }
-
-    default void onPositionUpdate(final PositionUpdate positionUpdate) {
-    }
+    default void onPacketReceive(final PacketReceiveEvent event) {}
+    default void onPacketSend(final PacketSendEvent event) {}
 }

src/main/java/ac/grim/grimac/checks/type/RotationCheck.java

@@ -1,8 +1,6 @@
 package ac.grim.grimac.checks.type;
 
 import ac.grim.grimac.api.AbstractCheck;
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.RotationUpdate;
 
 public interface RotationCheck extends AbstractCheck {

src/main/java/ac/grim/grimac/checks/type/VehicleCheck.java

@@ -1,8 +1,6 @@
 package ac.grim.grimac.checks.type;
 
 import ac.grim.grimac.api.AbstractCheck;
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.VehiclePositionUpdate;
 
 public interface VehicleCheck extends AbstractCheck {

src/main/java/ac/grim/grimac/commands/GrimDebug.java

@@ -70,4 +70,4 @@ public class GrimDebug extends BaseCommand {
 
         sender.sendMessage("Console output for " + (grimPlayer.bukkitPlayer == null ? grimPlayer.user.getProfile().getName() : grimPlayer.bukkitPlayer.getName()) + " is now " + isOutput);
     }
-}
+}

src/main/java/ac/grim/grimac/commands/GrimProfile.java

@@ -1,12 +1,9 @@
 package ac.grim.grimac.commands;
 
 import ac.grim.grimac.GrimAPI;
-import ac.grim.grimac.checks.impl.aim.processor.AimProcessor;
-import ac.grim.grimac.checks.impl.misc.ClientBrand;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.MessageUtil;
 import ac.grim.grimac.utils.anticheat.MultiLibUtil;
-import ac.grim.grimac.utils.math.GrimMath;
 import co.aikar.commands.BaseCommand;
 import co.aikar.commands.annotation.CommandAlias;
 import co.aikar.commands.annotation.CommandCompletion;

src/main/java/ac/grim/grimac/commands/GrimReload.java

@@ -1,15 +1,11 @@
 package ac.grim.grimac.commands;
 
 import ac.grim.grimac.GrimAPI;
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.MessageUtil;
 import co.aikar.commands.BaseCommand;
 import co.aikar.commands.annotation.CommandAlias;
 import co.aikar.commands.annotation.CommandPermission;
 import co.aikar.commands.annotation.Subcommand;
-import com.github.retrooper.packetevents.netty.channel.ChannelHelper;
-import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
 
 @CommandAlias("grim|grimac")
@@ -18,14 +14,15 @@ public class GrimReload extends BaseCommand {
     @CommandPermission("grim.reload")
     public void onReload(CommandSender sender) {
         //reload config
-        try {
-            GrimAPI.INSTANCE.getExternalAPI().reload();
-        } catch (RuntimeException e) {
-            sender.sendMessage(ChatColor.RED + e.getMessage());
-            return;
-        }
-
-        sender.sendMessage(MessageUtil.format("%prefix% &fConfig has been reloaded."));
+        sender.sendMessage(MessageUtil.format("%prefix% &7Reloading config..."));
+        GrimAPI.INSTANCE.getExternalAPI().reloadAsync().exceptionally(throwable -> false)
+                .thenAccept(bool -> {
+                    if (bool) {
+                        sender.sendMessage(MessageUtil.format("%prefix% &fConfig has been reloaded."));
+                    } else {
+                        sender.sendMessage(MessageUtil.format("%prefix% &cFailed to reload config."));
+                    }
+                });
     }
 
 }

src/main/java/ac/grim/grimac/commands/GrimSendAlert.java

@@ -20,7 +20,7 @@ public class GrimSendAlert extends BaseCommand {
             bukkitPlayer.sendMessage(string);
         }
 
-        if (GrimAPI.INSTANCE.getConfigManager().getConfig().getBooleanElse("alerts.print-to-console", true)) {
+        if (GrimAPI.INSTANCE.getConfigManager().isPrintAlertsToConsole()) {
             LogUtil.console(string); // Print alert to console
         }
     }

src/main/java/ac/grim/grimac/commands/GrimSpectate.java

@@ -23,8 +23,7 @@ public class GrimSpectate extends BaseCommand {
     @CommandPermission("grim.spectate")
     @CommandCompletion("@players")
     public void onSpectate(CommandSender sender, @Optional OnlinePlayer target) {
-        if (!(sender instanceof Player)) return;
-        Player player = (Player) sender;
+        if (!(sender instanceof Player player)) return;
 
         if (target != null && target.getPlayer().getUniqueId().equals(player.getUniqueId())) {
             String message = GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("cannot-run-on-self", "%prefix% &cYou cannot use this command on yourself!");

src/main/java/ac/grim/grimac/commands/GrimStopSpectating.java

@@ -3,6 +3,8 @@ package ac.grim.grimac.commands;
 import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.utils.anticheat.MessageUtil;
 import co.aikar.commands.BaseCommand;
+import co.aikar.commands.BukkitCommandCompletionContext;
+import co.aikar.commands.CommandCompletions.CommandCompletionHandler;
 import co.aikar.commands.annotation.CommandAlias;
 import co.aikar.commands.annotation.CommandCompletion;
 import co.aikar.commands.annotation.CommandPermission;
@@ -10,17 +12,21 @@ import co.aikar.commands.annotation.Subcommand;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
+import java.util.List;
+
 @CommandAlias("grim|grimac")
 public class GrimStopSpectating extends BaseCommand {
+    public static final CommandCompletionHandler<BukkitCommandCompletionContext> completionHandler = context -> context.getSender().hasPermission("grim.spectate.stophere") ? List.of("here") : List.of();
+
     @Subcommand("stopspectating")
     @CommandPermission("grim.spectate")
-    @CommandCompletion("here")
+    @CommandCompletion("@stopspectating")
     public void onStopSpectate(CommandSender sender, String[] args) {
         String string = args.length > 0 ? args[0] : null;
         if (!(sender instanceof Player)) return;
         Player player = (Player) sender;
         if (GrimAPI.INSTANCE.getSpectateManager().isSpectating(player.getUniqueId())) {
-            boolean teleportBack = string == null || !string.equalsIgnoreCase("here");
+            boolean teleportBack = string == null || !string.equalsIgnoreCase("here") || !sender.hasPermission("grim.spectate.stophere");
             GrimAPI.INSTANCE.getSpectateManager().disable(player, teleportBack);
         } else {
             String message = GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("cannot-spectate-return", "%prefix% &cYou can only do this after spectating a player.");
@@ -28,4 +34,3 @@ public class GrimStopSpectating extends BaseCommand {
         }
     }
 }
-

src/main/java/ac/grim/grimac/events/packets/CheckManagerListener.java

@@ -14,8 +14,11 @@ import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
 import ac.grim.grimac.utils.data.*;
 import ac.grim.grimac.utils.inventory.Inventory;
 import ac.grim.grimac.utils.latency.CompensatedWorld;
+import ac.grim.grimac.utils.math.GrimMath;
 import ac.grim.grimac.utils.math.VectorUtils;
 import ac.grim.grimac.utils.nmsutil.*;
+import ac.grim.grimac.utils.vector.Vector3D;
+import ac.grim.grimac.utils.vector.VectorFactory;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketListenerAbstract;
 import com.github.retrooper.packetevents.event.PacketListenerPriority;
@@ -46,9 +49,11 @@ import com.github.retrooper.packetevents.wrapper.play.client.*;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerAcknowledgeBlockChanges;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerSetSlot;
 import io.github.retrooper.packetevents.util.SpigotConversionUtil;
+
 import java.util.ArrayList;
 import java.util.List;
-import org.bukkit.util.Vector;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 
 public class CheckManagerListener extends PacketListenerAbstract {
 
@@ -56,8 +61,79 @@ public class CheckManagerListener extends PacketListenerAbstract {
         super(PacketListenerPriority.LOW);
     }
 
+    // Copied from MCP...
+    // Returns null if there isn't anything.
+    //
+    // I do have to admit that I'm starting to like bifunctions/new java 8 things more than I originally did.
+    // although I still don't understand Mojang's obsession with streams in some of the hottest methods... that kills performance
+    public static HitData traverseBlocks(GrimPlayer player, Vector3d start, Vector3d end, BiFunction<WrappedBlockState, Vector3i, HitData> predicate) {
+        // I guess go back by the collision epsilon?
+        double endX = GrimMath.lerp(-1.0E-7D, end.x, start.x);
+        double endY = GrimMath.lerp(-1.0E-7D, end.y, start.y);
+        double endZ = GrimMath.lerp(-1.0E-7D, end.z, start.z);
+        double startX = GrimMath.lerp(-1.0E-7D, start.x, end.x);
+        double startY = GrimMath.lerp(-1.0E-7D, start.y, end.y);
+        double startZ = GrimMath.lerp(-1.0E-7D, start.z, end.z);
+        int floorStartX = GrimMath.floor(startX);
+        int floorStartY = GrimMath.floor(startY);
+        int floorStartZ = GrimMath.floor(startZ);
+
+
+        if (start.equals(end)) return null;
+
+        WrappedBlockState state = player.compensatedWorld.getWrappedBlockStateAt(floorStartX, floorStartY, floorStartZ);
+        HitData apply = predicate.apply(state, new Vector3i(floorStartX, floorStartY, floorStartZ));
+
+        if (apply != null) {
+            return apply;
+        }
+
+        double xDiff = endX - startX;
+        double yDiff = endY - startY;
+        double zDiff = endZ - startZ;
+        double xSign = Math.signum(xDiff);
+        double ySign = Math.signum(yDiff);
+        double zSign = Math.signum(zDiff);
+
+        double posXInverse = xSign == 0 ? Double.MAX_VALUE : xSign / xDiff;
+        double posYInverse = ySign == 0 ? Double.MAX_VALUE : ySign / yDiff;
+        double posZInverse = zSign == 0 ? Double.MAX_VALUE : zSign / zDiff;
+
+        double d12 = posXInverse * (xSign > 0 ? 1.0D - GrimMath.frac(startX) : GrimMath.frac(startX));
+        double d13 = posYInverse * (ySign > 0 ? 1.0D - GrimMath.frac(startY) : GrimMath.frac(startY));
+        double d14 = posZInverse * (zSign > 0 ? 1.0D - GrimMath.frac(startZ) : GrimMath.frac(startZ));
+
+        // Can't figure out what this code does currently
+        while (d12 <= 1.0D || d13 <= 1.0D || d14 <= 1.0D) {
+            if (d12 < d13) {
+                if (d12 < d14) {
+                    floorStartX += xSign;
+                    d12 += posXInverse;
+                } else {
+                    floorStartZ += zSign;
+                    d14 += posZInverse;
+                }
+            } else if (d13 < d14) {
+                floorStartY += ySign;
+                d13 += posYInverse;
+            } else {
+                floorStartZ += zSign;
+                d14 += posZInverse;
+            }
+
+            state = player.compensatedWorld.getWrappedBlockStateAt(floorStartX, floorStartY, floorStartZ);
+            apply = predicate.apply(state, new Vector3i(floorStartX, floorStartY, floorStartZ));
+
+            if (apply != null) {
+                return apply;
+            }
+        }
+
+        return null;
+    }
+
     private static void placeWaterLavaSnowBucket(GrimPlayer player, ItemStack held, StateType toPlace, InteractionHand hand) {
-        HitData data = BlockRayTrace.getNearestHitResult(player, StateTypes.AIR, false);
+        HitData data = getNearestHitResult(player, StateTypes.AIR, false);
         if (data != null) {
             BlockPlace blockPlace = new BlockPlace(player, hand, data.getPosition(), data.getClosestDirection().getFaceValue(), data.getClosestDirection(), held, data);
 
@@ -150,11 +226,10 @@ public class CheckManagerListener extends PacketListenerAbstract {
         }
     }
 
-    private static void handleBlockPlaceOrUseItem(PacketWrapper packet, GrimPlayer player) {
+    private static void handleBlockPlaceOrUseItem(PacketWrapper<?> packet, GrimPlayer player) {
         // Legacy "use item" packet
-        if (packet instanceof WrapperPlayClientPlayerBlockPlacement &&
+        if (packet instanceof WrapperPlayClientPlayerBlockPlacement place &&
                 PacketEvents.getAPI().getServerManager().getVersion().isOlderThan(ServerVersion.V_1_9)) {
-            WrapperPlayClientPlayerBlockPlacement place = (WrapperPlayClientPlayerBlockPlacement) packet;
 
             if (player.gamemode == GameMode.SPECTATOR || player.gamemode == GameMode.ADVENTURE) return;
 
@@ -169,9 +244,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
             }
         }
 
-        if (packet instanceof WrapperPlayClientUseItem) {
-            WrapperPlayClientUseItem place = (WrapperPlayClientUseItem) packet;
-
+        if (packet instanceof WrapperPlayClientUseItem place) {
             if (player.gamemode == GameMode.SPECTATOR || player.gamemode == GameMode.ADVENTURE) return;
 
             ItemStack placedWith = player.getInventory().getHeldItem();
@@ -183,9 +256,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
         }
 
         // Check for interactable first (door, etc)
-        if (packet instanceof WrapperPlayClientPlayerBlockPlacement) {
-            WrapperPlayClientPlayerBlockPlacement place = (WrapperPlayClientPlayerBlockPlacement) packet;
-
+        if (packet instanceof WrapperPlayClientPlayerBlockPlacement place) {
             ItemStack placedWith = player.getInventory().getHeldItem();
             ItemStack offhand = player.getInventory().getOffHand();
 
@@ -194,7 +265,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
             // The offhand is unable to interact with blocks like this... try to stop some desync points before they happen
             if ((!player.isSneaking || onlyAir) && place.getHand() == InteractionHand.MAIN_HAND) {
                 Vector3i blockPosition = place.getBlockPosition();
-                BlockPlace blockPlace = new BlockPlace(player, place.getHand(), blockPosition, place.getFaceId(), place.getFace(), placedWith, BlockRayTrace.getNearestHitResult(player, null, true));
+                BlockPlace blockPlace = new BlockPlace(player, place.getHand(), blockPosition, place.getFaceId(), place.getFace(), placedWith, getNearestHitResult(player, null, true));
 
                 // Right-clicking a trapdoor/door/etc.
                 StateType placedAgainst = blockPlace.getPlacedAgainstMaterial();
@@ -221,8 +292,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
             }
         }
 
-        if (packet instanceof WrapperPlayClientPlayerBlockPlacement) {
-            WrapperPlayClientPlayerBlockPlacement place = (WrapperPlayClientPlayerBlockPlacement) packet;
+        if (packet instanceof WrapperPlayClientPlayerBlockPlacement place) {
             Vector3i blockPosition = place.getBlockPosition();
             BlockFace face = place.getFace();
 
@@ -234,7 +304,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
                 placedWith = player.getInventory().getOffHand();
             }
 
-            BlockPlace blockPlace = new BlockPlace(player, place.getHand(), blockPosition, place.getFaceId(), face, placedWith, BlockRayTrace.getNearestHitResult(player, null, true));
+            BlockPlace blockPlace = new BlockPlace(player, place.getHand(), blockPosition, place.getFaceId(), face, placedWith, getNearestHitResult(player, null, true));
             // At this point, it is too late to cancel, so we can only flag, and cancel subsequent block places more aggressively
             if (!player.compensatedEntities.getSelf().inVehicle()) {
                 player.checkManager.onPostFlyingBlockPlace(blockPlace);
@@ -274,7 +344,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
             // Additionally, only yaw/pitch matters: https://github.com/GrimAnticheat/Grim/issues/1275#issuecomment-1872444018
             // 1.9+ isn't impacted by this packet as much.
             if (PacketEvents.getAPI().getServerManager().getVersion().isOlderThanOrEquals(ServerVersion.V_1_9)) {
-                if (GrimAPI.INSTANCE.getConfigManager().getConfig().getBooleanElse("cancel-duplicate-packet", true)) {
+                if (player.isCancelDuplicatePacket()) {
                     player.packetStateData.cancelDuplicatePacket = true;
                 }
             } else {
@@ -284,7 +354,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
 
             player.packetStateData.lastPacketWasOnePointSeventeenDuplicate = true;
 
-            if (!GrimAPI.INSTANCE.getConfigManager().isIgnoreDuplicatePacketRotation()) {
+            if (!player.isIgnoreDuplicatePacketRotation()) {
                 if (player.xRot != location.getYaw() || player.yRot != location.getPitch()) {
                     player.lastXRot = player.xRot;
                     player.lastYRot = player.yRot;
@@ -301,6 +371,9 @@ public class CheckManagerListener extends PacketListenerAbstract {
         return false;
     }
 
+    // Manual filter on FINISH_DIGGING to prevent clients setting non-breakable blocks to air
+    private static final Function<StateType, Boolean> BREAKABLE = type -> !type.isAir() && type.getHardness() != -1.0f && type != StateTypes.WATER && type != StateTypes.LAVA;
+
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getConnectionState() != ConnectionState.PLAY) return;
@@ -354,7 +427,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
         if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) {
             WrapperPlayClientPlayerFlying flying = new WrapperPlayClientPlayerFlying(event);
             Location pos = flying.getLocation();
-            boolean ignoreRotation = player.packetStateData.lastPacketWasOnePointSeventeenDuplicate && GrimAPI.INSTANCE.getConfigManager().isIgnoreDuplicatePacketRotation();
+            boolean ignoreRotation = player.packetStateData.lastPacketWasOnePointSeventeenDuplicate && player.isIgnoreDuplicatePacketRotation();
             handleFlying(player, pos.getX(), pos.getY(), pos.getZ(), ignoreRotation ? player.xRot : pos.getYaw(), ignoreRotation ? player.yRot : pos.getPitch(), flying.hasPositionChanged(), flying.hasRotationChanged(), flying.isOnGround(), teleportData, event);
         }
 
@@ -381,41 +454,43 @@ public class CheckManagerListener extends PacketListenerAbstract {
         }
 
         if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING) {
-            WrapperPlayClientPlayerDigging dig = new WrapperPlayClientPlayerDigging(event);
-            WrappedBlockState block = player.compensatedWorld.getWrappedBlockStateAt(dig.getBlockPosition());
+            final WrapperPlayClientPlayerDigging packet = new WrapperPlayClientPlayerDigging(event);
+            final BlockBreak blockBreak = new BlockBreak(packet, player);
 
-            player.checkManager.getPacketCheck(BadPacketsX.class).handle(event, dig, block.getType());
-            player.checkManager.getPacketCheck(BadPacketsZ.class).handle(event, dig);
+            player.checkManager.getPacketCheck(BadPacketsX.class).handle(blockBreak);
+            player.checkManager.getPacketCheck(BadPacketsZ.class).handle(blockBreak);
 
-            if (dig.getAction() == DiggingAction.FINISHED_DIGGING) {
-                // Not unbreakable
-                if (!block.getType().isAir() && block.getType().getHardness() != -1.0f && !event.isCancelled()) {
-                    player.compensatedWorld.startPredicting();
-                    player.compensatedWorld.updateBlock(dig.getBlockPosition().getX(), dig.getBlockPosition().getY(), dig.getBlockPosition().getZ(), 0);
-                    player.compensatedWorld.stopPredicting(dig);
-                }
-            }
-
-            if (dig.getAction() == DiggingAction.START_DIGGING && !event.isCancelled()) {
-                double damage = BlockBreakSpeed.getBlockDamage(player, dig.getBlockPosition());
-
-                //Instant breaking, no damage means it is unbreakable by creative players (with swords)
-                if (damage >= 1) {
-                    player.compensatedWorld.startPredicting();
-                    if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_13) && Materials.isWaterSource(player.getClientVersion(), block)) {
-                        // Vanilla uses a method to grab water flowing, but as you can't break flowing water
-                        // We can simply treat all waterlogged blocks or source blocks as source blocks
-                        player.compensatedWorld.updateBlock(dig.getBlockPosition(), StateTypes.WATER.createBlockState(CompensatedWorld.blockVersion));
-                    } else {
-                        player.compensatedWorld.updateBlock(dig.getBlockPosition().getX(), dig.getBlockPosition().getY(), dig.getBlockPosition().getZ(), 0);
-                    }
-                    player.compensatedWorld.stopPredicting(dig);
-                }
+            if (blockBreak.isCancelled()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
             }
 
             if (!event.isCancelled()) {
-                if (dig.getAction() == DiggingAction.START_DIGGING || dig.getAction() == DiggingAction.FINISHED_DIGGING || dig.getAction() == DiggingAction.CANCELLED_DIGGING) {
-                    player.compensatedWorld.handleBlockBreakPrediction(dig);
+                if (blockBreak.action == DiggingAction.FINISHED_DIGGING && BREAKABLE.apply(blockBreak.block.getType())) {
+                    player.compensatedWorld.startPredicting();
+                    player.compensatedWorld.updateBlock(blockBreak.position.x, blockBreak.position.y, blockBreak.position.z, 0);
+                    player.compensatedWorld.stopPredicting(packet);
+                }
+
+                if (blockBreak.action == DiggingAction.START_DIGGING) {
+                    double damage = BlockBreakSpeed.getBlockDamage(player, blockBreak.position);
+
+                    // Instant breaking, no damage means it is unbreakable by creative players (with swords)
+                    if (damage >= 1) {
+                        player.compensatedWorld.startPredicting();
+                        if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_13) && Materials.isWaterSource(player.getClientVersion(), blockBreak.block)) {
+                            // Vanilla uses a method to grab water flowing, but as you can't break flowing water
+                            // We can simply treat all waterlogged blocks or source blocks as source blocks
+                            player.compensatedWorld.updateBlock(blockBreak.position, StateTypes.WATER.createBlockState(CompensatedWorld.blockVersion));
+                        } else {
+                            player.compensatedWorld.updateBlock(blockBreak.position.x, blockBreak.position.y, blockBreak.position.z, 0);
+                        }
+                        player.compensatedWorld.stopPredicting(packet);
+                    }
+                }
+
+                if (blockBreak.action == DiggingAction.START_DIGGING || blockBreak.action == DiggingAction.FINISHED_DIGGING || blockBreak.action == DiggingAction.CANCELLED_DIGGING) {
+                    player.compensatedWorld.handleBlockBreakPrediction(packet);
                 }
             }
         }
@@ -434,7 +509,7 @@ public class CheckManagerListener extends PacketListenerAbstract {
                 player.placeUseItemPackets.add(new BlockPlaceSnapshot(packet, player.isSneaking));
             } else {
                 // Anti-air place
-                BlockPlace blockPlace = new BlockPlace(player, packet.getHand(), packet.getBlockPosition(), packet.getFaceId(), packet.getFace(), placedWith, BlockRayTrace.getNearestHitResult(player, null, true));
+                BlockPlace blockPlace = new BlockPlace(player, packet.getHand(), packet.getBlockPosition(), packet.getFaceId(), packet.getFace(), placedWith, getNearestHitResult(player, null, true));
                 blockPlace.setCursor(packet.getCursorPosition());
 
                 if (PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_11) && player.getClientVersion().isOlderThan(ClientVersion.V_1_11)) {
@@ -502,13 +577,22 @@ public class CheckManagerListener extends PacketListenerAbstract {
             player.packetStateData.cancelDuplicatePacket = false;
         }
 
+        if (event.getPacketType() == PacketType.Play.Client.CLIENT_TICK_END) {
+            if (!player.packetStateData.didSendMovementBeforeTickEnd) {
+                // The player didn't send a movement packet, so we can predict this like we had idle tick on 1.8
+                player.packetStateData.didLastLastMovementIncludePosition = player.packetStateData.didLastMovementIncludePosition;
+                player.packetStateData.didLastMovementIncludePosition = false;
+            }
+            player.packetStateData.didSendMovementBeforeTickEnd = false;
+        }
+
         // Finally, remove the packet state variables on this packet
         player.packetStateData.lastPacketWasOnePointSeventeenDuplicate = false;
         player.packetStateData.lastPacketWasTeleport = false;
     }
 
     private static void placeBucket(GrimPlayer player, InteractionHand hand) {
-        HitData data = BlockRayTrace.getNearestHitResult(player, null, true);
+        HitData data = getNearestHitResult(player, null, true);
 
         if (data != null) {
             BlockPlace blockPlace = new BlockPlace(player, hand, data.getPosition(), data.getClosestDirection().getFaceValue(), data.getClosestDirection(), ItemStack.EMPTY, data);
@@ -671,10 +755,14 @@ public class CheckManagerListener extends PacketListenerAbstract {
 
         player.packetStateData.didLastLastMovementIncludePosition = player.packetStateData.didLastMovementIncludePosition;
         player.packetStateData.didLastMovementIncludePosition = hasPosition;
+
+        if (!player.packetStateData.lastPacketWasTeleport) {
+            player.packetStateData.didSendMovementBeforeTickEnd = true;
+        }
     }
 
     private static void placeLilypad(GrimPlayer player, InteractionHand hand) {
-        HitData data = BlockRayTrace.getNearestHitResult(player, null, true);
+        HitData data = getNearestHitResult(player, null, true);
 
         if (data != null) {
             // A lilypad cannot replace a fluid
@@ -704,6 +792,56 @@ public class CheckManagerListener extends PacketListenerAbstract {
         }
     }
 
+    private static HitData getNearestHitResult(GrimPlayer player, StateType heldItem, boolean sourcesHaveHitbox) {
+        Vector3d startingPos = new Vector3d(player.x, player.y + player.getEyeHeight(), player.z);
+        Vector3D startingVec = VectorFactory.newVector3D(startingPos.getX(), startingPos.getY(), startingPos.getZ());
+        Ray trace = new Ray(player, startingPos.getX(), startingPos.getY(), startingPos.getZ(), player.xRot, player.yRot);
+        final double distance = player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_BLOCK_INTERACTION_RANGE);
+        Vector3D endVec = trace.getPointAtDistance(distance);
+        Vector3d endPos = new Vector3d(endVec.getX(), endVec.getY(), endVec.getZ());
+
+        return traverseBlocks(player, startingPos, endPos, (block, vector3i) -> {
+            CollisionBox data = HitboxData.getBlockHitbox(player, heldItem, player.getClientVersion(), block, vector3i.getX(), vector3i.getY(), vector3i.getZ());
+            List<SimpleCollisionBox> boxes = new ArrayList<>();
+            data.downCast(boxes);
+
+            double bestHitResult = Double.MAX_VALUE;
+            Vector3D bestHitLoc = null;
+            BlockFace bestFace = null;
+
+            for (SimpleCollisionBox box : boxes) {
+                Pair<Vector3D, BlockFace> intercept = ReachUtils.calculateIntercept(box, trace.getOrigin(), trace.getPointAtDistance(distance));
+                if (intercept.first() == null) continue; // No intercept
+
+                Vector3D hitLoc = intercept.first();
+
+                if (hitLoc.distanceSquared(startingVec) < bestHitResult) {
+                    bestHitResult = hitLoc.distanceSquared(startingVec);
+                    bestHitLoc = hitLoc;
+                    bestFace = intercept.second();
+                }
+            }
+            if (bestHitLoc != null) {
+                return new HitData(vector3i, bestHitLoc, bestFace, block);
+            }
+
+            if (sourcesHaveHitbox &&
+                    (player.compensatedWorld.isWaterSourceBlock(vector3i.getX(), vector3i.getY(), vector3i.getZ())
+                            || player.compensatedWorld.getLavaFluidLevelAt(vector3i.getX(), vector3i.getY(), vector3i.getZ()) == (8 / 9f))) {
+                double waterHeight = player.compensatedWorld.getFluidLevelAt(vector3i.getX(), vector3i.getY(), vector3i.getZ());
+                SimpleCollisionBox box = new SimpleCollisionBox(vector3i.getX(), vector3i.getY(), vector3i.getZ(), vector3i.getX() + 1, vector3i.getY() + waterHeight, vector3i.getZ() + 1);
+
+                Pair<Vector3D, BlockFace> intercept = ReachUtils.calculateIntercept(box, trace.getOrigin(), trace.getPointAtDistance(distance));
+
+                if (intercept.first() != null) {
+                    return new HitData(vector3i, intercept.first(), intercept.second(), block);
+                }
+            }
+
+            return null;
+        });
+    }
+
     @Override
     public void onPacketSend(PacketSendEvent event) {
         if (event.getConnectionState() != ConnectionState.PLAY) return;

src/main/java/ac/grim/grimac/events/packets/PacketEntityAction.java

@@ -1,9 +1,6 @@
 package ac.grim.grimac.events.packets;
 
 import ac.grim.grimac.GrimAPI;
-import ac.grim.grimac.checks.impl.movement.NoSlowC;
-import ac.grim.grimac.checks.impl.movement.NoSlowD;
-import ac.grim.grimac.checks.impl.movement.NoSlowE;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketListenerAbstract;
 import com.github.retrooper.packetevents.event.PacketListenerPriority;

src/main/java/ac/grim/grimac/events/packets/PacketEntityReplication.java

@@ -1,6 +1,6 @@
 package ac.grim.grimac.events.packets;
 
-import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
@@ -13,6 +13,7 @@ import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
 import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.protocol.entity.EntityPositionData;
 import com.github.retrooper.packetevents.protocol.entity.data.EntityData;
 import com.github.retrooper.packetevents.protocol.entity.type.EntityType;
 import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
@@ -21,7 +22,6 @@ import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.UserProfile;
 import com.github.retrooper.packetevents.protocol.potion.PotionType;
 import com.github.retrooper.packetevents.util.Vector3d;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 import com.github.retrooper.packetevents.wrapper.play.server.*;
 import io.github.retrooper.packetevents.util.viaversion.ViaVersionUtil;
 
@@ -53,7 +53,6 @@ public class PacketEntityReplication extends Check implements PacketCheck {
     private final List<Integer> despawnedEntitiesThisTransaction = new ArrayList<>();
 
     // Maximum ping when a firework boost is removed from the player.
-    private final int maxFireworkBoostPing = GrimAPI.INSTANCE.getConfigManager().getConfig().getIntElse("max-ping-firework-boost", 1000);
 
     public PacketEntityReplication(GrimPlayer player) {
         super(player);
@@ -61,22 +60,19 @@ public class PacketEntityReplication extends Check implements PacketCheck {
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) {
-            // Teleports don't interpolate, duplicate 1.17 packets don't interpolate
-            if (player.packetStateData.lastPacketWasTeleport || player.packetStateData.lastPacketWasOnePointSeventeenDuplicate)
-                return;
+        // Teleports don't interpolate, duplicate 1.17 packets don't interpolate
+        if (!isTickPacket(event.getPacketType())) return;
 
-            boolean isTickingReliably = player.isTickingReliablyFor(3);
+        boolean isTickingReliably = player.isTickingReliablyFor(3);
 
-            PacketEntity playerVehicle = player.compensatedEntities.getSelf().getRiding();
-            for (PacketEntity entity : player.compensatedEntities.entityMap.values()) {
-                if (entity == playerVehicle && !player.vehicleData.lastDummy) {
-                    // The player has this as their vehicle, so they aren't interpolating it.
-                    // And it isn't a dummy position
-                    entity.setPositionRaw(entity.getPossibleCollisionBoxes());
-                } else {
-                    entity.onMovement(isTickingReliably);
-                }
+        PacketEntity playerVehicle = player.compensatedEntities.getSelf().getRiding();
+        for (PacketEntity entity : player.compensatedEntities.entityMap.values()) {
+            if (entity == playerVehicle && !player.vehicleData.lastDummy) {
+                // The player has this as their vehicle, so they aren't interpolating it.
+                // And it isn't a dummy position
+                entity.setPositionRaw(entity.getPossibleCollisionBoxes());
+            } else {
+                entity.onMovement(isTickingReliably);
             }
         }
     }
@@ -87,44 +83,55 @@ public class PacketEntityReplication extends Check implements PacketCheck {
         if ((event.getPacketType() == PacketType.Play.Server.PING || event.getPacketType() == PacketType.Play.Server.WINDOW_CONFIRMATION) && player.packetStateData.lastServerTransWasValid) {
             despawnedEntitiesThisTransaction.clear();
         }
-        if (event.getPacketType() == PacketType.Play.Server.SPAWN_LIVING_ENTITY) {
+        else if (event.getPacketType() == PacketType.Play.Server.SPAWN_LIVING_ENTITY) {
             WrapperPlayServerSpawnLivingEntity packetOutEntity = new WrapperPlayServerSpawnLivingEntity(event);
             addEntity(packetOutEntity.getEntityId(), packetOutEntity.getEntityUUID(), packetOutEntity.getEntityType(), packetOutEntity.getPosition(), packetOutEntity.getYaw(), packetOutEntity.getPitch(), packetOutEntity.getEntityMetadata(), 0);
         }
-        if (event.getPacketType() == PacketType.Play.Server.SPAWN_ENTITY) {
+        else if (event.getPacketType() == PacketType.Play.Server.SPAWN_ENTITY) {
             WrapperPlayServerSpawnEntity packetOutEntity = new WrapperPlayServerSpawnEntity(event);
             addEntity(packetOutEntity.getEntityId(), packetOutEntity.getUUID().orElse(null), packetOutEntity.getEntityType(), packetOutEntity.getPosition(), packetOutEntity.getYaw(), packetOutEntity.getPitch(), null, packetOutEntity.getData());
         }
-        if (event.getPacketType() == PacketType.Play.Server.SPAWN_PLAYER) {
+        else if (event.getPacketType() == PacketType.Play.Server.SPAWN_PLAYER) {
             WrapperPlayServerSpawnPlayer packetOutEntity = new WrapperPlayServerSpawnPlayer(event);
             addEntity(packetOutEntity.getEntityId(), packetOutEntity.getUUID(), EntityTypes.PLAYER, packetOutEntity.getPosition(), packetOutEntity.getYaw(), packetOutEntity.getPitch(), packetOutEntity.getEntityMetadata(), 0);
         }
-
-        if (event.getPacketType() == PacketType.Play.Server.ENTITY_RELATIVE_MOVE) {
+        else if (event.getPacketType() == PacketType.Play.Server.SPAWN_PAINTING) {
+            WrapperPlayServerSpawnPainting packetOutEntity = new WrapperPlayServerSpawnPainting(event);
+            addEntity(packetOutEntity.getEntityId(), packetOutEntity.getUUID(), EntityTypes.PAINTING, packetOutEntity.getPosition().toVector3d(), 0, 0f, null, packetOutEntity.getDirection().getHorizontalIndex());
+        }
+        else if (event.getPacketType() == PacketType.Play.Server.ENTITY_RELATIVE_MOVE) {
             WrapperPlayServerEntityRelativeMove move = new WrapperPlayServerEntityRelativeMove(event);
             handleMoveEntity(event, move.getEntityId(), move.getDeltaX(), move.getDeltaY(), move.getDeltaZ(), null, null, true, true);
         }
-        if (event.getPacketType() == PacketType.Play.Server.ENTITY_RELATIVE_MOVE_AND_ROTATION) {
+        else if (event.getPacketType() == PacketType.Play.Server.ENTITY_RELATIVE_MOVE_AND_ROTATION) {
             WrapperPlayServerEntityRelativeMoveAndRotation move = new WrapperPlayServerEntityRelativeMoveAndRotation(event);
             handleMoveEntity(event, move.getEntityId(), move.getDeltaX(), move.getDeltaY(), move.getDeltaZ(), move.getYaw() * 0.7111111F, move.getPitch() * 0.7111111F, true, true);
         }
-        if (event.getPacketType() == PacketType.Play.Server.ENTITY_TELEPORT) {
+        else if (event.getPacketType() == PacketType.Play.Server.ENTITY_TELEPORT) {
             WrapperPlayServerEntityTeleport move = new WrapperPlayServerEntityTeleport(event);
             Vector3d pos = move.getPosition();
             handleMoveEntity(event, move.getEntityId(), pos.getX(), pos.getY(), pos.getZ(), move.getYaw(), move.getPitch(), false, true);
         }
-        if (event.getPacketType() == PacketType.Play.Server.ENTITY_ROTATION) { // Affects interpolation
+        else if (event.getPacketType() == PacketType.Play.Server.ENTITY_POSITION_SYNC) {
+            // ENTITY_TELEPORT but without relative flags
+            WrapperPlayServerEntityPositionSync move = new WrapperPlayServerEntityPositionSync(event);
+            final EntityPositionData values = move.getValues();
+            final Vector3d pos = values.getPosition();
+            // TODO this isn't technically correct
+            // If the position sync is to a pos > 4096 from the entity pos, client does some special stuff without interpolation
+            handleMoveEntity(event, move.getId(), pos.getX(), pos.getY(), pos.getZ(), values.getYaw(), values.getPitch(), false, true);
+        }
+        else if (event.getPacketType() == PacketType.Play.Server.ENTITY_ROTATION) { // Affects interpolation
             WrapperPlayServerEntityRotation move = new WrapperPlayServerEntityRotation(event);
             handleMoveEntity(event, move.getEntityId(), 0, 0, 0, move.getYaw() * 0.7111111F, move.getPitch() * 0.7111111F, true, false);
         }
-
-        if (event.getPacketType() == PacketType.Play.Server.ENTITY_METADATA) {
+        else if (event.getPacketType() == PacketType.Play.Server.ENTITY_METADATA) {
             WrapperPlayServerEntityMetadata entityMetadata = new WrapperPlayServerEntityMetadata(event);
             player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get(), () -> player.compensatedEntities.updateEntityMetadata(entityMetadata.getEntityId(), entityMetadata.getEntityMetadata()));
         }
 
         // 1.19.3+
-        if (event.getPacketType() == PacketType.Play.Server.PLAYER_INFO_UPDATE) {
+        else if (event.getPacketType() == PacketType.Play.Server.PLAYER_INFO_UPDATE) {
             WrapperPlayServerPlayerInfoUpdate info = new WrapperPlayServerPlayerInfoUpdate(event);
             player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get(), () -> {
                 for (WrapperPlayServerPlayerInfoUpdate.PlayerInfo entry : info.getEntries()) {
@@ -151,7 +158,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
             });
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.ENTITY_EFFECT) {
+        else if (event.getPacketType() == PacketType.Play.Server.ENTITY_EFFECT) {
             WrapperPlayServerEntityEffect effect = new WrapperPlayServerEntityEffect(event);
 
             PotionType type = effect.getPotionType();
@@ -183,7 +190,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
             });
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.REMOVE_ENTITY_EFFECT) {
+        else if (event.getPacketType() == PacketType.Play.Server.REMOVE_ENTITY_EFFECT) {
             WrapperPlayServerRemoveEntityEffect effect = new WrapperPlayServerRemoveEntityEffect(event);
 
             if (isDirectlyAffectingPlayer(player, effect.getEntityId())) player.sendTransaction();
@@ -196,7 +203,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
             });
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.UPDATE_ATTRIBUTES) {
+        else if (event.getPacketType() == PacketType.Play.Server.UPDATE_ATTRIBUTES) {
             WrapperPlayServerUpdateAttributes attributes = new WrapperPlayServerUpdateAttributes(event);
 
             int entityID = attributes.getEntityId();
@@ -208,7 +215,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
                     () -> player.compensatedEntities.updateAttributes(entityID, attributes.getProperties()));
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.ENTITY_STATUS) {
+        else if (event.getPacketType() == PacketType.Play.Server.ENTITY_STATUS) {
             WrapperPlayServerEntityStatus status = new WrapperPlayServerEntityStatus(event);
             // This hasn't changed from 1.7.2 to 1.17
             // Needed to exempt players on dead vehicles, as dead entities have strange physics.
@@ -228,9 +235,8 @@ public class PacketEntityReplication extends Check implements PacketCheck {
 
             if (status.getStatus() == 31) {
                 PacketEntity hook = player.compensatedEntities.getEntity(status.getEntityId());
-                if (!(hook instanceof PacketEntityHook)) return;
+                if (!(hook instanceof PacketEntityHook hookEntity)) return;
 
-                PacketEntityHook hookEntity = (PacketEntityHook) hook;
                 if (hookEntity.attached == player.entityID) {
                     player.sendTransaction();
                     // We don't transaction sandwich this, it's too rare to be a real problem.
@@ -243,7 +249,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
             }
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.SET_SLOT) {
+        else if (event.getPacketType() == PacketType.Play.Server.SET_SLOT) {
             WrapperPlayServerSetSlot slot = new WrapperPlayServerSetSlot(event);
 
             if (slot.getWindowId() == 0) {
@@ -261,7 +267,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
             }
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.WINDOW_ITEMS) {
+        else if (event.getPacketType() == PacketType.Play.Server.WINDOW_ITEMS) {
             WrapperPlayServerWindowItems items = new WrapperPlayServerWindowItems(event);
 
             if (items.getWindowId() == 0) { // Player inventory
@@ -271,16 +277,16 @@ public class PacketEntityReplication extends Check implements PacketCheck {
         }
 
         // 1.8 clients fail to send the RELEASE_USE_ITEM packet when a window is opened client sided while using an item
-        if (event.getPacketType() == PacketType.Play.Server.OPEN_WINDOW) {
+        else if (event.getPacketType() == PacketType.Play.Server.OPEN_WINDOW) {
             player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get(), () -> player.packetStateData.setSlowedByUsingItem(false));
             player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get() + 1, () -> player.packetStateData.setSlowedByUsingItem(false));
         }
-        if (event.getPacketType() == PacketType.Play.Server.OPEN_HORSE_WINDOW) {
+        else if (event.getPacketType() == PacketType.Play.Server.OPEN_HORSE_WINDOW) {
             player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get(), () -> player.packetStateData.setSlowedByUsingItem(false));
             player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get() + 1, () -> player.packetStateData.setSlowedByUsingItem(false));
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.SET_PASSENGERS) {
+        else if (event.getPacketType() == PacketType.Play.Server.SET_PASSENGERS) {
             WrapperPlayServerSetPassengers mount = new WrapperPlayServerSetPassengers(event);
 
             int vehicleID = mount.getEntityId();
@@ -289,7 +295,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
             handleMountVehicle(event, vehicleID, passengers);
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.ATTACH_ENTITY) {
+        else if (event.getPacketType() == PacketType.Play.Server.ATTACH_ENTITY) {
             WrapperPlayServerAttachEntity attach = new WrapperPlayServerAttachEntity(event);
 
             // This packet was replaced by the mount packet on 1.9+ servers - to support multiple passengers on one vehicle
@@ -320,7 +326,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
             }
         }
 
-        if (event.getPacketType() == PacketType.Play.Server.DESTROY_ENTITIES) {
+        else if (event.getPacketType() == PacketType.Play.Server.DESTROY_ENTITIES) {
             WrapperPlayServerDestroyEntities destroy = new WrapperPlayServerDestroyEntities(event);
 
             int[] destroyEntityIds = destroy.getEntityIds();
@@ -415,9 +421,13 @@ public class PacketEntityReplication extends Check implements PacketCheck {
                 // As we don't want vehicles to fly, we need to replace it with a teleport if it is player vehicle
                 //
                 // Don't bother with client controlled vehicles though
-                boolean vanillaVehicleFlight = player.compensatedEntities.serverPlayerVehicle != null && player.compensatedEntities.serverPlayerVehicle == entityId
-                        && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9) &&
-                        PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_9);
+                boolean vanillaVehicleFlight = player.compensatedEntities.serverPlayerVehicle != null
+                        && player.compensatedEntities.serverPlayerVehicle == entityId
+                        && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9)
+                        // TODO: https://discord.com/channels/721686193061888071/721686193515003966/1310659538831020123
+                        // Why does the server now send an entity rel move packet matching the player's vehicle movement every time?
+                        && PacketEvents.getAPI().getServerManager().getVersion().isOlderThan(ServerVersion.V_1_21_2)
+                        && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_9);
 
                 // ViaVersion sends two relative packets when moving more than 4 blocks
                 // This is broken and causes the client to interpolate like (0, 4) and (1, 3) instead of (1, 7)
@@ -455,8 +465,7 @@ public class PacketEntityReplication extends Check implements PacketCheck {
         player.latencyUtils.addRealTimeTask(lastTrans, () -> {
             PacketEntity entity = player.compensatedEntities.getEntity(entityId);
             if (entity == null) return;
-            if (entity instanceof PacketEntityTrackXRot && yaw != null) {
-                PacketEntityTrackXRot xRotEntity = (PacketEntityTrackXRot) entity;
+            if (entity instanceof PacketEntityTrackXRot xRotEntity && yaw != null) {
                 xRotEntity.packetYaw = yaw;
                 xRotEntity.steps = entity.isBoat() ? 10 : 3;
             }
@@ -500,4 +509,12 @@ public class PacketEntityReplication extends Check implements PacketCheck {
     public void tickStartTick() {
         hasSentPreWavePacket = false;
     }
+
+    private int maxFireworkBoostPing = 1000;
+
+    @Override
+    public void onReload(ConfigManager config) {
+        maxFireworkBoostPing = config.getIntElse("max-ping-firework-boost", 1000);
+    }
+
 }

src/main/java/ac/grim/grimac/events/packets/PacketHidePlayerInfo.java

@@ -5,14 +5,11 @@ import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketListenerAbstract;
 import com.github.retrooper.packetevents.event.PacketListenerPriority;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
 import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
-import com.github.retrooper.packetevents.protocol.packettype.PacketTypeCommon;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
-import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerEntityMetadata;
+import com.github.retrooper.packetevents.protocol.player.UserProfile;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerPlayerInfo;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerPlayerInfoUpdate;
 
@@ -20,22 +17,15 @@ import java.util.ArrayList;
 import java.util.EnumSet;
 import java.util.List;
 
-public class PacketSetWrapperNull extends PacketListenerAbstract {
-    // It's faster (and less buggy) to simply not re-encode the wrapper unless we changed something
-    // The two packets we change are clientbound entity metadata (to fix a netcode issue)
-    // and the serverbound player flying packets (to patch NoFall)
-    public PacketSetWrapperNull() {
+public class PacketHidePlayerInfo extends PacketListenerAbstract {
+
+    public PacketHidePlayerInfo() {
         super(PacketListenerPriority.HIGHEST);
     }
 
     @Override
     public void onPacketSend(PacketSendEvent event) {
-        if (event.getPacketType() == PacketType.Play.Server.ENTITY_METADATA) {
-            WrapperPlayServerEntityMetadata wrapper = new WrapperPlayServerEntityMetadata(event);
-            if (wrapper.getEntityId() != event.getUser().getEntityId()) {
-                event.setLastUsedWrapper(null);
-            }
-        } else if (event.getPacketType() == PacketType.Play.Server.PLAYER_INFO) {
+        if (event.getPacketType() == PacketType.Play.Server.PLAYER_INFO) {
             //iterate through players and fake their game mode if they are spectating via grim spectate
             if (PacketEvents.getAPI().getServerManager().getVersion().isOlderThanOrEquals(ServerVersion.V_1_12_2))
                 return;
@@ -62,8 +52,8 @@ public class PacketSetWrapperNull extends PacketListenerAbstract {
                 //if amount of hidden players is the amount of players updated & is an update game mode action just cancel it
                 if (hideCount == nmsPlayerInfoDataList.size() && info.getAction() == WrapperPlayServerPlayerInfo.Action.UPDATE_GAME_MODE) {
                     event.setCancelled(true);
-                } else if (hideCount <= 0) {
-                    event.setLastUsedWrapper(null);
+                } else if (hideCount > 0) {
+                    event.markForReEncode(true);
                 }
             }
         } else if (event.getPacketType() == PacketType.Play.Server.PLAYER_INFO_UPDATE) {
@@ -81,12 +71,13 @@ public class PacketSetWrapperNull extends PacketListenerAbstract {
                 for (WrapperPlayServerPlayerInfoUpdate.PlayerInfo entry : wrapper.getEntries()) {
                     //check if the player should be hidden
                     WrapperPlayServerPlayerInfoUpdate.PlayerInfo modifiedPacket = null;
-                    if (GrimAPI.INSTANCE.getSpectateManager().shouldHidePlayer(receiver, entry.getProfileId())) {
+                    final UserProfile gameProfile = entry.getGameProfile();
+                    if (GrimAPI.INSTANCE.getSpectateManager().shouldHidePlayer(receiver, gameProfile.getUUID())) {
                         hideCount++;
                         //modify & create a new packet from pre-existing one if they are a spectator
                         if (entry.getGameMode() == GameMode.SPECTATOR) {
                             modifiedPacket = new WrapperPlayServerPlayerInfoUpdate.PlayerInfo(
-                                    entry.getGameProfile(),
+                                    gameProfile,
                                     entry.isListed(),
                                     entry.getLatency(),
                                     GameMode.SURVIVAL,
@@ -104,30 +95,20 @@ public class PacketSetWrapperNull extends PacketListenerAbstract {
                     } //if only the game mode was updated and the packet was modified, don't send anything
 
                 }
-                //if no hidden players, don't modify packet
-                if (hideCount <= 0) {
-                    event.setLastUsedWrapper(null);
-                } else if (hideCount == modified.size()) { //if the amount of hidden players & modified entries are the same
+
+                // if the amount of hidden players & modified entries are the same
+                if (hideCount == modified.size()) {
                     if (onlyGameMode) { // if only the game mode changed, cancel
                         event.setCancelled(true);
                     } else { //if more than the game mode changed, remove the action
                         wrapper.getActions().remove(WrapperPlayServerPlayerInfoUpdate.Action.UPDATE_GAME_MODE);
+                        event.markForReEncode(true);
                     }
                 } else { //modify entries
                     wrapper.setEntries(modified);
+                    event.markForReEncode(true);
                 }
             }
-
-        } else if (event.getPacketType() != PacketType.Play.Server.PLAYER_POSITION_AND_LOOK) {
-            event.setLastUsedWrapper(null);
-        }
-    }
-
-    @Override
-    public void onPacketReceive(PacketReceiveEvent event) {
-        PacketTypeCommon packetType = event.getPacketType();
-        if (!WrapperPlayClientPlayerFlying.isFlying(packetType) && packetType != PacketType.Play.Client.CLIENT_SETTINGS && !event.isCancelled()) {
-            event.setLastUsedWrapper(null);
         }
     }
 }

src/main/java/ac/grim/grimac/events/packets/PacketPlayerAbilities.java

@@ -1,6 +1,6 @@
 package ac.grim.grimac.events.packets;
 
-import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
@@ -37,7 +37,6 @@ public class PacketPlayerAbilities extends Check implements PacketCheck {
 
             if (lastSentPlayerCanFly && !abilities.isFlightAllowed()) {
                 int noFlying = player.lastTransactionSent.get();
-                int maxFlyingPing = GrimAPI.INSTANCE.getConfigManager().getConfig().getIntElse("max-ping-out-of-flying", 1000);
                 if (maxFlyingPing != -1) {
                     player.runNettyTaskInMs(() -> {
                         if (player.lastTransactionReceived.get() < noFlying) {
@@ -56,4 +55,12 @@ public class PacketPlayerAbilities extends Check implements PacketCheck {
 
         }
     }
+
+    int maxFlyingPing = 1000;
+
+    @Override
+    public void onReload(ConfigManager config) {
+        maxFlyingPing = config.getIntElse("max-ping-out-of-flying", 1000);
+    }
+
 }

src/main/java/ac/grim/grimac/events/packets/PacketPlayerAttack.java

@@ -8,6 +8,8 @@ import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketListenerAbstract;
 import com.github.retrooper.packetevents.event.PacketListenerPriority;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.protocol.attribute.Attributes;
 import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
 import com.github.retrooper.packetevents.protocol.item.ItemStack;
 import com.github.retrooper.packetevents.protocol.item.enchantment.type.EnchantmentTypes;
@@ -72,6 +74,13 @@ public class PacketPlayerAttack extends PacketListenerAbstract {
                             player.maxPlayerAttackSlow = 1;
                         }
                     } else if (!isLegacyPlayer && player.isSprinting) {
+                        // 1.9+ players who have attack speed cannot slow themselves twice in one tick because their attack cooldown gets reset on swing.
+                        if (player.maxPlayerAttackSlow > 0
+                                && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_9)
+                                && player.compensatedEntities.getSelf().getAttributeValue(Attributes.GENERIC_ATTACK_SPEED) < 16) { // 16 is a reasonable limit
+                            return;
+                        }
+
                         // 1.9+ player who might have been slowed, but we can't be sure
                         player.maxPlayerAttackSlow += 1;
                     }

src/main/java/ac/grim/grimac/events/packets/PacketPlayerDigging.java

@@ -2,7 +2,6 @@ package ac.grim.grimac.events.packets;
 
 import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.checks.impl.movement.NoSlowA;
-import ac.grim.grimac.checks.impl.movement.NoSlowD;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketListenerAbstract;
@@ -23,7 +22,6 @@ import com.github.retrooper.packetevents.protocol.player.GameMode;
 import com.github.retrooper.packetevents.protocol.player.InteractionHand;
 import com.github.retrooper.packetevents.protocol.world.BlockFace;
 import com.github.retrooper.packetevents.wrapper.play.client.*;
-import org.bukkit.Bukkit;
 
 public class PacketPlayerDigging extends PacketListenerAbstract {
 
@@ -172,10 +170,12 @@ public class PacketPlayerDigging extends PacketListenerAbstract {
 
         if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) {
             final GrimPlayer player = GrimAPI.INSTANCE.getPlayerDataManager().getPlayer(event.getUser());
-            if (player == null) return;
-
-            if (!player.packetStateData.lastPacketWasTeleport && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate) {
-                if (player.packetStateData.isSlowedByUsingItem() && player.packetStateData.getSlowedByUsingItemSlot() != player.packetStateData.lastSlotSelected) {
+            if (player != null && player.packetStateData.isSlowedByUsingItem()
+                    && !player.packetStateData.lastPacketWasTeleport
+                    && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate) {
+                if (player.packetStateData.eatingHand != InteractionHand.OFF_HAND
+                        && player.packetStateData.getSlowedByUsingItemSlot() != player.packetStateData.lastSlotSelected
+                        || player.getInventory().getItemInHand(player.packetStateData.eatingHand).isEmpty()) {
                     player.packetStateData.setSlowedByUsingItem(false);
                     player.checkManager.getPostPredictionCheck(NoSlowA.class).didSlotChangeLastTick = true;
                 }
@@ -196,7 +196,7 @@ public class PacketPlayerDigging extends PacketListenerAbstract {
 
             if (player.packetStateData.lastSlotSelected != slot) {
                 // just assume they tick after this
-                if (!player.isTickingReliablyFor(3) && player.skippedTickInActualMovement) {
+                if (!player.isTickingReliablyFor(3) && player.skippedTickInActualMovement && player.packetStateData.eatingHand != InteractionHand.OFF_HAND) {
                     player.packetStateData.setSlowedByUsingItem(false);
                 }
             }
@@ -220,13 +220,7 @@ public class PacketPlayerDigging extends PacketListenerAbstract {
             final ItemStack item = hand == InteractionHand.MAIN_HAND ?
                     player.getInventory().getHeldItem() : player.getInventory().getOffHand();
 
-            final boolean wasSlow = player.packetStateData.isSlowedByUsingItem();
-
             handleUseItem(player, item, hand);
-
-            if (!wasSlow) {
-                player.checkManager.getPostPredictionCheck(NoSlowD.class).startedSprintingBeforeUse = player.packetStateData.isSlowedByUsingItem() && player.isSprinting;
-            }
         }
     }
 }

src/main/java/ac/grim/grimac/events/packets/PacketPlayerJoinQuit.java

@@ -36,6 +36,9 @@ public class PacketPlayerJoinQuit extends PacketListenerAbstract {
         }
         if (player.hasPermission("grim.alerts") && player.hasPermission("grim.alerts.enable-on-join")) {
             GrimAPI.INSTANCE.getAlertManager().toggleAlerts(player);
+            if (player.hasPermission("grim.verbose") && player.hasPermission("grim.verbose.enable-on-join")) {
+                GrimAPI.INSTANCE.getAlertManager().toggleVerbose(player);
+            }
         }
         if (player.hasPermission("grim.spectate") && GrimAPI.INSTANCE.getConfigManager().getConfig().getBooleanElse("spectators.hide-regardless", false)) {
             GrimAPI.INSTANCE.getSpectateManager().onLogin(player);

src/main/java/ac/grim/grimac/events/packets/PacketPlayerRespawn.java

@@ -3,6 +3,7 @@ package ac.grim.grimac.events.packets;
 import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.checks.impl.badpackets.BadPacketsE;
 import ac.grim.grimac.checks.impl.badpackets.BadPacketsF;
+import ac.grim.grimac.checks.impl.badpackets.BadPacketsG;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.data.TrackerData;
 import ac.grim.grimac.utils.data.packetentity.PacketEntitySelf;
@@ -19,11 +20,12 @@ import com.github.retrooper.packetevents.util.Vector3d;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerJoinGame;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerRespawn;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerUpdateHealth;
-import org.bukkit.util.Vector;
 
 import java.util.List;
 import java.util.Objects;
 
+import static ac.grim.grimac.utils.vector.VectorFactory.newVector3D;
+
 /**
  * PlayerRespawnS2CPacket info (1.20.2+):
  * If the world is different (check via registry key), world is recreated (all entities etc destroyed).
@@ -130,9 +132,12 @@ public class PacketPlayerRespawn extends PacketListenerAbstract {
                 player.compensatedEntities.serverPositionsMap.clear();
             }
 
-            // TODO: What does keep all metadata do?
             player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get() + 1, () -> {
-                player.isSneaking = false;
+                // From 1.16 to 1.19, this doesn't get set to false for whatever reason
+                if (player.getClientVersion().isOlderThan(ClientVersion.V_1_16) || player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_20)) {
+                    player.isSneaking = false;
+                }
+
                 player.lastOnGround = false;
                 player.onGround = false;
                 player.isInBed = false;
@@ -141,8 +146,16 @@ public class PacketPlayerRespawn extends PacketListenerAbstract {
                 player.packetStateData.lastClaimedPosition = new Vector3d();
                 player.filterMojangStupidityOnMojangStupidity = new Vector3d();
 
+                final boolean keepTrackedData = this.hasFlag(respawn, KEEP_TRACKED_DATA);
+
+                if (!keepTrackedData) {
+                    player.powderSnowFrozenTicks = 0;
+                    player.compensatedEntities.getSelf().hasGravity = true;
+                    player.playerEntityHasGravity = true;
+                }
+
                 if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_19_4)) {
-                    if (!this.hasFlag(respawn, KEEP_TRACKED_DATA)) {
+                    if (!keepTrackedData) {
                         player.isSprinting = false;
                     }
                 } else {
@@ -150,6 +163,7 @@ public class PacketPlayerRespawn extends PacketListenerAbstract {
                 }
 
                 player.checkManager.getPacketCheck(BadPacketsE.class).handleRespawn(); // Reminder ticks reset
+                player.checkManager.getPacketCheck(BadPacketsG.class).handleRespawn();
 
                 // compensate for immediate respawn gamerule
                 if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_15)) {
@@ -178,13 +192,12 @@ public class PacketPlayerRespawn extends PacketListenerAbstract {
                     player.compensatedEntities.hasSprintingAttributeEnabled = false;
                 }
                 player.pose = Pose.STANDING;
-                player.clientVelocity = new Vector();
+                player.clientVelocity = newVector3D();
                 player.gamemode = respawn.getGameMode();
                 if (PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_17)) {
                     player.compensatedWorld.setDimension(respawn.getDimensionType(), event.getUser());
                 }
 
-                // TODO And there should probably be some attribute holder that we can just call reset() on.
                 if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_16) && !this.hasFlag(respawn, KEEP_ATTRIBUTES)) {
                     // Reset attributes if not kept
                     player.compensatedEntities.getSelf().resetAttributes();

src/main/java/ac/grim/grimac/events/packets/PacketPlayerSteer.java

@@ -3,6 +3,7 @@ package ac.grim.grimac.events.packets;
 import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
+import ac.grim.grimac.utils.data.KnownInput;
 import ac.grim.grimac.utils.data.packetentity.PacketEntity;
 import ac.grim.grimac.utils.data.packetentity.PacketEntityHorse;
 import com.github.retrooper.packetevents.PacketEvents;
@@ -10,9 +11,9 @@ import com.github.retrooper.packetevents.event.PacketListenerAbstract;
 import com.github.retrooper.packetevents.event.PacketListenerPriority;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.manager.server.ServerVersion;
-import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerInput;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientSteerVehicle;
 
 public class PacketPlayerSteer extends PacketListenerAbstract {
@@ -23,13 +24,12 @@ public class PacketPlayerSteer extends PacketListenerAbstract {
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-
         if (event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE) {
-            WrapperPlayClientSteerVehicle steer = new WrapperPlayClientSteerVehicle(event);
-
             GrimPlayer player = GrimAPI.INSTANCE.getPlayerDataManager().getPlayer(event.getUser());
             if (player == null) return;
 
+            WrapperPlayClientSteerVehicle steer = new WrapperPlayClientSteerVehicle(event);
+
             float forwards = steer.getForward();
             float sideways = steer.getSideways();
 
@@ -100,6 +100,33 @@ public class PacketPlayerSteer extends PacketListenerAbstract {
             }
 
             player.packetStateData.receivedSteerVehicle = true;
+        } else if (event.getPacketType() == PacketType.Play.Client.PLAYER_INPUT) {
+            GrimPlayer player = GrimAPI.INSTANCE.getPlayerDataManager().getPlayer(event.getUser());
+            if (player == null) return;
+
+            WrapperPlayClientPlayerInput input = new WrapperPlayClientPlayerInput(event);
+            byte forward = 0;
+            byte sideways = 0;
+            if (input.isForward()) {
+                forward++;
+            }
+
+            if (input.isBackward()) {
+                forward--;
+            }
+
+            if (input.isLeft()) {
+                sideways++;
+            }
+
+            if (input.isRight()) {
+                sideways--;
+            }
+
+            player.vehicleData.nextVehicleForward = forward * 0.98f;
+            player.vehicleData.nextVehicleHorizontal = sideways * 0.98f;
+
+            player.packetStateData.knownInput = new KnownInput(input.isForward(), input.isBackward(), input.isLeft(), input.isRight(), input.isJump(), input.isShift(), input.isSprint());
         }
     }
 }

src/main/java/ac/grim/grimac/events/packets/PacketSelfMetadataListener.java

@@ -1,7 +1,6 @@
 package ac.grim.grimac.events.packets;
 
 import ac.grim.grimac.GrimAPI;
-import ac.grim.grimac.checks.impl.movement.NoSlowD;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.nmsutil.WatchableIndexUtil;
 import com.github.retrooper.packetevents.PacketEvents;
@@ -24,6 +23,7 @@ import java.util.List;
 import java.util.Optional;
 
 public class PacketSelfMetadataListener extends PacketListenerAbstract {
+
     public PacketSelfMetadataListener() {
         super(PacketListenerPriority.HIGH);
     }
@@ -68,6 +68,7 @@ public class PacketSelfMetadataListener extends PacketListenerAbstract {
                     // Remove the pose metadata from the list
                     metadataStuff.removeIf(element -> element.getIndex() == 6);
                     entityMetadata.setEntityMetadata(metadataStuff);
+                    event.markForReEncode(true);
                 }
 
                 EntityData watchable = WatchableIndexUtil.getIndex(entityMetadata.getEntityMetadata(), 0);
@@ -207,8 +208,6 @@ public class PacketSelfMetadataListener extends PacketListenerAbstract {
                                     // The above line is a hack to fake activate use item
                                     player.packetStateData.setSlowedByUsingItem(isActive);
 
-                                    player.checkManager.getPostPredictionCheck(NoSlowD.class).startedSprintingBeforeUse = player.packetStateData.isSlowedByUsingItem() && player.isSprinting;
-
                                     if (isActive) {
                                         player.packetStateData.eatingHand = isOffhand ? InteractionHand.OFF_HAND : InteractionHand.MAIN_HAND;
                                     }

src/main/java/ac/grim/grimac/events/packets/PacketServerTeleport.java

@@ -6,14 +6,12 @@ import ac.grim.grimac.utils.data.Pair;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketListenerAbstract;
 import com.github.retrooper.packetevents.event.PacketListenerPriority;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
 import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.teleport.RelativeFlag;
 import com.github.retrooper.packetevents.util.Vector3d;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientTeleportConfirm;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerPlayerPositionAndLook;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerVehicleMove;
 import org.bukkit.Location;

src/main/java/ac/grim/grimac/events/packets/ProxyAlertMessenger.java

@@ -99,4 +99,4 @@ public class ProxyAlertMessenger extends PacketListenerAbstract {
         if (!file.exists()) return false;
         return YamlConfiguration.loadConfiguration(file).getBoolean(pathToValue);
     }
-}
+}

src/main/java/ac/grim/grimac/events/packets/patch/ResyncWorldUtil.java

@@ -12,6 +12,7 @@ import com.github.retrooper.packetevents.util.Vector3i;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerMultiBlockChange;
 import io.github.retrooper.packetevents.util.folia.FoliaScheduler;
 import org.bukkit.Chunk;
+import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
 
@@ -35,18 +36,20 @@ public class ResyncWorldUtil {
                 || !player.compensatedWorld.isChunkLoaded(maxBlockX >> 4, minBlockZ >> 4) || !player.compensatedWorld.isChunkLoaded(maxBlockX >> 4, maxBlockZ >> 4))
             return;
 
+        if (player.bukkitPlayer == null) return;
+        World world = player.bukkitPlayer.getWorld();
+
         // Takes 0.15ms or so to complete. Not bad IMO. Unsure how I could improve this other than sending packets async.
         // But that's on PacketEvents.
-        FoliaScheduler.getEntityScheduler().execute(player.bukkitPlayer, GrimAPI.INSTANCE.getPlugin(), () -> {
+        FoliaScheduler.getRegionScheduler().execute(GrimAPI.INSTANCE.getPlugin(), world,
+                minBlockX >> 4, minBlockZ >> 4, () -> {
             boolean flat = PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_13);
-
-            if (player.bukkitPlayer == null) return;
             // Player hasn't spawned, don't spam packets
             if (!player.getSetbackTeleportUtil().hasAcceptedSpawnTeleport) return;
 
             // Check the 4 corners of the BB for loaded chunks, don't freeze main thread to load chunks.
-            if (!player.bukkitPlayer.getWorld().isChunkLoaded(minBlockX >> 4, minBlockZ >> 4) || !player.bukkitPlayer.getWorld().isChunkLoaded(minBlockX >> 4, maxBlockZ >> 4)
-                    || !player.bukkitPlayer.getWorld().isChunkLoaded(maxBlockX >> 4, minBlockZ >> 4) || !player.bukkitPlayer.getWorld().isChunkLoaded(maxBlockX >> 4, maxBlockZ >> 4))
+            if (!world.isChunkLoaded(minBlockX >> 4, minBlockZ >> 4) || !world.isChunkLoaded(minBlockX >> 4, maxBlockZ >> 4)
+                    || !world.isChunkLoaded(maxBlockX >> 4, minBlockZ >> 4) || !world.isChunkLoaded(maxBlockX >> 4, maxBlockZ >> 4))
                 return;
 
             // This is based on Tuinity's code, thanks leaf. Now merged into paper.
@@ -75,7 +78,7 @@ public class ResyncWorldUtil {
                     int minX = currChunkX == minChunkX ? minBlockX & 15 : 0; // coordinate in chunk
                     int maxX = currChunkX == maxChunkX ? maxBlockX & 15 : 15; // coordinate in chunk
 
-                    Chunk chunk = player.bukkitPlayer.getWorld().getChunkAt(currChunkX, currChunkZ);
+                    Chunk chunk = world.getChunkAt(currChunkX, currChunkZ);
 
                     for (int currChunkY = minChunkY; currChunkY <= maxChunkY; ++currChunkY) {
                         int minY = currChunkY == minChunkY ? minBlockY & 15 : 0; // coordinate in chunk
@@ -111,6 +114,6 @@ public class ResyncWorldUtil {
                     }
                 }
             }
-        }, null, 0);
+        });
     }
 }

src/main/java/ac/grim/grimac/events/packets/worldreader/BasePacketWorldReader.java

@@ -174,4 +174,4 @@ public class BasePacketWorldReader extends PacketListenerAbstract {
             player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get(), () -> player.compensatedWorld.updateBlock(blockChange.getX(), blockChange.getY(), blockChange.getZ(), blockChange.getBlockId()));
         }
     }
-}
+}

src/main/java/ac/grim/grimac/events/packets/worldreader/PacketWorldReaderEight.java

@@ -15,7 +15,7 @@ import java.util.BitSet;
 public class PacketWorldReaderEight extends BasePacketWorldReader {
     @Override
     public void handleMapChunkBulk(final GrimPlayer player, final PacketSendEvent event) {
-        PacketWrapper wrapper = new PacketWrapper(event);
+        PacketWrapper<?> wrapper = new PacketWrapper<>(event);
         ByteBuf buffer = (ByteBuf) wrapper.getBuffer();
 
         boolean skylight = wrapper.readBoolean();
@@ -47,7 +47,7 @@ public class PacketWorldReaderEight extends BasePacketWorldReader {
 
     @Override
     public void handleMapChunk(final GrimPlayer player, final PacketSendEvent event) {
-        PacketWrapper wrapper = new PacketWrapper(event);
+        PacketWrapper<?> wrapper = new PacketWrapper<>(event);
 
         final int chunkX = wrapper.readInt();
         final int chunkZ = wrapper.readInt();

src/main/java/ac/grim/grimac/manager/ActionManager.java

@@ -6,7 +6,6 @@ import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 import lombok.Getter;
 
 @Getter
@@ -27,7 +26,7 @@ public class ActionManager extends Check implements PacketCheck {
                 attacking = true;
                 lastAttack = System.currentTimeMillis();
             }
-        } else if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) {
+        } else if (isTickPacketIncludingNonMovement(event.getPacketType())) {
             player.totalFlyingPacketsSent++;
             attacking = false;
         }

src/main/java/ac/grim/grimac/manager/CheckManager.java

@@ -1,21 +1,24 @@
 package ac.grim.grimac.manager;
 
-
 import ac.grim.grimac.api.AbstractCheck;
 import ac.grim.grimac.checks.impl.aim.AimDuplicateLook;
 import ac.grim.grimac.checks.impl.aim.AimModulo360;
 import ac.grim.grimac.checks.impl.aim.processor.AimProcessor;
 import ac.grim.grimac.checks.impl.badpackets.*;
+import ac.grim.grimac.checks.impl.combat.MultiInteractA;
+import ac.grim.grimac.checks.impl.combat.MultiInteractB;
 import ac.grim.grimac.checks.impl.combat.Reach;
 import ac.grim.grimac.checks.impl.crash.*;
 import ac.grim.grimac.checks.impl.exploit.ExploitA;
 import ac.grim.grimac.checks.impl.exploit.ExploitB;
+import ac.grim.grimac.checks.impl.exploit.ExploitC;
 import ac.grim.grimac.checks.impl.groundspoof.NoFallA;
 import ac.grim.grimac.checks.impl.misc.ClientBrand;
 import ac.grim.grimac.checks.impl.misc.FastBreak;
 import ac.grim.grimac.checks.impl.misc.GhostBlockMitigation;
 import ac.grim.grimac.checks.impl.misc.TransactionOrder;
 import ac.grim.grimac.checks.impl.movement.*;
+import ac.grim.grimac.checks.impl.multiactions.*;
 import ac.grim.grimac.checks.impl.post.PostCheck;
 import ac.grim.grimac.checks.impl.prediction.DebugHandler;
 import ac.grim.grimac.checks.impl.prediction.NoFallB;
@@ -42,8 +45,16 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
 import com.google.common.collect.ClassToInstanceMap;
 import com.google.common.collect.ImmutableClassToInstanceMap;
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionDefault;
+
+import java.util.concurrent.atomic.AtomicBoolean;
 
 public class CheckManager {
+    private static boolean inited;
+    private static final AtomicBoolean initedAtomic = new AtomicBoolean(false);
+
     ClassToInstanceMap<PacketCheck> packetChecks;
     ClassToInstanceMap<PositionCheck> positionCheck;
     ClassToInstanceMap<RotationCheck> rotationCheck;
@@ -89,11 +100,15 @@ public class CheckManager {
                 .put(BadPacketsS.class, new BadPacketsS(player))
                 .put(BadPacketsT.class, new BadPacketsT(player))
                 .put(BadPacketsU.class, new BadPacketsU(player))
-                .put(BadPacketsV.class, new BadPacketsV(player))
                 .put(BadPacketsW.class, new BadPacketsW(player))
                 .put(BadPacketsX.class, new BadPacketsX(player))
                 .put(BadPacketsY.class, new BadPacketsY(player))
                 .put(BadPacketsZ.class, new BadPacketsZ(player))
+                .put(MultiActionsA.class, new MultiActionsA(player))
+                .put(MultiActionsB.class, new MultiActionsB(player))
+                .put(MultiActionsC.class, new MultiActionsC(player))
+                .put(MultiActionsD.class, new MultiActionsD(player))
+                .put(MultiActionsE.class, new MultiActionsE(player))
                 .put(FastBreak.class, new FastBreak(player))
                 .put(TransactionOrder.class, new TransactionOrder(player))
                 .put(NoSlowB.class, new NoSlowB(player))
@@ -129,6 +144,8 @@ public class CheckManager {
                 .put(NoSlowC.class, new NoSlowC(player))
                 .put(NoSlowD.class, new NoSlowD(player))
                 .put(NoSlowE.class, new NoSlowE(player))
+                .put(MultiInteractA.class, new MultiInteractA(player))
+                .put(MultiInteractB.class, new MultiInteractB(player))
                 .put(SetbackTeleportUtil.class, new SetbackTeleportUtil(player)) // Avoid teleporting to new position, update safe pos last
                 .put(CompensatedFireworks.class, player.compensatedFireworks)
                 .put(SneakingEstimator.class, new SneakingEstimator(player))
@@ -139,6 +156,8 @@ public class CheckManager {
                 .put(InvalidPlaceA.class, new InvalidPlaceA(player))
                 .put(InvalidPlaceB.class, new InvalidPlaceB(player))
                 .put(AirLiquidPlace.class, new AirLiquidPlace(player))
+                .put(MultiPlace.class, new MultiPlace(player))
+                .put(MultiActionsF.class, new MultiActionsF(player))
                 .put(FarPlace.class, new FarPlace(player))
                 .put(FabricatedPlace.class, new FabricatedPlace(player))
                 .put(PositionPlace.class, new PositionPlace(player))
@@ -149,6 +168,7 @@ public class CheckManager {
 
         prePredictionChecks = new ImmutableClassToInstanceMap.Builder<PacketCheck>()
                 .put(TimerCheck.class, new TimerCheck(player))
+                .put(TickTimer.class, new TickTimer(player))
                 .put(CrashA.class, new CrashA(player))
                 .put(CrashB.class, new CrashB(player))
                 .put(CrashC.class, new CrashC(player))
@@ -159,6 +179,7 @@ public class CheckManager {
                 .put(CrashH.class, new CrashH(player))
                 .put(ExploitA.class, new ExploitA(player))
                 .put(ExploitB.class, new ExploitB(player))
+                .put(ExploitC.class, new ExploitC(player))
                 .put(VehicleTimer.class, new VehicleTimer(player))
                 .build();
 
@@ -171,6 +192,8 @@ public class CheckManager {
                 .putAll(blockPlaceCheck)
                 .putAll(prePredictionChecks)
                 .build();
+
+        init();
     }
 
     @SuppressWarnings("unchecked")
@@ -201,6 +224,9 @@ public class CheckManager {
         for (PostPredictionCheck check : postPredictionCheck.values()) {
             check.onPacketReceive(packet);
         }
+        for (BlockPlaceCheck check : blockPlaceCheck.values()) {
+            check.onPacketReceive(packet);
+        }
     }
 
     public void onPacketSend(final PacketSendEvent packet) {
@@ -213,6 +239,9 @@ public class CheckManager {
         for (PostPredictionCheck check : postPredictionCheck.values()) {
             check.onPacketSend(packet);
         }
+        for (BlockPlaceCheck check : blockPlaceCheck.values()) {
+            check.onPacketSend(packet);
+        }
     }
 
     public void onPositionUpdate(final PositionUpdate position) {
@@ -240,6 +269,9 @@ public class CheckManager {
         for (PostPredictionCheck check : postPredictionCheck.values()) {
             check.onPredictionComplete(complete);
         }
+        for (BlockPlaceCheck check : blockPlaceCheck.values()) {
+            check.onPredictionComplete(complete);
+        }
     }
 
     public void onBlockPlace(final BlockPlace place) {
@@ -314,4 +346,25 @@ public class CheckManager {
     public <T extends PostPredictionCheck> T getPostPredictionCheck(Class<T> check) {
         return (T) postPredictionCheck.get(check);
     }
+
+    private void init() {
+        // Fast non-thread safe check
+        if (inited) return;
+        // Slow thread safe check
+        if (!initedAtomic.compareAndSet(false, true)) return;
+        inited = true;
+
+        for (AbstractCheck check : allChecks.values()) {
+            if (check.getCheckName() != null) {
+                String permissionName = "grim.exempt." + check.getCheckName().toLowerCase();
+                Permission permission = Bukkit.getPluginManager().getPermission(permissionName);
+
+                if (permission == null) {
+                    Bukkit.getPluginManager().addPermission(new Permission(permissionName, PermissionDefault.FALSE));
+                } else {
+                    permission.setDefault(PermissionDefault.FALSE);
+                }
+            }
+        }
+    }
 }

src/main/java/ac/grim/grimac/manager/DiscordManager.java

@@ -19,6 +19,7 @@ public class DiscordManager implements Initable {
     private static WebhookClient client;
     private int embedColor;
     private String staticContent = "";
+    private String embedTitle = "";
 
     public static final Pattern WEBHOOK_PATTERN = Pattern.compile("(?:https?://)?(?:\\w+\\.)?\\w+\\.\\w+/api(?:/v\\d+)?/webhooks/(\\d+)/([\\w-]+)(?:/(?:\\w+)?)?");
 
@@ -40,6 +41,8 @@ public class DiscordManager implements Initable {
             client = WebhookClient.withId(Long.parseUnsignedLong(matcher.group(1)), matcher.group(2));
             client.setTimeout(15000); // Requests expire after 15 seconds
 
+            embedTitle = GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("embed-title", "**Grim Alert**");
+
             try {
                 embedColor = Color.decode(GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("embed-color", "#00FFFF")).getRGB();
             } catch (NumberFormatException e) {
@@ -67,12 +70,12 @@ public class DiscordManager implements Initable {
         return list;
     }
 
-    public void sendAlert(GrimPlayer player, String verbose, String checkName, String violations) {
+    public void sendAlert(GrimPlayer player, String verbose, String checkName, int violations) {
         if (client != null) {
 
-            String content = staticContent + "";
+            String content = staticContent;
             content = content.replace("%check%", checkName);
-            content = content.replace("%violations%", violations);
+            content = content.replace("%violations%", Integer.toString(violations));
             content = GrimAPI.INSTANCE.getExternalAPI().replaceVariables(player, content, false);
             content = content.replace("_", "\\_");
 
@@ -80,7 +83,7 @@ public class DiscordManager implements Initable {
                     .setImageUrl("https://i.stack.imgur.com/Fzh0w.png") // Constant width
                     .setThumbnailUrl("https://crafthead.net/helm/" + player.user.getProfile().getUUID())
                     .setColor(embedColor)
-                    .setTitle(new WebhookEmbed.EmbedTitle("**Grim Alert**", null))
+                    .setTitle(new WebhookEmbed.EmbedTitle(embedTitle, null))
                     .setDescription(content)
                     .setTimestamp(Instant.now())
                     .setFooter(new WebhookEmbed.EmbedFooter("", "https://grim.ac/images/grim.png"));

src/main/java/ac/grim/grimac/manager/InitManager.java

@@ -1,60 +1,72 @@
 package ac.grim.grimac.manager;
 
 import ac.grim.grimac.GrimAPI;
-import ac.grim.grimac.GrimExternalAPI;
 import ac.grim.grimac.manager.init.Initable;
 import ac.grim.grimac.manager.init.load.PacketEventsInit;
 import ac.grim.grimac.manager.init.start.*;
 import ac.grim.grimac.manager.init.stop.TerminatePacketEvents;
-import com.google.common.collect.ClassToInstanceMap;
-import com.google.common.collect.ImmutableClassToInstanceMap;
+import com.google.common.collect.ImmutableList;
+import lombok.Getter;
 
 public class InitManager {
-    ClassToInstanceMap<Initable> initializersOnLoad;
-    ClassToInstanceMap<Initable> initializersOnStart;
-    ClassToInstanceMap<Initable> initializersOnStop;
+
+    private final ImmutableList<Initable> initializersOnLoad;
+    private final ImmutableList<Initable> initializersOnStart;
+    private final ImmutableList<Initable> initializersOnStop;
+
+    @Getter private boolean loaded = false;
+    @Getter private boolean started = false;
+    @Getter private boolean stopped = false;
 
     public InitManager() {
-        initializersOnLoad = new ImmutableClassToInstanceMap.Builder<Initable>()
-                .put(PacketEventsInit.class, new PacketEventsInit())
+        initializersOnLoad = ImmutableList.<Initable>builder()
+                .add(new PacketEventsInit())
+                .add(() -> GrimAPI.INSTANCE.getExternalAPI().load())
                 .build();
 
-        initializersOnStart = new ImmutableClassToInstanceMap.Builder<Initable>()
-                .put(ExemptOnlinePlayers.class, new ExemptOnlinePlayers())
-                .put(EventManager.class, new EventManager())
-                .put(PacketManager.class, new PacketManager())
-                .put(ViaBackwardsManager.class, new ViaBackwardsManager())
-                .put(TickRunner.class, new TickRunner())
-                .put(TickEndEvent.class, new TickEndEvent())
-                .put(CommandRegister.class, new CommandRegister())
-                .put(BStats.class, new BStats())
-                .put(PacketLimiter.class, new PacketLimiter())
-                .put(DiscordManager.class, GrimAPI.INSTANCE.getDiscordManager())
-                .put(SpectateManager.class, GrimAPI.INSTANCE.getSpectateManager())
-                .put(GrimExternalAPI.class, GrimAPI.INSTANCE.getExternalAPI())
-                .put(JavaVersion.class, new JavaVersion())
+        initializersOnStart = ImmutableList.<Initable>builder()
+                .add(GrimAPI.INSTANCE.getExternalAPI())
+                .add(new ExemptOnlinePlayers())
+                .add(new EventManager())
+                .add(new PacketManager())
+                .add(new ViaBackwardsManager())
+                .add(new TickRunner())
+                .add(new TickEndEvent())
+                .add(new CommandRegister())
+                .add(new BStats())
+                .add(new PacketLimiter())
+                .add(GrimAPI.INSTANCE.getDiscordManager())
+                .add(GrimAPI.INSTANCE.getSpectateManager())
+                .add(new JavaVersion())
+                .add(new ViaVersion())
                 .build();
 
-        initializersOnStop = new ImmutableClassToInstanceMap.Builder<Initable>()
-                .put(TerminatePacketEvents.class, new TerminatePacketEvents())
+        initializersOnStop = ImmutableList.<Initable>builder()
+                .add(new TerminatePacketEvents())
                 .build();
     }
 
     public void load() {
-        for (Initable initable : initializersOnLoad.values()) {
-            initable.start();
-        }
+        for (Initable initable : initializersOnLoad) handle(initable);
+        loaded = true;
     }
 
     public void start() {
-        for (Initable initable : initializersOnStart.values()) {
-            initable.start();
-        }
+        for (Initable initable : initializersOnStart) handle(initable);
+        started = true;
     }
 
     public void stop() {
-        for (Initable initable : initializersOnStop.values()) {
+        for (Initable initable : initializersOnStop) handle(initable);
+        stopped = true;
+    }
+
+    private void handle(Initable initable) {
+        try {
             initable.start();
+        } catch (Exception e) {
+            e.printStackTrace();
         }
     }
-}
+
+}

src/main/java/ac/grim/grimac/manager/PunishmentManager.java

@@ -2,13 +2,14 @@ package ac.grim.grimac.manager;
 
 import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.api.AbstractCheck;
+import ac.grim.grimac.api.config.ConfigManager;
+import ac.grim.grimac.api.config.ConfigReloadable;
 import ac.grim.grimac.api.events.CommandExecuteEvent;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.events.packets.ProxyAlertMessenger;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.LogUtil;
 import ac.grim.grimac.utils.anticheat.MessageUtil;
-import github.scarsz.configuralize.DynamicConfig;
 import io.github.retrooper.packetevents.util.folia.FoliaScheduler;
 import lombok.Getter;
 import lombok.Setter;
@@ -17,21 +18,27 @@ import org.bukkit.entity.Player;
 
 import java.util.*;
 
-public class PunishmentManager {
+public class PunishmentManager implements ConfigReloadable {
     GrimPlayer player;
     List<PunishGroup> groups = new ArrayList<>();
     String experimentalSymbol = "*";
+    private String alertString;
+    private boolean testMode;
+    private boolean printToConsole;
+    private String proxyAlertString = "";
 
     public PunishmentManager(GrimPlayer player) {
         this.player = player;
-        reload();
     }
 
-    public void reload() {
-        DynamicConfig config = GrimAPI.INSTANCE.getConfigManager().getConfig();
+    @Override
+    public void reload(ConfigManager config) {
         List<String> punish = config.getStringListElse("Punishments", new ArrayList<>());
         experimentalSymbol = config.getStringElse("experimental-symbol", "*");
-
+        alertString = config.getStringElse("alerts-format", "%prefix% &f%player% &bfailed &f%check_name% &f(x&c%vl%&f) &7%verbose%");
+        testMode = config.getBooleanElse("test-mode", false);
+        printToConsole = config.getBooleanElse("verbose.print-to-console", false);
+        proxyAlertString = config.getStringElse("alerts-format-proxy", "%prefix% &f[&cproxy&f] &f%player% &bfailed &f%check_name% &f(x&c%vl%&f) &7%verbose%");
         try {
             groups.clear();
 
@@ -91,16 +98,14 @@ public class PunishmentManager {
         }
     }
 
-    private String replaceAlertPlaceholders(String original, PunishGroup group, Check check, String alertString, String verbose) {
-        // Streams are slow but this isn't a hot path... it's fine.
-        String vl = group.violations.values().stream().filter((e) -> e == check).count() + "";
+    private String replaceAlertPlaceholders(String original, int vl, PunishGroup group, Check check, String alertString, String verbose) {
 
         original = MessageUtil.format(original
                 .replace("[alert]", alertString)
                 .replace("[proxy]", alertString)
-                .replace("%check_name%", check.getCheckName())
+                .replace("%check_name%", check.getDisplayName())
                 .replace("%experimental%", check.isExperimental() ? experimentalSymbol : "")
-                .replace("%vl%", vl)
+                .replace("%vl%", Integer.toString(vl))
                 .replace("%verbose%", verbose)
                 .replace("%description%", check.getDescription())
         );
@@ -111,24 +116,23 @@ public class PunishmentManager {
     }
 
     public boolean handleAlert(GrimPlayer player, String verbose, Check check) {
-        String alertString = GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("alerts-format", "%prefix% &f%player% &bfailed &f%check_name% &f(x&c%vl%&f) &7%verbose%");
-        boolean testMode = GrimAPI.INSTANCE.getConfigManager().getConfig().getBooleanElse("test-mode", false);
         boolean sentDebug = false;
 
         // Check commands
         for (PunishGroup group : groups) {
             if (group.getChecks().contains(check)) {
-                int violationCount = group.getViolations().size();
+                final int vl = getViolations(group, check);
+                final int violationCount = group.getViolations().size();
                 for (ParsedCommand command : group.getCommands()) {
-                    String cmd = replaceAlertPlaceholders(command.getCommand(), group, check, alertString, verbose);
+                    String cmd = replaceAlertPlaceholders(command.getCommand(), vl, group, check, alertString, verbose);
 
                     // Verbose that prints all flags
-                    if (GrimAPI.INSTANCE.getAlertManager().getEnabledVerbose().size() > 0 && command.command.equals("[alert]")) {
+                    if (!GrimAPI.INSTANCE.getAlertManager().getEnabledVerbose().isEmpty() && command.command.equals("[alert]")) {
                         sentDebug = true;
                         for (Player bukkitPlayer : GrimAPI.INSTANCE.getAlertManager().getEnabledVerbose()) {
                             bukkitPlayer.sendMessage(cmd);
                         }
-                        if (GrimAPI.INSTANCE.getConfigManager().getConfig().getBooleanElse("verbose.print-to-console", false)) {
+                        if (printToConsole) {
                             LogUtil.console(cmd); // Print verbose to console
                         }
                     }
@@ -143,12 +147,9 @@ public class PunishmentManager {
                             if (executeEvent.isCancelled()) continue;
 
                             if (command.command.equals("[webhook]")) {
-                                String vl = group.violations.values().stream().filter((e) -> e == check).count() + "";
-                                GrimAPI.INSTANCE.getDiscordManager().sendAlert(player, verbose, check.getCheckName(), vl);
+                                GrimAPI.INSTANCE.getDiscordManager().sendAlert(player, verbose, check.getDisplayName(), vl);
                             } else if (command.command.equals("[proxy]")) {
-                                String proxyAlertString = GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("alerts-format-proxy", "%prefix% &f[&cproxy&f] &f%player% &bfailed &f%check_name% &f(x&c%vl%&f) &7%verbose%");
-                                proxyAlertString = replaceAlertPlaceholders(command.getCommand(), group, check, proxyAlertString, verbose);
-                                ProxyAlertMessenger.sendPluginMessage(proxyAlertString);
+                                ProxyAlertMessenger.sendPluginMessage(replaceAlertPlaceholders(command.getCommand(), vl, group, check, proxyAlertString, verbose));
                             } else {
                                 if (command.command.equals("[alert]")) {
                                     sentDebug = true;
@@ -160,9 +161,8 @@ public class PunishmentManager {
                                 }
 
                                 String finalCmd = cmd;
-                                FoliaScheduler.getGlobalRegionScheduler().run(GrimAPI.INSTANCE.getPlugin(), (dummy) -> {
-                                    Bukkit.dispatchCommand(Bukkit.getConsoleSender(), finalCmd);
-                                });
+                                FoliaScheduler.getGlobalRegionScheduler().run(GrimAPI.INSTANCE.getPlugin(), (dummy) ->
+                                        Bukkit.dispatchCommand(Bukkit.getConsoleSender(), finalCmd));
                             }
                         }
 
@@ -185,6 +185,15 @@ public class PunishmentManager {
             }
         }
     }
+
+    private int getViolations(PunishGroup group, Check check) {
+        int vl = 0;
+        for (Check value : group.violations.values()) {
+            if (value == check) vl++;
+        }
+        return vl;
+    }
+
 }
 
 class PunishGroup {
@@ -193,7 +202,7 @@ class PunishGroup {
     @Getter
     List<ParsedCommand> commands;
     @Getter
-    HashMap<Long, Check> violations = new HashMap<>();
+    public Map<Long, Check> violations = new HashMap<>();
     @Getter
     int removeViolationsAfter;
 

src/main/java/ac/grim/grimac/manager/SetbackTeleportUtil.java

@@ -19,6 +19,7 @@ import ac.grim.grimac.utils.math.VectorUtils;
 import ac.grim.grimac.utils.nmsutil.Collisions;
 import ac.grim.grimac.utils.nmsutil.GetBoundingBox;
 import ac.grim.grimac.utils.nmsutil.ReachUtils;
+import ac.grim.grimac.utils.vector.Vector3D;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
@@ -31,13 +32,15 @@ import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
-import org.bukkit.util.Vector;
+import ac.grim.grimac.utils.vector.Vector3D;
 
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Random;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
+import static ac.grim.grimac.utils.vector.VectorFactory.newVector3D;
+
 public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
     // Sync to netty
     public final ConcurrentLinkedQueue<TeleportData> pendingTeleports = new ConcurrentLinkedQueue<>();
@@ -65,7 +68,7 @@ public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
     @Override
     public void onPredictionComplete(final PredictionComplete predictionComplete) {
         // Grab friction now when we know player on ground and other variables
-        Vector afterTickFriction = player.clientVelocity.clone();
+        Vector3D afterTickFriction = player.clientVelocity.clone();
 
         // We must first check if the player has accepted their setback
         // If the setback isn't complete, then this position is illegitimate
@@ -115,7 +118,7 @@ public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
         return false;
     }
 
-    private void simulateFriction(Vector vector) {
+    private void simulateFriction(Vector3D vector) {
         // We must always do this before simulating positions, as this is the last actual (safe) movement
         // We must not do this for knockback or explosions, as they are at the start of the tick
         if (player.wasTouchingWater) {
@@ -123,12 +126,13 @@ public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
         } else if (player.wasTouchingLava) {
             vector.multiply(0.5D);
             if (player.hasGravity)
-                vector.add(new Vector(0.0D, -player.gravity / 4.0D, 0.0D));
+                vector.add(newVector3D(0.0D, -player.gravity / 4.0D, 0.0D));
         } else if (player.isGliding) {
-            PredictionEngineElytra.getElytraMovement(player, vector, ReachUtils.getLook(player, player.xRot, player.yRot)).multiply(player.stuckSpeedMultiplier).multiply(new Vector(0.99F, 0.98F, 0.99F));
+            PredictionEngineElytra.getElytraMovement(player, vector, ReachUtils.getLook(player, player.xRot, player.yRot)).multiply(player.stuckSpeedMultiplier).multiply(newVector3D(0.99F, 0.98F, 0.99F));
             vector.setY(vector.getY() - 0.05); // Make the player fall a bit
         } else { // Gliding doesn't have friction, we handle it differently
             PredictionEngineNormal.staticVectorEndOfTick(player, vector); // Lava and normal movement
+            vector.multiply(player.stuckSpeedMultiplier); // Prevent abusing setbacks to move out of blocks like webs
         }
 
         // stop 1.8 players from stepping onto 1.25 high blocks, because why not?
@@ -147,18 +151,18 @@ public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
             lastWorldResync = System.currentTimeMillis();
         }
 
-        Vector clientVel = lastKnownGoodPosition.vector.clone();
+        Vector3D clientVel = lastKnownGoodPosition.vector.clone();
 
-        Pair<VelocityData, Vector> futureKb = player.checkManager.getKnockbackHandler().getFutureKnockback();
+        Pair<VelocityData, Vector3D> futureKb = player.checkManager.getKnockbackHandler().getFutureKnockback();
         VelocityData futureExplosion = player.checkManager.getExplosionHandler().getFutureExplosion();
 
         // Velocity sets
-        if (futureKb.getFirst() != null) {
-            clientVel = futureKb.getSecond();
+        if (futureKb.first() != null) {
+            clientVel = futureKb.second();
         }
 
         // Explosion adds
-        if (futureExplosion != null && (futureKb.getFirst() == null || futureKb.getFirst().transaction < futureExplosion.transaction)) {
+        if (futureExplosion != null && (futureKb.first() == null || futureKb.first().transaction < futureExplosion.transaction)) {
             clientVel.add(futureExplosion.vector);
         }
 
@@ -169,7 +173,7 @@ public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
 
         // Mini prediction engine - simulate collisions
         if (simulateNextTickPosition) {
-            Vector collide = Collisions.collide(player, clientVel.getX(), clientVel.getY(), clientVel.getZ());
+            Vector3D collide = Collisions.collide(player, clientVel.getX(), clientVel.getY(), clientVel.getZ());
 
             position = position.withX(position.getX() + collide.getX());
             // 1.8 players need the collision epsilon to not phase into blocks when being setback
@@ -328,16 +332,16 @@ public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
         while (true) {
             Pair<Integer, Vector3d> teleportPos = player.vehicleData.vehicleTeleports.peek();
             if (teleportPos == null) break;
-            if (lastTransaction < teleportPos.getFirst()) {
+            if (lastTransaction < teleportPos.first()) {
                 break;
             }
 
-            Vector3d position = teleportPos.getSecond();
+            Vector3d position = teleportPos.second();
             if (position.getX() == x && position.getY() == y && position.getZ() == z) {
                 player.vehicleData.vehicleTeleports.poll();
 
                 return true;
-            } else if (lastTransaction > teleportPos.getFirst() + 1) {
+            } else if (lastTransaction > teleportPos.first() + 1) {
                 player.vehicleData.vehicleTeleports.poll();
 
                 // Vehicles have terrible netcode so just ignore it if the teleport wasn't from us setting the player back
@@ -397,22 +401,22 @@ public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
         Vector3d safePosition = new Vector3d(position.getX(), position.getY(), position.getZ());
 
         // We must convert relative teleports to avoid them becoming client controlled in the case of setback
-        if (flags.isSet(RelativeFlag.X.getMask())) {
+        if (flags.has(RelativeFlag.X)) {
             safePosition = safePosition.withX(safePosition.getX() + lastKnownGoodPosition.pos.getX());
         }
 
-        if (flags.isSet(RelativeFlag.Y.getMask())) {
+        if (flags.has(RelativeFlag.Y)) {
             safePosition = safePosition.withY(safePosition.getY() + lastKnownGoodPosition.pos.getY());
         }
 
-        if (flags.isSet(RelativeFlag.Z.getMask())) {
+        if (flags.has(RelativeFlag.Z)) {
             safePosition = safePosition.withZ(safePosition.getZ() + lastKnownGoodPosition.pos.getZ());
         }
 
         data = new TeleportData(safePosition, flags, transaction, teleportId);
         requiredSetBack = new SetBackData(data, player.xRot, player.yRot, null, false, plugin);
 
-        this.lastKnownGoodPosition = new SetbackPosWithVector(safePosition, new Vector());
+        this.lastKnownGoodPosition = new SetbackPosWithVector(safePosition, newVector3D());
     }
 
     @AllArgsConstructor
@@ -420,6 +424,6 @@ public class SetbackTeleportUtil extends Check implements PostPredictionCheck {
     @Setter
     public static class SetbackPosWithVector {
         private Vector3d pos;
-        private Vector vector;
+        private Vector3D vector;
     }
 }

src/main/java/ac/grim/grimac/manager/SpectateManager.java

@@ -71,14 +71,8 @@ public class SpectateManager implements Initable {
         spectatingPlayers.remove(uuid);
     }
 
-    private static class PreviousState {
-        public PreviousState(org.bukkit.GameMode gameMode, Location location) {
-            this.gameMode = gameMode;
-            this.location = location;
-        }
+    private record PreviousState(org.bukkit.GameMode gameMode, Location location) {
 
-        private final org.bukkit.GameMode gameMode;
-        private final Location location;
     }
 
 }

src/main/java/ac/grim/grimac/manager/config/BaseConfigManager.java

@@ -0,0 +1,63 @@
+package ac.grim.grimac.manager.config;
+
+import ac.grim.grimac.api.config.ConfigManager;
+import ac.grim.grimac.utils.anticheat.LogUtil;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+public class BaseConfigManager {
+
+    /*
+    This is to hold whatever config manager was set via the reload method in the API
+    and any global variables that are the same between players.
+     */
+
+    @Getter
+    private ConfigManager config = null;
+
+    // initialize the config
+    public void load(ConfigManager config) {
+        this.config = config;
+        //
+        int configuredMaxTransactionTime = config.getIntElse("max-transaction-time", 60);
+        if (configuredMaxTransactionTime > 180 || configuredMaxTransactionTime < 1) {
+            LogUtil.warn("Detected invalid max-transaction-time! This setting is clamped between 1 and 180 to prevent issues. Attempting to disable or set this too high can result in memory usage issues.");
+        }
+
+        ignoredClientPatterns.clear();
+        for (String string : config.getStringList("client-brand.ignored-clients")) {
+            try {
+                ignoredClientPatterns.add(Pattern.compile(string));
+            } catch (PatternSyntaxException e) {
+                throw new RuntimeException("Failed to compile client pattern", e);
+            }
+        }
+
+        printAlertsToConsole = config.getBooleanElse("alerts.print-to-console", true);
+        prefix = config.getStringElse("prefix", "&bGrim &8»");
+    }
+
+    // ran on start, can be used to handle things that can't be done while loading
+    public void start() {
+
+    }
+
+    @Getter private boolean printAlertsToConsole = false;
+
+    @Getter private String prefix = "&bGrim &8»";
+
+    private final List<Pattern> ignoredClientPatterns = new ArrayList<>();
+
+    public boolean isIgnoredClient(String brand) {
+        for (Pattern pattern : ignoredClientPatterns) {
+            if (pattern.matcher(brand).find()) return true;
+        }
+        return false;
+    }
+
+
+}

src/main/java/ac/grim/grimac/manager/config/ConfigManagerFileImpl.java

@@ -1,56 +1,43 @@
-package ac.grim.grimac.manager;
+package ac.grim.grimac.manager.config;
 
 import ac.grim.grimac.GrimAC;
 import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.common.BasicReloadable;
+import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.utils.anticheat.LogUtil;
 import github.scarsz.configuralize.DynamicConfig;
 import github.scarsz.configuralize.Language;
-import lombok.Getter;
 
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
-import java.util.ArrayList;
 import java.util.List;
-import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
 
-public class ConfigManager {
-    @Getter
+public class ConfigManagerFileImpl implements ConfigManager, BasicReloadable {
+
     private final DynamicConfig config;
-    @Getter
-    private final File configFile = new File(GrimAPI.INSTANCE.getPlugin().getDataFolder(), "config.yml");
-    @Getter
-    private final File messagesFile = new File(GrimAPI.INSTANCE.getPlugin().getDataFolder(), "messages.yml");
-    @Getter
-    private final File discordFile = new File(GrimAPI.INSTANCE.getPlugin().getDataFolder(), "discord.yml");
-    @Getter
-    private final File punishFile = new File(GrimAPI.INSTANCE.getPlugin().getDataFolder(), "punishments.yml");
-    @Getter
-    private int maxPingTransaction = 60; // This is just a really hot variable so cache it.
-    @Getter
-    private boolean ignoreDuplicatePacketRotation = false;
 
-    @Getter
-    private boolean experimentalChecks = false;
-
-    private final List<Pattern> ignoredClientPatterns = new ArrayList<>();
-
-    public ConfigManager() {
-        upgrade();
-
-        // load config
-        GrimAPI.INSTANCE.getPlugin().getDataFolder().mkdirs();
-        config = new DynamicConfig();
-        config.addSource(GrimAC.class, "config", getConfigFile());
-        config.addSource(GrimAC.class, "messages", getMessagesFile());
-        config.addSource(GrimAC.class, "discord", getDiscordFile());
-        config.addSource(GrimAC.class, "punishments", getPunishFile());
-
-        reload();
+    private File getConfigFile(String path) {
+        return new File(GrimAPI.INSTANCE.getPlugin().getDataFolder(), path);
     }
 
+    public ConfigManagerFileImpl() {
+        config = new DynamicConfig();
+    }
+
+    private boolean initialized = false;
+
+    @Override
     public void reload() {
+        GrimAPI.INSTANCE.getPlugin().getDataFolder().mkdirs();
+        if (!initialized) {
+            initialized = true;
+            config.addSource(GrimAC.class, "config", getConfigFile("config.yml"));
+            config.addSource(GrimAC.class, "messages", getConfigFile("messages.yml"));
+            config.addSource(GrimAC.class, "discord", getConfigFile("discord.yml"));
+            config.addSource(GrimAC.class, "punishments", getConfigFile("punishments.yml"));
+        }
+        //
         String languageCode = System.getProperty("user.language").toUpperCase();
 
         try {
@@ -77,24 +64,6 @@ public class ConfigManager {
         } catch (Exception e) {
             throw new RuntimeException("Failed to load config", e);
         }
-        maxPingTransaction = config.getIntElse("max-transaction-time", 60);
-        ignoredClientPatterns.clear();
-        for (String string : config.getStringList("client-brand.ignored-clients")) {
-            try {
-                ignoredClientPatterns.add(Pattern.compile(string));
-            } catch (PatternSyntaxException e) {
-                throw new RuntimeException("Failed to compile client pattern", e);
-            }
-        }
-        experimentalChecks = config.getBooleanElse("experimental-checks", false);
-        ignoreDuplicatePacketRotation = config.getBooleanElse("ignore-duplicate-packet-rotation", false);
-    }
-
-    public boolean isIgnoredClient(String brand) {
-        for (Pattern pattern : ignoredClientPatterns) {
-            if (pattern.matcher(brand).find()) return true;
-        }
-        return false;
     }
 
     private void upgrade() {
@@ -317,4 +286,45 @@ public class ConfigManager {
         );
         Files.write(config.toPath(), configString.getBytes());
     }
+
+    @Override
+    public String getStringElse(String key, String otherwise) {
+        return config.getStringElse(key, otherwise);
+    }
+
+    @Override
+    public List<String> getStringList(String key) {
+        return config.getStringList(key);
+    }
+
+    @Override
+    public List<String> getStringListElse(String key, List<String> otherwise) {
+        return config.getStringListElse(key, otherwise);
+    }
+
+    @Override
+    public int getIntElse(String key, int other) {
+        return config.getIntElse(key, other);
+    }
+
+    @Override
+    public long getLongElse(String key, long otherwise) {
+        return config.getLongElse(key, otherwise);
+    }
+
+    @Override
+    public double getDoubleElse(String key, double otherwise) {
+        return config.getDoubleElse(key, otherwise);
+    }
+
+    @Override
+    public boolean getBooleanElse(String key, boolean otherwise) {
+        return config.getBooleanElse(key, otherwise);
+    }
+
+    @Override
+    public <T> T get(String key) {
+        return config.get(key);
+    }
+
 }

src/main/java/ac/grim/grimac/manager/init/load/PacketEventsInit.java

@@ -4,8 +4,17 @@ import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.manager.init.Initable;
 import ac.grim.grimac.utils.anticheat.LogUtil;
 import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.protocol.chat.ChatTypes;
+import com.github.retrooper.packetevents.protocol.entity.data.EntityDataTypes;
+import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
+import com.github.retrooper.packetevents.protocol.item.enchantment.type.EnchantmentTypes;
+import com.github.retrooper.packetevents.protocol.item.type.ItemTypes;
+import com.github.retrooper.packetevents.protocol.particle.type.ParticleTypes;
+import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
 import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
 
+import java.util.concurrent.Executors;
+
 public class PacketEventsInit implements Initable {
     @Override
     public void start() {
@@ -16,7 +25,18 @@ public class PacketEventsInit implements Initable {
                 .fullStackTrace(true)
                 .kickOnPacketException(true)
                 .checkForUpdates(false)
+                .reEncodeByDefault(false)
                 .debug(false);
         PacketEvents.getAPI().load();
+        // This may seem useless, but it causes java to start loading stuff async before we need it
+        Executors.defaultThreadFactory().newThread(() -> {
+            StateTypes.AIR.getName();
+            ItemTypes.AIR.getName();
+            EntityTypes.PLAYER.getParent();
+            EntityDataTypes.BOOLEAN.getName();
+            ChatTypes.CHAT.getName();
+            EnchantmentTypes.ALL_DAMAGE_PROTECTION.getName();
+            ParticleTypes.DUST.getName();
+        }).start();
     }
 }

src/main/java/ac/grim/grimac/manager/init/start/BStats.java

@@ -2,13 +2,14 @@ package ac.grim.grimac.manager.init.start;
 
 import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.manager.init.Initable;
+import io.github.retrooper.packetevents.bstats.bukkit.Metrics;
 
 public class BStats implements Initable {
     @Override
     public void start() {
         int pluginId = 12820; // <-- Replace with the id of your plugin!
         try {
-            new io.github.retrooper.packetevents.bstats.Metrics(GrimAPI.INSTANCE.getPlugin(), pluginId);
+            new Metrics(GrimAPI.INSTANCE.getPlugin(), pluginId);
         } catch (Exception ignored) {
         }
     }