Add support for not loading checks for incompatible players

* Refactor and improve numerous PacketOrder checks
* Fix some BadPacketsX falses
* Fix some LineOfSightPlace falses

build.gradle.kts

@@ -26,12 +26,10 @@ spotless {
 }
 
 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 {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(17))
-}
+java.sourceCompatibility = JavaVersion.VERSION_1_8
+java.targetCompatibility = JavaVersion.VERSION_1_8
 
 // Set to false for debug builds
 // You cannot live reload classes if the jar relocates dependencies
@@ -66,15 +64,17 @@ dependencies {
     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.15")
     implementation("github.scarsz:configuralize:1.4.0")
+    implementation("com.zaxxer:HikariCP:4.0.3")
 
     //implementation("com.github.grimanticheat:grimapi:1193c4fa41")
-    // Used for local testing: implementation("ac.grim.grimac:GRIMAPI:1.0")
-    implementation("com.github.grimanticheat:grimapi:fc5634e444")
+    // Used for local testing:
+    implementation("ac.grim.grimac:GrimAPI:1.0")
+//    implementation("com.github.grimanticheat:grimapi:fc5634e444")
 
     implementation("org.jetbrains:annotations:24.1.0")
-    compileOnly("org.geysermc.floodgate:api:2.0-SNAPSHOT")
+    compileOnly("org.geysermc.floodgate:api:2.2.3-SNAPSHOT")
     compileOnly("org.spigotmc:spigot-api:1.18.2-R0.1-SNAPSHOT")
-    compileOnly("com.viaversion:viaversion-api:5.0.4-SNAPSHOT")
+    compileOnly("com.viaversion:viaversion-api:5.1.1-SNAPSHOT")
     //
     compileOnly("io.netty:netty-all:4.1.85.Final")
 }
@@ -191,5 +191,6 @@ tasks.shadowJar {
         relocate("org.json", "ac.grim.grimac.shaded.json")
         relocate("org.intellij", "ac.grim.grimac.shaded.intellij")
         relocate("org.jetbrains", "ac.grim.grimac.shaded.jetbrains")
+        relocate("com.zaxxer", "ac.grim.rgimac.shaded.zaxxer")
     }
 }

settings.gradle.kts

@@ -1 +1,9 @@
+pluginManagement {
+    plugins {
+        kotlin("jvm") version "2.0.21"
+    }
+}
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
 rootProject.name = "grimac"

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

@@ -2,6 +2,7 @@ package ac.grim.grimac;
 
 import ac.grim.grimac.manager.*;
 import ac.grim.grimac.manager.config.BaseConfigManager;
+import ac.grim.grimac.manager.violationdatabase.ViolationDatabaseManager;
 import ac.grim.grimac.utils.anticheat.PlayerDataManager;
 import lombok.Getter;
 import org.bukkit.plugin.java.JavaPlugin;
@@ -17,11 +18,13 @@ public enum GrimAPI {
     private final PlayerDataManager playerDataManager = new PlayerDataManager();
     private final TickManager tickManager = new TickManager();
     private final GrimExternalAPI externalAPI = new GrimExternalAPI(this);
+    private ViolationDatabaseManager violationDatabaseManager;
     private InitManager initManager;
     private JavaPlugin plugin;
 
     public void load(final JavaPlugin plugin) {
         this.plugin = plugin;
+        this.violationDatabaseManager = new ViolationDatabaseManager(plugin);
         initManager = new InitManager();
         initManager.load();
     }

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

@@ -114,6 +114,12 @@ public class GrimExternalAPI implements GrimAbstractAPI, ConfigReloadObserver, I
         return configManager;
     }
 
+    @Override
+    public boolean hasStarted() {
+        // TODO implement this
+        throw new UnsupportedOperationException("Not implemented yet");
+    }
+
     private ConfigManager configManager = null;
     private final ConfigManagerFileImpl configManagerFile = new ConfigManagerFileImpl();
     private boolean started = false;

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

@@ -3,6 +3,8 @@ 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.dynamic.DefaultUnloadedBehavior;
+import ac.grim.grimac.api.dynamic.UnloadedBehavior;
 import ac.grim.grimac.api.events.FlagEvent;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.common.ConfigReloadObserver;
@@ -15,6 +17,8 @@ import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.Bukkit;
 
