Some API additions

protocolize-api/src/main/java/dev/simplix/protocolize/api/listener/AbstractPacketEvent.java

@@ -0,0 +1,49 @@
+package dev.simplix.protocolize.api.listener;
+
+import dev.simplix.protocolize.api.player.ProtocolizePlayer;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+
+/**
+ * This class is containing information about the packet event.
+ * <br><br>
+ * Date: 19.11.2023
+ *
+ * @author Rubenicos
+ */
+@Getter
+@Setter
+@Accessors(fluent = true)
+@AllArgsConstructor
+@ToString
+public abstract class AbstractPacketEvent<T> {
+
+    protected final ProtocolizePlayer player;
+    protected final Object server;
+    protected T packet;
+    protected boolean cancelled;
+
+    /**
+     * The protocolize player instance.
+     *
+     * @return The player instance or null if Protocolize was unable to track down the player
+     * during early communication phases like HANDSHAKE or STATUS.
+     */
+    public ProtocolizePlayer player() {
+        return player;
+    }
+
+    /**
+     * The platform dependent server info instance.
+     *
+     * @param <S> The type of the server info
+     * @return The platform dependent server info instance or null if Protocolize was unable to track down the server
+     * during early communication phases like HANDSHAKE or STATUS.
+     */
+    public <S> S server() {
+        return (S) server;
+    }
+}

protocolize-api/src/main/java/dev/simplix/protocolize/api/listener/AbstractPacketListener.java

@@ -2,8 +2,11 @@
 
 import dev.simplix.protocolize.api.Direction;
 import lombok.Getter;
+import lombok.Setter;
 import lombok.experimental.Accessors;
 
+import java.util.function.Consumer;
+
 /**
  * Used for listening to incoming and outgoing packets.
  * <br><br>
@@ -13,13 +16,19 @@
  * @author Exceptionflug
  */
 @Getter
+@Setter
 @Accessors(fluent = true)
 public abstract class AbstractPacketListener<T> {
 
     private final Class<T> type;
     private final Direction direction;
     private final int priority;
 
+    private Consumer<PacketReceiveEvent<T>> onReceive;
+    private Consumer<PacketSendEvent<T>> onSend;
+
+    private transient boolean registered;
+
     /**
      * Creates an instance of your listener.
      *
@@ -38,13 +47,33 @@ protected AbstractPacketListener(Class<T> type, Direction direction, int priorit
      *
      * @param event The event containing information about the packet
      */
-    public abstract void packetReceive(PacketReceiveEvent<T> event);
+    public void packetReceive(PacketReceiveEvent<T> event) {
+        if (onReceive == null) {
+            packetEvent(event);
+        } else {
+            onReceive.accept(event);
+        }
+    }
 
     /**
      * Gets called when a packet has been processed by the Protocolize encoder handler.
      *
      * @param event The event containing information about the packet
      */
-    public abstract void packetSend(PacketSendEvent<T> event);
+    public void packetSend(PacketSendEvent<T> event) {
+        if (onSend == null) {
+            packetEvent(event);
+        } else {
+            onSend.accept(event);
+        }
+    }
 
+    /**
+     * Gets called when a packet has been processed by any Protocolize handler.
+     *
+     * @param event The event containing information about the packet
+     */
+    public void packetEvent(AbstractPacketEvent<T> event) {
+        // empty default method
+    }
 }

protocolize-api/src/main/java/dev/simplix/protocolize/api/listener/PacketReceiveEvent.java

@@ -1,7 +1,6 @@
 package dev.simplix.protocolize.api.listener;
 
 import dev.simplix.protocolize.api.player.ProtocolizePlayer;
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
@@ -17,35 +16,44 @@
 @Getter
 @Setter
 @Accessors(fluent = true)
-@AllArgsConstructor
 @ToString
