refactor: packet event types

Author: emyfops

common/src/main/java/com/lambda/mixin/ClientConnectionMixin.java

@@ -6,7 +6,9 @@
 import io.netty.channel.ChannelHandlerContext;
 import net.minecraft.network.ClientConnection;
 import net.minecraft.network.NetworkSide;
+import net.minecraft.network.listener.ClientPacketListener;
 import net.minecraft.network.listener.PacketListener;
+import net.minecraft.network.listener.ServerPacketListener;
 import net.minecraft.network.packet.Packet;
 import net.minecraft.network.packet.c2s.handshake.ConnectionIntent;
 import net.minecraft.text.Text;
@@ -25,14 +27,14 @@ public class ClientConnectionMixin {
 
     @Inject(method = "send(Lnet/minecraft/network/packet/Packet;)V", at = @At("HEAD"), cancellable = true)
     private void sendingPacket(Packet<?> packet, final CallbackInfo callbackInfo) {
-        if (EventFlow.post(new PacketEvent.Send.Pre(packet)).isCanceled()) {
+        if (EventFlow.post(new PacketEvent.Send.Pre((Packet<ServerPacketListener>) packet)).isCanceled()) {
             callbackInfo.cancel();
         }
     }
 
     @Inject(method = "send(Lnet/minecraft/network/packet/Packet;)V", at = @At("RETURN"))
     private void sendingPacketPost(Packet<?> packet, final CallbackInfo callbackInfo) {
-        EventFlow.post(new PacketEvent.Send.Post(packet));
+        EventFlow.post(new PacketEvent.Send.Post((Packet<ServerPacketListener>) packet));
     }
 
     @Inject(method = "channelRead0(Lio/netty/channel/ChannelHandlerContext;Lnet/minecraft/network/packet/Packet;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/ClientConnection;handlePacket(Lnet/minecraft/network/packet/Packet;Lnet/minecraft/network/listener/PacketListener;)V", shift = At.Shift.BEFORE), cancellable = true, require = 1)
@@ -42,7 +44,7 @@ private void receivingPacket(
             CallbackInfo callbackInfo
     ) {
         if (side != NetworkSide.CLIENTBOUND) return;
-        if (EventFlow.post(new PacketEvent.Receive.Pre(packet)).isCanceled()) {
+        if (EventFlow.post(new PacketEvent.Receive.Pre((Packet<ClientPacketListener>) packet)).isCanceled()) {
             callbackInfo.cancel();
         }
     }
@@ -55,7 +57,7 @@ private void receivingPacketPost(
     ) {
         if (side != NetworkSide.CLIENTBOUND) return;
 
-        EventFlow.post(new PacketEvent.Receive.Post(packet));
+        EventFlow.post(new PacketEvent.Receive.Post((Packet<ClientPacketListener>) packet));
     }
 
     @Inject(method = "connect(Ljava/lang/String;ILnet/minecraft/network/listener/PacketListener;Lnet/minecraft/network/packet/c2s/handshake/ConnectionIntent;)V", at = @At("HEAD"))

common/src/main/kotlin/com/lambda/event/events/PacketEvent.kt

@@ -6,13 +6,15 @@ import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
 import com.lambda.event.events.PacketEvent.Receive
 import com.lambda.event.events.PacketEvent.Send
+import net.minecraft.network.listener.ClientPacketListener
+import net.minecraft.network.listener.ServerPacketListener
 import net.minecraft.network.packet.Packet
 
 /**
  * An abstract class representing a [PacketEvent] in the [EventFlow].
  *
  * A [PacketEvent] is a type of [Event] that is triggered when a packet is sent or received.
- * It has two subclasses: [Send] and [Receive],
+ * It has two sealed subclasses: [Send] and [Receive],
  * which are triggered when a packet is sent and received, respectively.
  *
  * Each subclass has two further subclasses: `Pre` and `Post`,
@@ -25,20 +27,42 @@ import net.minecraft.network.packet.Packet
  */
 abstract class PacketEvent : Event {
     /**
-     * Representing a [PacketEvent] that is triggered when a packet is sent.
+     * Represents a [PacketEvent] that is triggered when a packet is sent.
      * It has two subclasses: [Pre] and [Post], which are triggered before and after the packet is sent.
      */
-    abstract class Send : PacketEvent() {
-        class Pre(val packet: Packet<*>) : Send(), ICancellable by Cancellable()
-        class Post(val packet: Packet<*>) : Send()
+    sealed class Send : PacketEvent() {
+        /**
+         * Represents the event triggered before a packet is sent.
+         *
+         * @param packet the packet that is about to be sent.
+         */
+        class Pre(val packet: Packet<out ServerPacketListener>) : Send(), ICancellable by Cancellable()
+
+        /**
+         * Represents the event triggered after a packet is sent.
+         *
+         * @param packet the packet that has been sent.
+         */
+        class Post(val packet: Packet<out ServerPacketListener>) : Send()
     }
 
     /**
-     * Representing a `PacketEvent` that is triggered when a packet is received.
+     * Represents a [PacketEvent] that is triggered when a packet is received.
      * It has two subclasses: [Pre] and [Post], which are triggered before and after the packet is received.
      */
-    abstract class Receive : PacketEvent() {
-        class Pre(val packet: Packet<*>) : Receive(), ICancellable by Cancellable()
-        class Post(val packet: Packet<*>) : Receive()
+    sealed class Receive : PacketEvent() {
+        /**
+         * Represents the event triggered before a packet is received.
+         *
+         * @param packet the packet that is about to be received.
+         */
+        class Pre(val packet: Packet<out ClientPacketListener>) : Receive(), ICancellable by Cancellable()
+
+        /**
+         * Represents the event triggered after a packet is received.
+         *
+         * @param packet the packet that has been received.
+         */
+        class Post(val packet: Packet<out ClientPacketListener>) : Receive()
     }
 }

common/src/main/kotlin/com/lambda/module/modules/movement/Blink.kt

@@ -10,9 +10,10 @@ import com.lambda.module.Module
 import com.lambda.module.modules.client.GuiSettings
 import com.lambda.module.modules.combat.KillAura
 import com.lambda.module.tag.ModuleTag
+import com.lambda.util.PacketUtils.handlePacketSilently
 import com.lambda.util.PacketUtils.sendPacketSilently
 import com.lambda.util.math.ColorUtils.setAlpha
-import net.minecraft.network.ClientConnection
+import net.minecraft.network.listener.ServerPacketListener
 import net.minecraft.network.packet.Packet
 import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket
 import net.minecraft.network.packet.s2c.play.EntityVelocityUpdateS2CPacket
@@ -31,7 +32,7 @@ object Blink : Module(
 
     private val isActive get() = (KillAura.isEnabled && KillAura.target != null) || !requiresAura
 
-    private var packetPool = ConcurrentLinkedDeque<Packet<*>>()
+    private var packetPool = ConcurrentLinkedDeque<Packet<out ServerPacketListener>>()
     private var lastVelocity: EntityVelocityUpdateS2CPacket? = null
     private var lastUpdate = 0L
 
@@ -64,8 +65,6 @@ object Blink : Module(
 
         listener<PacketEvent.Receive.Pre> { event ->
             if (!isActive || !shiftVelocity) return@listener
-            if (!connection.connection.isOpen) return@listener
-            if (connection.connection.packetListener?.accepts(event.packet) == false) return@listener
 
             if (event.packet !is EntityVelocityUpdateS2CPacket) return@listener
             if (event.packet.id != player.id) return@listener
@@ -84,7 +83,6 @@ object Blink : Module(
         while (packetPool.isNotEmpty()) {
             packetPool.poll().let { packet ->
                 connection.sendPacketSilently(packet)
-                connection.connection.packetsSentCounter++
 
                 if (packet is PlayerMoveC2SPacket && packet.changesPosition()) {
                     lastBox = player.boundingBox
@@ -95,8 +93,7 @@ object Blink : Module(
         }
 
         lastVelocity?.let { velocity ->
-            ClientConnection.handlePacket(velocity, connection.connection.packetListener)
-            connection.connection.packetsReceivedCounter++
+            connection.handlePacketSilently(velocity)
             lastVelocity = null
         }
     }

common/src/main/kotlin/com/lambda/util/PacketUtils.kt

@@ -1,10 +1,37 @@
 package com.lambda.util
 
 import net.minecraft.client.network.ClientPlayNetworkHandler
+import net.minecraft.network.ClientConnection
+import net.minecraft.network.listener.ClientPacketListener
+import net.minecraft.network.listener.ServerPacketListener
 import net.minecraft.network.packet.Packet
 
 object PacketUtils {
-    fun ClientPlayNetworkHandler.sendPacketSilently(packet: Packet<*>) {
+    /**
+     * Sends a packet to the server without notifying the client.
+     * It bypasses the mixins that would normally intercept the packet
+     * and send it through the client's event bus.
+     *
+     * @param packet The packet to send.
+     */
+    fun ClientPlayNetworkHandler.sendPacketSilently(packet: Packet<out ServerPacketListener>) {
+        if (!connection.isOpen) return
         connection.send(packet, null, true)
+        connection.packetsSentCounter++
     }
-}
+
+    /**
+     * Handles a packet without notifying the client.
+     * It bypasses the mixins that would normally intercept the packet
+     * and send it through the client's event bus.
+     *
+     * @param packet The packet to handle.
+     */
+    fun ClientPlayNetworkHandler.handlePacketSilently(packet: Packet<out ClientPacketListener>) {
+        if (!connection.isOpen) return
+        if (connection.packetListener?.accepts(packet) == false) return
+
+        ClientConnection.handlePacket(packet, connection.packetListener)
+        connection.packetsReceivedCounter++
+    }
+}