+import java.lang.reflect.Method;
+
 // Class from https://github.com/Tecnio/AntiCheatBase/blob/master/src/main/java/me/tecnio/anticheat/check/Check.java
 @Getter
 public class Check implements AbstractCheck, ConfigReloadObserver {
@@ -40,6 +44,16 @@ public class Check implements AbstractCheck, ConfigReloadObserver {
         return experimental;
     }
 
+    @Override
+    public UnloadedBehavior getUnloadedBehavior() {
+        return DefaultUnloadedBehavior.INSTANCE;
+    }
+
+    @Override
+    public int getMask() {
+        throw new UnsupportedOperationException("Override this method to show which check types your check is!");
+    }
+
     public Check(final GrimPlayer player) {
         this.player = player;
 
@@ -112,7 +126,6 @@ public class Check implements AbstractCheck, ConfigReloadObserver {
         violations = Math.max(0, violations - decay);
     }
 
-    @Override
     public void reload(ConfigManager configuration) {
         decay = configuration.getDoubleElse(configName + ".decay", decay);
         setbackVL = configuration.getDoubleElse(configName + ".setbackvl", setbackVL);
@@ -185,6 +198,28 @@ public class Check implements AbstractCheck, ConfigReloadObserver {
         return isFlying(packetType);
     }
 
+    public interface UnloadedCheckHandler<T extends Check> {
+        // Return what the check's methods should return when unloaded
+        Object handleUnloadedCall(Method method, Object[] args);
+    }
+
+    // Default behavior - do nothing and return false/0/null
+    public static final UnloadedCheckHandler<?> DEFAULT_HANDLER = (method, args) -> {
+        // Return appropriate "no-op" value based on return type
+        Class<?> returnType = method.getReturnType();
+        if (returnType == boolean.class) return false;
+        if (returnType == int.class) return 0;
+        if (returnType == void.class) return null;
+        // etc...
+        return null;
+    };
+
+    private UnloadedCheckHandler<?> unloadedHandler = DEFAULT_HANDLER;
+
+    public void setUnloadedHandler(UnloadedCheckHandler<?> handler) {
+        this.unloadedHandler = handler;
+    }
+
     @Override
     public void reload() {
         reload(GrimAPI.INSTANCE.getConfigManager().getConfig());

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

@@ -1,13 +1,12 @@
 package ac.grim.grimac.checks.impl.aim;
 
-import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.RotationCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractRotationCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.RotationUpdate;
 
 @CheckData(name = "AimDuplicateLook")
-public class AimDuplicateLook extends Check implements RotationCheck {
+public class AimDuplicateLook extends AbstractRotationCheck {
     public AimDuplicateLook(GrimPlayer playerData) {
         super(playerData);
     }

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

@@ -1,8 +1,7 @@
 package ac.grim.grimac.checks.impl.aim;
 
-import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.RotationCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractRotationCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.RotationUpdate;
 
@@ -10,7 +9,7 @@ import ac.grim.grimac.utils.anticheat.update.RotationUpdate;
 // I also discovered this flaw before open source Kauri, but did not want to open source its detection.
 // It works on clients who % 360 their rotation.
 @CheckData(name = "AimModulo360", decay = 0.005)
-public class AimModulo360 extends Check implements RotationCheck {
+public class AimModulo360 extends AbstractRotationCheck {
 
     private float lastDeltaYaw;
 

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

@@ -1,7 +1,6 @@
 package ac.grim.grimac.checks.impl.aim.processor;
 
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.checks.type.RotationCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractRotationCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.RotationUpdate;
 import ac.grim.grimac.utils.data.Pair;
@@ -9,7 +8,7 @@ import ac.grim.grimac.utils.lists.RunningMode;
 import ac.grim.grimac.utils.math.GrimMath;
 
 
-public class AimProcessor extends Check implements RotationCheck {
+public class AimProcessor extends AbstractRotationCheck {
 
     private static final int SIGNIFICANT_SAMPLES_THRESHOLD = 15;
     private static final int TOTAL_SAMPLES_THRESHOLD = 80;

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.WrapperPlayClientHeldItemChange;
 
 @CheckData(name = "BadPacketsA", description = "Sent duplicate slot id")
-public class BadPacketsA extends Check implements PacketCheck {
+public class BadPacketsA extends AbstractPacketCheck {
     int lastSlot = -1;
 
     public BadPacketsA(final GrimPlayer player) {

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.WrapperPlayClientSteerVehicle;
 
 @CheckData(name = "BadPacketsB", description = "Sent impossible steer vehicle packet")
-public class BadPacketsB extends Check implements PacketCheck {
+public class BadPacketsB extends AbstractPacketCheck {
     public BadPacketsB(GrimPlayer player) {
         super(player);
     }

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
 
 @CheckData(name = "BadPacketsC", description = "Interacted with self")
-public class BadPacketsC extends Check implements PacketCheck {
+public class BadPacketsC extends AbstractPacketCheck {
     public BadPacketsC(GrimPlayer player) {
         super(player);
     }

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.WrapperPlayClientPlayerFlying;
 
 @CheckData(name = "BadPacketsD")
-public class BadPacketsD extends Check implements PacketCheck {
+public class BadPacketsD extends AbstractPacketCheck {
     public BadPacketsD(GrimPlayer player) {
         super(player);
     }

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

@@ -1,8 +1,7 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
@@ -10,7 +9,7 @@ import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 @CheckData(name = "BadPacketsE")
-public class BadPacketsE extends Check implements PacketCheck {
+public class BadPacketsE extends AbstractPacketCheck {
     private int noReminderTicks;
 
     public BadPacketsE(GrimPlayer player) {

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.WrapperPlayClientEntityAction;
 
 @CheckData(name = "BadPacketsF", description = "Sent duplicate sprinting status")
-public class BadPacketsF extends Check implements PacketCheck {
+public class BadPacketsF extends AbstractPacketCheck {
     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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.WrapperPlayClientEntityAction;
 
 @CheckData(name = "BadPacketsG", description = "Sent duplicate sneaking status")
-public class BadPacketsG extends Check implements PacketCheck {
+public class BadPacketsG extends AbstractPacketCheck {
     private boolean lastSneaking, respawn;
 
     public BadPacketsG(GrimPlayer player) {

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.WrapperPlayClientPlayerAbilities;
 
 @CheckData(name = "BadPacketsI", description = "Claimed to be flying while unable to fly")
-public class BadPacketsI extends Check implements PacketCheck {
+public class BadPacketsI extends AbstractPacketCheck {
     public BadPacketsI(GrimPlayer player) {
         super(player);
     }

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

@@ -1,14 +1,13 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 
 @CheckData(name = "BadPacketsJ", description = "Sent steer vehicle packets while not in a vehicle")
-public class BadPacketsJ extends Check implements PacketCheck {
+public class BadPacketsJ extends AbstractPacketCheck {
     public BadPacketsJ(GrimPlayer player) {
         super(player);
     }

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.GameMode;
 
 @CheckData(name = "BadPacketsK", description = "Sent spectate packets while not in spectator mode")
-public class BadPacketsK extends Check implements PacketCheck {
+public class BadPacketsK extends AbstractPacketCheck {
     public BadPacketsK(GrimPlayer player) {
         super(player);
     }

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

@@ -1,8 +1,7 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
@@ -14,7 +13,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPl
 import java.util.Locale;
 
 @CheckData(name = "BadPacketsL", description = "Sent impossible dig packet")
-public class BadPacketsL extends Check implements PacketCheck {
+public class BadPacketsL extends AbstractPacketCheck {
 
     public BadPacketsL(GrimPlayer player) {
         super(player);

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

@@ -1,61 +0,0 @@
-package ac.grim.grimac.checks.impl.badpackets;
-
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
-import ac.grim.grimac.player.GrimPlayer;
-import ac.grim.grimac.utils.data.packetentity.PacketEntity;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
-import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
-import com.github.retrooper.packetevents.protocol.packettype.PacketType;
-import com.github.retrooper.packetevents.protocol.player.ClientVersion;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
-
-@CheckData(name = "BadPacketsM", experimental = true)
-public class BadPacketsM extends Check implements PacketCheck {
-    public BadPacketsM(final GrimPlayer player) {
-        super(player);
-    }
-
-    // 1.7 players do not send INTERACT_AT, so we cannot check them
-    private final boolean exempt = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10);
-    private boolean sentInteractAt = false;
-
-    @Override
-    public void onPacketReceive(PacketReceiveEvent event) {
-        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY && !exempt) {
-
-            final WrapperPlayClientInteractEntity wrapper = new WrapperPlayClientInteractEntity(event);
-
-            final PacketEntity entity = player.compensatedEntities.entityMap.get(wrapper.getEntityId());
-
-            // For armor stands, vanilla clients send:
-            //  - when renaming the armor stand or in spectator mode: INTERACT_AT + INTERACT
-            //  - in all other cases: only INTERACT
-            // Just exempt armor stands to be safe
-            if (entity != null && entity.getType() == EntityTypes.ARMOR_STAND) return;
-
-            switch (wrapper.getAction()) {
-                // INTERACT_AT then INTERACT
-                case INTERACT:
-                    if (!sentInteractAt) {
-                        if (flagAndAlert("Missed Interact-At") && shouldModifyPackets()) {
-                            event.setCancelled(true);
-                            player.onPacketCancel();
-                        }
-                    }
-                    sentInteractAt = false;
-                    break;
-                case INTERACT_AT:
-                    if (sentInteractAt) {
-                        if (flagAndAlert("Missed Interact") && shouldModifyPackets()) {
-                            event.setCancelled(true);
-                            player.onPacketCancel();
-                        }
-                    }
-                    sentInteractAt = true;
-                    break;
-            }
-        }
-    }
-}

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

@@ -1,12 +1,11 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
 @CheckData(name = "BadPacketsN")
-public class BadPacketsN extends Check implements PacketCheck {
+public class BadPacketsN extends AbstractPacketCheck {
     public BadPacketsN(final GrimPlayer player) {
         super(player);
     }

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

@@ -1,8 +1,7 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.data.Pair;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
@@ -15,7 +14,7 @@ import java.util.LinkedList;
 import java.util.Queue;
 
 @CheckData(name = "BadPacketsO")
-public class BadPacketsO extends Check implements PacketCheck {
+public class BadPacketsO extends AbstractPacketCheck {
     Queue<Pair<Long, Long>> keepaliveMap = new LinkedList<>();
 
     public BadPacketsO(GrimPlayer player) {

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

@@ -1,8 +1,7 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.event.PacketSendEvent;
@@ -11,8 +10,9 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientCl
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClickWindow.WindowClickType;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerOpenWindow;
 
+
 @CheckData(name = "BadPacketsP", experimental = true)
-public class BadPacketsP extends Check implements PacketCheck {
+public class BadPacketsP extends AbstractPacketCheck {
 
     public BadPacketsP(GrimPlayer playerData) {
         super(playerData);
@@ -38,14 +38,31 @@ public class BadPacketsP extends Check implements PacketCheck {
             int button = wrapper.getButton();
 
             // TODO: Adjust for containers
-            boolean flag = switch (clickType) {
-                case PICKUP, QUICK_MOVE, THROW -> button != 0 && button != 1;
-                case SWAP -> (button > 8 || button < 0) && button != 40;
-                case CLONE -> button != 2;
-                case QUICK_CRAFT -> button == 3 || button == 7 || button > 10 || button < 0;
-                case PICKUP_ALL -> button != 0;
-                case UNKNOWN -> false;
-            };
+            boolean flag;
+            switch (clickType) {
+                case PICKUP:
+                case QUICK_MOVE:
+                case THROW:
+                    flag = button != 0 && button != 1;
+                    break;
+                case SWAP:
+                    flag = (button > 8 || button < 0) && button != 40;
+                    break;
+                case CLONE:
+                    flag = button != 2;
+                    break;
+                case QUICK_CRAFT:
+                    flag = button == 3 || button == 7 || button > 10 || button < 0;
+                    break;
+                case PICKUP_ALL:
+                    flag = button != 0;
+                    break;
+                case UNKNOWN:
+                    flag = false;
+                    break;
+                default:
+                    throw new IllegalStateException("Impossible clickType; Compiler does not know this is unreachable!");
+            }
 
             // Allowing this to false flag to debug and find issues faster
             if (flag) {

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

@@ -1,8 +1,7 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType.Play.Client;
@@ -10,7 +9,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEn
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction.Action;
 
 @CheckData(name = "BadPacketsQ")
-public class BadPacketsQ extends Check implements PacketCheck {
+public class BadPacketsQ extends AbstractPacketCheck {
     public BadPacketsQ(final GrimPlayer player) {
         super(player);
     }

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.GameMode;
 
 @CheckData(name = "BadPacketsR", decay = 0.25, experimental = true)
-public class BadPacketsR extends Check implements PacketCheck {
+public class BadPacketsR extends AbstractPacketCheck {
     public BadPacketsR(final GrimPlayer player) {
         super(player);
     }

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

@@ -1,12 +1,11 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
 @CheckData(name = "BadPacketsS")
-public class BadPacketsS extends Check implements PacketCheck {
+public class BadPacketsS extends AbstractPacketCheck {
     public BadPacketsS(GrimPlayer player) {
         super(player);
     }

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

@@ -1,8 +1,7 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.data.packetentity.PacketEntity;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
@@ -13,7 +12,7 @@ import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
 
 @CheckData(name = "BadPacketsT")
-public class BadPacketsT extends Check implements PacketCheck {
+public class BadPacketsT extends AbstractPacketCheck {
     public BadPacketsT(final GrimPlayer player) {
         super(player);
     }

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

@@ -1,8 +1,7 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.item.ItemStack;
@@ -15,7 +14,7 @@ import com.github.retrooper.packetevents.util.Vector3i;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerBlockPlacement;
 
 @CheckData(name = "BadPacketsU", description = "Sent impossible use item packet", experimental = true)
-public class BadPacketsU extends Check implements PacketCheck {
+public class BadPacketsU extends AbstractPacketCheck {
     public BadPacketsU(GrimPlayer player) {
         super(player);
     }

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

@@ -1,12 +1,11 @@
 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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
 @CheckData(name = "BadPacketsW", description = "Interacted with non-existent entity", experimental = true)
-public class BadPacketsW extends Check implements PacketCheck {
+public class BadPacketsW extends AbstractPacketCheck {
     public BadPacketsW(GrimPlayer player) {
         super(player);
     }

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

@@ -1,11 +1,11 @@
 package ac.grim.grimac.checks.impl.badpackets;
 
 import ac.grim.grimac.GrimAPI;
-import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractBlockBreakCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.BlockBreak;
+import ac.grim.grimac.utils.change.BlockModification;
 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;
@@ -13,8 +13,12 @@ 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;
 
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 @CheckData(name = "BadPacketsX")
-public class BadPacketsX extends Check implements BlockBreakCheck {
+public class BadPacketsX extends AbstractBlockBreakCheck {
     public BadPacketsX(GrimPlayer player) {
         super(player);
     }
@@ -45,26 +49,44 @@ public class BadPacketsX extends Check implements BlockBreakCheck {
                 && 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;
+        // prevents rare false on rapidly breaking short grass
+        List<StateType> previousBlockStates = player.blockHistory.modificationQueue.stream()
+                .filter((blockModification) -> blockModification.getLocation().equals(blockBreak.position)
+                        && newTick - blockModification.getTick() < 2
+                        && (blockModification.getCause() == BlockModification.Cause.START_DIGGING || blockModification.getCause() == BlockModification.Cause.HANDLE_NETTY_SYNC_TRANSACTION))
+                .flatMap(mod -> Stream.of(mod.getOldBlockContents().getType()))
+                .collect(Collectors.toList());
 
-        if (invalid && flagAndAlert("block=" + block.getName() + ", type=" + blockBreak.action) && shouldModifyPackets()) {
+        previousBlockStates.add(0, block);
+
+        boolean invalid = false;
+        for (StateType possibleBlockState : previousBlockStates) {
+            // the block does not have a hitbox
+            invalid = (possibleBlockState == StateTypes.LIGHT && !(player.getInventory().getHeldItem().is(ItemTypes.LIGHT) || player.getInventory().getOffHand().is(ItemTypes.LIGHT)))
+                    || possibleBlockState.isAir()
+                    || possibleBlockState == StateTypes.WATER
+                    || possibleBlockState == StateTypes.LAVA
+                    || possibleBlockState == StateTypes.BUBBLE_COLUMN
+                    || possibleBlockState == StateTypes.MOVING_PISTON
+                    || possibleBlockState == StateTypes.FIRE && noFireHitbox
+                    // or the client claims to have broken an unbreakable block
+                    || possibleBlockState.getHardness() == -1.0f && blockBreak.action == DiggingAction.FINISHED_DIGGING;
+            if (!invalid) {
+                break;
+            }
+        }
+
+        if (invalid && flagAndAlert("block=" + block.getName() + ", type=" + blockBreak.action)) {
             didLastFlag = true;
-            blockBreak.cancel();
+            if (shouldModifyPackets()) {
+                blockBreak.cancel();
+            }
         } else {
             didLastFlag = false;
         }
+        lastTick = newTick;
+        lastBreakLoc = blockBreak.position;
+        lastBlockType = block;
     }
 }

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

@@ -1,15 +1,14 @@
 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.abstracts.AbstractPacketCheck;
 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.WrapperPlayClientHeldItemChange;
 
 @CheckData(name = "BadPacketsY", description = "Sent out of bounds slot id")
-public class BadPacketsY extends Check implements PacketCheck {
+public class BadPacketsY extends AbstractPacketCheck {
     public BadPacketsY(GrimPlayer player) {
         super(player);
     }

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

@@ -1,8 +1,7 @@
 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.BlockBreakCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractBlockBreakCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.MessageUtil;
 import ac.grim.grimac.utils.anticheat.update.BlockBreak;
@@ -15,7 +14,7 @@ import com.github.retrooper.packetevents.util.Vector3i;
 import static ac.grim.grimac.utils.nmsutil.BlockBreakSpeed.getBlockDamage;
 
 @CheckData(name = "BadPacketsZ")
-public class BadPacketsZ extends Check implements BlockBreakCheck {
+public class BadPacketsZ extends AbstractBlockBreakCheck {
     public BadPacketsZ(final GrimPlayer player) {
         super(player);
     }

src/main/java/ac/grim/grimac/checks/impl/baritone/Baritone.java

@@ -3,7 +3,7 @@ package ac.grim.grimac.checks.impl.baritone;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
 import ac.grim.grimac.checks.impl.aim.processor.AimProcessor;
-import ac.grim.grimac.checks.type.RotationCheck;
+import ac.grim.grimac.checks.type.interfaces.RotationCheckI;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.RotationUpdate;
 import ac.grim.grimac.utils.data.HeadRotation;
@@ -11,7 +11,7 @@ import ac.grim.grimac.utils.math.GrimMath;
 
 // This check has been patched by Baritone for a long time and it also seems to false with cinematic camera now, so it is disabled.
 @CheckData(name = "Baritone")
-public class Baritone extends Check implements RotationCheck {
+public class Baritone extends Check implements RotationCheckI {
     public Baritone(GrimPlayer playerData) {
         super(playerData);
     }

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

@@ -0,0 +1,12 @@
+package ac.grim.grimac.checks.impl.combat;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+
+@CheckData(name = "HitboxBlock", configName = "HitboxBlock", setback = 20)
+public class HitboxBlock extends AbstractPacketCheck {
+    public HitboxBlock(GrimPlayer player) {
+        super(player);
+    }
+}

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

@@ -0,0 +1,12 @@
+package ac.grim.grimac.checks.impl.combat;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+
+@CheckData(name = "HitboxEntity", configName = "HitboxEntity", setback = 30)
+public class HitboxEntity extends AbstractPacketCheck {
+    public HitboxEntity(GrimPlayer player) {
+        super(player);
+    }
+}

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

@@ -0,0 +1,12 @@
+package ac.grim.grimac.checks.impl.combat;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+
+@CheckData(name = "HitboxMiss", configName = "HitboxMiss", setback = 10)
+public class HitboxMiss extends AbstractPacketCheck {
+    public HitboxMiss(GrimPlayer player) {
+        super(player);
+    }
+}

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

@@ -1,8 +1,7 @@
 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.checks.type.abstracts.AbstractPostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
@@ -14,7 +13,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPl
 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 class MultiInteractA extends AbstractPostPredictionCheck {
     public MultiInteractA(final GrimPlayer player) {
         super(player);
     }

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

@@ -1,8 +1,7 @@
 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.checks.type.abstracts.AbstractPostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.MessageUtil;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
@@ -16,7 +15,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPl
 import java.util.ArrayList;
 
 @CheckData(name = "MultiInteractB", experimental = true)
-public class MultiInteractB extends Check implements PostPredictionCheck {
+public class MultiInteractB extends AbstractPostPredictionCheck {
     public MultiInteractB(final GrimPlayer player) {
         super(player);
     }

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

@@ -18,10 +18,16 @@ 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;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+import ac.grim.grimac.checks.type.interfaces.PacketCheckI;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
+import ac.grim.grimac.utils.data.BlockHitData;
+import ac.grim.grimac.utils.data.EntityHitData;
+import ac.grim.grimac.utils.data.HitData;
+import ac.grim.grimac.utils.data.Pair;
 import ac.grim.grimac.utils.data.packetentity.PacketEntity;
+import ac.grim.grimac.utils.nmsutil.BlockRayTrace;
 import ac.grim.grimac.utils.data.packetentity.dragon.PacketEntityEnderDragonPart;
 import ac.grim.grimac.utils.nmsutil.ReachUtils;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
@@ -31,27 +37,44 @@ import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.GameMode;
+import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
 import com.github.retrooper.packetevents.util.Vector3d;
+import com.github.retrooper.packetevents.util.Vector3i;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import org.bukkit.util.Vector;
+import org.jetbrains.annotations.Nullable;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 // You may not copy the check unless you are licensed under GPL
 @CheckData(name = "Reach", configName = "Reach", setback = 10)
-public class Reach extends Check implements PacketCheck {
+public class Reach extends AbstractPacketCheck {
     // Only one flag per reach attack, per entity, per tick.
     // We store position because lastX isn't reliable on teleports.
     private final Int2ObjectMap<Vector3d> playerAttackQueue = new Int2ObjectOpenHashMap<>();
+    // Used to prevent falses in the wall hit check
+    private final Set<Vector3i> blocksChangedThisTick = new HashSet<>();
+
     private static final List<EntityType> blacklisted = Arrays.asList(
             EntityTypes.BOAT,
             EntityTypes.CHEST_BOAT,
             EntityTypes.SHULKER);
 
+    private static final double ENTITY_HITBOX_REACH_EPSILON = 1E-12;
+
+    private boolean ignoreNonPlayerTargets;
+    private boolean skipBlockCheck;
+    private boolean skipEntityCheck;
     private boolean cancelImpossibleHits;
-    private double threshold;
+    public double reachThreshold;
     private double cancelBuffer; // For the next 4 hits after using reach, we aggressively cancel reach
 
     public Reach(GrimPlayer player) {
@@ -83,6 +106,10 @@ public class Reach extends Check implements PacketCheck {
                 return;
             }
 
+            if (ignoreNonPlayerTargets && !entity.getType().equals(EntityTypes.PLAYER)) {
+                return;
+            }
+
             // Dead entities cause false flags (https://github.com/GrimAnticheat/Grim/issues/546)
             if (entity.isDead) return;
 
@@ -107,8 +134,9 @@ public class Reach extends Check implements PacketCheck {
         }
 
         // If the player set their look, or we know they have a new tick
+        final boolean isFlying = WrapperPlayClientPlayerFlying.isFlying(event.getPacketType());
         if (isUpdate(event.getPacketType())) {
-            tickBetterReachCheckWithAngle();
+            tickBetterReachCheckWithAngle(isFlying);
         }
     }
 
@@ -140,24 +168,28 @@ public class Reach extends Check implements PacketCheck {
         }
     }
 
-    private void tickBetterReachCheckWithAngle() {
+    private void tickBetterReachCheckWithAngle(boolean isFlying) {
         for (Int2ObjectMap.Entry<Vector3d> attack : playerAttackQueue.int2ObjectEntrySet()) {
             PacketEntity reachEntity = player.compensatedEntities.entityMap.get(attack.getIntKey());
             if (reachEntity != null) {
-                String result = checkReach(reachEntity, attack.getValue(), false);
+                Pair<Class<? extends PacketCheckI>, String> result = checkReach(reachEntity, attack.getValue(), false);
                 if (result != null) {
+                    PacketCheckI check = player.checkManager.getPacketCheck(result.first());
                     if (reachEntity.getType() == EntityTypes.PLAYER) {
-                        flagAndAlert(result);
+                        ((Check)check).flagAndAlert(result.second());
                     } else {
-                        flagAndAlert(result + " type=" + reachEntity.getType().getName().getKey());
+                        ((Check) check).flagAndAlert(result.second() + "type=" + reachEntity.getType().getName().getKey());
                     }
                 }
             }
         }
         playerAttackQueue.clear();
+        // We can't use transactions for this because of this problem:
+        // transaction -> block changed applied -> 2nd transaction -> list cleared -> attack packet -> flying -> reach block hit checked, falses
+        if (isFlying) blocksChangedThisTick.clear();
     }
 
-    private String checkReach(PacketEntity reachEntity, Vector3d from, boolean isPrediction) {
+    private Pair<Class<? extends PacketCheckI>, String> checkReach(PacketEntity reachEntity, Vector3d from, boolean isPrediction) {
         SimpleCollisionBox targetBox = reachEntity.getPossibleCollisionBoxes();
 
         if (reachEntity.getType() == EntityTypes.END_CRYSTAL) { // Hardcode end crystal box
@@ -170,7 +202,7 @@ public class Reach extends Check implements PacketCheck {
             targetBox.expand(0.1f);
         }
 
-        targetBox.expand(threshold);
+        targetBox.expand(reachThreshold);
 
         // This is better than adding to the reach, as 0.03 can cause a player to miss their target
         // Adds some more than 0.03 uncertainty in some cases, but a good trade off for simplicity
@@ -199,9 +231,13 @@ public class Reach extends Check implements PacketCheck {
             }
         }
 
+        // We raytrace for > the player's reach distance so in the case a player is hacking
+        // We can return in the flag the distance of the reach hit instead of a generic "player failed reach check"
         // +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.ENTITY_INTERACTION_RANGE) + 3;
-        final double[] possibleEyeHeights = player.getPossibleEyeHeights();
+        double[] possibleEyeHeights = player.getPossibleEyeHeights();
+//        possibleEyeHeights = new double[]{possibleEyeHeights[0]};
+//        double realMinDistance = 0;
         for (Vector lookVec : possibleLookDirs) {
             for (double eye : possibleEyeHeights) {
                 Vector eyePos = new Vector(from.getX(), from.getY() + eye, from.getZ());
@@ -216,18 +252,47 @@ public class Reach extends Check implements PacketCheck {
 
                 if (intercept != null) {
                     minDistance = Math.min(eyePos.distance(intercept), minDistance);
+//                    if (eye == possibleEyeHeights[0]) {
+//                        realMinDistance = minDistance;
+//                    }
+                }
+            }
+        }
+
+        HitData foundHitData = null;
+        // If the entity is within range of the player (we'll flag anyway if not, so no point checking blocks in this case)
+        // Ignore when could be hitting through a moving shulker, piston blocks. They are just too glitchy/uncertain to check.
+        if (!skipEntityCheck || !skipBlockCheck) {
+            if (minDistance <= distance - 3 && !player.compensatedWorld.isNearHardEntity(player.boundingBox.copy().expand(4))) {
+                final @Nullable Pair<Double, HitData> hitResult = didRayTraceHit(reachEntity, possibleLookDirs, from, minDistance);
+
+                // if the hitResult is closer to the player than the target entity box, they shouldn't have hit the target entity
+                // We are checking if the diff > epsilon because the hit distance returned is slightly different due to floating point shennanigans
+                // - This filters out when the ray trace hits the target entity without having to do an expensive .equals()
+                // - You may have to adjust the epsilon if you increase the reach threshold, especially by a lot
+                // ...but there is literally no reason you would ever want to increase it, only decrease, so that doesn't matter.
+                if (hitResult != null && (minDistance * minDistance) - hitResult.first() > ENTITY_HITBOX_REACH_EPSILON) { // returned double is distanceSq
+                    minDistance = Double.MIN_VALUE;
+                    foundHitData = hitResult.second();
                 }
             }
         }
 
         // if the entity is not exempt and the entity is alive
         if ((!blacklisted.contains(reachEntity.getType()) && reachEntity.isLivingEntity()) || reachEntity.getType() == EntityTypes.END_CRYSTAL) {
-            if (minDistance == Double.MAX_VALUE) {
+            if (minDistance == Double.MIN_VALUE && foundHitData != null) {
                 cancelBuffer = 1;
-                return "Missed hitbox";
+                if (foundHitData instanceof BlockHitData) {
+                    return new Pair<>(HitboxBlock.class, "Hit block=" + ((BlockHitData) foundHitData).getState().getType().getName() + " ");
+                } else { // entity hit data
+                    return new Pair<>(HitboxEntity.class, "Hit entity=" + ((EntityHitData) foundHitData).getEntity().getType().getName() + " ");
+                }
+            } else if (minDistance == Double.MAX_VALUE) {
+                cancelBuffer = 1;
+                return new Pair<>(HitboxMiss.class, "");
             } else if (minDistance > player.compensatedEntities.getSelf().getAttributeValue(Attributes.ENTITY_INTERACTION_RANGE)) {
                 cancelBuffer = 1;
-                return String.format("%.5f", minDistance) + " blocks";
+                return new Pair<>(Reach.class, String.format("%.5f", minDistance) + " blocks");
             } else {
                 cancelBuffer = Math.max(0, cancelBuffer - 0.25);
             }
@@ -236,9 +301,80 @@ public class Reach extends Check implements PacketCheck {
         return null;
     }
 
+    public void handleBlockChange(Vector3i vector3i, WrappedBlockState state) {
+        if (blocksChangedThisTick.size() >= 40) return; // Don't let players freeze movement packets to grow this
+        // Only do this for nearby blocks
+        if (new Vector(vector3i.x, vector3i.y, vector3i.z).distanceSquared(new Vector(player.x, player.y, player.z)) > 6) return;
+        // Only do this if the state really had any world impact
+        if (state.equals(player.compensatedWorld.getWrappedBlockStateAt(vector3i))) return;
+        blocksChangedThisTick.add(vector3i);
+    }
+
+    // Checks if it was possible to hit a target entity
+    @Nullable
+    private Pair<Double, HitData> didRayTraceHit(PacketEntity targetEntity, List<Vector> possibleLookDirs, Vector3d from, double minDistance) {
+        HitData bestHitData = null;
+        double bestDistanceSq = Double.MAX_VALUE;
+        double bestBlockingEntityDistanceSq = Double.MAX_VALUE;
+        HitData bestBlockingEntityHit = null;
+
+        // Check every possible look direction and every possible eye height
+        // IF *NONE* of them allow the player to hit the entity, this is an invalid hit
+        for (Vector lookVec : possibleLookDirs) {
+            for (double eye : player.getPossibleEyeHeights()) {
+                Vector eyes = new Vector(from.getX(), from.getY() + eye, from.getZ());
+                // this function is completely 0.03 aware
+                final HitData hitResult = BlockRayTrace.getNearestHitResult(player, targetEntity, eyes, lookVec, minDistance, skipBlockCheck, skipEntityCheck);
+
+                if (hitResult == null)
+                    if (skipEntityCheck)
+                        return null;
+                    else
+                        continue;
+
+                double distanceSquared = eyes.distanceSquared(hitResult.getBlockHitLocation());
+
+                // Check if the hit result is the target entity
+                if (hitResult instanceof EntityHitData && ((EntityHitData) hitResult).getEntity().equals(targetEntity)) {
+                    return new Pair<>(distanceSquared, hitResult); // Legitimate hit
+                }
+
+                // Check for potential blocking entities
+                if (hitResult instanceof EntityHitData) {
+                    // Consider entities that are blocking the path to the target
+                    if (distanceSquared < bestBlockingEntityDistanceSq) {
+                        bestBlockingEntityDistanceSq = distanceSquared;
+                        bestBlockingEntityHit = hitResult;
+                    }
+                } else if (hitResult instanceof BlockHitData) {
+                    // don't false on recently rapidly changed blocks
+                    if (distanceSquared < (minDistance * minDistance) && blocksChangedThisTick.contains(((BlockHitData) hitResult).getPosition())) {
+                        return null;
+                    }
+                    // Check if block is closer than any blocking entity found
+                    if (bestBlockingEntityHit == null && distanceSquared < bestDistanceSq) {
+                        bestDistanceSq = distanceSquared;
+                        bestHitData = hitResult;
+                    }
+                }
+            }
+        }
+
+        // Prefer returning the entity that blocks the path to the target entity
+        if (bestBlockingEntityHit != null) {
+            return new Pair<>(bestBlockingEntityDistanceSq, bestBlockingEntityHit);
+        }
+
+        // If no blocking entity, return the closest block
+        return bestHitData == null ? null : new Pair<>(bestDistanceSq, bestHitData);
+    }
+
     @Override
     public void onReload(ConfigManager config) {
+        this.ignoreNonPlayerTargets = config.getBooleanElse("Reach.ignore-non-player-targets", false);
+        this.skipBlockCheck = config.getBooleanElse("Reach.skip-block-check", false);
+        this.skipEntityCheck = config.getBooleanElse("Reach.skip-entity-check", true);
         this.cancelImpossibleHits = config.getBooleanElse("Reach.block-impossible-hits", true);
-        this.threshold = config.getDoubleElse("Reach.threshold", 0.0005);
+        this.reachThreshold = config.getDoubleElse("Reach.threshold", 0.0005);
     }
 }

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

@@ -1,14 +1,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.type.PacketCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPrePredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 @CheckData(name = "CrashA")
-public class CrashA extends Check implements PacketCheck {
+public class CrashA extends AbstractPrePredictionCheck {
     private static final double HARD_CODED_BORDER = 2.9999999E7D;
 
     public CrashA(GrimPlayer player) {

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

@@ -1,15 +1,14 @@
 package ac.grim.grimac.checks.impl.crash;
 
-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.abstracts.AbstractPrePredictionCheck;
 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.GameMode;
 
 @CheckData(name = "CrashB", description = "Sent creative mode inventory click packets while not in creative mode")
-public class CrashB extends Check implements PacketCheck {
+public class CrashB extends AbstractPrePredictionCheck {
     public CrashB(GrimPlayer player) {
         super(player);
     }

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

@@ -1,15 +1,14 @@
 package ac.grim.grimac.checks.impl.crash;
 
-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.abstracts.AbstractPrePredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 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", description = "Sent non-finite position or rotation")
-public class CrashC extends Check implements PacketCheck {
+public class CrashC extends AbstractPrePredictionCheck {
     public CrashC(GrimPlayer playerData) {
         super(playerData);
     }

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

@@ -1,8 +1,7 @@
 package ac.grim.grimac.checks.impl.crash;
 
-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.abstracts.AbstractPrePredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.inventory.inventory.MenuType;
 import com.github.retrooper.packetevents.PacketEvents;
@@ -14,7 +13,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientCl
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerOpenWindow;
 
 @CheckData(name = "CrashD", description = "Clicking slots in lectern window")
-public class CrashD extends Check implements PacketCheck {
+public class CrashD extends AbstractPrePredictionCheck {
 
     public CrashD(GrimPlayer playerData) {
         super(playerData);

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

@@ -1,16 +1,15 @@
 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.checks.type.abstracts.AbstractPrePredictionCheck;
 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)
-public class CrashE extends Check implements PacketCheck {
+public class CrashE extends AbstractPrePredictionCheck {
 
     public CrashE(GrimPlayer playerData) {
         super(playerData);

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

@@ -1,15 +1,14 @@
 package ac.grim.grimac.checks.impl.crash;
 
-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.abstracts.AbstractPrePredictionCheck;
 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.WrapperPlayClientClickWindow;
 
 @CheckData(name = "CrashF")
-public class CrashF extends Check implements PacketCheck {
+public class CrashF extends AbstractPrePredictionCheck {
 
     public CrashF(GrimPlayer playerData) {
         super(playerData);

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

@@ -1,8 +1,8 @@
 package ac.grim.grimac.checks.impl.crash;
 
-import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.api.GrimUser;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPrePredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
@@ -14,7 +14,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPl
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientUseItem;
 
 @CheckData(name = "CrashG", description = "Sent negative sequence id")
-public class CrashG extends Check implements PacketCheck {
+public class CrashG extends AbstractPrePredictionCheck {
 
     public CrashG(GrimPlayer player) {
         super(player);
@@ -22,8 +22,6 @@ public class CrashG extends Check implements PacketCheck {
 
     @Override
     public void onPacketReceive(final PacketReceiveEvent event) {
-        if (!isSupportedVersion()) return;
-
         if (event.getPacketType() == PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT) {
             WrapperPlayClientPlayerBlockPlacement place = new WrapperPlayClientPlayerBlockPlacement(event);
             if (place.getSequence() < 0) {
@@ -53,8 +51,10 @@ public class CrashG extends Check implements PacketCheck {
 
     }
 
-    private boolean isSupportedVersion() {
-        return player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_19) && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_19);
+    @Override
+    public boolean supportsPlayer(GrimUser player) {
+        // TODO make this a part of GrimUser interface
+        // TODO server version check when we bypass via for listening for packets
+        return ((GrimPlayer) player).getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_19) && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_19);
     }
-
 }

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

@@ -1,15 +1,14 @@
 package ac.grim.grimac.checks.impl.crash;
 
-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.abstracts.AbstractPrePredictionCheck;
 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.WrapperPlayClientTabComplete;
 
 @CheckData(name = "CrashH")
-public class CrashH extends Check implements PacketCheck {
+public class CrashH extends AbstractPrePredictionCheck {
 
     public CrashH(GrimPlayer player) {
         super(player);

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

@@ -1,8 +1,7 @@
 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.checks.type.abstracts.AbstractPrePredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
@@ -12,7 +11,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientNa
 import java.util.regex.Pattern;
 
 @CheckData(name = "ExploitA", experimental = true)
-public class ExploitA extends Check implements PacketCheck {
+public class ExploitA extends AbstractPrePredictionCheck {
 
     public ExploitA(GrimPlayer playerData) {
         super(playerData);

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

@@ -1,8 +1,7 @@
 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.checks.type.abstracts.AbstractPrePredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
@@ -11,7 +10,7 @@ import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientTabComplete;
 
 @CheckData(name = "ExploitB", experimental = true)
-public class ExploitB extends Check implements PacketCheck {
+public class ExploitB extends AbstractPrePredictionCheck {
 
     public ExploitB(GrimPlayer playerData) {
         super(playerData);

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

@@ -1,15 +1,14 @@
 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.checks.type.abstracts.AbstractPrePredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEditBook;
 
 @CheckData(name = "ExploitC", description = "Too long book title")
-public class ExploitC extends Check implements PacketCheck {
+public class ExploitC extends AbstractPrePredictionCheck {
     public ExploitC(GrimPlayer playerData) {
         super(playerData);
     }

src/main/java/ac/grim/grimac/checks/impl/flight/FlightA.java

@@ -1,13 +1,12 @@
 package ac.grim.grimac.checks.impl.flight;
 
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 
 // This check catches 100% of cheaters.
-public class FlightA extends Check implements PacketCheck {
+public class FlightA extends AbstractPacketCheck {
     public FlightA(GrimPlayer player) {
         super(player);
     }

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

@@ -1,8 +1,7 @@
 package ac.grim.grimac.checks.impl.groundspoof;
 
-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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.predictionengine.GhostBlockDetector;
 import ac.grim.grimac.utils.collisions.datatypes.SimpleCollisionBox;
@@ -18,7 +17,7 @@ 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 {
+public class NoFallA extends AbstractPacketCheck {
 
     public boolean flipPlayerGroundStatus = false;
 

src/main/java/ac/grim/grimac/checks/impl/inventory/InventoryA.java

@@ -0,0 +1,47 @@
+package ac.grim.grimac.checks.impl.inventory;
+
+import ac.grim.grimac.api.CheckType;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.InventoryCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity.InteractAction;
+
+@CheckData(name = "InventoryA", setback = 3, description = "Attacked an entity while inventory is open")
+public class InventoryA extends InventoryCheck {
+    public InventoryA(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        super.onPacketReceive(event);
+
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            WrapperPlayClientInteractEntity wrapper = new WrapperPlayClientInteractEntity(event);
+
+            if (wrapper.getAction() != InteractAction.ATTACK) return;
+
+            // Is not possible to attack while the inventory is open.
+            if (player.hasInventoryOpen) {
+                if (flagAndAlert()) {
+                    // Cancel the packet
+                    if (shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                    closeInventory();
+                }
+            } else {
+                reward();
+            }
+        }
+    }
+
+    @Override
+    public int getMask() {
+        return CheckType.PACKET.getMask();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/inventory/InventoryB.java

@@ -0,0 +1,39 @@
+package ac.grim.grimac.checks.impl.inventory;
+
+import ac.grim.grimac.api.CheckType;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.InventoryCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.player.DiggingAction;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+
+@CheckData(name = "InventoryB", setback = 3, description = "Started digging blocks while inventory is open")
+public class InventoryB extends InventoryCheck {
+    public InventoryB(GrimPlayer player) {
+        super(player);
+    }
+
+    public void handle(PacketReceiveEvent event, WrapperPlayClientPlayerDigging wrapper) {
+        if (wrapper.getAction() != DiggingAction.START_DIGGING) return;
+
+        // Is not possible to start digging a block while the inventory is open.
+        if (player.hasInventoryOpen) {
+            if (flagAndAlert()) {
+                // Cancel the packet
+                if (shouldModifyPackets()) {
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
+                closeInventory();
+            }
+        } else {
+            reward();
+        }
+    }
+
+    @Override
+    public int getMask() {
+        return CheckType.PACKET.getMask();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/inventory/InventoryC.java

@@ -0,0 +1,28 @@
+package ac.grim.grimac.checks.impl.inventory;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.InventoryCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.BlockPlace;
+
+@CheckData(name = "InventoryC", setback = 3, description = "Placed a block while inventory is open")
+public class InventoryC extends InventoryCheck {
+
+    public InventoryC(GrimPlayer player) {
+        super(player);
+    }
+
+    public void onBlockPlace(final BlockPlace place) {
+        // It is not possible to place a block while the inventory is open
+        if (player.hasInventoryOpen) {
+            if (flagAndAlert()) {
+                if (shouldModifyPackets()) {
+                    place.resync();
+                }
+                closeInventory();
+            }
+        } else {
+            reward();
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/inventory/InventoryD.java

@@ -0,0 +1,90 @@
+package ac.grim.grimac.checks.impl.inventory;
+
+import ac.grim.grimac.api.CheckType;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.InventoryCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+import ac.grim.grimac.utils.data.VectorData;
+import ac.grim.grimac.utils.data.VectorData.MoveVectorData;
+import ac.grim.grimac.utils.data.VehicleData;
+
+import java.util.StringJoiner;
+
+@CheckData(name = "InventoryD", setback = 1, decay = 0.25)
+public class InventoryD extends InventoryCheck {
+    private int horseJumpVerbose;
+
+    public InventoryD(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPredictionComplete(final PredictionComplete predictionComplete) {
+        if (!predictionComplete.isChecked() ||
+                predictionComplete.getData().isTeleport() ||
+                player.getSetbackTeleportUtil().blockOffsets ||
+                player.packetStateData.lastPacketWasTeleport ||
+                player.packetStateData.isSlowedByUsingItem() ||
+                System.currentTimeMillis() - player.lastBlockPlaceUseItem < 50L) {
+            return;
+        }
+
+        if (player.hasInventoryOpen) {
+            boolean inVehicle = player.compensatedEntities.getSelf().inVehicle();
+            boolean isJumping, isMoving;
+
+            if (inVehicle) {
+                VehicleData vehicle = player.vehicleData;
+
+                // Will flag once if player open anything with pressed space bar
+                isJumping = vehicle.nextHorseJump > 0 && horseJumpVerbose++ >= 1;
+                isMoving = vehicle.nextVehicleForward != 0 || vehicle.nextVehicleHorizontal != 0;
+            } else {
+                MoveVectorData move = findMovement(player.predictedVelocity);
+
+                isJumping = player.predictedVelocity.isJump();
+                isMoving = move != null && (move.x != 0 || move.z != 0);
+            }
+
+            if (!isMoving && !isJumping) {
+                reward();
+                return;
+            }
+
+            if (flag()) {
+                closeInventory();
+
+                StringJoiner joiner = new StringJoiner(" ");
+
+                if (isMoving) joiner.add("moving");
+                if (isJumping) joiner.add("jumping");
+                if (inVehicle) joiner.add("inVehicle");
+
+                alert(joiner.toString());
+            }
+        } else {
+            horseJumpVerbose = 0;
+        }
+    }
+
+    private MoveVectorData findMovement(VectorData vectorData) {
+        if (vectorData instanceof MoveVectorData) {
+            return (MoveVectorData) vectorData;
+        }
+
+        while (vectorData != null) {
+            vectorData = vectorData.lastVector;
+            if (vectorData instanceof MoveVectorData) {
+                return (MoveVectorData) vectorData;
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public int getMask() {
+        return CheckType.POST_PREDICTION.getMask();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/inventory/InventoryE.java

@@ -0,0 +1,54 @@
+package ac.grim.grimac.checks.impl.inventory;
+
+import ac.grim.grimac.api.CheckType;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.InventoryCheck;
+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 = "InventoryE", setback = 3, description = "Sent a held item change packet while inventory is open")
+public class InventoryE extends InventoryCheck {
+    private long lastTransaction = Long.MAX_VALUE; // Impossible transaction ID
+
+    public InventoryE(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        super.onPacketReceive(event);
+
+        if (event.getPacketType() == PacketType.Play.Client.HELD_ITEM_CHANGE) {
+            // It is not possible to change hotbar slots with held item change while the inventory is open
+            // A container click packet would be sent instead
+            if (player.hasInventoryOpen) {
+                if (this.lastTransaction < player.lastTransactionReceived.get()
+                        && flagAndAlert()) {
+                    // Cancel the packet
+                    if (shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                        player.getInventory().needResend = true;
+                    }
+                    closeInventory();
+                }
+            } else {
+                reward();
+            }
+        }
+    }
+
+    @Override
+    public void onPacketSend(PacketSendEvent event) {
+        if (event.getPacketType() == PacketType.Play.Server.HELD_ITEM_CHANGE) {
+            this.lastTransaction = player.lastTransactionSent.get();
+        }
+    }
+
+    @Override
+    public int getMask() {
+        return CheckType.PACKET.getMask();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/inventory/InventoryF.java

@@ -0,0 +1,50 @@
+package ac.grim.grimac.checks.impl.inventory;
+
+import ac.grim.grimac.api.CheckType;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.InventoryCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.inventory.InventoryDesyncStatus;
+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;
+
+@CheckData(name = "InventoryF", setback = 3, description = "Sent a click window packet without a open inventory", experimental = true)
+public class InventoryF extends InventoryCheck {
+
+    public InventoryF(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        // Exempt on 1.9+ server version due to the Via hack done in PacketPlayerWindow, the exemption can be deleted
+        // once we are ahead of ViaVersion
+        if (PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_9)
+                || player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9)) return;
+
+        super.onPacketReceive(event);
+
+        if (event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW) {
+            if (!player.hasInventoryOpen && player.inventoryDesyncStatus == InventoryDesyncStatus.NOT_DESYNCED) {
+                if (flagAndAlert()) {
+                    // Cancel the packet
+                    if (shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                    closeInventory();
+                }
+            } else {
+                reward();
+            }
+        }
+    }
+
+    @Override
+    public int getMask() {
+        return CheckType.PACKET.getMask();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/inventory/InventoryG.java

@@ -0,0 +1,46 @@
+package ac.grim.grimac.checks.impl.inventory;
+
+import ac.grim.grimac.api.CheckType;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.InventoryCheck;
+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.WrapperPlayClientEntityAction;
+
+@CheckData(name = "InventoryG", setback = 3, description = "Sent a entity action packet while inventory is open", experimental = true)
+public class InventoryG extends InventoryCheck {
+
+    public InventoryG(GrimPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (player.packetStateData.lastPacketWasTeleport) return;
+        super.onPacketReceive(event);
+
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
+            WrapperPlayClientEntityAction wrapper = new WrapperPlayClientEntityAction(event);
+            WrapperPlayClientEntityAction.Action action = wrapper.getAction();
+
+            if (action == WrapperPlayClientEntityAction.Action.STOP_SNEAKING
+                    || action == WrapperPlayClientEntityAction.Action.STOP_SPRINTING) {
+                return;
+            }
+
+            if (player.hasInventoryOpen) {
+                if (flagAndAlert()) {
+                    closeInventory();
+                }
+            } else {
+                reward();
+            }
+        }
+    }
+
+    @Override
+    public int getMask() {
+        return CheckType.PACKET.getMask();
+    }
+}

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

@@ -1,9 +1,8 @@
 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.checks.type.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
@@ -12,7 +11,7 @@ import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 
-public class ClientBrand extends Check implements PacketCheck {
+public class ClientBrand extends AbstractPacketCheck {
     String brand = "vanilla";
     boolean hasBrand = false;
 

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

@@ -1,8 +1,7 @@
 package ac.grim.grimac.checks.impl.misc;
 
-import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.BlockBreakCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractBlockBreakCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.BlockBreak;
 import ac.grim.grimac.utils.math.GrimMath;
@@ -20,7 +19,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPl
 // 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 class FastBreak extends AbstractBlockBreakCheck {
     public FastBreak(GrimPlayer playerData) {
         super(playerData);
     }

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

@@ -1,16 +0,0 @@
-package ac.grim.grimac.checks.impl.misc;
-
-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 = "TransactionOrder", experimental = false)
-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,12 +1,11 @@
 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.checks.type.abstracts.AbstractPostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 
 @CheckData(name = "Entity control", configName = "EntityControl")
-public class EntityControl extends Check implements PostPredictionCheck {
+public class EntityControl extends AbstractPostPredictionCheck {
     public EntityControl(GrimPlayer player) {
         super(player);
     }

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

@@ -1,14 +1,15 @@
 package ac.grim.grimac.checks.impl.movement;
 
+import ac.grim.grimac.api.CheckType;
 import ac.grim.grimac.api.config.ConfigManager;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.checks.type.interfaces.PostPredictionCheckI;
 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 = -1, experimental = true)
-public class NegativeTimerCheck extends TimerCheck implements PostPredictionCheck {
+public class NegativeTimerCheck extends TimerCheck implements PostPredictionCheckI {
 
     public NegativeTimerCheck(GrimPlayer player) {
         super(player);
@@ -39,4 +40,9 @@ public class NegativeTimerCheck extends TimerCheck implements PostPredictionChec
     public void onReload(ConfigManager config) {
         clockDrift = (long) (config.getDoubleElse(getConfigName() + ".drift", 1200.0) * 1e6);
     }
+
+    @Override
+    public int getMask() {
+        return CheckType.POST_PREDICTION.getMask();
+    }
 }

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

@@ -1,15 +1,14 @@
 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;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
 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", description = "Was not slowed while using an item", setback = 5)
-public class NoSlowA extends Check implements PostPredictionCheck {
+public class NoSlowA extends AbstractPostPredictionCheck {
     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

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

@@ -1,14 +1,13 @@
 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.abstracts.AbstractPacketCheck;
 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", description = "Sprinting with too low hunger", setback = 5)
-public class NoSlowB extends Check implements PacketCheck {
+public class NoSlowB extends AbstractPacketCheck {
 
     public NoSlowB(GrimPlayer player) {
         super(player);

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

@@ -1,19 +1,35 @@
 package ac.grim.grimac.checks.impl.movement;
 
+import ac.grim.grimac.api.CheckType;
 import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.checks.type.interfaces.PacketCheckI;
+import ac.grim.grimac.checks.type.interfaces.PostPredictionCheckI;
 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 ac.grim.grimac.utils.enums.FluidTag;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
 @CheckData(name = "NoSlowC", description = "Sprinting while sneaking", setback = 5, experimental = true)
-public class NoSlowC extends Check implements PostPredictionCheck {
+public class NoSlowC extends Check implements PostPredictionCheckI, PacketCheckI {
     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;
@@ -22,13 +38,22 @@ public class NoSlowC extends Check implements PostPredictionCheck {
             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)) {
+            if (startedSprintingBeforeSlowMovement && client.isNewerThanOrEquals(ClientVersion.V_1_14_2) && client.isOlderThan(ClientVersion.V_1_21_4)) {
+                reward();
                 return;
             }
-
-            if (player.isSprinting && !player.isSwimming && (player.fluidOnEyes != FluidTag.WATER || client.isOlderThan(ClientVersion.V_1_21_4))) {
+            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.fluidOnEyes != FluidTag.WATER || client.isOlderThan(ClientVersion.V_1_21_4))
+            ) {
                 if (flagWithSetback()) alert("");
             } else reward();
         }
     }
+
+    @Override
+    public int getMask() {
+        return CheckType.POST_PREDICTION.getMask();
+    }
 }

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

@@ -1,20 +1,32 @@
 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.checks.type.abstracts.AbstractPostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEntityAction;
 
 @CheckData(name = "NoSlowD", description = "Sprinting while using an item", setback = 5, experimental = true)
-public class NoSlowD extends Check implements PostPredictionCheck {
+public class NoSlowD extends AbstractPostPredictionCheck {
     public NoSlowD(GrimPlayer player) {
         super(player);
     }
 
+    public boolean startedSprintingBeforeUse = false;
     private boolean flaggedLastTick = false;
 
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
+            if (new WrapperPlayClientEntityAction(event).getAction() == WrapperPlayClientEntityAction.Action.START_SPRINTING) {
+                startedSprintingBeforeUse = false;
+            }
+        }
+    }
+
     @Override
     public void onPredictionComplete(final PredictionComplete predictionComplete) {
         if (!predictionComplete.isChecked()) return;
@@ -23,7 +35,9 @@ public class NoSlowD extends Check implements PostPredictionCheck {
             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)) {
+            if (startedSprintingBeforeUse && client.isNewerThanOrEquals(ClientVersion.V_1_14_2) && client.isOlderThan(ClientVersion.V_1_21_4)) {
+                reward();
+                flaggedLastTick = false;
                 return;
             }
 

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

@@ -1,8 +1,7 @@
 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.checks.type.abstracts.AbstractPostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
@@ -12,7 +11,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientEn
 import static com.github.retrooper.packetevents.protocol.potion.PotionTypes.BLINDNESS;
 
 @CheckData(name = "NoSlowE", description = "Started sprinting while having blindness", setback = 5, experimental = true)
-public class NoSlowE extends Check implements PostPredictionCheck {
+public class NoSlowE extends AbstractPostPredictionCheck {
     public NoSlowE(GrimPlayer player) {
         super(player);
     }

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

@@ -1,11 +1,10 @@
 package ac.grim.grimac.checks.impl.movement;
 
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.checks.type.PositionCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPositionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PositionUpdate;
 
-public class PredictionRunner extends Check implements PositionCheck {
+public class PredictionRunner extends AbstractPositionCheck {
     public PredictionRunner(GrimPlayer playerData) {
         super(playerData);
     }

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

@@ -1,14 +1,13 @@
 package ac.grim.grimac.checks.impl.movement;
 
-import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
 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.WrapperPlayClientPlayerFlying;
 
-public class SetbackBlocker extends Check implements PacketCheck {
+public class SetbackBlocker extends AbstractPacketCheck {
     public SetbackBlocker(GrimPlayer playerData) {
         super(playerData);
     }

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

@@ -1,15 +1,18 @@
 package ac.grim.grimac.checks.impl.movement;
 
-import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.api.GrimUser;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPrePredictionCheck;
 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;
 
 
 @CheckData(name = "TickTimer", setback = 1)
-public class TickTimer extends Check implements PostPredictionCheck {
+public class TickTimer extends AbstractPrePredictionCheck {
 
     private boolean receivedTickEnd = true;
     private int flyingPackets = 0;
@@ -31,4 +34,11 @@ public class TickTimer extends Check implements PostPredictionCheck {
             flyingPackets = 0;
         }
     }
+
+    @Override
+    public boolean supportsPlayer(GrimUser player) {
+        // TODO make this a part of GrimUser interface and remove the server version check when we bypass via
+        // TODO server version check when we bypass via for listening for packets
+        return ((GrimPlayer) player).getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_2) && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_21_2);
+    }
 }

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

@@ -1,16 +1,16 @@
 package ac.grim.grimac.checks.impl.movement;
 
+import ac.grim.grimac.api.CheckType;
 import ac.grim.grimac.api.config.ConfigManager;
-import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPrePredictionCheck;
 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;
 
 @CheckData(name = "Timer", configName = "TimerA", setback = 10)
-public class TimerCheck extends Check implements PacketCheck {
+public class TimerCheck extends AbstractPrePredictionCheck {
     long timerBalanceRealTime = 0;
 
     // Default value is real time minus max keep-alive time
@@ -114,4 +114,9 @@ public class TimerCheck extends Check implements PacketCheck {
         clockDrift = (long) (config.getDoubleElse(getConfigName() + ".drift", 120.0) * 1e6);
         limitAbuseOverPing = (long) (config.getDoubleElse(getConfigName() + ".ping-abuse-limit-threshold", 1000) * 1e6);
     }
+
+    @Override
+    public int getMask() {
+        return CheckType.PRE_PREDICTION.getMask();
+    }
 }

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

@@ -1,12 +1,13 @@
 package ac.grim.grimac.checks.impl.movement;
 
+import ac.grim.grimac.api.CheckType;
 import ac.grim.grimac.checks.Check;
-import ac.grim.grimac.checks.type.VehicleCheck;
+import ac.grim.grimac.checks.type.interfaces.VehicleCheckI;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PositionUpdate;
 import ac.grim.grimac.utils.anticheat.update.VehiclePositionUpdate;
 
-public class VehiclePredictionRunner extends Check implements VehicleCheck {
+public class VehiclePredictionRunner extends Check implements VehicleCheckI {
     public VehiclePredictionRunner(GrimPlayer playerData) {
         super(playerData);
     }
@@ -17,4 +18,9 @@ public class VehiclePredictionRunner extends Check implements VehicleCheck {
         // We don't do vehicle setbacks because vehicle netcode sucks.
         player.movementCheckRunner.processAndCheckMovementPacket(new PositionUpdate(vehicleUpdate.getFrom(), vehicleUpdate.getTo(), false, null, null, vehicleUpdate.isTeleport()));
     }
+
+    @Override
+    public int getMask() {
+        return CheckType.VEHICLE.getMask();
+    }
 }

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

@@ -1,8 +1,7 @@
 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.checks.type.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
@@ -10,7 +9,7 @@ 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 class MultiActionsA extends AbstractPacketCheck {
     public MultiActionsA(GrimPlayer player) {
         super(player);
     }

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

@@ -1,10 +1,12 @@
 package ac.grim.grimac.checks.impl.multiactions;
 
-import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.api.GrimUser;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
 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.protocol.player.DiggingAction;
@@ -14,7 +16,7 @@ import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPl
 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 class MultiActionsB extends AbstractPacketCheck {
     public MultiActionsB(GrimPlayer player) {
         super(player);
     }
@@ -38,4 +40,11 @@ public class MultiActionsB extends Check implements PacketCheck {
             }
         }
     }
+
+    @Override
+    public boolean supportsPlayer(GrimUser player) {
+        // TODO make this a part of GrimUser interface
+        // TODO server version check when we bypass via for listening for packets
+        return ((GrimPlayer) player).getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_8) && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_8);
+    }
 }

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

@@ -1,15 +1,14 @@
 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.checks.type.abstracts.AbstractPacketCheck;
 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 performing other actions", experimental = true)
-public class MultiActionsC extends Check implements PacketCheck {
+public class MultiActionsC extends AbstractPacketCheck {
     public MultiActionsC(GrimPlayer player) {
         super(player);
     }

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

@@ -1,14 +1,13 @@
 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.checks.type.abstracts.AbstractPacketCheck;
 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 performing other actions", experimental = true)
-public class MultiActionsD extends Check implements PacketCheck {
+public class MultiActionsD extends AbstractPacketCheck {
     public MultiActionsD(GrimPlayer player) {
         super(player);
     }

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

@@ -1,16 +1,18 @@
 package ac.grim.grimac.checks.impl.multiactions;
 
-import ac.grim.grimac.checks.Check;
+import ac.grim.grimac.api.GrimUser;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PacketCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
 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.protocol.player.InteractionHand;
 
 @CheckData(name = "MultiActionsE", description = "Swinging while using an item", experimental = true)
-public class MultiActionsE extends Check implements PacketCheck {
+public class MultiActionsE extends AbstractPacketCheck {
     public MultiActionsE(GrimPlayer player) {
         super(player);
     }
@@ -29,4 +31,11 @@ public class MultiActionsE extends Check implements PacketCheck {
             }
         }
     }
+
+    @Override
+    public boolean supportsPlayer(GrimUser player) {
+        // TODO make this a part of GrimUser interface
+        // TODO server version check when we bypass via for listening for packets
+        return ((GrimPlayer) player).getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_8) && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_8);
+    }
 }

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderA.java

@@ -0,0 +1,51 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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.WrapperPlayClientClickWindow;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClickWindow.WindowClickType;
+
+@CheckData(name = "PacketOrderA", experimental = true)
+public class PacketOrderA extends AbstractPostPredictionCheck {
+    public PacketOrderA(final GrimPlayer player) {
+        super(player);
+    }
+
+    private int invalid;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW) {
+            final WindowClickType clickType = new WrapperPlayClientClickWindow(event).getWindowClickType();
+
+            if ((clickType == WindowClickType.PICKUP || clickType == WindowClickType.PICKUP_ALL) && player.packetOrderProcessor.isQuickMoveClicking()
+                    || clickType == WindowClickType.QUICK_MOVE && player.packetOrderProcessor.isPickUpClicking()) {
+                if (!player.canSkipTicks()) {
+                    if (flagAndAlert() && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    invalid++;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (; invalid >= 1; invalid--) {
+                flagAndAlert();
+            }
+        }
+
+        invalid = 0;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderB.java

@@ -1,8 +1,7 @@
-package ac.grim.grimac.checks.impl.badpackets;
+package ac.grim.grimac.checks.impl.packetorder;
 
-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.abstracts.AbstractPacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import com.github.retrooper.packetevents.PacketEvents;
 import com.github.retrooper.packetevents.event.PacketReceiveEvent;
@@ -11,15 +10,15 @@ 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 = "BadPacketsH")
-public class BadPacketsH extends Check implements PacketCheck {
+@CheckData(name = "PacketOrderB")
+public class PacketOrderB extends AbstractPacketCheck {
 
     // 1.9 packet order: INTERACT -> ANIMATION
     // 1.8 packet order: ANIMATION -> INTERACT
     // I personally think 1.8 made much more sense. You swing and THEN you hit!
     private boolean sentAnimation = player.getClientVersion().isNewerThan(ClientVersion.V_1_8);
 
-    public BadPacketsH(final GrimPlayer player) {
+    public PacketOrderB(final GrimPlayer player) {
         super(player);
     }
 

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderC.java

@@ -0,0 +1,90 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.data.packetentity.PacketEntity;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.InteractionHand;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
+
+@CheckData(name = "PacketOrderC", experimental = true)
+public class PacketOrderC extends AbstractPacketCheck {
+    public PacketOrderC(final GrimPlayer player) {
+        super(player);
+    }
+
+    // 1.7 players do not send INTERACT_AT, so we cannot check them
+    private final boolean exempt = player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10);
+    private boolean sentInteractAt = false;
+    private int requiredEntity;
+    private InteractionHand requiredHand;
+    private boolean requiredSneaking;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (exempt) {
+            return;
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            final WrapperPlayClientInteractEntity packet = new WrapperPlayClientInteractEntity(event);
+
+            final PacketEntity entity = player.compensatedEntities.entityMap.get(packet.getEntityId());
+
+            // For armor stands, vanilla clients send:
+            //  - when renaming the armor stand or in spectator mode: INTERACT_AT + INTERACT
+            //  - in all other cases: only INTERACT
+            // Just exempt armor stands to be safe
+            if (entity != null && entity.getType() == EntityTypes.ARMOR_STAND) return;
+
+            final boolean sneaking = packet.isSneaking().orElse(false);
+
+            switch (packet.getAction()) {
+                // INTERACT_AT then INTERACT
+                case INTERACT:
+                    if (!sentInteractAt) {
+                        if (flagAndAlert("Skipped Interact-At") && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    } else if (packet.getEntityId() != requiredEntity || packet.getHand() != requiredHand || sneaking != requiredSneaking) {
+                        String verbose = "requiredEntity=" + requiredEntity + ", entity=" + packet.getEntityId()
+                                + ", requiredHand=" + requiredHand + ", hand=" + packet.getHand()
+                                + ", requiredSneaking=" + requiredSneaking + ", sneaking=" + sneaking;
+                        if (flagAndAlert(verbose) && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    }
+
+                    sentInteractAt = false;
+                    break;
+                case INTERACT_AT:
+                    if (sentInteractAt) {
+                        if (flagAndAlert("Skipped Interact") && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    }
+
+                    requiredHand = packet.getHand();
+                    requiredEntity = packet.getEntityId();
+                    requiredSneaking = sneaking;
+                    sentInteractAt = true;
+                    break;
+            }
+        }
+
+        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType())) {
+            if (sentInteractAt) {
+                sentInteractAt = false;
+                flagAndAlert("Skipped Interact (Tick)");
+            }
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderD.java

@@ -0,0 +1,12 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+
+@CheckData(name = "PacketOrderD")
+public class PacketOrderD extends AbstractPacketCheck {
+    public PacketOrderD(GrimPlayer player) {
+        super(player);
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderE.java

@@ -0,0 +1,64 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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;
+
+@CheckData(name = "PacketOrderE", experimental = true)
+public class PacketOrderE extends AbstractPostPredictionCheck {
+    public PacketOrderE(final GrimPlayer player) {
+        super(player);
+    }
+
+    private int invalid;
+    private boolean setback;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.HELD_ITEM_CHANGE) {
+            if (player.packetOrderProcessor.isAttacking()
+                    || player.packetOrderProcessor.isRightClicking()
+                    || player.packetOrderProcessor.isOpeningInventory()
+                    || player.packetOrderProcessor.isReleasing()
+                    || player.packetOrderProcessor.isSneaking()
+                    || player.packetOrderProcessor.isSprinting()
+                    || player.packetOrderProcessor.isLeavingBed()
+                    || player.packetOrderProcessor.isStartingToGlide()
+                    || player.packetOrderProcessor.isJumpingWithMount()
+            ) {
+                if (player.canSkipTicks() || flagAndAlert()) {
+                    invalid++;
+
+                    if (player.packetOrderProcessor.isUsing()) {
+                        setback = true;
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) {
+            if (setback) {
+                setback = false;
+                setbackIfAboveSetbackVL();
+            }
+            return;
+        }
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (; invalid >= 1; invalid--) {
+                if (flagAndAlert() && setback) {
+                    setback = false;
+                    setbackIfAboveSetbackVL();
+                }
+            }
+        }
+
+        invalid = 0;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderF.java

@@ -0,0 +1,58 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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.DiggingAction;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClientStatus;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+
+@CheckData(name = "PacketOrderF", experimental = true)
+public class PacketOrderF extends AbstractPostPredictionCheck {
+    public PacketOrderF(GrimPlayer player) {
+        super(player);
+    }
+
+    private int invalid;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY
+                || event.getPacketType() == PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT
+                || event.getPacketType() == PacketType.Play.Client.USE_ITEM
+                || event.getPacketType() == PacketType.Play.Client.PICK_ITEM
+                || event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING
+                || (event.getPacketType() == PacketType.Play.Client.CLIENT_STATUS
+                && new WrapperPlayClientClientStatus(event).getAction() == WrapperPlayClientClientStatus.Action.OPEN_INVENTORY_ACHIEVEMENT)
+        ) if (player.packetOrderProcessor.isSprinting() || player.packetOrderProcessor.isSneaking()) {
+            if (!player.canSkipTicks()) {
+                if (flagAndAlert() && shouldModifyPackets()) {
+                    if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING
+                            && new WrapperPlayClientPlayerDigging(event).getAction() == DiggingAction.RELEASE_USE_ITEM
+                    ) return; // don't cause a noslow
+
+                    event.setCancelled(true);
+                    player.onPacketCancel();
+                }
+            } else {
+                invalid++;
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (; invalid >= 1; invalid--) {
+                flagAndAlert();
+            }
+        }
+
+        invalid = 0;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderG.java

@@ -0,0 +1,66 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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.DiggingAction;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClientStatus;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+
+@CheckData(name = "PacketOrderG", experimental = true)
+public class PacketOrderG extends AbstractPostPredictionCheck {
+    public PacketOrderG(GrimPlayer player) {
+        super(player);
+    }
+
+    private int invalid;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING
+                || (event.getPacketType() == PacketType.Play.Client.CLIENT_STATUS
+                && new WrapperPlayClientClientStatus(event).getAction() == WrapperPlayClientClientStatus.Action.OPEN_INVENTORY_ACHIEVEMENT)
+        ) {
+            if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING) {
+                final DiggingAction action = new WrapperPlayClientPlayerDigging(event).getAction();
+                if (action == DiggingAction.RELEASE_USE_ITEM
+                        || action == DiggingAction.START_DIGGING
+                        || action == DiggingAction.CANCELLED_DIGGING
+                        || action == DiggingAction.FINISHED_DIGGING
+                ) return;
+            }
+
+            if (player.packetOrderProcessor.isAttacking()
+                    || player.packetOrderProcessor.isReleasing()
+                    || player.packetOrderProcessor.isRightClicking()
+                    || player.packetOrderProcessor.isPicking()
+                    || player.packetOrderProcessor.isDigging()
+            ) {
+                if (!player.canSkipTicks()) {
+                    if (flagAndAlert() && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    invalid++;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (; invalid >= 1; invalid--) {
+                flagAndAlert();
+            }
+        }
+
+        invalid = 0;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderH.java

@@ -0,0 +1,61 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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 = "PacketOrderH", experimental = true)
+public class PacketOrderH extends AbstractPostPredictionCheck {
+    public PacketOrderH(final GrimPlayer player) {
+        super(player);
+    }
+
+    private int invalid;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
+            switch (new WrapperPlayClientEntityAction(event).getAction()) {
+                case START_SPRINTING:
+                case STOP_SPRINTING:
+                    if (player.getClientVersion().isOlderThan(ClientVersion.V_1_21_2) && player.packetOrderProcessor.isSneaking()) {
+                        if (!player.canSkipTicks()) {
+                            flagAndAlert();
+                        } else {
+                            invalid++;
+                        }
+                    }
+                    break;
+
+                case START_SNEAKING:
+                case STOP_SNEAKING:
+                    if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_2) && player.packetOrderProcessor.isSprinting()) {
+                        if (!player.canSkipTicks()) {
+                            flagAndAlert();
+                        } else {
+                            invalid++;
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (; invalid >= 1; invalid--) {
+                flagAndAlert();
+            }
+        }
+
+        invalid = 0;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderI.java

@@ -0,0 +1,131 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.api.config.ConfigManager;
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
+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.GameMode;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+
+import java.util.ArrayDeque;
+
+@CheckData(name = "PacketOrderI", experimental = true)
+public class PacketOrderI extends AbstractPostPredictionCheck {
+    public PacketOrderI(final GrimPlayer player) {
+        super(player);
+    }
+
+    private boolean exemptPlacingWhileDigging;
+
+    private boolean setback;
+    private boolean digging; // for placing
+    private final ArrayDeque<String> flags = new ArrayDeque<>();
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            if (new WrapperPlayClientInteractEntity(event).getAction() == WrapperPlayClientInteractEntity.InteractAction.ATTACK) {
+                if (player.packetOrderProcessor.isRightClicking() || player.packetOrderProcessor.isPicking() || player.packetOrderProcessor.isReleasing() || player.packetOrderProcessor.isDigging()) {
+                    if (!player.canSkipTicks()) {
+                        if (flagAndAlert("attack") && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    } else {
+                        flags.add("attack");
+                    }
+                }
+            } else if (player.packetOrderProcessor.isReleasing() || player.packetOrderProcessor.isDigging()) {
+                if (!player.canSkipTicks()) {
+                    if (flagAndAlert("interact") && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    flags.add("interact");
+                }
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT || event.getPacketType() == PacketType.Play.Client.USE_ITEM) {
+            if (player.packetOrderProcessor.isReleasing() || digging) {
+                if (!player.canSkipTicks()) {
+                    if (flagAndAlert("place/use") && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    flags.add("place");
+                }
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING) {
+            WrapperPlayClientPlayerDigging packet = new WrapperPlayClientPlayerDigging(event);
+
+            switch (packet.getAction()) {
+                case RELEASE_USE_ITEM:
+                    if (player.packetOrderProcessor.isAttacking() || player.packetOrderProcessor.isRightClicking() || player.packetOrderProcessor.isPicking() || player.packetOrderProcessor.isDigging()) {
+                        if (!player.canSkipTicks()) {
+                            if (flagAndAlert("release")) {
+                                setback = true;
+                            }
+                        } else {
+                            flags.add("release");
+                            setback = true;
+                        }
+                    }
+                    break;
+                case START_DIGGING:
+                    double damage = BlockBreakSpeed.getBlockDamage(player, packet.getBlockPosition());
+                    if (damage >= 1 || damage <= 0 && player.gamemode == GameMode.CREATIVE) {
+                        return;
+                    }
+                case CANCELLED_DIGGING:
+                case FINISHED_DIGGING:
+                    if (exemptPlacingWhileDigging || player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_7_10)) {
+                        return;
+                    }
+                    digging = true;
+            }
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            digging = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) {
+            if (setback) {
+                setbackIfAboveSetbackVL();
+                setback = false;
+            }
+            return;
+        }
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (String verbose : flags) {
+                if (flagAndAlert(verbose) && setback) {
+                    setbackIfAboveSetbackVL();
+                    setback = false;
+                }
+            }
+        }
+
+        flags.clear();
+        setback = false;
+    }
+
+    @Override
+    public void onReload(ConfigManager config) {
+        exemptPlacingWhileDigging = config.getBooleanElse(getConfigName() + ".exempt-placing-while-digging", false);
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderJ.java

@@ -0,0 +1,46 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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;
+
+@CheckData(name = "PacketOrderJ", experimental = true)
+public class PacketOrderJ extends AbstractPostPredictionCheck {
+    public PacketOrderJ(final GrimPlayer player) {
+        super(player);
+    }
+
+    private int invalid;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT || event.getPacketType() == PacketType.Play.Client.USE_ITEM) {
+            if (player.packetOrderProcessor.isAttacking() && !player.packetOrderProcessor.isInteracting()) {
+                if (!player.canSkipTicks()) {
+                    if (flagAndAlert() && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    invalid++;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (; invalid >= 1; invalid--) {
+                flagAndAlert();
+            }
+        }
+
+        invalid = 0;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderK.java

@@ -0,0 +1,61 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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.WrapperPlayClientClientStatus;
+
+import java.util.ArrayDeque;
+
+@CheckData(name = "PacketOrderK", experimental = true)
+public class PacketOrderK extends AbstractPostPredictionCheck {
+    public PacketOrderK(final GrimPlayer player) {
+        super(player);
+    }
+
+    private final ArrayDeque<String> flags = new ArrayDeque<>();
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CLIENT_STATUS) {
+            if (new WrapperPlayClientClientStatus(event).getAction() == WrapperPlayClientClientStatus.Action.OPEN_INVENTORY_ACHIEVEMENT) {
+                if (player.packetOrderProcessor.isClickingInInventory() || player.packetOrderProcessor.isClosingInventory()) {
+                    if (!player.canSkipTicks()) {
+                        flagAndAlert("open");
+                    } else {
+                        flags.add("open");
+                    }
+                }
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW || event.getPacketType() == PacketType.Play.Client.CLOSE_WINDOW) {
+            if (player.packetOrderProcessor.isOpeningInventory()) {
+                if (!player.canSkipTicks()) {
+                    if (flagAndAlert(event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW ? "click" : "close") && shouldModifyPackets()) {
+                        event.setCancelled(true);
+                        player.onPacketCancel();
+                    }
+                } else {
+                    flags.add(event.getPacketType() == PacketType.Play.Client.CLICK_WINDOW ? "click" : "close");
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderL.java

@@ -0,0 +1,68 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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.DiggingAction;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientClientStatus;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
+
+import java.util.ArrayDeque;
+
+@CheckData(name = "PacketOrderL", experimental = true)
+public class PacketOrderL extends AbstractPostPredictionCheck {
+    public PacketOrderL(final GrimPlayer player) {
+        super(player);
+    }
+
+    private final ArrayDeque<String> flags = new ArrayDeque<>();
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.CLIENT_STATUS) {
+            if (new WrapperPlayClientClientStatus(event).getAction() == WrapperPlayClientClientStatus.Action.OPEN_INVENTORY_ACHIEVEMENT) {
+                if (player.packetOrderProcessor.isDropping()) {
+                    if (!player.canSkipTicks()) {
+                        if (flagAndAlert("inventory") && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    } else {
+                        flags.add("inventory");
+                    }
+                }
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.PLAYER_DIGGING) {
+            if (new WrapperPlayClientPlayerDigging(event).getAction() == DiggingAction.SWAP_ITEM_WITH_OFFHAND) {
+                if (player.packetOrderProcessor.isDropping()) {
+                    if (!player.canSkipTicks()) {
+                        if (flagAndAlert("swap") && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    } else {
+                        flags.add("swap");
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (String verbose : flags) {
+                flagAndAlert(verbose);
+            }
+        }
+
+        flags.clear();
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderM.java

@@ -0,0 +1,67 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
+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.world.BlockFace;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerBlockPlacement;
+
+@CheckData(name = "PacketOrderM", experimental = true)
+public class PacketOrderM extends AbstractPostPredictionCheck {
+    public PacketOrderM(final GrimPlayer player) {
+        super(player);
+    }
+
+    private int invalid;
+    private boolean usingWithoutInteract, interacting;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
+            if (new WrapperPlayClientInteractEntity(event).getAction() != WrapperPlayClientInteractEntity.InteractAction.ATTACK) {
+                interacting = true;
+                if (usingWithoutInteract) {
+                    if (!player.canSkipTicks()) {
+                        if (flagAndAlert() && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    } else {
+                        invalid++;
+                    }
+                }
+            }
+        }
+
+        if (event.getPacketType() == PacketType.Play.Client.USE_ITEM
+                || event.getPacketType() == PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT
+                && new WrapperPlayClientPlayerBlockPlacement(event).getFace() == BlockFace.OTHER) {
+            if (!interacting) {
+                usingWithoutInteract = true;
+            }
+
+            interacting = false;
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            usingWithoutInteract = interacting = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (; invalid >= 1; invalid--) {
+                flagAndAlert();
+            }
+        }
+
+        invalid = 0;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderN.java

@@ -0,0 +1,65 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+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.world.BlockFace;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerBlockPlacement;
+
+@CheckData(name = "PacketOrderN", experimental = true)
+public class PacketOrderN extends BlockPlaceCheck {
+    public PacketOrderN(final GrimPlayer player) {
+        super(player);
+    }
+
+    private int invalid;
+    private boolean usingWithoutPlacing, placing;
+
+    @Override
+    public void onBlockPlace(BlockPlace place) {
+        placing = true;
+        if (usingWithoutPlacing) {
+            if (!player.canSkipTicks()) {
+                if (flagAndAlert() && shouldModifyPackets() && shouldCancel()) {
+                    place.resync();
+                }
+            } else {
+                invalid++;
+            }
+        }
+    }
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.USE_ITEM
+                || event.getPacketType() == PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT
+                && new WrapperPlayClientPlayerBlockPlacement(event).getFace() == BlockFace.OTHER) {
+            if (!placing) {
+                usingWithoutPlacing = true;
+            }
+
+            placing = false;
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            usingWithoutPlacing = placing = false;
+        }
+    }
+
+    @Override
+    public void onPredictionComplete(PredictionComplete predictionComplete) {
+        if (!player.canSkipTicks()) return;
+
+        if (player.isTickingReliablyFor(3) && !player.uncertaintyHandler.lastVehicleSwitch.hasOccurredSince(0)) {
+            for (; invalid >= 1; invalid--) {
+                flagAndAlert();
+            }
+        }
+
+        invalid = 0;
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderO.java

@@ -0,0 +1,61 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.InteractionHand;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity.InteractAction;
+
+@CheckData(name = "PacketOrderO", experimental = true)
+public class PacketOrderO extends AbstractPacketCheck {
+    public PacketOrderO(final GrimPlayer player) {
+        super(player);
+    }
+
+    private boolean sentMainhand;
+    private int requiredEntity;
+    private boolean requiredSneaking;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9)) {
+            final WrapperPlayClientInteractEntity packet = new WrapperPlayClientInteractEntity(event);
+            InteractAction action = packet.getAction();
+            if (action != InteractAction.ATTACK) {
+                final boolean sneaking = packet.isSneaking().orElse(false);
+                final int entity = packet.getEntityId();
+
+                if (packet.getHand() == InteractionHand.OFF_HAND) {
+                    if (action == InteractAction.INTERACT) {
+                        if (!sentMainhand) {
+                            if (flagAndAlert("Skipped Mainhand") && shouldModifyPackets()) {
+                                event.setCancelled(true);
+                                player.onPacketCancel();
+                            }
+                        }
+                        sentMainhand = false;
+                    } else if (sneaking != requiredSneaking || entity != requiredEntity) {
+                        String verbose = "requiredEntity=" + requiredEntity + ", entity=" + entity
+                                + ", requiredSneaking=" + requiredSneaking + ", sneaking=" + sneaking;
+                        if (flagAndAlert(verbose) && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    }
+                } else {
+                    requiredEntity = entity;
+                    requiredSneaking = sneaking;
+                    sentMainhand = true;
+                }
+            }
+        }
+
+        if (isTickPacket(event.getPacketType())) {
+            sentMainhand = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderP.java

@@ -0,0 +1,62 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.CheckData;
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+import ac.grim.grimac.player.GrimPlayer;
+import com.github.retrooper.packetevents.event.PacketReceiveEvent;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.InteractionHand;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity.InteractAction;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
+
+@CheckData(name = "PacketOrderP", experimental = true)
+public class PacketOrderP extends AbstractPacketCheck {
+    public PacketOrderP(final GrimPlayer player) {
+        super(player);
+    }
+
+    private boolean sentMainhand;
+    private int requiredEntity;
+    private boolean requiredSneaking;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_9)) {
+            final WrapperPlayClientInteractEntity packet = new WrapperPlayClientInteractEntity(event);
+            InteractAction action = packet.getAction();
+            if (action != InteractAction.ATTACK) {
+                final boolean sneaking = packet.isSneaking().orElse(false);
+                final int entity = packet.getEntityId();
+
+                if (packet.getHand() == InteractionHand.OFF_HAND) {
+                    if (action == InteractAction.INTERACT) {
+                        if (!sentMainhand) {
+                            if (flagAndAlert("Skipped Mainhand") && shouldModifyPackets()) {
+                                event.setCancelled(true);
+                                player.onPacketCancel();
+                            }
+                        }
+                        sentMainhand = false;
+                    } else if (sneaking != requiredSneaking || entity != requiredEntity) {
+                        String verbose = "requiredEntity=" + requiredEntity + ", entity=" + entity
+                                + ", requiredSneaking=" + requiredSneaking + ", sneaking=" + sneaking;
+                        if (flagAndAlert(verbose) && shouldModifyPackets()) {
+                            event.setCancelled(true);
+                            player.onPacketCancel();
+                        }
+                    }
+                } else {
+                    requiredEntity = entity;
+                    requiredSneaking = sneaking;
+                    sentMainhand = true;
+                }
+            }
+        }
+
+        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType()) && !player.packetStateData.lastPacketWasTeleport && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate) {
+            sentMainhand = false;
+        }
+    }
+}

src/main/java/ac/grim/grimac/checks/impl/packetorder/PacketOrderProcessor.java

@@ -0,0 +1,164 @@
+package ac.grim.grimac.checks.impl.packetorder;
+
+import ac.grim.grimac.checks.type.abstracts.AbstractPacketCheck;
+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.protocol.world.BlockFace;
+import com.github.retrooper.packetevents.wrapper.play.client.*;
+import lombok.Getter;
+import org.jetbrains.annotations.Contract;
+
+@Getter
+public final class PacketOrderProcessor extends AbstractPacketCheck {
+    public PacketOrderProcessor(final GrimPlayer player) {
+        super(player);
+    }
+
+    private boolean openingInventory; // only pre 1.9 clients on pre 1.9 servers
+    private boolean swapping;
+    private boolean dropping;
+    private boolean interacting;
+    private boolean attacking;
+    private boolean releasing;
+    private boolean digging;
+    private boolean sprinting;
+    private boolean sneaking;
+    private boolean placing;
+    private boolean using;
+    private boolean picking;
+    private boolean clickingInInventory;
+    private boolean closingInventory;
+    private boolean quickMoveClicking;
+    private boolean pickUpClicking;
+    private boolean leavingBed;
+    private boolean startingToGlide;
+    private boolean jumpingWithMount;
+
+    @Override
+    public void onPacketReceive(PacketReceiveEvent event) {
+        final PacketTypeCommon packetType = event.getPacketType();
+
+        if (packetType == PacketType.Play.Client.CLIENT_STATUS) {
+            if (new WrapperPlayClientClientStatus(event).getAction() == WrapperPlayClientClientStatus.Action.OPEN_INVENTORY_ACHIEVEMENT) {
+                openingInventory = true;
+            }
+        }
+
+        if (packetType == PacketType.Play.Client.INTERACT_ENTITY) {
+            if (new WrapperPlayClientInteractEntity(event).getAction() == WrapperPlayClientInteractEntity.InteractAction.ATTACK) {
+                attacking = true;
+            } else {
+                interacting = true;
+            }
+        }
+
+        if (packetType == PacketType.Play.Client.PLAYER_DIGGING) {
+            switch (new WrapperPlayClientPlayerDigging(event).getAction()) {
+                case SWAP_ITEM_WITH_OFFHAND:
+                    swapping = true;
+                    break;
+                case DROP_ITEM:
+                case DROP_ITEM_STACK:
+                    dropping = true;
+                    break;
+                case RELEASE_USE_ITEM:
+                    releasing = true;
+                    break;
+                case FINISHED_DIGGING:
+                case CANCELLED_DIGGING:
+                case START_DIGGING:
+                    digging = true;
+                    break;
+            }
+        }
+
+        if (packetType == PacketType.Play.Client.ENTITY_ACTION) {
+            switch (new WrapperPlayClientEntityAction(event).getAction()) {
+                case START_SPRINTING:
+                case STOP_SPRINTING:
+                    sprinting = true;
+                    break;
+                case STOP_SNEAKING:
+                case START_SNEAKING:
+                    sneaking = true;
+                    break;
+                case LEAVE_BED:
+                    leavingBed = true;
+                    break;
+                case START_FLYING_WITH_ELYTRA:
+                    startingToGlide = true;
+                    break;
+                case OPEN_HORSE_INVENTORY:
+                    openingInventory = true;
+                    break;
+                case START_JUMPING_WITH_HORSE:
+                case STOP_JUMPING_WITH_HORSE:
+                    jumpingWithMount = true;
+                    break;
+            }
+        }
+
+        if (packetType == PacketType.Play.Client.USE_ITEM) {
+            using = true;
+        }
+
+        if (packetType == PacketType.Play.Client.PLAYER_BLOCK_PLACEMENT) {
+            if (new WrapperPlayClientPlayerBlockPlacement(event).getFace() == BlockFace.OTHER) {
+                using = true;
+            } else {
+                placing = true;
+            }
+        }
+
+        if (packetType == PacketType.Play.Client.PICK_ITEM) {
+            picking = true;
+        }
+
+        if (packetType == PacketType.Play.Client.CLICK_WINDOW) {
+            clickingInInventory = true;
+
+            switch (new WrapperPlayClientClickWindow(event).getWindowClickType()) {
+                case QUICK_MOVE:
+                    quickMoveClicking = true;
+                    break;
+                case PICKUP:
+                case PICKUP_ALL:
+                    pickUpClicking = true;
+                    break;
+            }
+        }
+
+        if (packetType == PacketType.Play.Client.CLOSE_WINDOW) {
+            closingInventory = true;
+        }
+
+        if (isTickPacket(packetType)) {
+            openingInventory = false;
+            swapping = false;
+            dropping = false;
+            attacking = false;
+            interacting = false;
+            releasing = false;
+            digging = false;
+            placing = false;
+            using = false;
+            picking = false;
+            sprinting = false;
+            sneaking = false;
+            clickingInInventory = false;
+            closingInventory = false;
+            quickMoveClicking = false;
+            pickUpClicking = false;
+            leavingBed = false;
+            startingToGlide = false;
+            jumpingWithMount = false;
+        }
+    }
+
+    @Contract(pure = true)
+    public boolean isRightClicking() {
+        return placing || using || interacting;
+    }
+}

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

@@ -0,0 +1 @@
+

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

@@ -1,9 +1,10 @@
 package ac.grim.grimac.checks.impl.post;
 
+import ac.grim.grimac.api.CheckType;
 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.checks.type.interfaces.PacketCheckI;
+import ac.grim.grimac.checks.type.interfaces.PostPredictionCheckI;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
 import ac.grim.grimac.utils.lists.EvictingQueue;
@@ -24,7 +25,7 @@ import java.util.Locale;
 import static com.github.retrooper.packetevents.protocol.packettype.PacketType.Play.Client.*;
 
 @CheckData(name = "Post")
-public class Post extends Check implements PacketCheck, PostPredictionCheck {
+public class Post extends Check implements PacketCheckI, PostPredictionCheckI {
     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
@@ -103,4 +104,9 @@ public class Post extends Check implements PacketCheck, PostPredictionCheck {
             }
         }
     }
+
+    @Override
+    public int getMask() {
+        return CheckType.POST_PREDICTION.getMask();
+    }
 }

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

@@ -1,8 +1,7 @@
 package ac.grim.grimac.checks.impl.prediction;
 
-import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.LogUtil;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
@@ -16,7 +15,7 @@ import java.util.Set;
 import java.util.concurrent.CopyOnWriteArraySet;
 
 @CheckData(name = "Prediction (Debug)")
-public class DebugHandler extends Check implements PostPredictionCheck {
+public class DebugHandler extends AbstractPostPredictionCheck {
 
     Set<Player> listeners = new CopyOnWriteArraySet<>(new HashSet<>());
     boolean outputToConsole = false;

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

@@ -1,8 +1,7 @@
 package ac.grim.grimac.checks.impl.prediction;
 
-import ac.grim.grimac.checks.Check;
 import ac.grim.grimac.checks.CheckData;
-import ac.grim.grimac.checks.type.PostPredictionCheck;
+import ac.grim.grimac.checks.type.abstracts.AbstractPostPredictionCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.update.PredictionComplete;
 import com.github.retrooper.packetevents.PacketEvents;
@@ -10,7 +9,7 @@ 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 {
+public class NoFallB extends AbstractPostPredictionCheck {
 
     public NoFallB(GrimPlayer player) {
         super(player);