Merge remote-tracking branch 'origin/2.0' into simd-upstream

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

build.gradle.kts

@@ -143,6 +143,16 @@ bukkit {
             description = "Exempt from all checks"
             default = Permission.Default.FALSE
         }
+
+        register("grim.verbose") {
+            description = "Receive verbose alerts for violations. Requires grim.alerts"
+            default = Permission.Default.OP
+        }
+
+        register("grim.verbose.enable-on-join") {
+            description = "Enable verbose alerts on join. Requires grim.alerts and grim.alerts.enable-on-join"
+            default = Permission.Default.FALSE
+        }
     }
 }
 

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

@@ -8,6 +8,8 @@
 import ac.grim.grimac.utils.common.ConfigReloadObserver;
 import com.github.retrooper.packetevents.protocol.packettype.PacketType;
 import com.github.retrooper.packetevents.protocol.packettype.PacketTypeCommon;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 import io.github.retrooper.packetevents.util.folia.FoliaScheduler;
 import lombok.Getter;
 import lombok.Setter;
@@ -150,6 +152,39 @@ public boolean isTransaction(PacketTypeCommon packetType) {
                 packetType == PacketType.Play.Client.WINDOW_CONFIRMATION;
     }
 
+    public boolean isFlying(PacketTypeCommon packetType) {
+        return WrapperPlayClientPlayerFlying.isFlying(packetType);
+    }
+
+    public boolean isUpdate(PacketTypeCommon packetType) {
+        return isFlying(packetType)
+                || packetType == PacketType.Play.Client.CLIENT_TICK_END
+                || isTransaction(packetType);
+    }
+
+    public boolean isTickPacket(PacketTypeCommon packetType) {
+        if (isTickPacketIncludingNonMovement(packetType)) {
+            if (isFlying(packetType)) {
+                return !player.packetStateData.lastPacketWasTeleport && !player.packetStateData.lastPacketWasOnePointSeventeenDuplicate;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    public boolean isTickPacketIncludingNonMovement(PacketTypeCommon packetType) {
+        // On 1.21.2+ fall back to the TICK_END packet IF the player did not send a movement packet for their tick
+        // TickTimer checks to see if player did not send a tick end packet before new flying packet is sent
+        if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_2)
+                && !player.packetStateData.didSendMovementBeforeTickEnd) {
+            if (packetType == PacketType.Play.Client.CLIENT_TICK_END) {
+                return true;
+            }
+        }
+
+        return isFlying(packetType);
+    }
+
     @Override
     public void reload() {
         reload(GrimAPI.INSTANCE.getConfigManager().getConfig());

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

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

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

@@ -10,39 +10,44 @@
 
 @CheckData(name = "BadPacketsG")
 public class BadPacketsG extends Check implements PacketCheck {
-    boolean wasTeleport;
-    boolean lastSneaking;
+    private boolean lastSneaking, respawn;
 
     public BadPacketsG(GrimPlayer player) {
         super(player);
     }
 
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
-        wasTeleport = player.packetStateData.lastPacketWasTeleport || wasTeleport;
-
         if (event.getPacketType() == PacketType.Play.Client.ENTITY_ACTION) {
             WrapperPlayClientEntityAction packet = new WrapperPlayClientEntityAction(event);
 
             if (packet.getAction() == WrapperPlayClientEntityAction.Action.START_SNEAKING) {
-                if (lastSneaking && !wasTeleport) {
+                // The player may send two START_SNEAKING packets if they respawned
+                if (lastSneaking && !respawn) {
                     if (flagAndAlert("state=true") && shouldModifyPackets()) {
                         event.setCancelled(true);
                         player.onPacketCancel();
                     }
                 } else {
                     lastSneaking = true;
                 }
+                respawn = false;
             } else if (packet.getAction() == WrapperPlayClientEntityAction.Action.STOP_SNEAKING) {
-                if (!lastSneaking && !wasTeleport) {
+                if (!lastSneaking && !respawn) {
                     if (flagAndAlert("state=false") && shouldModifyPackets()) {
                         event.setCancelled(true);
                         player.onPacketCancel();
                     }
                 } else {
                     lastSneaking = false;
                 }
+                respawn = false;
             }
         }
     }
+
+    public void handleRespawn() {
+        // Clients could potentially not send a STOP_SNEAKING packet when they die, so we need to track it
+        respawn = true;
+    }
 }

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

@@ -43,7 +43,7 @@ public void onPacketReceive(PacketReceiveEvent event) {
             if (player.getClientVersion().isOlderThan(ClientVersion.V_1_9)
                     && PacketEvents.getAPI().getServerManager().getVersion().isNewerThan(ServerVersion.V_1_8)) return;
 
-            if (!sentAnimation && flagAndAlert()) {
+            if (!sentAnimation && flagAndAlert() && shouldModifyPackets()) {
                 event.setCancelled(true);
                 player.onPacketCancel();
             }

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

@@ -41,9 +41,8 @@ public void onPacketReceive(final PacketReceiveEvent event) {
         if ((event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION ||
                 event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION) && !player.compensatedEntities.getSelf().inVehicle()) {
             positions++;
-        } else if ((event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE ||
-                event.getPacketType() == PacketType.Play.Client.VEHICLE_MOVE)
-                && player.compensatedEntities.getSelf().inVehicle()) {
+        } else if ((event.getPacketType() == PacketType.Play.Client.STEER_VEHICLE || event.getPacketType() == PacketType.Play.Client.VEHICLE_MOVE)
+                && player.inVehicle()) {
             positions++;
         }
     }

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

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

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

@@ -5,13 +5,12 @@
 import ac.grim.grimac.checks.type.PacketCheck;
 import ac.grim.grimac.player.GrimPlayer;
 import ac.grim.grimac.utils.anticheat.MessageUtil;
+import ac.grim.grimac.utils.anticheat.update.BlockBreak;
 import com.github.retrooper.packetevents.PacketEvents;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
 import com.github.retrooper.packetevents.manager.server.ServerVersion;
 import com.github.retrooper.packetevents.protocol.player.ClientVersion;
 import com.github.retrooper.packetevents.protocol.player.DiggingAction;
 import com.github.retrooper.packetevents.util.Vector3i;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerDigging;
 
 import static ac.grim.grimac.events.packets.patch.ResyncWorldUtil.resyncPosition;
 import static ac.grim.grimac.utils.nmsutil.BlockBreakSpeed.getBlockDamage;
@@ -40,18 +39,18 @@ private boolean shouldExempt(final Vector3i pos) {
         return player.getClientVersion().isOlderThan(ClientVersion.V_1_14_4) || getBlockDamage(player, pos) < 1;
     }
 
-    public void handle(PacketReceiveEvent event, WrapperPlayClientPlayerDigging dig) {
-        if (dig.getAction() == DiggingAction.START_DIGGING) {
-            final Vector3i pos = dig.getBlockPosition();
+    public void handle(BlockBreak blockBreak) {
+        if (blockBreak.action == DiggingAction.START_DIGGING) {
+            final Vector3i pos = blockBreak.position;
 
             lastBlockWasInstantBreak = getBlockDamage(player, pos) >= 1;
             lastCancelledBlock = null;
             lastLastBlock = lastBlock;
             lastBlock = pos;
         }
 
-        if (dig.getAction() == DiggingAction.CANCELLED_DIGGING) {
-            final Vector3i pos = dig.getBlockPosition();
+        if (blockBreak.action == DiggingAction.CANCELLED_DIGGING) {
+            final Vector3i pos = blockBreak.position;
 
             if (shouldExempt(pos)) {
                 lastCancelledBlock = pos;
@@ -65,8 +64,7 @@ public void handle(PacketReceiveEvent event, WrapperPlayClientPlayerDigging dig)
                 if (player.getClientVersion().isOlderThan(ClientVersion.V_1_14_4) || (!lastBlockWasInstantBreak && pos.equals(lastCancelledBlock))) {
                     if (flagAndAlert("action=CANCELLED_DIGGING" + ", last=" + MessageUtil.toUnlabledString(lastBlock) + ", pos=" + MessageUtil.toUnlabledString(pos))) {
                         if (shouldModifyPackets()) {
-                            event.setCancelled(true);
-                            player.onPacketCancel();
+                            blockBreak.cancel();
                             resyncPosition(player, pos);
                         }
                     }
@@ -79,15 +77,14 @@ public void handle(PacketReceiveEvent event, WrapperPlayClientPlayerDigging dig)
             return;
         }
 
-        if (dig.getAction() == DiggingAction.FINISHED_DIGGING) {
-            final Vector3i pos = dig.getBlockPosition();
+        if (blockBreak.action == DiggingAction.FINISHED_DIGGING) {
+            final Vector3i pos = blockBreak.position;
 
             // when a player looks away from the mined block, they send a cancel, and if they look at it again, they don't send another start. (thanks mojang!)
             if (!pos.equals(lastCancelledBlock) && (!lastBlockWasInstantBreak || player.getClientVersion().isOlderThan(ClientVersion.V_1_14_4)) && !pos.equals(lastBlock)) {
                 if (flagAndAlert("action=FINISHED_DIGGING" + ", last=" + MessageUtil.toUnlabledString(lastBlock) + ", pos=" + MessageUtil.toUnlabledString(pos))) {
                     if (shouldModifyPackets()) {
-                        event.setCancelled(true);
-                        player.onPacketCancel();
+                        blockBreak.cancel();
                         resyncPosition(player, pos);
                     }
                 }

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

@@ -34,7 +34,6 @@
 import com.github.retrooper.packetevents.protocol.player.GameMode;
 import com.github.retrooper.packetevents.util.Vector3d;
 import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
-import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerFlying;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import ac.grim.grimac.utils.vector.Vector3D;
@@ -111,9 +110,7 @@ public void onPacketReceive(final PacketReceiveEvent event) {
         }
 
         // If the player set their look, or we know they have a new tick
-        if (WrapperPlayClientPlayerFlying.isFlying(event.getPacketType()) ||
-                event.getPacketType() == PacketType.Play.Client.PONG ||
-                event.getPacketType() == PacketType.Play.Client.WINDOW_CONFIRMATION) {
+        if (isUpdate(event.getPacketType())) {
             tickBetterReachCheckWithAngle();
         }
     }

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

@@ -17,7 +17,7 @@ public ExploitC(GrimPlayer playerData) {
     @Override
     public void onPacketReceive(PacketReceiveEvent event) {
         if (event.getPacketType() == PacketType.Play.Client.EDIT_BOOK) {
-            final var title = new WrapperPlayClientEditBook(event).getTitle();
+            final String title = new WrapperPlayClientEditBook(event).getTitle();
 
             if (title == null) return; // book was not signed
 

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

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