-public class PacketReceiveEvent<T> {
+public class PacketReceiveEvent<T> extends AbstractPacketEvent<T> {
 
-    private final ProtocolizePlayer player;
-    private final Object server;
-    private T packet;
-    private boolean cancelled;
     private boolean dirty;
 
-    /**
-     * The platform {@link ProtocolizePlayer} instance.
-     *
-     * @return The player instance or null if Protocolize was unable to track down the player
-     * during early communication phases like HANDSHAKE or STATUS.
-     */
+    public PacketReceiveEvent(ProtocolizePlayer player, Object server, T packet, boolean cancelled, boolean dirty) {
+        super(player, server, packet, cancelled);
+        this.dirty = dirty;
+    }
+
+    @Override
     public ProtocolizePlayer player() {
-        return player;
+        return super.player();
     }
 
-    /**
-     * The platform dependent server info instance.
-     *
-     * @param <S> The type of the server info
-     * @return The platform dependent server info instance or null if Protocolize was unable to track down the server
-     * during early communication phases like HANDSHAKE or STATUS.
-     */
+    @Override
     public <S> S server() {
-        return (S) server;
+        return super.server();
+    }
+
+    @Override
+    public T packet() {
+        return super.packet();
+    }
+
+    @Override
+    public AbstractPacketEvent<T> packet(T packet) {
+        return super.packet(packet);
+    }
+
+    @Override
+    public boolean cancelled() {
+        return super.cancelled();
+    }
+
+    @Override
+    public AbstractPacketEvent<T> cancelled(boolean cancelled) {
+        return super.cancelled(cancelled);
     }
 
     /**

protocolize-api/src/main/java/dev/simplix/protocolize/api/listener/PacketSendEvent.java

@@ -1,7 +1,6 @@
 package dev.simplix.protocolize.api.listener;
 
 import dev.simplix.protocolize.api.player.ProtocolizePlayer;
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
@@ -17,34 +16,41 @@
 @Getter
 @Setter
 @Accessors(fluent = true)
-@AllArgsConstructor
 @ToString
-public class PacketSendEvent<T> {
+public class PacketSendEvent<T> extends AbstractPacketEvent<T> {
 
-    private final ProtocolizePlayer player;
-    private final Object server;
-    private T packet;
-    private boolean cancelled;
+    public PacketSendEvent(ProtocolizePlayer player, Object server, T packet, boolean cancelled) {
+        super(player, server, packet, cancelled);
+    }
 
-    /**
-     * The protocolize player instance.
-     *
-     * @return The player instance or null if Protocolize was unable to track down the player
-     * during early communication phases like HANDSHAKE or STATUS.
-     */
+    @Override
     public ProtocolizePlayer player() {
-        return player;
+        return super.player();
     }
 
-    /**
-     * The platform dependent server info instance.
-     *
-     * @param <S> The type of the server info
-     * @return The platform dependent server info instance or null if Protocolize was unable to track down the server
-     * during early communication phases like HANDSHAKE or STATUS.
-     */
+    @Override
     public <S> S server() {
-        return (S) server;
+        return super.server();
+    }
+
+    @Override
+    public T packet() {
+        return super.packet();
+    }
+
+    @Override
+    public AbstractPacketEvent<T> packet(T packet) {
+        return super.packet(packet);
+    }
+
+    @Override
+    public boolean cancelled() {
+        return super.cancelled();
+    }
+
+    @Override
+    public AbstractPacketEvent<T> cancelled(boolean cancelled) {
+        return super.cancelled(cancelled);
     }
 
     /**

protocolize-api/src/main/java/dev/simplix/protocolize/api/packet/RegisteredPacket.java

@@ -1,6 +1,7 @@
 package dev.simplix.protocolize.api.packet;
 
 import dev.simplix.protocolize.api.PacketDirection;
+import dev.simplix.protocolize.api.Protocol;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.experimental.Accessors;
@@ -15,6 +16,7 @@
 @Accessors(fluent = true)
 public class RegisteredPacket {
 
+    private final Protocol protocol;
     private final PacketDirection direction;
     private final Class<? extends AbstractPacket> packetClass;
 

protocolize-api/src/main/java/dev/simplix/protocolize/api/player/ProtocolizePlayer.java

@@ -1,9 +1,7 @@
 package dev.simplix.protocolize.api.player;
 
 import com.google.common.collect.Lists;
-import dev.simplix.protocolize.api.Location;
-import dev.simplix.protocolize.api.PlayerInteract;
-import dev.simplix.protocolize.api.SoundCategory;
+import dev.simplix.protocolize.api.*;
 import dev.simplix.protocolize.api.inventory.Inventory;
 import dev.simplix.protocolize.api.inventory.PlayerInventory;
 import dev.simplix.protocolize.api.item.BaseItemStack;
@@ -28,16 +26,28 @@ public interface ProtocolizePlayer {
 
     PlayerInventory proxyInventory();
 
-    void sendPacket(Object packet);
+    default void sendPacket(Object packet) {
+        sendPacket(packet, Protocol.PLAY);
+    }
+
+    void sendPacket(Object packet, Protocol protocol);
+
+    default void sendPacketToServer(Object packet) {
+        sendPacketToServer(packet, Protocol.PLAY);
+    }
 
-    void sendPacketToServer(Object packet);
+    void sendPacketToServer(Object packet, Protocol protocol);
 
     Map<Integer, Inventory> registeredInventories();
 
     int generateWindowId();
 
     int protocolVersion();
 
+    Protocol decodeProtocol();
+
+    Protocol encodeProtocol();
+
     <T> T handle();
 
     Location location();

protocolize-api/src/main/java/dev/simplix/protocolize/api/providers/AbstractPacketListenerProvider.java

@@ -0,0 +1,66 @@
+package dev.simplix.protocolize.api.providers;
+
+import com.google.common.base.Preconditions;
+import dev.simplix.protocolize.api.listener.AbstractPacketListener;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Date: 19.11.2023
+ *
+ * @author Rubenicos
+ */
+public abstract class AbstractPacketListenerProvider  implements PacketListenerProvider {
+
+    protected final List<AbstractPacketListener<?>> listeners = new ArrayList<>();
+
+    @Override
+    public <T, A extends AbstractPacketListener<T>> A register(A listener) {
+        Preconditions.checkNotNull(listener, "The listener cannot be null!");
+        if (listeners.contains(listener)) {
+            throw new IllegalStateException("Listener already registered.");
+        }
+        addListener(listener);
+        return listener;
+    }
+
+    protected void addListener(AbstractPacketListener<?> listener) {
+        listeners.add(listener);
+        listener.registered(true);
+    }
+
+    @Override
+    public <T, A extends AbstractPacketListener<T>> A unregister(A listener) throws IllegalArgumentException {
+        if (listeners.contains(listener)) {
+            listeners.remove(listener);
+            listener.registered(false);
+            return listener;
+        } else {
+            throw new IllegalArgumentException("Did not find " + listener.getClass().getName() + " as a registered listener");
+        }
+    }
+
+    @Override
+    public String debugInformation() {
+        StringBuilder builder = new StringBuilder("Generated export of " + getClass().getName() + ":\n\n");
+        for (AbstractPacketListener<?> listener : listeners) {
+            builder.append(" - ").append(listener.getClass().getName()).append(" listening for ")
+                .append(listener.type().getName()).append(" on ").append(listener.direction().name())
+                .append(" with priority ").append(listener.priority()).append("\n");
+        }
+        return builder.toString();
+    }
+
+    @Override
+    public List<AbstractPacketListener<?>> listenersForType(Class<?> clazz) {
+        Preconditions.checkNotNull(clazz, "The clazz cannot be null!");
+        List<AbstractPacketListener<?>> out = new ArrayList<>();
+        for (AbstractPacketListener<?> listener : listeners) {
+            if (listener.type().equals(clazz)) {
+                out.add(listener);
+            }
+        }
+        return out;
+    }
+}