Refactor HitboxData.getBlockHitbox() to include isTargetBlock as parameter

Also fixes a rare NPE

.github/workflows/codeql-analysis.yml

@@ -39,11 +39,11 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
+        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.
@@ -54,7 +54,7 @@ jobs:
       # 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@v1
+        uses: github/codeql-action/autobuild@v3
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -68,4 +68,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v1
+        uses: github/codeql-action/analyze@v3

.github/workflows/gradle-publish.yml

@@ -19,9 +19,9 @@ jobs:
       packages: write
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up JDK 17
-      uses: actions/setup-java@v3
+      uses: actions/setup-java@v4
       with:
         java-version: '17'
         distribution: 'temurin'
@@ -29,10 +29,10 @@ jobs:
         settings-path: ${{ github.workspace }} # location for the settings.xml file
 
     - name: Build with Gradle
-      uses: gradle/gradle-build-action@67421db6bd0bf253fb4bd25b31ebb98943c375e1
+      uses: gradle/actions/setup-gradle@v3
       with:
         arguments: build
     - name: Upload a Build Artifact
-      uses: actions/upload-artifact@v3.1.0
+      uses: actions/upload-artifact@v4
       with:
         path: /home/runner/work/Grim/Grim/build/libs/**.jar

README.md

@@ -1,21 +1,42 @@
 # GrimAC
 
-This project is considered feature complete for the 2.0 (open-source) branch of this project. If you would like a bugfix or enhancement and cannot sponsor the work, pull requests are welcome. You can join the [discord](https://discord.com/invite/kqQAhTmkUF) for jar releases & changelogs.
-
 GrimAC is an open source Minecraft anticheat designed for 1.21 and supports 1.8-1.21. It is free while in beta. It will eventually become paid and/or will include offering additional subscription based paid checks. Geyser players are fully exempt.
 
-### 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
-4. The final jar is located in build/libs
+This project is considered feature complete for the 2.0 (open-source) branch of this project. If you would like a bugfix or enhancement and cannot sponsor the work, pull requests are welcome.
 
-### API Information
-Grim's API allows you to integrate Grim into your own plugins. For more information, check out the API's GitHub repository [here](https://github.com/GrimAnticheat/GrimAPI).
+## Downloads
+- [Modrinth](https://modrinth.com/plugin/grimac)
+- [Hangar](https://hangar.papermc.io/GrimAnticheat/GrimAnticheat)
+- [SpigotMC](https://www.spigotmc.org/resources/grim-anticheat.99923/)
+- *For bleeding edge builds use* [Github artifacts](https://nightly.link/GrimAnticheat/Grim/workflows/gradle-publish/2.0/artifact.zip)
+
+## Installation notes
+> [!WARNING]
+> Java 17 is now required. More information [here](https://github.com/GrimAnticheat/Grim/wiki/Updating-to-Java-17).
+- Paper, Spigot, and Folia are currently supported.
+- If you use Geyser, place Floodgate on the backend server so grim can exempt bedrock players. Grim cannot access the Floodgate API if it is on the proxy.
+- If you use ViaVersion, it should be on the backend server as movement is highly dependent on client version.
+
+## Support & wiki information
+- Support & discussion: [Discord](https://discord.com/invite/kqQAhTmkUF)
+- Report issues: [Issues](https://github.com/GrimAnticheat/Grim/issues/new/choose)
+- Wiki & examples: [Wiki](https://github.com/GrimAnticheat/Grim/wiki)
+
+## Developer API
+Grim's API allows you to integrate Grim into your own plugins.
+- API repository: [GrimAPI](https://github.com/GrimAnticheat/GrimAPI)
+- Wiki info: [Wiki](https://github.com/GrimAnticheat/GrimAPI)
+
+## How to compile
+
+1. `git clone https://github.com/GrimAnticheat/Grim.git`
+2. `cd Grim`
+3. `./gradlew build`
+4. The final jar will compile into the build/libs folder
 
 ## Grim supremacy
 
-Here are the main cores that make Grim stand out against other anticheats
+What makes Grim stand out against other anticheats?
 
 ### Movement Simulation Engine
 

build.gradle.kts

@@ -6,17 +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.68"
+version = "2.3.69"
 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(17))
+}
 
 // Set to false for debug builds
 // You cannot live reload classes if the jar relocates dependencies
-var relocate = true;
+// Checks Project properties -> environment variable -> defaults true
+val relocate: Boolean = project.findProperty("relocate")?.toString()?.toBoolean()
+    ?: System.getenv("RELOCATE_JAR")?.toBoolean()
+    ?: true
 
 repositories {
     mavenLocal()
@@ -33,25 +55,32 @@ repositories {
     maven("https://repo.opencollab.dev/maven-releases/") // Cumulus (for Floodgate)
     maven("https://repo.codemc.io/repository/maven-releases/") // PacketEvents
     maven("https://repo.codemc.io/repository/maven-snapshots/")
+    maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
+    maven("https://repo.extendedclip.com/content/repositories/placeholderapi/") // placeholderapi
     mavenCentral()
     // FastUtil, Discord-Webhooks
 }
 
 dependencies {
-    implementation("com.github.retrooper:packetevents-spigot:2.5.1-SNAPSHOT")
+    implementation("com.github.retrooper:packetevents-spigot:2.7.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")
+
+    // Used for local testing:
+    //implementation("ac.grim.grimac:GrimAPI:1.0")
+    implementation("com.github.grimanticheat:grimapi:ed1ec7b4a1")
+
+    implementation("net.kyori:adventure-text-minimessage:4.17.0")
+    implementation("net.kyori:adventure-platform-bukkit:4.3.4")
 
     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("io.papermc.paper:paper-api:1.18.2-R0.1-SNAPSHOT")
+    compileOnly("com.viaversion:viaversion-api:5.0.4-SNAPSHOT")
+    compileOnly("me.clip:placeholderapi:2.11.6")
     compileOnly("io.netty:netty-all:4.1.85.Final")
 }
 
@@ -59,6 +88,7 @@ bukkit {
     name = "GrimAC"
     author = "GrimAC"
     main = "ac.grim.grimac.GrimAC"
+    website = "https://grim.ac/"
     apiVersion = "1.13"
     foliaSupported = true
 
@@ -71,7 +101,8 @@ bukkit {
         "ViaRewind",
         "Geyser-Spigot",
         "floodgate",
-        "FastLogin"
+        "FastLogin",
+        "PlaceholderAPI",
     )
 
     permissions {
@@ -100,6 +131,11 @@ bukkit {
             default = Permission.Default.OP
         }
 
+        register("grim.brand.enable-on-join") {
+            description = "Enable showing client brands on join"
+            default = Permission.Default.OP
+        }
+
         register("grim.sendalert") {
             description = "Send cheater alert"
             default = Permission.Default.OP
@@ -119,11 +155,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> {
@@ -156,4 +203,4 @@ tasks.shadowJar {
         relocate("org.intellij", "ac.grim.grimac.shaded.intellij")
         relocate("org.jetbrains", "ac.grim.grimac.shaded.jetbrains")
     }
-}
+}

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.12-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -86,8 +86,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
-' "$PWD" ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum

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,35 @@
 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.UUID;
+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;
 
@@ -34,17 +44,19 @@ public class GrimExternalAPI implements GrimAbstractAPI, Initable {
     }
 
     @Override
-    public void setServerName(String name) {
-        variableReplacements.put("%server%", user -> name);
+    public @Nullable GrimUser getGrimUser(UUID uuid) {
+        Player player = Bukkit.getPlayer(uuid);
+        if (player == null) return null;
+        return getGrimUser(player);
     }
 
     @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);
+    public String replaceVariables(GrimUser user, String content) {
         for (Map.Entry<String, String> entry : staticReplacements.entrySet()) {
             content = content.replace(entry.getKey(), entry.getValue());
         }
@@ -56,12 +68,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 +90,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 +112,116 @@ 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;
     }
+
+    @Override
+    public boolean hasStarted() {
+        return started;
+    }
+
+    @Override
+    public int getCurrentTick() {
+        return GrimAPI.INSTANCE.getTickManager().currentTick;
+    }
+
+    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.put("%prefix%", ChatColor.translateAlternateColorCodes('&', GrimAPI.INSTANCE.getConfigManager().getPrefix()));
+        staticReplacements.putIfAbsent("%grim_version%", getGrimVersion());
+    }
+
 }

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

@@ -2,11 +2,13 @@ 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 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;
@@ -14,7 +16,7 @@ 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 extends GrimProcessor implements AbstractCheck {
     protected final GrimPlayer player;
 
     public double violations;
@@ -24,25 +26,22 @@ 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() {
-        return experimental;
-    }
+    private boolean exemptPermission;
+    private boolean noSetbackPermission;
+    private boolean noModifyPacketPermission;
 
     public Check(final GrimPlayer player) {
         this.player = player;
 
-        final Class<?> checkClass = this.getClass();
-
-        if (checkClass.isAnnotationPresent(CheckData.class)) {
-            final CheckData checkData = checkClass.getAnnotation(CheckData.class);
+        final CheckData checkData = this.getClass().getAnnotation(CheckData.class);
+        if (checkData != null) {
             this.checkName = checkData.name();
             this.configName = checkData.configName();
             // Fall back to check name
@@ -52,24 +51,33 @@ 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 && !exempted;
+        return isEnabled && !player.disableGrim && !player.noModifyPacketPermission && !exemptPermission;
     }
 
-    public void updateExempted() {
+    public void updatePermissions() {
         if (player.bukkitPlayer == null || checkName == null) return;
-        FoliaScheduler.getEntityScheduler().run(player.bukkitPlayer, GrimAPI.INSTANCE.getPlugin(),
-                t -> exempted = player.bukkitPlayer.hasPermission("grim.exempt." + checkName.toLowerCase()),
-                () -> {});
+        FoliaScheduler.getEntityScheduler().run(
+                player.bukkitPlayer,
+                GrimAPI.INSTANCE.getPlugin(),
+                t -> {
+                    final String id = checkName.toLowerCase();
+                    exemptPermission = player.bukkitPlayer.hasPermission("grim.exempt." + id);
+                    noSetbackPermission = player.bukkitPlayer.hasPermission("grim.nosetback." + id);
+                    noModifyPacketPermission = player.bukkitPlayer.hasPermission("grim.nomodifypacket." + id);
+                },
+                () -> {}
+        );
     }
 
     public final boolean flagAndAlert(String verbose) {
-        if (flag()) {
+        if (flag(verbose)) {
             alert(verbose);
             return true;
         }
@@ -81,16 +89,21 @@ public class Check implements AbstractCheck {
     }
 
     public final boolean flag() {
-        if (player.disableGrim || (experimental && !GrimAPI.INSTANCE.getConfigManager().isExperimentalChecks()) || exempted)
+        return flag("");
+    }
+
+    private long lastViolationTime;
+
+    public final boolean flag(String verbose) {
+        if (player.disableGrim || (experimental && !player.isExperimentalChecks()) || exemptPermission)
             return false; // Avoid calling event if disabled
 
-        FlagEvent event = new FlagEvent(player, this);
+        FlagEvent event = new FlagEvent(player, this, verbose);
         Bukkit.getPluginManager().callEvent(event);
         if (event.isCancelled()) return false;
 
-
         player.punishmentManager.handleViolation(this);
-
+        lastViolationTime = System.currentTimeMillis();
         violations++;
         return true;
     }
@@ -107,32 +120,36 @@ 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);
+        description = configuration.getStringElse(configName + ".description", description);
 
         if (setbackVL == -1) setbackVL = Double.MAX_VALUE;
+        updatePermissions();
+        onReload(configuration);
+    }
+
+    @Override
+    public void onReload(ConfigManager config) {
 
-        updateExempted();
     }
 
     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) {
+        if (shouldSetback()) {
             return player.getSetbackTeleportUtil().executeViolationSetback();
         }
         return false;
     }
 
-    public boolean isAboveSetbackVl() {
-        return getViolations() > setbackVL;
+    public boolean shouldSetback() {
+        return !noSetbackPermission && violations > setbackVL;
     }
 
     public String formatOffset(double offset) {
@@ -144,5 +161,37 @@ 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);
+    }
+
+}

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

@@ -0,0 +1,17 @@
+package ac.grim.grimac.checks;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.api.AbstractProcessor;
+import ac.grim.grimac.api.config.ConfigReloadable;
+import ac.grim.grimac.utils.common.ConfigReloadObserver;
+
+public abstract class GrimProcessor implements AbstractProcessor, ConfigReloadable, ConfigReloadObserver {
+
+    // Not everything has to be a check for it to process packets & be configurable
+
+    @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,18 @@ public class AimModulo360 extends Check implements RotationCheck {
 
     @Override
     public void process(final RotationUpdate rotationUpdate) {
-        lastDeltaYaw = rotationUpdate.getDeltaXRot();
-        if (player.packetStateData.lastPacketWasTeleport) return;
+        // Exempt for teleport or entering a vehicle due to rotation reset
+        if (player.packetStateData.lastPacketWasTeleport || player.vehicleData.wasVehicleSwitch) {
+            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/BadPacketsA.java

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientHeldItemChange;
 
-@CheckData(name = "BadPacketsA")
+@CheckData(name = "BadPacketsA", description = "Sent duplicate slot id")
 public class BadPacketsA extends Check implements PacketCheck {
     int lastSlot = -1;
 

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

@@ -5,10 +5,11 @@ 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.player.GameMode;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
 
-@CheckData(name = "BadPacketsC")
+@CheckData(name = "BadPacketsC", description = "Interacted with self")
 public class BadPacketsC extends Check implements PacketCheck {
     public BadPacketsC(GrimPlayer player) {
         super(player);
@@ -17,6 +18,7 @@ public class BadPacketsC extends Check implements PacketCheck {
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            if (player.gamemode == GameMode.SPECTATOR) return;
             if (new WrapperPlayClientInteractEntity(event).getEntityId() == player.entityID) {
                 // Instant ban
                 if (flagAndAlert() && shouldModifyPackets()) {

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

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
-@CheckData(name = "BadPacketsD")
+@CheckData(name = "BadPacketsD", description = "Impossible pitch")
 public class BadPacketsD extends Check implements PacketCheck {
     public BadPacketsD(GrimPlayer player) {
         super(player);

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

@@ -4,8 +4,11 @@ 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.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+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.WrapperPlayClientPlayerFlying;
 
 @CheckData(name = "BadPacketsE")
@@ -18,12 +21,14 @@ public class BadPacketsE extends Check implements PacketCheck {
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
+        final boolean isViaPleaseStopUsingProtocolHacksOnYourServer = player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_2) || PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_21_2);
         if (event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION ||
                 event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION) {
             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
+                || (isViaPleaseStopUsingProtocolHacksOnYourServer && player.compensatedEntities.getSelf().inVehicle())) {
             noReminderTicks = 0; // Exempt vehicles
         }
 

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

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
-@CheckData(name = "BadPacketsF")
+@CheckData(name = "BadPacketsF", description = "Sent duplicate sprinting status")
 public class BadPacketsF extends Check implements PacketCheck {
     public boolean lastSprinting;
     public boolean exemptNext = true; // Support 1.14+ clients starting on either true or false sprinting, we don't know

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

@@ -8,10 +8,9 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
-@CheckData(name = "BadPacketsG")
+@CheckData(name = "BadPacketsG", description = "Sent duplicate sneaking status")
 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,9 +10,8 @@ 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")
+@CheckData(name = "BadPacketsH", description = "Did not swing for attack")
 public class BadPacketsH extends Check implements PacketCheck {
 
     // 1.9 packet order: INTERACT -> ANIMATION
@@ -42,9 +41,9 @@ public class BadPacketsH extends Check implements PacketCheck {
             // I will simply disable this check for 1.8- clients on 1.9+ servers as I can't be bothered to find a way around this.
             // Stop supporting such old clients on modern servers!
             if (player.getClientVersion().isOlderThan(ClientVersion.V_1_9)
-                    && PacketEvents.getAPI().getServerManager().getVersion().isNewerThan(ServerVersion.V_1_8)) return;
+                    && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_9)) return;
 
-            if (!sentAnimation && flagAndAlert()) {
+            if (!sentAnimation && flagAndAlert() && shouldModifyPackets()) {
                 event.setCancelled(true);
                 player.onPacketCancel();
             }

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

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerAbilities;
 
-@CheckData(name = "BadPacketsI")
+@CheckData(name = "BadPacketsI", description = "Claimed to be flying while unable to fly")
 public class BadPacketsI extends Check implements PacketCheck {
     public BadPacketsI(GrimPlayer player) {
         super(player);

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

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
 
-@CheckData(name = "BadPacketsK")
+@CheckData(name = "BadPacketsK", description = "Sent spectate packets while not in spectator mode")
 public class BadPacketsK extends Check implements PacketCheck {
     public BadPacketsK(GrimPlayer player) {
         super(player);

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

@@ -8,13 +8,11 @@ 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.world.BlockFace;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
 
 import java.util.Locale;
 
-// checks for impossible dig packets
-@CheckData(name = "BadPacketsL")
+@CheckData(name = "BadPacketsL", description = "Sent impossible dig packet")
 public class BadPacketsL extends Check implements PacketCheck {
 
     public BadPacketsL(GrimPlayer player) {
@@ -30,19 +28,20 @@ public class BadPacketsL extends Check implements PacketCheck {
 
             // 1.8 and above clients always send digging packets that aren't used for digging at 0, 0, 0, facing DOWN
             // 1.7 and below clients do the same, except use SOUTH for RELEASE_USE_ITEM
-            final BlockFace expectedFace = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10) && packet.getAction() == DiggingAction.RELEASE_USE_ITEM
-                    ? BlockFace.SOUTH : BlockFace.DOWN;
+            final int expectedFace = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10) && packet.getAction() == DiggingAction.RELEASE_USE_ITEM
+                    ? 255 : 0;
 
-            if (packet.getBlockFace() != expectedFace
+            if (packet.getBlockFaceId() != expectedFace
                     || packet.getBlockPosition().getX() != 0
                     || packet.getBlockPosition().getY() != 0
                     || packet.getBlockPosition().getZ() != 0
                     || packet.getSequence() != 0
             ) {
-                if (flagAndAlert("xyzF="
-                        + packet.getBlockPosition().getX() + ", " + packet.getBlockPosition().getY() + ", " + packet.getBlockPosition().getZ() + ", " + packet.getBlockFace()
+                if (flagAndAlert("pos="
+                        + packet.getBlockPosition().getX() + ", " + packet.getBlockPosition().getY() + ", " + packet.getBlockPosition().getZ()
+                        + ", face=" + packet.getBlockFace()
                         + ", sequence=" + packet.getSequence()
-                        + ", action=" + packet.getAction().toString().toLowerCase(Locale.ROOT).replace("_", " ") + " v" + player.getVersionName()
+                        + ", action=" + packet.getAction().toString().toLowerCase(Locale.ROOT)
                 ) && shouldModifyPackets() && packet.getAction() != DiggingAction.RELEASE_USE_ITEM) {
                     event.setCancelled(true);
                     player.onPacketCancel();

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

@@ -11,7 +11,7 @@ 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;
 
-@CheckData(name = "BadPacketsM", experimental = true)
+@CheckData(name = "BadPacketsM")
 public class BadPacketsM extends Check implements PacketCheck {
     public BadPacketsM(final GrimPlayer player) {
         super(player);

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

@@ -5,7 +5,7 @@ import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
-@CheckData(name = "BadPacketsN")
+@CheckData(name = "BadPacketsN", setback = 0)
 public class BadPacketsN extends Check implements PacketCheck {
     public BadPacketsN(final GrimPlayer player) {
         super(player);

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/BadPacketsP.java

@@ -8,6 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClickWindow;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClickWindow.WindowClickType;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerOpenWindow;
 
 @CheckData(name = "BadPacketsP", experimental = true)
@@ -33,35 +34,22 @@ public class BadPacketsP extends Check implements PacketCheck {
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW) {
             WrapperPlayClientClickWindow wrapper = new WrapperPlayClientClickWindow(event);
-            int clickType = wrapper.getWindowClickType().ordinal();
+            WindowClickType clickType = wrapper.getWindowClickType();
             int button = wrapper.getButton();
 
-            boolean flag = false;
+            // TODO: Adjust for containers
+            boolean flag = switch (clickType) {
+                case PICKUP, QUICK_MOVE, CLONE -> button > 2 || button < 0;
+                case SWAP -> (button > 8 || button < 0) && button != 40;
+                case THROW -> button != 0 && button != 1;
+                case QUICK_CRAFT -> button == 3 || button == 7 || button > 10 || button < 0;
+                case PICKUP_ALL -> button != 0;
+                case UNKNOWN -> false;
+            };
 
-            //TODO: Adjust for containers
-            switch (clickType) {
-                case 0:
-                case 1:
-                case 4:
-                    if (button != 0 && button != 1) flag = true;
-                    break;
-                case 2:
-                    if ((button > 8 || button < 0) && button != 40) flag = true;
-                    break;
-                case 3:
-                    if (button != 2) flag = true;
-                    break;
-                case 5:
-                    if (button == 3 || button == 7 || button > 10 || button < 0) flag = true;
-                    break;
-                case 6:
-                    if (button != 0) flag = true;
-                    break;
-            }
-
-            //Allowing this to false flag to debug and find issues faster
+            // Allowing this to false flag to debug and find issues faster
             if (flag) {
-                if (flagAndAlert("clickType=" + clickType + " button=" + button + (wrapper.getWindowId() == containerId ? " container=" + containerType : "")) && shouldModifyPackets()) {
+                if (flagAndAlert("clickType=" + clickType.toString().toLowerCase() + ", button=" + button + (wrapper.getWindowId() == containerId ? ", container=" + containerType : "")) && shouldModifyPackets()) {
                     event.setCancelled(true);
                     player.onPacketCancel();
                 }

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

@@ -19,8 +19,10 @@ public class BadPacketsQ extends Check implements PacketCheck {
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == Client.ENTITY_ACTION) {
             WrapperPlayClientEntityAction wrapper = new WrapperPlayClientEntityAction(event);
-
-            if (wrapper.getJumpBoost() < 0 || wrapper.getJumpBoost() > 100 || wrapper.getEntityId() != player.entityID || (wrapper.getAction() != Action.START_JUMPING_WITH_HORSE && wrapper.getJumpBoost() != 0)) {
+            // you are able to send negative jump boost, how and why!?
+            if (Math.abs(wrapper.getJumpBoost()) > 100
+                    || wrapper.getEntityId() != player.entityID
+                    || wrapper.getAction() != Action.START_JUMPING_WITH_HORSE && wrapper.getJumpBoost() != 0) {
                 if (flagAndAlert("boost=" + wrapper.getJumpBoost() + ", action=" + wrapper.getAction() + ", entity=" + wrapper.getEntityId()) && shouldModifyPackets()) {
                     event.setCancelled(true);
                     player.onPacketCancel();

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

@@ -26,7 +26,7 @@ public class BadPacketsR extends Check implements PacketCheck {
             long diff = (System.currentTimeMillis() - lastTransTime);
             if (diff > 2000 && ms > 2000) {
                 if (positions == 0 && clock != 0 && player.gamemode != GameMode.SPECTATOR && !player.compensatedEntities.getSelf().isDead) {
-                    flagAndAlert("time=" + ms + "ms, " + "lst=" + diff + "ms, positions=" + positions);
+                    flag("time=" + ms + "ms, " + "lst=" + diff + "ms, positions=" + positions);
                 } else {
                     reward();
                 }
@@ -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/BadPacketsT.java

@@ -49,7 +49,7 @@ public class BadPacketsT extends Check implements PacketCheck {
                 //  27/12/2023 - Dynamic values for more than just one entity type?
                 //  28/12/2023 - Player-only is fine
                 //  30/12/2023 - Expansions differ in 1.9+
-                final float scale = (float) packetEntity.getAttributeValue(Attributes.GENERIC_SCALE);
+                final float scale = (float) packetEntity.getAttributeValue(Attributes.SCALE);
                 if (targetVector.y > (minVerticalDisplacement * scale) && targetVector.y < (maxVerticalDisplacement * scale)
                         && Math.abs(targetVector.x) < (maxHorizontalDisplacement * scale)
                         && Math.abs(targetVector.z) < (maxHorizontalDisplacement * scale)) {

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;
@@ -15,7 +14,7 @@ import com.github.retrooper.packetevents.util.Vector3f;
 import com.github.retrooper.packetevents.util.Vector3i;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerBlockPlacement;
 
-@CheckData(name = "BadPacketsU", experimental = true)
+@CheckData(name = "BadPacketsU", description = "Sent impossible use item packet")
 public class BadPacketsU extends Check implements PacketCheck {
     public BadPacketsU(GrimPlayer player) {
         super(player);

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

@@ -5,26 +5,36 @@ 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;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.util.Vector3d;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
-@CheckData(name = "BadPacketsV", experimental = true)
+@CheckData(name = "BadPacketsV", description = "Did not move far enough", experimental = true)
 public class BadPacketsV extends Check implements PacketCheck {
     public BadPacketsV(GrimPlayer player) {
         super(player);
     }
 
+    private int noReminderTicks;
+
     @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();
+        if (!player.canSkipTicks() && isTickPacket(event.getPacketType())) {
+            if (event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION || event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION) {
+                int positionAtLeastEveryNTicks = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8) ? 20 : 19;
+
+                if (noReminderTicks < positionAtLeastEveryNTicks && !player.uncertaintyHandler.lastTeleportTicks.hasOccurredSince(1)) {
+                    final double deltaSq = new WrapperPlayClientPlayerFlying(event).getLocation().getPosition()
+                            .distanceSquared(new Vector3d(player.lastX, player.lastY, player.lastZ));
+                    if (deltaSq <= player.getMovementThreshold() * player.getMovementThreshold()) {
+                        flagAndAlert("delta=" + Math.sqrt(deltaSq));
+                    }
+                }
+
+                noReminderTicks = 0;
+            } else {
+                noReminderTicks++;
             }
         }
     }

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

@@ -5,7 +5,7 @@ import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
-@CheckData(name = "BadPacketsW", experimental = true)
+@CheckData(name = "BadPacketsW", description = "Interacted with non-existent entity", experimental = true)
 public class BadPacketsW extends Check implements PacketCheck {
     public BadPacketsW(GrimPlayer player) {
         super(player);

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

@@ -2,43 +2,78 @@ 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.checks.type.PostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
-import ac.grim.grimac.utils.nmsutil.BlockBreakSpeed;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
-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.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.GameMode;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
 @CheckData(name = "BadPacketsX", experimental = true)
-public class BadPacketsX extends Check implements PacketCheck {
+public class BadPacketsX extends Check implements PostPredictionCheck {
     public BadPacketsX(GrimPlayer player) {
         super(player);
     }
 
-    public final boolean noFireHitbox = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_15_2);
+    private boolean sprint;
+    private boolean sneak;
+    private int flags;
 
-    public final void handle(PacketReceiveEvent event, WrapperPlayClientPlayerDigging dig, StateType block) {
-        if (dig.getAction() != DiggingAction.START_DIGGING && dig.getAction() != DiggingAction.FINISHED_DIGGING)
+    @Override
+    public void onPredictionComplete(final PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) {
+            if (flags > 0) {
+                setbackIfAboveSetbackVL();
+            }
+
+            flags = 0;
             return;
+        }
 
-        // 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)
-                // or the client claims to have broken an unbreakable block
-                || block.getHardness() == -1.0f && dig.getAction() == DiggingAction.FINISHED_DIGGING;
+        if (player.isTickingReliablyFor(3)) {
+            for (; flags > 0; flags--) {
+                if (flagAndAlert()) {
+                    setbackIfAboveSetbackVL();
+                }
+            }
+        }
 
-        if (invalid && flagAndAlert("block=" + block.getName() + ", type=" + dig.getAction()) && shouldModifyPackets()) {
-            event.setCancelled(true);
-            player.onPacketCancel();
+        flags = 0;
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.gamemode == GameMode.SPECTATOR || isTickPacket(event.getPacketType())) {
+            sprint = sneak = false;
+            return;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
+            switch (new WrapperPlayClientEntityAction(event).getAction()) {
+                case START_SNEAKING, STOP_SNEAKING -> {
+                    if (sneak) {
+                        if (player.canSkipTicks() || flagAndAlert()) {
+                            flags++;
+                        }
+                    }
+
+                    sneak = true;
+                }
+                case START_SPRINTING, STOP_SPRINTING -> {
+                    if (player.inVehicle()) {
+                        return;
+                    }
+
+                    if (sprint) {
+                        if (player.canSkipTicks() || flagAndAlert()) {
+                            flags++;
+                        }
+                    }
+
+                    sprint = true;
+                }
+            }
         }
     }
 }

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

@@ -8,10 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientHeldItemChange;
 
-/**
- * Checks for out of bounds slot changes
- */
-@CheckData(name = "BadPacketsY")
+@CheckData(name = "BadPacketsY", description = "Sent out of bounds slot id")
 public class BadPacketsY extends Check implements PacketCheck {
     public BadPacketsY(GrimPlayer player) {
         super(player);

src/main/java/ac/grim/grimac/checks/impl/breaking/AirLiquidBreak.java

@@ -0,0 +1,70 @@
+package ac.grim.grimac.checks.impl.breaking;
+
+import ac.grim.grimac.GrimAPI;
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.player.GrimPlayer;
+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.util.Vector3i;
+
+@CheckData(name = "AirLiquidBreak", description = "Breaking a block that cannot be broken")
+public class AirLiquidBreak extends Check implements BlockBreakCheck {
+    public AirLiquidBreak(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);
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (blockBreak.action != DiggingAction.START_DIGGING && blockBreak.action != DiggingAction.FINISHED_DIGGING)
+            return;
+
+        final StateType block = blockBreak.block.getType();
+
+        // Fixes false from breaking kelp underwater
+        // The client sends two start digging packets to the server both in the same tick. AirLiquidBreak 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
+                // 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=" + blockBreak.action) && shouldModifyPackets()) {
+            didLastFlag = true;
+            blockBreak.cancel();
+        } else {
+            didLastFlag = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/breaking/FarBreak.java

@@ -0,0 +1,45 @@
+package ac.grim.grimac.checks.impl.breaking;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+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.DiggingAction;
+import com.github.retrooper.packetevents.protocol.player.GameMode;
+import org.bukkit.util.Vector;
+
+@CheckData(name = "FarBreak", description = "Breaking blocks too far away", experimental = true)
+public class FarBreak extends Check implements BlockBreakCheck {
+    public FarBreak(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (player.gamemode == GameMode.SPECTATOR || player.compensatedEntities.getSelf().inVehicle() || blockBreak.action == DiggingAction.CANCELLED_DIGGING) return; // falses
+
+        double min = Double.MAX_VALUE;
+        for (double d : player.getPossibleEyeHeights()) {
+            SimpleCollisionBox box = new SimpleCollisionBox(blockBreak.position);
+            Vector eyes = new Vector(player.x, player.y + d, player.z);
+            Vector best = VectorUtils.cutBoxToVector(eyes, box);
+            min = Math.min(min, eyes.distanceSquared(best));
+        }
+
+        // getPickRange() determines this?
+        // With 1.20.5+ the new attribute determines creative mode reach using a modifier
+        double maxReach = player.compensatedEntities.getSelf().getAttributeValue(Attributes.BLOCK_INTERACTION_RANGE);
+        if (player.packetStateData.didLastMovementIncludePosition || player.canSkipTicks()) {
+            double threshold = player.getMovementThreshold();
+            maxReach += Math.hypot(threshold, threshold);
+        }
+
+        if (min > maxReach * maxReach && flagAndAlert(String.format("distance=%.2f", Math.sqrt(min))) && shouldModifyPackets()) {
+            blockBreak.cancel();
+        }
+    }
+}

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

@@ -0,0 +1,111 @@
+package ac.grim.grimac.checks.impl.breaking;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import ac.grim.grimac.utils.math.GrimMath;
+import ac.grim.grimac.utils.nmsutil.BlockBreakSpeed;
+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.world.states.WrappedBlockState;
+import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
+import com.github.retrooper.packetevents.util.Vector3i;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
+
+// Based loosely off of Hawk BlockBreakSpeedSurvival
+// Also based loosely off of NoCheatPlus FastBreak
+// Also based off minecraft wiki: https://minecraft.wiki/w/Breaking#Instant_breaking
+@CheckData(name = "FastBreak", description = "Breaking blocks too quickly")
+public class FastBreak extends Check implements BlockBreakCheck {
+    public FastBreak(GrimPlayer playerData) {
+        super(playerData);
+    }
+
+    // The block the player is currently breaking
+    Vector3i targetBlock = null;
+    // The maximum amount of damage the player deals to the block
+    //
+    double maximumBlockDamage = 0;
+    // The last time a finish digging packet was sent, to enforce 0.3-second delay after non-instabreak
+    long lastFinishBreak = 0;
+    // The time the player started to break the block, to know how long the player waited until they finished breaking the block
+    long startBreak = 0;
+
+    // The buffer to this check
+    double blockBreakBalance = 0;
+    double blockDelayBalance = 0;
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (blockBreak.action == DiggingAction.START_DIGGING) {
+            WrappedBlockState block = blockBreak.block;
+
+            // 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 = blockBreak.position;
+
+            maximumBlockDamage = BlockBreakSpeed.getBlockDamage(player, targetBlock);
+
+            double breakDelay = System.currentTimeMillis() - lastFinishBreak;
+
+            if (breakDelay >= 275) { // Reduce buffer if "close enough"
+                blockDelayBalance *= 0.9;
+            } else { // Otherwise, increase buffer
+                blockDelayBalance += 300 - breakDelay;
+            }
+
+            if (blockDelayBalance > 1000) { // If more than a second of advantage
+                if (flagAndAlert("Delay=" + breakDelay) && shouldModifyPackets()) {
+                    blockBreak.cancel();
+                }
+            }
+
+            clampBalance();
+        }
+
+        if (blockBreak.action == DiggingAction.FINISHED_DIGGING && targetBlock != null) {
+            double predictedTime = Math.ceil(1 / maximumBlockDamage) * 50;
+            double realTime = System.currentTimeMillis() - startBreak;
+            double diff = predictedTime - realTime;
+
+            clampBalance();
+
+            if (diff < 25) {  // Reduce buffer if "close enough"
+                blockBreakBalance *= 0.9;
+            } else { // Otherwise, increase buffer
+                blockBreakBalance += diff;
+            }
+
+            if (blockBreakBalance > 1000) { // If more than a second of advantage
+                if (flagAndAlert("Diff=" + diff + ",Balance=" + blockBreakBalance) && shouldModifyPackets()) {
+                    blockBreak.cancel();
+                }
+            }
+
+            lastFinishBreak = System.currentTimeMillis();
+        }
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        // Find the most optimal block damage using the animation packet, which is sent at least once a tick when breaking blocks
+        // On 1.8 clients, via screws with this packet meaning we must fall back to the 1.8 idle flying packet
+        if ((player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9) ? event.getPacketType() == PacketType.Play.Client.ANIMATION : WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) && targetBlock != null) {
+            maximumBlockDamage = Math.max(maximumBlockDamage, BlockBreakSpeed.getBlockDamage(player, targetBlock));
+        }
+    }
+
+    private void clampBalance() {
+        double balance = Math.max(1000, (player.getTransactionPing()));
+        blockBreakBalance = GrimMath.clamp(blockBreakBalance, -balance, balance); // Clamp not Math.max in case other logic changes
+        blockDelayBalance = GrimMath.clamp(blockDelayBalance, -balance, balance);
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/breaking/InvalidBreak.java

@@ -0,0 +1,30 @@
+package ac.grim.grimac.checks.impl.breaking;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.DiggingAction;
+
+@CheckData(name = "InvalidBreak", description = "Sent impossible block face id")
+public class InvalidBreak extends Check implements BlockBreakCheck {
+    public InvalidBreak(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (blockBreak.faceId == 255 && blockBreak.action == DiggingAction.CANCELLED_DIGGING && player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10)) {
+            return;
+        }
+
+        if (blockBreak.faceId < 0 || blockBreak.faceId > 5) {
+            // ban
+            if (flagAndAlert("face=" + blockBreak.faceId + ", action=" + blockBreak.action) && shouldModifyPackets()) {
+                blockBreak.cancel();
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/breaking/MultiBreak.java

@@ -0,0 +1,74 @@
+package ac.grim.grimac.checks.impl.breaking;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.MessageUtil;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.player.DiggingAction;
+import com.github.retrooper.packetevents.protocol.player.GameMode;
+import com.github.retrooper.packetevents.protocol.world.BlockFace;
+import com.github.retrooper.packetevents.util.Vector3i;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@CheckData(name = "MultiBreak", experimental = true)
+public class MultiBreak extends Check implements BlockBreakCheck {
+    public MultiBreak(GrimPlayer player) {
+        super(player);
+    }
+
+    private final List<String> flags = new ArrayList<>();
+
+    private boolean hasBroken;
+    private BlockFace lastFace;
+    private Vector3i lastPos;
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (blockBreak.action == DiggingAction.CANCELLED_DIGGING) {
+            return;
+        }
+
+        if (hasBroken && (blockBreak.face != lastFace || !blockBreak.position.equals(lastPos))) {
+            final String verbose = "face=" + blockBreak.face + ", lastFace=" + lastFace
+                    + ", pos=" + MessageUtil.toUnlabledString(blockBreak.position)
+                    + ", lastPos=" + MessageUtil.toUnlabledString(lastPos);
+            if (!player.canSkipTicks()) {
+                if (flagAndAlert(verbose) && shouldModifyPackets()) {
+                    blockBreak.cancel();
+                }
+            } else {
+                flags.add(verbose);
+            }
+        }
+
+        lastFace = blockBreak.face;
+        lastPos = blockBreak.position;
+        hasBroken = true;
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.gamemode == GameMode.SPECTATOR || isTickPacket(event.getPacketType())) {
+            hasBroken = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/breaking/NoSwingBreak.java

@@ -0,0 +1,42 @@
+package ac.grim.grimac.checks.impl.breaking;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.DiggingAction;
+
+@CheckData(name = "NoSwingBreak", description = "Did not swing while breaking block", experimental = true)
+public class NoSwingBreak extends Check implements BlockBreakCheck {
+    public NoSwingBreak(GrimPlayer playerData) {
+        super(playerData);
+    }
+
+    private boolean sentAnimation;
+    private boolean sentBreak;
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (blockBreak.action != DiggingAction.CANCELLED_DIGGING) {
+            sentBreak = true;
+        }
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.ANIMATION) {
+            sentAnimation = true;
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            if (sentBreak && !sentAnimation) {
+                flagAndAlert();
+            }
+
+            sentAnimation = sentBreak = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/breaking/PositionBreakA.java

@@ -0,0 +1,61 @@
+package ac.grim.grimac.checks.impl.breaking;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
+import com.github.retrooper.packetevents.protocol.player.DiggingAction;
+import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
+
+@CheckData(name = "PositionBreakA")
+public class PositionBreakA extends Check implements BlockBreakCheck {
+    public PositionBreakA(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (player.compensatedEntities.getSelf().inVehicle()
+                || blockBreak.action == DiggingAction.CANCELLED_DIGGING
+                || blockBreak.block.getType() == StateTypes.REDSTONE_WIRE
+        ) return;
+
+        SimpleCollisionBox combined = blockBreak.getCombinedBox();
+
+        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);
+        }
+
+        SimpleCollisionBox eyePositions = new SimpleCollisionBox(player.x, player.y + minEyeHeight, player.z, player.x, player.y + maxEyeHeight, player.z);
+        if (!player.packetStateData.didLastMovementIncludePosition || player.canSkipTicks()) {
+            eyePositions.expand(player.getMovementThreshold());
+        }
+
+        // If the player is inside a block, then they can ray trace through the block and hit the other side of the block
+        if (eyePositions.isIntersected(combined)) {
+            return;
+        }
+
+        // So now we have the player's possible eye positions
+        // So then look at the face that the player has clicked
+        boolean flag = switch (blockBreak.face) {
+            case NORTH -> eyePositions.minZ > combined.minZ; // Z- face
+            case SOUTH -> eyePositions.maxZ < combined.maxZ; // Z+ face
+            case EAST -> eyePositions.maxX < combined.maxX; // X+ face
+            case WEST -> eyePositions.minX > combined.minX; // X- face
+            case UP -> eyePositions.maxY < combined.maxY; // Y+ face
+            case DOWN -> eyePositions.minY > combined.minY; // Y- face
+            default -> false;
+        };
+
+        if (flag && flagAndAlert("action=" + blockBreak.action + ", face=" + blockBreak.face) && shouldModifyPackets()) {
+            blockBreak.cancel();
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/breaking/PositionBreakB.java

@@ -0,0 +1,37 @@
+package ac.grim.grimac.checks.impl.breaking;
+
+import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.DiggingAction;
+import com.github.retrooper.packetevents.protocol.world.BlockFace;
+
+@CheckData(name = "PositionBreakB", experimental = true)
+public class PositionBreakB extends Check implements BlockBreakCheck {
+    public PositionBreakB(GrimPlayer player) {
+        super(player);
+    }
+
+    private BlockFace lastFace;
+    private final int releaseFace = player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_8) ? 0 : 255;
+
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (blockBreak.action == DiggingAction.START_DIGGING) {
+            if (blockBreak.face == lastFace) {
+                lastFace = null;
+            }
+        }
+
+        if (lastFace != null) {
+            flagAndAlert("lastFace=" + lastFace + ", action=" + blockBreak.action);
+        }
+
+        if (blockBreak.action == DiggingAction.CANCELLED_DIGGING) {
+            lastFace = blockBreak.faceId == releaseFace ? null : blockBreak.face;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/breaking/WrongBreak.java

@@ -1,23 +1,22 @@
-package ac.grim.grimac.checks.impl.badpackets;
+package ac.grim.grimac.checks.impl.breaking;
 
 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.BlockBreakCheck;
 import ac.grim.grimac.player.GrimPlayer;
+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.event.PacketReceiveEvent;
 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)
-public class BadPacketsZ extends Check implements PacketCheck {
-    public BadPacketsZ(final GrimPlayer player) {
+@CheckData(name = "WrongBreak")
+public class WrongBreak extends Check implements BlockBreakCheck {
+    public WrongBreak(final GrimPlayer player) {
         super(player);
     }
 
@@ -39,13 +38,10 @@ public class BadPacketsZ extends Check implements PacketCheck {
         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();
+    @Override
+    public void onBlockBreak(BlockBreak blockBreak) {
+        if (blockBreak.action == DiggingAction.START_DIGGING) {
+            final Vector3i pos = blockBreak.position;
 
             lastBlockWasInstantBreak = getBlockDamage(player, pos) >= 1;
             lastCancelledBlock = null;
@@ -53,24 +49,15 @@ 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;
-                lastLastBlock = null;
-                lastBlock = null;
-                return;
-            }
-
-            if (!pos.equals(lastBlock)) {
+            if (!shouldExempt(pos) && !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();
-                            resyncPosition(player, pos);
+                            blockBreak.cancel();
                         }
                     }
                 }
@@ -82,24 +69,21 @@ 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();
-                        resyncPosition(player, pos);
+                        blockBreak.cancel();
                     }
                 }
             }
 
-            lastCancelledBlock = null;
-
             // 1.14.4+ clients don't send another start break in protected regions
             if (player.getClientVersion().isOlderThan(ClientVersion.V_1_14_4)) {
+                lastCancelledBlock = null;
                 lastLastBlock = null;
                 lastBlock = null;
             }

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

@@ -0,0 +1,13 @@
+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.PacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+
+@CheckData(name = "Hitboxes", setback = 10)
+public class Hitboxes extends Check implements PacketCheck {
+    public Hitboxes(GrimPlayer player) {
+        super(player);
+    }
+}

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

@@ -0,0 +1,68 @@
+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.GameMode;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+
+import java.util.ArrayList;
+
+@CheckData(name = "MultiInteractA", description = "Interacted with multiple entities in the same tick", 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.canSkipTicks()) {
+                    if (flagAndAlert(verbose) && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    flags.add(verbose);
+                }
+            }
+
+            lastEntity = entity;
+            lastSneaking = sneaking;
+            hasInteracted = true;
+        }
+
+        if (player.gamemode == GameMode.SPECTATOR || isTickPacket(event.getPacketType())) {
+            hasInteracted = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+    }
+}

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

@@ -0,0 +1,69 @@
+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.GameMode;
+import com.github.retrooper.packetevents.util.Vector3f;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+
+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.canSkipTicks()) {
+                    if (flagAndAlert(verbose) && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    flags.add(verbose);
+                }
+            }
+
+            lastPos = pos;
+            hasInteracted = true;
+        }
+
+        if (player.gamemode == GameMode.SPECTATOR || isTickPacket(event.getPacketType())) {
+            hasInteracted = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+    }
+}

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

@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package ac.grim.grimac.checks.impl.combat;
 
+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;
@@ -32,17 +33,20 @@ import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
 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;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import org.bukkit.util.Vector;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
 
 // You may not copy the check unless you are licensed under GPL
-@CheckData(name = "Reach", configName = "Reach", setback = 10)
+@CheckData(name = "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<>();
+    private final Int2ObjectMap<Vector3d> playerAttackQueue = new Int2ObjectOpenHashMap<>();
     private static final List<EntityType> blacklisted = Arrays.asList(
             EntityTypes.BOAT,
             EntityTypes.CHEST_BOAT,
@@ -80,7 +84,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;
 
@@ -105,9 +109,7 @@ public class Reach extends Check implements PacketCheck {
         }
 
         // If the player set their look, or we know they have a new tick
-        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType()) ||
-                event.getPacketType() == PacketType.Play.Client.PONG ||
-                event.getPacketType() == PacketType.Play.Client.WINDOW_CONFIRMATION) {
+        if (isUpdate(event.getPacketType())) {
             tickBetterReachCheckWithAngle();
         }
     }
@@ -130,34 +132,40 @@ public class Reach extends Check implements PacketCheck {
 
         // Filter out what we assume to be cheats
         if (cancelBuffer != 0) {
-            return checkReach(reachEntity, new Vector3d(player.x, player.y, player.z), true) != null; // If they flagged
+            CheckResult result = checkReach(reachEntity, new Vector3d(player.x, player.y, player.z), true);
+            return result.isFlag(); // If they flagged
         } else {
             SimpleCollisionBox targetBox = reachEntity.getPossibleCollisionBoxes();
             if (reachEntity.getType() == EntityTypes.END_CRYSTAL) {
                 targetBox = new SimpleCollisionBox(reachEntity.trackedServerPosition.getPos().subtract(1, 0, 1), reachEntity.trackedServerPosition.getPos().add(1, 2, 1));
             }
-            return ReachUtils.getMinReachToBox(player, targetBox) > player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_ENTITY_INTERACTION_RANGE);
+            return ReachUtils.getMinReachToBox(player, targetBox) > player.compensatedEntities.getSelf().getAttributeValue(Attributes.ENTITY_INTERACTION_RANGE);
         }
     }
 
     private void tickBetterReachCheckWithAngle() {
-        for (Map.Entry<Integer, Vector3d> attack : playerAttackQueue.entrySet()) {
-            PacketEntity reachEntity = player.compensatedEntities.entityMap.get(attack.getKey().intValue());
-            if (reachEntity != null) {
-                String result = checkReach(reachEntity, attack.getValue(), false);
-                if (result != null) {
-                    if (reachEntity.getType() == EntityTypes.PLAYER) {
-                        flagAndAlert(result);
-                    } else {
-                        flagAndAlert(result + " type=" + reachEntity.getType().getName().getKey());
-                    }
+        for (Int2ObjectMap.Entry<Vector3d> attack : playerAttackQueue.int2ObjectEntrySet()) {
+            PacketEntity reachEntity = player.compensatedEntities.entityMap.get(attack.getIntKey());
+            if (reachEntity == null) continue;
+
+            CheckResult result = checkReach(reachEntity, attack.getValue(), false);
+            switch (result.type()) {
+                case REACH -> {
+                    String added = reachEntity.getType() == EntityTypes.PLAYER ? "" : ", type=" + reachEntity.getType().getName().getKey();
+                    flagAndAlert(result.verbose() + added);
+                }
+                case HITBOX -> {
+                    String added = reachEntity.getType() == EntityTypes.PLAYER ? "" : "type=" + reachEntity.getType().getName().getKey();
+                    player.checkManager.getPacketCheck(Hitboxes.class).flagAndAlert(result.verbose() + added);
                 }
             }
         }
+
         playerAttackQueue.clear();
     }
 
-    private String checkReach(PacketEntity reachEntity, Vector3d from, boolean isPrediction) {
+    @NotNull
+    private CheckResult checkReach(PacketEntity reachEntity, Vector3d from, boolean isPrediction) {
         SimpleCollisionBox targetBox = reachEntity.getPossibleCollisionBoxes();
 
         if (reachEntity.getType() == EntityTypes.END_CRYSTAL) { // Hardcode end crystal box
@@ -176,7 +184,8 @@ public class Reach extends Check implements PacketCheck {
         // Adds some more than 0.03 uncertainty in some cases, but a good trade off for simplicity
         //
         // Just give the uncertainty on 1.9+ clients as we have no way of knowing whether they had 0.03 movement
-        if (!player.packetStateData.didLastLastMovementIncludePosition || player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9))
+        // However, on 1.21.2+ we do know if they had 0.03 movement
+        if (!player.packetStateData.didLastLastMovementIncludePosition || player.canSkipTicks())
             targetBox.expand(player.getMovementThreshold());
 
         double minDistance = Double.MAX_VALUE;
@@ -199,14 +208,17 @@ public class Reach extends Check implements PacketCheck {
             }
         }
 
+        final double maxReach = player.compensatedEntities.getSelf().getAttributeValue(Attributes.ENTITY_INTERACTION_RANGE);
         // +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;
+        final double distance = maxReach + 3;
+        final double[] possibleEyeHeights = player.getPossibleEyeHeights();
+        final Vector eyePos = new Vector(from.getX(), 0, from.getZ());
         for (Vector lookVec : possibleLookDirs) {
-            for (double eye : player.getPossibleEyeHeights()) {
-                Vector eyePos = new Vector(from.getX(), from.getY() + eye, from.getZ());
+            for (double eye : possibleEyeHeights) {
+                eyePos.setY(from.getY() + eye);
                 Vector endReachPos = eyePos.clone().add(new Vector(lookVec.getX() * distance, lookVec.getY() * distance, lookVec.getZ() * distance));
 
-                Vector intercept = ReachUtils.calculateIntercept(targetBox, eyePos, endReachPos).getFirst();
+                Vector intercept = ReachUtils.calculateIntercept(targetBox, eyePos, endReachPos).first();
 
                 if (ReachUtils.isVecInside(targetBox, eyePos)) {
                     minDistance = 0;
@@ -223,22 +235,33 @@ public class Reach extends Check implements PacketCheck {
         if ((!blacklisted.contains(reachEntity.getType()) && reachEntity.isLivingEntity()) || reachEntity.getType() == EntityTypes.END_CRYSTAL) {
             if (minDistance == Double.MAX_VALUE) {
                 cancelBuffer = 1;
-                return "Missed hitbox";
-            } else if (minDistance > player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_ENTITY_INTERACTION_RANGE)) {
+                return new CheckResult(ResultType.HITBOX, "");
+            } else if (minDistance > maxReach) {
                 cancelBuffer = 1;
-                return String.format("%.5f", minDistance) + " blocks";
+                return new CheckResult(ResultType.REACH, String.format("%.5f", minDistance) + " blocks");
             } else {
                 cancelBuffer = Math.max(0, cancelBuffer - 0.25);
             }
         }
 
-        return null;
+        return NONE;
+    }
+
+    private static final CheckResult NONE = new CheckResult(ResultType.NONE, "");
+
+    private record CheckResult(ResultType type, String verbose) {
+        public boolean isFlag() {
+            return type != ResultType.NONE;
+        }
+    }
+
+    private enum ResultType {
+        REACH, HITBOX, NONE
     }
 
     @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

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
 
-@CheckData(name = "CrashB")
+@CheckData(name = "CrashB", description = "Sent creative mode inventory click packets while not in creative mode")
 public class CrashB extends Check implements PacketCheck {
     public CrashB(GrimPlayer player) {
         super(player);
@@ -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/crash/CrashC.java

@@ -8,7 +8,7 @@ import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.world.Location;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
-@CheckData(name = "CrashC")
+@CheckData(name = "CrashC", description = "Sent non-finite position or rotation")
 public class CrashC extends Check implements PacketCheck {
     public CrashC(GrimPlayer playerData) {
         super(playerData);

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

@@ -13,7 +13,7 @@ import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClickWindow;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerOpenWindow;
 
-@CheckData(name = "CrashD", experimental = false)
+@CheckData(name = "CrashD", description = "Clicking slots in lectern window")
 public class CrashD extends Check implements PacketCheck {
 
     public CrashD(GrimPlayer playerData) {

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

@@ -2,14 +2,13 @@ package ac.grim.grimac.checks.impl.crash;
 
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.impl.exploit.ExploitA;
 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.WrapperPlayClientSettings;
 
-@CheckData(name = "CrashE", experimental = false)
+@CheckData(name = "CrashE")
 public class CrashE extends Check implements PacketCheck {
 
     public CrashE(GrimPlayer playerData) {
@@ -21,12 +20,10 @@ public class CrashE extends Check implements PacketCheck {
         if (event.getPacketType() == PacketType.Play.Client.CLIENT_SETTINGS) {
             WrapperPlayClientSettings wrapper = new WrapperPlayClientSettings(event);
             int viewDistance = wrapper.getViewDistance();
-            boolean invalidLocale = player.checkManager.getPrePredictionCheck(ExploitA.class).checkString(wrapper.getLocale());
             if (viewDistance < 2) {
                 flagAndAlert("distance=" + viewDistance);
                 wrapper.setViewDistance(2);
             }
-            if (invalidLocale) wrapper.setLocale("en_us");
         }
     }
 

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

@@ -13,7 +13,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPl
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientUseItem;
 
-@CheckData(name = "CrashG")
+@CheckData(name = "CrashG", description = "Sent negative sequence id")
 public class CrashG extends Check implements PacketCheck {
 
     public CrashG(GrimPlayer player) {

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

@@ -32,7 +32,7 @@ public class CrashH extends Check implements PacketCheck {
             }
             // paper's patch
             final int index;
-            if (text.length() > 64 && ((index = text.indexOf(' ')) == -1 || index >= 64)) {
+            if (length > 64 && ((index = text.indexOf(' ')) == -1 || index >= 64)) {
                 if (shouldModifyPackets()) {
                     event.setCancelled(true);
                     player.onPacketCancel();

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraA.java

@@ -0,0 +1,50 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraA", description = "Started gliding while already gliding", experimental = true)
+public class ElytraA extends Check implements PostPredictionCheck {
+    private boolean setback;
+
+    public ElytraA(GrimPlayer player) {
+        super(player);
+    }
+
+    public void onStartGliding(PacketReceiveEvent event) {
+        if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+            return;
+        }
+
+        if (player.isGliding && flagAndAlert()) {
+            setback = true;
+            if (shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+                player.resyncPose();
+            }
+        }
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.getClientVersion().isOlderThan(ClientVersion.V_1_15) && event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION
+                && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA
+        ) onStartGliding(event);
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (setback) {
+            setbackIfAboveSetbackVL();
+            setback = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraB.java

@@ -0,0 +1,57 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.wrapper.play.client.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraB", description = "Started gliding without jumping", experimental = true)
+public class ElytraB extends Check implements PostPredictionCheck {
+    private boolean glide;
+    private boolean setback;
+
+    public ElytraB(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION
+                && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA
+                && player.supportsEndTick()
+        ) {
+            if (player.packetStateData.knownInput.jump()) {
+                if (flagAndAlert("no release")) {
+                    setback = true;
+                    if (shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                        player.resyncPose();
+                    }
+                }
+            } else {
+                glide = true;
+            }
+        }
+
+        if (isUpdate(event.getPacketType())) {
+            if (glide && !player.packetStateData.knownInput.jump() && flagAndAlert("no jump")) {
+                setback = true;
+            }
+
+            glide = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (setback) {
+            setback = false;
+            setbackIfAboveSetbackVL();
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraC.java

@@ -0,0 +1,76 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.protocol.player.GameMode;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraC", description = "Started gliding too frequently", experimental = true)
+public class ElytraC extends Check implements PostPredictionCheck {
+    private boolean glideThisTick, glideLastTick, setback;
+    private int flags;
+
+    public ElytraC(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+            return;
+        }
+
+        if (player.gamemode == GameMode.SPECTATOR) {
+            glideThisTick = glideLastTick = false;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA) {
+            if (glideThisTick || glideLastTick) {
+                if (player.canSkipTicks()) {
+                    flags++;
+                } else {
+                    if (flagAndAlert()) {
+                        setback = true;
+                        if (shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                            player.resyncPose();
+                        }
+                    }
+                }
+            }
+
+            glideThisTick = true;
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            glideLastTick = glideThisTick;
+            glideThisTick = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (player.canSkipTicks()) {
+            if (player.isTickingReliablyFor(3)) {
+                for (; flags > 0; flags--) {
+                    flagAndAlert();
+                }
+            }
+
+            flags = 0;
+            setback = false;
+        }
+
+        if (setback) {
+            setback = false;
+            setbackIfAboveSetbackVL();
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraD.java

@@ -0,0 +1,48 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraD", description = "Started gliding without an elytra", experimental = true)
+public class ElytraD extends Check implements PostPredictionCheck {
+    private boolean setback;
+
+    public ElytraD(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+            return;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION
+                && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA
+                && !player.canGlide()
+                && flagAndAlert()
+        ) {
+            setback = true;
+            if (shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+                player.resyncPose();
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (setback) {
+            setbackIfAboveSetbackVL();
+            setback = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraE.java

@@ -0,0 +1,48 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraE", description = "Started gliding while flying", experimental = true)
+public class ElytraE extends Check implements PostPredictionCheck {
+    private boolean setback;
+
+    public ElytraE(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+            return;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION
+                && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA
+                && player.isFlying
+                && flagAndAlert()
+        ) {
+            setback = true;
+            if (shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+                player.resyncPose();
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (setback) {
+            setbackIfAboveSetbackVL();
+            setback = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraF.java

@@ -0,0 +1,48 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraF", description = "Started gliding while on ground", experimental = true)
+public class ElytraF extends Check implements PostPredictionCheck {
+    private boolean setback;
+
+    public ElytraF(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+            return;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION
+                && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA
+                && player.clientClaimsLastOnGround
+                && flagAndAlert()
+        ) {
+            setback = true;
+            if (shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+                player.resyncPose();
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (setback) {
+            setbackIfAboveSetbackVL();
+            setback = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraG.java

@@ -0,0 +1,46 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.protocol.potion.PotionTypes;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraG", description = "Started gliding with levitation", experimental = true)
+public class ElytraG extends Check implements PostPredictionCheck {
+    private boolean setback;
+
+    public ElytraG(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION
+                && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA
+                && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_16)
+                && player.compensatedEntities.getSelf().hasPotionEffect(PotionTypes.LEVITATION)
+                && flagAndAlert()
+        ) {
+            setback = true;
+            if (shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+                player.resyncPose();
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (setback) {
+            setbackIfAboveSetbackVL();
+            setback = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraH.java

@@ -0,0 +1,48 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraH", description = "Started gliding in vehicle", experimental = true)
+public class ElytraH extends Check implements PostPredictionCheck {
+    private boolean setback;
+
+    public ElytraH(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_8)) {
+            return;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION
+                && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA
+                && player.inVehicle()
+                && flagAndAlert()
+        ) {
+            setback = true;
+            if (shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+                player.resyncPose();
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (setback) {
+            setbackIfAboveSetbackVL();
+            setback = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/elytra/ElytraI.java

@@ -0,0 +1,45 @@
+package ac.grim.grimac.checks.impl.elytra;
+
+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.WrapperPlayClientEntityAction;
+
+@CheckData(name = "ElytraI", description = "Started gliding in water", experimental = true)
+public class ElytraI extends Check implements PostPredictionCheck {
+    private boolean setback;
+
+    public ElytraI(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION
+                && new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_FLYING_WITH_ELYTRA
+                && player.wasTouchingWater
+                && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_15)
+                && flagAndAlert()
+        ) {
+            setback = true;
+            if (shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+                player.resyncPose();
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (setback) {
+            setbackIfAboveSetbackVL();
+            setback = false;
+        }
+    }
+}

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

@@ -4,12 +4,11 @@ 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.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientChatMessage;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientNameItem;
-
-import java.util.regex.Pattern;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientTabComplete;
 
 @CheckData(name = "ExploitA", experimental = true)
 public class ExploitA extends Check implements PacketCheck {
@@ -18,35 +17,18 @@ public class ExploitA extends Check implements PacketCheck {
         super(playerData);
     }
 
-    private static final Pattern EXPLOIT_PATTERN = Pattern.compile("\\$\\{.+}");
-
-    /*
-     WARNING: This doesn't fully patch Log4J! It is highly recommended you update your server
-     jar to a version that has true Log4J migrations instead of using a plugin. However, this
-     patch is better than nothing and will still be useful for punishing players who attempt
-     to abuse this exploit.
-     */
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.CHAT_MESSAGE) {
-            if (true) return; // TODO: Fix PacketEvents pls retrooper
-            WrapperPlayClientChatMessage wrapper = new WrapperPlayClientChatMessage(event);
-            String message = wrapper.getMessage();
-            if (checkString(message)) {
-                event.setCancelled(true);
-                player.onPacketCancel();
-            }
-        } else if (event.getPacketType() == PacketType.Play.Client.NAME_ITEM) {
-            WrapperPlayClientNameItem wrapper = new WrapperPlayClientNameItem(event);
-            String name = wrapper.getItemName();
-            if (checkString(name)) {
-                event.setCancelled(true);
-                player.onPacketCancel();
+        if (event.getPacketType() == PacketType.Play.Client.TAB_COMPLETE && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_13)) {
+            WrapperPlayClientTabComplete wrapper = new WrapperPlayClientTabComplete(event);
+            String text = wrapper.getText();
+            if (text.equals("/") || text.trim().isEmpty()) {
+                if (flagAndAlert("")) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
             }
         }
     }
 
-    public boolean checkString(String message) {
-        return EXPLOIT_PATTERN.matcher(message).matches() && flagAndAlert();
-    }
 }

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

@@ -4,31 +4,29 @@ 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.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
-import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientTabComplete;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEditBook;
 
-@CheckData(name = "ExploitB", experimental = true)
+@CheckData(name = "ExploitB", description = "Too long book title")
 public class ExploitB extends Check implements PacketCheck {
-
     public ExploitB(GrimPlayer playerData) {
         super(playerData);
     }
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.TAB_COMPLETE && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_13)) {
-            WrapperPlayClientTabComplete wrapper = new WrapperPlayClientTabComplete(event);
-            String text = wrapper.getText();
-            if (text.equals("/") || text.trim().length() == 0) {
-                if (flagAndAlert("")) {
+        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/exploit/ExploitC.java

@@ -0,0 +1,55 @@
+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.PacketEvents;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientChatCommand;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientChatCommandUnsigned;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientChatMessage;
+
+// this can false from click events, but I doubt this would actually
+// happen unless they're trying to flag, or if the server is set up badly
+@CheckData(name = "ExploitC", description = "Invalid chat message")
+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.CHAT_MESSAGE) {
+            String message = new WrapperPlayClientChatMessage(event).getMessage();
+            if (message.isEmpty() || !message.trim().equals(message) || message.startsWith("/") && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_19)) {
+                if (flagAndAlert("message=" + message)) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.CHAT_COMMAND_UNSIGNED) {
+            String command = "/" + new WrapperPlayClientChatCommandUnsigned(event).getCommand();
+            if (!command.stripTrailing().equals(command)) {
+                if (flagAndAlert("command=" + command)) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.CHAT_COMMAND) {
+            String command = "/" + new WrapperPlayClientChatCommand(event).getCommand();
+            if (!command.trim().equals(command)) {
+                if (flagAndAlert("command=" + command)) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
+            }
+        }
+    }
+}

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

@@ -17,12 +17,12 @@ import java.util.List;
 
 // Catches NoFalls for LOOK and GROUND packets
 // This check runs AFTER the predictions
-@CheckData(name = "NoFall", configName = "nofall", setback = 10)
-public class NoFallA extends Check implements PacketCheck {
+@CheckData(name = "NoFall", setback = 10)
+public class NoFall extends Check implements PacketCheck {
 
     public boolean flipPlayerGroundStatus = false;
 
-    public NoFallA(GrimPlayer player) {
+    public NoFall(GrimPlayer player) {
         super(player);
     }
 
@@ -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

@@ -2,18 +2,24 @@ package ac.grim.grimac.checks.impl.misc;
 
 import ac.grim.grimac.GrimAPI;
 import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.checks.impl.exploit.ExploitA;
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.MessageUtil;
 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.configuration.client.WrapperConfigClientPluginMessage;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPluginMessage;
+import lombok.Getter;
+import net.kyori.adventure.text.Component;
 import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 
 public class ClientBrand extends Check implements PacketCheck {
-    String brand = "vanilla";
-    boolean hasBrand = false;
+    @Getter
+    private String brand = "vanilla";
+    private boolean hasBrand = false;
 
     public ClientBrand(GrimPlayer player) {
         super(player);
@@ -23,39 +29,39 @@ public class ClientBrand extends Check implements PacketCheck {
     public void onPacketReceive(final PacketReceiveEvent event) {
         if (event.getPacketType() == PacketType.Play.Client.PLUGIN_MESSAGE) {
             WrapperPlayClientPluginMessage packet = new WrapperPlayClientPluginMessage(event);
-            String channelName = packet.getChannelName();
-            handle(channelName, packet.getData());
+            handle(packet.getChannelName(), packet.getData());
+        } else if (event.getPacketType() == PacketType.Configuration.Client.PLUGIN_MESSAGE) {
+            WrapperConfigClientPluginMessage packet = new WrapperConfigClientPluginMessage(event);
+            handle(packet.getChannelName(), packet.getData());
         }
     }
 
-    public void handle(String channel, byte[] data) {
-        if (channel.equalsIgnoreCase("minecraft:brand") || // 1.13+
-                channel.equals("MC|Brand")) { // 1.12
-            if (data.length > 64 || data.length == 0) {
-                brand = "sent " + data.length + " bytes as brand";
-            } else if (!hasBrand) {
-                byte[] minusLength = new byte[data.length - 1];
-                System.arraycopy(data, 1, minusLength, 0, minusLength.length);
+    private void handle(String channel, byte[] data) {
+        final String expectedChannel = player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_13) ? "minecraft:brand" : "MC|Brand";
+        if (!channel.equals(expectedChannel)) return;
 
-                brand = new String(minusLength).replace(" (Velocity)", ""); //removes velocity's brand suffix
-                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%");
-                    message = GrimAPI.INSTANCE.getExternalAPI().replaceVariables(getPlayer(), message, true);
-                    // sendMessage is async safe while broadcast isn't due to adventure
-                    for (Player player : Bukkit.getOnlinePlayers()) {
-                        if (player.hasPermission("grim.brand")) {
-                            player.sendMessage(message);
-                        }
+        if (data.length > 64 || data.length == 0) {
+            brand = "sent " + data.length + " bytes as brand";
+        } else if (!hasBrand) {
+            byte[] minusLength = new byte[data.length - 1];
+            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 (!GrimAPI.INSTANCE.getConfigManager().isIgnoredClient(brand)) {
+                String message = GrimAPI.INSTANCE.getConfigManager().getConfig().getStringElse("client-brand-format", "%prefix% &f%player% joined using %brand%");
+                message = MessageUtil.replacePlaceholders(player, message);
+
+                Component component = MessageUtil.miniMessage(message);
+
+                for (Player player : Bukkit.getOnlinePlayers()) {
+                    if (GrimAPI.INSTANCE.getAlertManager().hasBrandsEnabled(player)) {
+                        MessageUtil.sendMessage(player, component);
                     }
                 }
             }
-
-            hasBrand = true;
         }
-    }
 
-    public String getBrand() {
-        return brand;
+        hasBrand = true;
     }
 }

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

@@ -1,155 +0,0 @@
-package ac.grim.grimac.checks.impl.misc;
-
-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.math.GrimMath;
-import ac.grim.grimac.utils.nmsutil.BlockBreakSpeed;
-import com.github.retrooper.packetevents.PacketEvents;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
-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.player.DiggingAction;
-import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
-import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
-import com.github.retrooper.packetevents.util.Vector3i;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
-import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerAcknowledgeBlockChanges;
-import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerBlockChange;
-import io.github.retrooper.packetevents.util.folia.FoliaScheduler;
-import org.bukkit.Chunk;
-import org.bukkit.Location;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-
-// Based loosely off of Hawk BlockBreakSpeedSurvival
-// Also based loosely off of NoCheatPlus FastBreak
-// Also based off minecraft wiki: https://minecraft.wiki/w/Breaking#Instant_breaking
-@CheckData(name = "FastBreak", experimental = false)
-public class FastBreak extends Check implements PacketCheck {
-    public FastBreak(GrimPlayer playerData) {
-        super(playerData);
-    }
-
-    // The block the player is currently breaking
-    Vector3i targetBlock = null;
-    // The maximum amount of damage the player deals to the block
-    //
-    double maximumBlockDamage = 0;
-    // The last time a finish digging packet was sent, to enforce 0.3-second delay after non-instabreak
-    long lastFinishBreak = 0;
-    // The time the player started to break the block, to know how long the player waited until they finished breaking the block
-    long startBreak = 0;
-
-    // The buffer to this check
-    double blockBreakBalance = 0;
-    double blockDelayBalance = 0;
-
-    @Override
-    public void onPacketReceive(PacketReceiveEvent event) {
-        // Find the most optimal block damage using the animation packet, which is sent at least once a tick when breaking blocks
-        // On 1.8 clients, via screws with this packet meaning we must fall back to the 1.8 idle flying packet
-        if ((player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9) ? event.getPacketType() == PacketType.Play.Client.ANIMATION : WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) && targetBlock != null) {
-            maximumBlockDamage = Math.max(maximumBlockDamage, BlockBreakSpeed.getBlockDamage(player, targetBlock));
-        }
-
-        if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING) {
-            WrapperPlayClientPlayerDigging digging = new WrapperPlayClientPlayerDigging(event);
-            final Vector3i blockPosition = digging.getBlockPosition();
-
-            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;
-
-                if (breakDelay >= 275) { // Reduce buffer if "close enough"
-                    blockDelayBalance *= 0.9;
-                } else { // Otherwise, increase buffer
-                    blockDelayBalance += 300 - breakDelay;
-                }
-
-                if (blockDelayBalance > 1000) { // If more than a second of advantage
-                    flagAndAlert("Delay=" + breakDelay);
-                    if (shouldModifyPackets()) {
-                        event.setCancelled(true); // Cancelling start digging will cause server to reject block break
-                        player.onPacketCancel();
-                    }
-                }
-
-                clampBalance();
-            }
-
-            if (digging.getAction() == DiggingAction.FINISHED_DIGGING && targetBlock != null) {
-                double predictedTime = Math.ceil(1 / maximumBlockDamage) * 50;
-                double realTime = System.currentTimeMillis() - startBreak;
-                double diff = predictedTime - realTime;
-
-                clampBalance();
-
-                if (diff < 25) {  // Reduce buffer if "close enough"
-                    blockBreakBalance *= 0.9;
-                } else { // Otherwise, increase buffer
-                    blockBreakBalance += diff;
-                }
-
-                if (blockBreakBalance > 1000) { // If more than a second of advantage
-                    FoliaScheduler.getEntityScheduler().execute(player.bukkitPlayer, GrimAPI.INSTANCE.getPlugin(), () -> {
-                        Player bukkitPlayer = player.bukkitPlayer;
-                        if (bukkitPlayer == null || !bukkitPlayer.isOnline()) return;
-
-                        if (bukkitPlayer.getLocation().distance(new Location(bukkitPlayer.getWorld(), blockPosition.getX(), blockPosition.getY(), blockPosition.getZ())) < 64) {
-                            final int chunkX = blockPosition.getX() >> 4;
-                            final int chunkZ = blockPosition.getZ() >> 4;
-                            if (!bukkitPlayer.getWorld().isChunkLoaded(chunkX, chunkZ)) return; // Don't load chunks sync
-
-                            Chunk chunk = bukkitPlayer.getWorld().getChunkAt(chunkX, chunkZ);
-                            Block block = chunk.getBlock(blockPosition.getX() & 15, blockPosition.getY(), blockPosition.getZ() & 15);
-
-                            int blockId;
-
-                            if (PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_13)) {
-                                // Cache this because strings are expensive
-                                blockId = WrappedBlockState.getByString(PacketEvents.getAPI().getServerManager().getVersion().toClientVersion(), block.getBlockData().getAsString(false)).getGlobalId();
-                            } else {
-                                blockId = (block.getType().getId() << 4) | block.getData();
-                            }
-
-                            player.user.sendPacket(new WrapperPlayServerBlockChange(blockPosition, blockId));
-
-                            if (PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_19)) { // Via will handle this for us pre-1.19
-                                player.user.sendPacket(new WrapperPlayServerAcknowledgeBlockChanges(digging.getSequence())); // Make 1.19 clients apply the changes
-                            }
-                        }
-                    }, null, 0);
-
-                    if (flagAndAlert("Diff=" + diff + ",Balance=" + blockBreakBalance) && shouldModifyPackets()) {
-                        event.setCancelled(true);
-                        player.onPacketCancel();
-                    }
-                }
-
-                lastFinishBreak = System.currentTimeMillis();
-            }
-        }
-    }
-
-    private void clampBalance() {
-        double balance = Math.max(1000, (player.getTransactionPing()));
-        blockBreakBalance = GrimMath.clamp(blockBreakBalance, -balance, balance); // Clamp not Math.max in case other logic changes
-        blockDelayBalance = GrimMath.clamp(blockDelayBalance, -balance, balance);
-    }
-}

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,13 +5,9 @@ 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)
+@CheckData(name = "TransactionOrder")
 public class TransactionOrder extends Check implements PacketCheck {
-
     public TransactionOrder(GrimPlayer player) {
         super(player);
     }
-
-}
+}

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

@@ -1,17 +0,0 @@
-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;
-
-@CheckData(name = "Entity control", configName = "EntityControl")
-public class EntityControl extends Check implements PostPredictionCheck {
-    public EntityControl(GrimPlayer player) {
-        super(player);
-    }
-
-    public void rewardPlayer() {
-        reward();
-    }
-}

src/main/java/ac/grim/grimac/checks/impl/movement/NoSlow.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;
@@ -7,8 +8,8 @@ import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 
-@CheckData(name = "NoSlowA (Prediction)", configName = "NoSlowA", setback = 5)
-public class NoSlowA extends Check implements PostPredictionCheck {
+@CheckData(name = "NoSlow (Prediction)", configName = "NoSlow", description = "Was not slowed while using an item", setback = 5)
+public class NoSlow extends Check implements PostPredictionCheck {
     double offsetToFlag;
     double bestOffset = 1;
     // The player sends that they switched items the next tick if they switch from an item that can be used
@@ -16,7 +17,7 @@ public class NoSlowA extends Check implements PostPredictionCheck {
     public boolean didSlotChangeLastTick = false;
     public boolean flaggedLastTick = false;
 
-    public NoSlowA(GrimPlayer player) {
+    public NoSlow(GrimPlayer player) {
         super(player);
     }
 
@@ -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("NoSlow.threshold", 0.001);
     }
 }

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

@@ -1,53 +0,0 @@
-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 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;
-
-        if (player.isSlowMovement) {
-            ClientVersion client = player.getClientVersion();
-
-            // https://bugs.mojang.com/browse/MC-152728
-            if (startedSprintingBeforeSlowMovement && client.isNewerThanOrEquals(ClientVersion.V_1_14_2)) {
-                reward();
-                return;
-            }
-
-            if (player.isSprinting
-                    // you can sneak and swim in 1.13 - 1.14.1
-                    && (!player.isSwimming || client.isNewerThan(ClientVersion.V_1_14_1) || client.isOlderThan(ClientVersion.V_1_13))
-                    && player.sneakingSpeedMultiplier < 0.8f
-            ) {
-                if (flagWithSetback()) alert("");
-            } else reward();
-        }
-    }
-}

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/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", description = "Attacked while using an item", 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", description = "Breaking blocks while using an item", 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,40 @@
+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.event.PacketSendEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+
+@CheckData(name = "MultiActionsC", description = "Clicked in inventory while sprinting", experimental = true)
+public class MultiActionsC extends Check implements PacketCheck {
+    public MultiActionsC(GrimPlayer player) {
+        super(player);
+    }
+
+    private boolean serverOpenedInventoryThisTick;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW) {
+
+            if (player.isSprinting && !player.isSwimming && !serverOpenedInventoryThisTick && flagAndAlert() && shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+            }
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            serverOpenedInventoryThisTick = false;
+        }
+    }
+
+    @Override
+    public void onPacketSend(PacketSendEvent event) {
+        if (event.getPacketType() == PacketType.Play.Server.OPEN_WINDOW) {
+            player.latencyUtils.addRealTimeTask(player.lastTransactionSent.get(), () -> serverOpenedInventoryThisTick = true);
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+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", description = "Closed inventory while sprinting", 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) {
+            if (player.isSprinting && !player.isSwimming && flagAndAlert() && shouldModifyPackets()) {
+                event.setCancelled(true);
+                player.onPacketCancel();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+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;
+
+@CheckData(name = "MultiActionsE", description = "Swinging while using an item", experimental = true)
+public class MultiActionsE extends Check implements PacketCheck {
+    public MultiActionsE(GrimPlayer player) {
+        super(player);
+    }
+
+    private boolean dropping;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (!dropping && 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();
+            }
+        }
+
+        dropping = false;
+
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_15)) {
+            DiggingAction action = new WrapperPlayClientPlayerDigging(event).getAction();
+            dropping = action == DiggingAction.DROP_ITEM || action == DiggingAction.DROP_ITEM_STACK;
+        }
+    }
+}

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.DiggingAction;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static ac.grim.grimac.events.packets.patch.ResyncWorldUtil.resyncPosition;
+
+@CheckData(name = "MultiActionsF", description = "Interacting with a block and an entity in the same tick", 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.canSkipTicks()) {
+                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.canSkipTicks()) {
+                    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.canSkipTicks()) {
+                        if (flagAndAlert("dig") && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                            resyncPosition(player, packet.getBlockPosition());
+                        }
+                    } else {
+                        flags.add("dig");
+                    }
+                }
+            }
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            block = entity = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+    }
+}

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

@@ -15,7 +15,6 @@ 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;
@@ -25,7 +24,7 @@ import java.util.Locale;
 import static com.github.retrooper.packetevents.protocol.packettype.PacketType.Play.Client.*;
 
 @CheckData(name = "Post")
-public class PostCheck extends Check implements PacketCheck, PostPredictionCheck {
+public class Post extends Check implements PacketCheck, PostPredictionCheck {
     private final ArrayDeque<PacketTypeCommon> post = new ArrayDeque<>();
     // Due to 1.9+ missing the idle packet, we must queue flags
     // 1.8 clients will have the same logic for simplicity, although it's not needed
@@ -33,7 +32,7 @@ public class PostCheck extends Check implements PacketCheck, PostPredictionCheck
     private boolean sentFlying = false;
     private int isExemptFromSwingingCheck = Integer.MIN_VALUE;
 
-    public PostCheck(GrimPlayer playerData) {
+    public Post(GrimPlayer playerData) {
         super(playerData);
     }
 
@@ -68,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 {

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

@@ -9,10 +9,10 @@ import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
 
-@CheckData(name = "GroundSpoof", configName = "GroundSpoof", setback = 10, decay = 0.01)
-public class NoFallB extends Check implements PostPredictionCheck {
+@CheckData(name = "GroundSpoof", setback = 10, decay = 0.01)
+public class GroundSpoof extends Check implements PostPredictionCheck {
 
-    public NoFallB(GrimPlayer player) {
+    public GroundSpoof(GrimPlayer player) {
         super(player);
     }
 
@@ -29,11 +29,9 @@ public class NoFallB extends Check implements PostPredictionCheck {
         // Viaversion sends wrong ground status... (doesn't matter but is annoying)
         if (player.packetStateData.lastPacketWasTeleport) return;
 
-        boolean invalid = player.clientClaimsLastOnGround != player.onGround;
-
-        if (invalid) {
-            if (flagWithSetback()) {
-                alert("claimed " + player.clientClaimsLastOnGround);
+        if (player.clientClaimsLastOnGround != player.onGround) {
+            if (flagAndAlert("claimed " + player.clientClaimsLastOnGround)) {
+                setbackIfAboveSetbackVL();
             }
             player.checkManager.getNoFall().flipPlayerGroundStatus = true;
         }

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;
@@ -10,7 +11,7 @@ import org.bukkit.Bukkit;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
-@CheckData(name = "Simulation", configName = "Simulation", decay = 0.02)
+@CheckData(name = "Simulation", decay = 0.02)
 public class OffsetHandler extends Check implements PostPredictionCheck {
     // Config
     double setbackDecayMultiplier;
@@ -29,11 +30,11 @@ public class OffsetHandler extends Check implements PostPredictionCheck {
     }
 
     public void onPredictionComplete(final PredictionComplete predictionComplete) {
-        double offset = predictionComplete.getOffset();
-
         if (!predictionComplete.isChecked()) return;
 
-        CompletePredictionEvent completePredictionEvent = new CompletePredictionEvent(getPlayer(), this, predictionComplete.getOffset());
+        double offset = predictionComplete.getOffset();
+
+        CompletePredictionEvent completePredictionEvent = new CompletePredictionEvent(player, this, "", offset);
         Bukkit.getPluginManager().callEvent(completePredictionEvent);
 
         if (completePredictionEvent.isCancelled()) return;
@@ -42,7 +43,7 @@ public class OffsetHandler extends Check implements PostPredictionCheck {
         if ((offset >= threshold || offset >= immediateSetbackThreshold) && flag()) {
             advantageGained += offset;
 
-            boolean isSetback = advantageGained >= maxAdvantage || offset >= immediateSetbackThreshold;
+            boolean isSetback = (advantageGained >= maxAdvantage || offset >= immediateSetbackThreshold) && !isNoSetbackPermission();
             giveOffsetLenienceNextTick(offset);
 
             if (isSetback) {
@@ -66,7 +67,7 @@ public class OffsetHandler extends Check implements PostPredictionCheck {
                     humanFormattedOffset = humanFormattedOffset.replace("0.", ".");
                 }
 
-                if(alert(humanFormattedOffset + " /gl " + flagId)) {
+                if (alert(humanFormattedOffset + " /gl " + flagId)) {
                     flags.incrementAndGet(); // This debug was sent somewhere
                     predictionComplete.setIdentifier(flagId);
                 }
@@ -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/prediction/Phase.java

@@ -15,7 +15,7 @@ import com.github.retrooper.packetevents.protocol.world.states.type.StateTypes;
 import java.util.ArrayList;
 import java.util.List;
 
-@CheckData(name = "Phase", configName = "Phase", setback = 1, decay = 0.005)
+@CheckData(name = "Phase", setback = 1, decay = 0.005)
 public class Phase extends Check implements PostPredictionCheck {
     SimpleCollisionBox oldBB;
 

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

@@ -1,9 +1,12 @@
 package ac.grim.grimac.checks.impl.scaffolding;
 
+import ac.grim.grimac.GrimAPI;
+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;
 import ac.grim.grimac.utils.anticheat.update.BlockPlace;
+import ac.grim.grimac.utils.change.BlockModification;
 import ac.grim.grimac.utils.nmsutil.Materials;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
 import com.github.retrooper.packetevents.protocol.world.states.type.StateType;
@@ -15,12 +18,65 @@ public class AirLiquidPlace extends BlockPlaceCheck {
         super(player);
     }
 
+    /*
+     * This check has been plagued by falses for ages, and I've finally figured it out.
+     * When breaking and placing on the same tick in the same tick, I believe the vanilla client always sends DIGGING ACTION packets first
+     * This check's falses all seem to stem from processing DiggingAction.START_DIGGING before PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT in the same tick
+     * Since we process the break first, when we go to process the place it looks like the player placed against air in the async world
+     *
+     * We will often see:
+     *     Async world updated: short_grass -> air at X: -32, Y: 69, Z: -240, tick 0, cause/source: DiggingAction.START_DIGGING
+     *     AirLiquidPlace Check: Block state at X: -32, Y: 69, Z: -240 is air (valid: false), tick +0-1, cause/source: PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT <---- previously falsed here
+     *     Async world updated: air -> short_grass at X: -32, Y: 69, Z: -240, tick +3-4, cause: realtime task in applyBlockChanges(List<Vector3i> toApplyBlocks) source: PacketType.Play.Client.PONG
+     *     Async world updated: short_grass -> air at X: -32, Y: 69, Z: -240, tick +0-1, cause: handleNettySyncTransaction(LatencyUtils.java:56) source: PacketType.Play.Client.PONG
+     *
+     * In addition, it is possible for:
+     *     Async world updated: short_grass -> air at X: -49, Y: 69, Z: -190, tick 0, cause: realtime task in applyBlockChanges(List<Vector3i> toApplyBlocks) source: PacketType.Play.Client.PONG
+     *     AirLiquidPlace Check: Block state at X: -49, Y: 69, Z: -190 is air (valid=false), tick 0 <--- false due to change from applyBlockChanges()
+     *     Async world updated: grass_block[snowy=false] -> grass_block[snowy=false] at X: -49, Y: 69, Z: -189, tick 0, cause: handleNettySyncTransaction(LatencyUtils.java:56) source: PacketType.Play.Client.PONG
+     *
+     * And in even more rare cases:
+     *     Async world updated: air -> air at X: -51, Y: 71, Z: -179, tick 0, cause: handleNettySyncTransaction(LatencyUtils.java:56) source: PacketType.Play.Client.PONG
+     *     AirLiquidPlace Check: Block state at X: -49, Y: 70, Z: -180 is short_grass (valid=true), tick 0
+     *     Async world updated: short_grass -> air at X: -49, Y: 70, Z: -180, tick 1, cause/source: DiggingAction.START_DIGGING <--- double dig here (see my AirLiquidBreak patch) this is legit behaviour. Can only be up to 2 in 1 tick though.
+     *     Async world updated: air -> short_grass at X: -49, Y: 70, Z: -180, tick 1, cause/source: DiggingAction.START_DIGGING
+     *     Async world updated: short_grass -> air at X: -51, Y: 70, Z: -179, tick 1, cause: realtime task in applyBlockChanges(List<Vector3i> toApplyBlocks) source: PacketType.Play.Client.PONG
+     *     AirLiquidPlace Check: Block state at X: -49, Y: 70, Z: -179 is air (valid=false), tick 2 <--- falses here due to double dig if we only check the latest changed blockstate. We have to check all changes at the location in same tick.
+     *     AirLiquidPlace Check: Block state at X: -49, Y: 70, Z: -179 is air (valid=true), tick 2
+     *
+     *     All of which previously would've caused a false.
+     *     To solve this we store recently changed blocks caused by DiggingAction.START_DIGGING (instant breaking) and check against the old block.
+     *     Lots of other checks have similar issues, and with the new player.blockHistory we can patch those.
+     *
+     * So that's it right? It's unfalsable?
+     *     Very close but not quite. Vanilla's client game desyncs, especially on a laggy connection where a player is breaking and placing grass 20 cps/sec in the same tick
+     *     it is possible for short grass to be interacted with even if server-side the block is air much later, and it won't be accounted for because the modification isn't recent.
+     *     This is incredibly rare, unreliable and is only triggerable if you intentionally want to false the check. I consider a violation lvl of 2-3 to be reliable
+     *     and 5-6 to be autobannable (if you don't care about people who are deliberately trying to get themselves false banned)
+     */
     @Override
     public void onBlockPlace(final BlockPlace place) {
         if (player.gamemode == GameMode.CREATIVE) return;
+
         Vector3i blockPos = place.getPlacedAgainstBlockLocation();
         StateType placeAgainst = player.compensatedWorld.getStateTypeAt(blockPos.getX(), blockPos.getY(), blockPos.getZ());
 
+        int currentTick = GrimAPI.INSTANCE.getTickManager().currentTick;
+        // this is actual more lenient then we need to be, We can check up to 1 ticks for all changes at location sand up to 0 ticks for first change
+        // But for such tiny differences in legitness its not worth it.
+        Iterable<BlockModification> blockModifications = player.blockHistory.getRecentModifications((blockModification) -> currentTick - blockModification.tick() < 2
+                && blockPos.equals(blockModification.location())
+                && (blockModification.cause() == BlockModification.Cause.START_DIGGING || blockModification.cause() == BlockModification.Cause.HANDLE_NETTY_SYNC_TRANSACTION));
+
+        // Check if old block from instant breaking in same tick as the current placement was valid
+        // There should only be one block here for legit clients
+        for (BlockModification blockModification : blockModifications) {
+            StateType stateType = blockModification.oldBlockContents().getType();
+            if (!stateType.isAir() && !Materials.isNoPlaceLiquid(stateType)) {
+                return;
+            }
+        }
+
         if (placeAgainst.isAir() || Materials.isNoPlaceLiquid(placeAgainst)) { // fail
             if (flagAndAlert() && shouldModifyPackets() && shouldCancel()) {
                 place.resync();
@@ -29,8 +85,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,13 +7,12 @@ 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;
 
-@CheckData(name = "FarPlace")
+@CheckData(name = "FarPlace", description = "Placing blocks from too far away")
 public class FarPlace extends BlockPlaceCheck {
     public FarPlace(GrimPlayer player) {
         super(player);
@@ -21,12 +20,15 @@ public class FarPlace extends BlockPlaceCheck {
 
     @Override
     public void onBlockPlace(final BlockPlace place) {
+        if (player.gamemode == GameMode.SPECTATOR) return;
+
         Vector3i blockPos = place.getPlacedAgainstBlockLocation();
 
         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);
@@ -35,7 +37,7 @@ public class FarPlace extends BlockPlaceCheck {
 
         // getPickRange() determines this?
         // With 1.20.5+ the new attribute determines creative mode reach using a modifier
-        double maxReach = player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_BLOCK_INTERACTION_RANGE);
+        double maxReach = player.compensatedEntities.getSelf().getAttributeValue(Attributes.BLOCK_INTERACTION_RANGE);
         double threshold = player.getMovementThreshold();
         maxReach += Math.hypot(threshold, threshold);
 

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

@@ -7,7 +7,7 @@ import ac.grim.grimac.utils.anticheat.update.BlockPlace;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.manager.server.ServerVersion;
 
-@CheckData(name = "InvalidPlaceB")
+@CheckData(name = "InvalidPlaceB", description = "Sent impossible block face id")
 public class InvalidPlaceB extends BlockPlaceCheck {
     public InvalidPlaceB(GrimPlayer player) {
         super(player);

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

@@ -7,11 +7,10 @@ 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.player.GameMode;
 import com.github.retrooper.packetevents.protocol.world.BlockFace;
 import com.github.retrooper.packetevents.util.Vector3f;
 import com.github.retrooper.packetevents.util.Vector3i;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -39,7 +38,7 @@ public class MultiPlace extends BlockPlaceCheck {
             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 (!player.canSkipTicks()) {
                 if (flagAndAlert(verbose) && shouldModifyPackets() && shouldCancel()) {
                     place.resync();
                 }
@@ -56,14 +55,16 @@ public class MultiPlace extends BlockPlaceCheck {
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType()) && !player.packetStateData.lastPacketWasTeleport && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate) {
+        if (player.gamemode == GameMode.SPECTATOR || isTickPacket(event.getPacketType())) {
             hasPlaced = false;
         }
     }
 
     @Override
     public void onPredictionComplete(PredictionComplete predictionComplete) {
-        if (player.getClientVersion().isNewerThan(ClientVersion.V_1_8) && !player.skippedTickInActualMovement) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3)) {
             for (String verbose : flags) {
                 flagAndAlert(verbose);
             }

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

@@ -5,11 +5,8 @@ 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.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,11 +25,16 @@ 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;
+        double movementThreshold = !player.packetStateData.didLastMovementIncludePosition || player.canSkipTicks() ? player.getMovementThreshold() : 0;
 
         SimpleCollisionBox eyePositions = new SimpleCollisionBox(player.x, player.y + minEyeHeight, player.z, player.x, player.y + maxEyeHeight, player.z);
         eyePositions.expand(movementThreshold);
@@ -44,32 +46,18 @@ 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 -> eyePositions.minZ > combined.minZ; // Z- face
+            case SOUTH -> eyePositions.maxZ < combined.maxZ; // Z+ face
+            case EAST -> eyePositions.maxX < combined.maxX; // X+ face
+            case WEST -> eyePositions.minX > combined.minX; // X- face
+            case UP -> eyePositions.maxY < combined.maxY; // Y+ face
+            case DOWN -> eyePositions.minY > combined.minY; // Y- face
+            default -> false;
+        };
 
-        if (flag) {
-            if (flagAndAlert() && shouldModifyPackets() && shouldCancel()) {
-                place.resync();
-            }
+        if (flag && flagAndAlert() && shouldModifyPackets() && shouldCancel()) {
+            place.resync();
         }
     }
 }

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

@@ -75,9 +75,15 @@ public class RotationPlace extends BlockPlaceCheck {
                 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());
@@ -98,8 +104,8 @@ public class RotationPlace extends BlockPlaceCheck {
             possibleLookDirs = Collections.singletonList(new Vector3f(player.xRot, player.yRot, 0));
         }
 
-        final double distance = player.compensatedEntities.getSelf().getAttributeValue(Attributes.PLAYER_BLOCK_INTERACTION_RANGE);
-        for (double d : player.getPossibleEyeHeights()) {
+        final double distance = player.compensatedEntities.getSelf().getAttributeValue(Attributes.BLOCK_INTERACTION_RANGE);
+        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);
@@ -107,7 +113,7 @@ public class RotationPlace extends BlockPlaceCheck {
                 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));
 
-                if (intercept.getFirst() != null) return true;
+                if (intercept.first() != null) return true;
             }
         }
 

src/main/java/ac/grim/grimac/checks/impl/sprint/SprintA.java

@@ -1,4 +1,4 @@
-package ac.grim.grimac.checks.impl.movement;
+package ac.grim.grimac.checks.impl.sprint;
 
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
@@ -7,10 +7,10 @@ import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
-@CheckData(name = "NoSlowB", setback = 5)
-public class NoSlowB extends Check implements PacketCheck {
+@CheckData(name = "SprintA", description = "Sprinting with too low hunger", setback = 0)
+public class SprintA extends Check implements PacketCheck {
 
-    public NoSlowB(GrimPlayer player) {
+    public SprintA(GrimPlayer player) {
         super(player);
     }
 
@@ -21,18 +21,19 @@ public class NoSlowB extends Check implements PacketCheck {
             if (player.canFly) return;
 
             if (player.food < 6.0F && player.isSprinting) {
-                if (flag()) {
+                if (flagAndAlert()) {
                     // Cancel the packet
                     if (shouldModifyPackets()) {
                         event.setCancelled(true);
                         player.onPacketCancel();
                     }
-                    alert("");
-                    player.getSetbackTeleportUtil().executeNonSimulatingSetback();
+                    if (shouldSetback()) {
+                        player.getSetbackTeleportUtil().executeNonSimulatingSetback();
+                    }
                 }
             } else {
                 reward();
             }
         }
     }
-}
+}

src/main/java/ac/grim/grimac/checks/impl/sprint/SprintB.java

@@ -0,0 +1,40 @@
+package ac.grim.grimac.checks.impl.sprint;
+
+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 ac.grim.grimac.utils.enums.FluidTag;
+import ac.grim.grimac.utils.enums.Pose;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+
+@CheckData(name = "SprintB", description = "Sprinting while sneaking", setback = 5, experimental = true)
+public class SprintB extends Check implements PostPredictionCheck {
+    public SprintB(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPredictionComplete(final PredictionComplete predictionComplete) {
+        if (!predictionComplete.isChecked()) return;
+
+        if (player.isSlowMovement && player.sneakingSpeedMultiplier < 0.8f) {
+            ClientVersion version = player.getClientVersion();
+
+            // https://bugs.mojang.com/browse/MC-152728
+            if (version.isNewerThanOrEquals(ClientVersion.V_1_14_2) && version.isOlderThan(ClientVersion.V_1_21_4)) {
+                return;
+            }
+
+            // https://github.com/GrimAnticheat/Grim/issues/1932
+            if (version.isNewerThanOrEquals(ClientVersion.V_1_14) && player.wasFlying && player.lastPose == Pose.FALL_FLYING && !player.isGliding) {
+                return;
+            }
+
+            if (player.isSprinting && !player.isSwimming && (player.fluidOnEyes != FluidTag.WATER || version.isOlderThan(ClientVersion.V_1_21_4))) {
+                if (flagWithSetback()) alert("");
+            } else reward();
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/sprint/SprintC.java

@@ -0,0 +1,39 @@
+package ac.grim.grimac.checks.impl.sprint;
+
+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.protocol.player.ClientVersion;
+
+@CheckData(name = "SprintC", description = "Sprinting while using an item", setback = 5, experimental = true)
+public class SprintC extends Check implements PostPredictionCheck {
+    public SprintC(GrimPlayer player) {
+        super(player);
+    }
+
+    private boolean flaggedLastTick = false;
+
+    @Override
+    public void onPredictionComplete(final PredictionComplete predictionComplete) {
+        if (!predictionComplete.isChecked()) return;
+
+        if (player.packetStateData.isSlowedByUsingItem()) {
+            ClientVersion client = player.getClientVersion();
+
+            // https://bugs.mojang.com/browse/MC-152728
+            if (client.isNewerThanOrEquals(ClientVersion.V_1_14_2) && client.isOlderThan(ClientVersion.V_1_21_4)) {
+                return;
+            }
+
+            if (player.isSprinting && (!player.isSwimming || client.isOlderThan(ClientVersion.V_1_21_4))) {
+                if (flaggedLastTick && flagWithSetback()) alert("");
+                flaggedLastTick = true;
+            } else {
+                reward();
+                flaggedLastTick = false;
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/sprint/SprintD.java

@@ -1,8 +1,7 @@
-package ac.grim.grimac.checks.impl.movement;
+package ac.grim.grimac.checks.impl.sprint;
 
 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;
@@ -12,9 +11,9 @@ 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 NoSlowE(GrimPlayer player) {
+@CheckData(name = "SprintD", description = "Started sprinting while having blindness", setback = 5, experimental = true)
+public class SprintD extends Check implements PostPredictionCheck {
+    public SprintD(GrimPlayer player) {
         super(player);
     }
 

src/main/java/ac/grim/grimac/checks/impl/sprint/SprintE.java

@@ -1,8 +1,7 @@
-package ac.grim.grimac.checks.impl.movement;
+package ac.grim.grimac.checks.impl.sprint;
 
 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;
@@ -11,20 +10,19 @@ 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 NoSlowD(GrimPlayer player) {
+@CheckData(name = "SprintE", description = "Sprinting while colliding with a wall", setback = 5, experimental = true)
+public class SprintE extends Check implements PostPredictionCheck {
+    public SprintE(GrimPlayer player) {
         super(player);
     }
 
-    public boolean startedSprintingBeforeUse = false;
-    private boolean flaggedLastTick = false;
+    private boolean startedSprintingThisTick, wasHorizontalCollision;
 
     @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;
+                startedSprintingThisTick = true;
             }
         }
     }
@@ -33,21 +31,17 @@ public class NoSlowD extends Check implements PostPredictionCheck, PacketCheck {
     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;
-                return;
-            }
+        // there's a mechanic in 1.18+ that allows this if you are looking far enough away from the wall
+        // I'll probably check 1.18+ later
+        if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_18)) return;
 
+        if (wasHorizontalCollision && !startedSprintingThisTick) {
             if (player.isSprinting) {
-                if (flaggedLastTick && flagWithSetback()) alert("");
-                flaggedLastTick = true;
-            } else {
-                reward();
-                flaggedLastTick = false;
-            }
+                if (flagAndAlert()) setbackIfAboveSetbackVL();
+            } else reward();
         }
+
+        wasHorizontalCollision = player.horizontalCollision;
+        startedSprintingThisTick = false;
     }
 }

src/main/java/ac/grim/grimac/checks/impl/sprint/SprintF.java

@@ -0,0 +1,26 @@
+package ac.grim.grimac.checks.impl.sprint;
+
+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.protocol.player.ClientVersion;
+
+@CheckData(name = "SprintF", description = "Sprinting while gliding", experimental = true)
+public class SprintF extends Check implements PostPredictionCheck {
+    public SprintF(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPredictionComplete(final PredictionComplete predictionComplete) {
+        if (player.wasGliding && player.isGliding && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_4)) {
+            if (player.isSprinting) {
+                if (flagAndAlert()) setbackIfAboveSetbackVL();
+            } else {
+                reward();
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/timer/NegativeTimer.java

@@ -1,15 +1,16 @@
-package ac.grim.grimac.checks.impl.movement;
+package ac.grim.grimac.checks.impl.timer;
 
+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)
-public class NegativeTimerCheck extends TimerCheck implements PostPredictionCheck {
+@CheckData(name = "NegativeTimer", setback = -1, experimental = true)
+public class NegativeTimer extends Timer implements PostPredictionCheck {
 
-    public NegativeTimerCheck(GrimPlayer player) {
+    public NegativeTimer(GrimPlayer player) {
         super(player);
         timerBalanceRealTime = System.nanoTime() + clockDrift;
     }
@@ -17,13 +18,13 @@ public class NegativeTimerCheck extends TimerCheck implements PostPredictionChec
     @Override
     public void onPredictionComplete(final PredictionComplete predictionComplete) {
         // We can't negative timer check a 1.9+ player who is standing still.
-        if (!player.canThePlayerBeCloseToZeroMovement(2) || !predictionComplete.isChecked()) {
+        if (player.uncertaintyHandler.lastPointThree.hasOccurredSince(2) || !predictionComplete.isChecked()) {
             timerBalanceRealTime = System.nanoTime() + clockDrift;
         }
 
         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/timer/TickTimer.java

@@ -0,0 +1,44 @@
+package ac.grim.grimac.checks.impl.timer;
+
+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)) {
+                handleViolation();
+            }
+            receivedTickEnd = false;
+            flyingPackets++;
+        } else if (event.getPacketType() == PacketType.Play.Client.CLIENT_TICK_END) {
+            receivedTickEnd = true;
+            if (flyingPackets > 1 && flagAndAlert("type=end, packets=" + flyingPackets)) {
+                handleViolation();
+            }
+            flyingPackets = 0;
+        }
+    }
+
+    private void handleViolation() {
+        setbackIfAboveSetbackVL();
+        // Although we don't cancel the packet, this should be counted as an invalid packet.
+        player.onPacketCancel();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/timer/Timer.java

@@ -1,5 +1,6 @@
-package ac.grim.grimac.checks.impl.movement;
+package ac.grim.grimac.checks.impl.timer;
 
+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,21 +8,20 @@ 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 {
+public class Timer extends Check implements PacketCheck {
     long timerBalanceRealTime = 0;
 
     // Default value is real time minus max keep-alive time
     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;
 
@@ -52,7 +52,7 @@ public class TimerCheck extends Check implements PacketCheck {
     //
     // We then take the last transaction before this to increase stability with these lag spikes and
     // to guarantee that we are at least 50 ms back before adding the time
-    public TimerCheck(GrimPlayer player) {
+    public Timer(GrimPlayer player) {
         super(player);
     }
 
@@ -72,27 +72,18 @@ 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 (flag()) {
+        if (timerBalanceRealTime > System.nanoTime()) {
+            if (flagAndAlert()) {
                 // 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("");
+                if (shouldSetback()) {
+                    player.getSetbackTeleportUtil().executeNonSimulatingSetback();
                 }
             }
 
@@ -100,7 +91,12 @@ public class TimerCheck extends Check implements PacketCheck {
             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);
     }
 }