Restarted development

Author: IllusionTheDev

1_13/build.gradle

@@ -1,67 +1,55 @@
-package me.illusion.skyblockcore.shared.packet;
+package me.illusion.skyblockcore.common.communication.packet;
 
 import com.google.common.io.ByteArrayDataInput;
 import com.google.common.io.ByteArrayDataOutput;
 import com.google.common.io.ByteStreams;
-import lombok.SneakyThrows;
-import me.illusion.skyblockcore.shared.packet.data.PacketDirection;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.chat.ComponentSerializer;
-
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInput;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.util.UUID;
+import lombok.SneakyThrows;
 
 public abstract class Packet {
 
     private final byte identifier;
-    private final PacketDirection direction;
+    private final UUID uuid;
 
     private ByteArrayDataOutput stream;
     private ByteArrayDataInput input;
 
     public Packet(byte[] bytes) {
         input = ByteStreams.newDataInput(bytes);
         identifier = readByte();
-        direction = PacketDirection.fromIndex(readByte());
-
+        uuid = readUUID();
     }
 
-    public Packet(PacketDirection direction) {
-
+    public Packet() {
         this.identifier = PacketManager.getIdentifier(getClass());
-        this.direction = direction;
+        this.uuid = UUID.randomUUID();
 
         validateStream();
         writeByte(identifier);
-        writeByte(direction.getIndex());
+        writeUUID(uuid);
     }
 
-    public abstract void write();
-
     protected byte getIdentifier() {
         return identifier;
     }
 
-    protected PacketDirection getDirection() {
-        return direction;
-    }
-
     private void validateStream() {
-        if (stream == null)
+        if (stream == null) {
             stream = ByteStreams.newDataOutput();
-    }
-
-    protected void writeBoolean(boolean value) {
-        validateStream();
-        stream.writeBoolean(value);
+        }
     }
 
     protected void writeByte(byte value) {
         validateStream();
         stream.writeByte(value);
     }
 
-    protected void writeByteArray(byte... bytes) {
+    protected void writeByteArray(byte[] bytes) {
         validateStream();
         writeInt(bytes.length);
         stream.write(bytes);
@@ -107,28 +95,21 @@ protected void writeUUID(UUID uuid) {
         writeLong(uuid.getLeastSignificantBits());
     }
 
-    protected void writeBungeeText(BaseComponent... text) {
-        writeString(ComponentSerializer.toString(text));
-    }
-
-
     @SneakyThrows
     protected void writeObject(Object object) {
         validateStream();
-        try (ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(bos)) {
+        try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
+            ObjectOutputStream out = new ObjectOutputStream(bos);
             out.writeObject(object);
             out.flush();
             byte[] bytes = bos.toByteArray();
             writeByteArray(bytes);
+            out.close();
         }
         // ignore close exception
     }
 
 
-    protected boolean readBoolean() {
-        return input.readBoolean();
-    }
-
     protected byte readByte() {
         return input.readByte();
     }
@@ -137,8 +118,9 @@ protected byte[] readByteArray() {
         int arraySize = readInt();
         byte[] array = new byte[arraySize];
 
-        for (int index = 0; index < arraySize; index++)
+        for (int index = 0; index < arraySize; index++) {
             array[index] = readByte();
+        }
 
         return array;
     }
@@ -163,15 +145,13 @@ protected UUID readUUID() {
         return new UUID(readLong(), readLong());
     }
 
-    protected BaseComponent[] readBungeeText() {
-        return ComponentSerializer.parse(readString());
-    }
 
     @SneakyThrows
     protected Object readObject() {
         byte[] bytes = readByteArray();
 
-        try (ByteArrayInputStream bis = new ByteArrayInputStream(bytes); ObjectInput in = new ObjectInputStream(bis)) {
+        try (ByteArrayInputStream bis = new ByteArrayInputStream(
+            bytes); ObjectInput in = new ObjectInputStream(bis)) {
             return in.readObject();
         }
 
@@ -181,4 +161,8 @@ protected Object readObject() {
     public byte[] getAllBytes() {
         return stream.toByteArray();
     }
+
+    public UUID getPacketId() {
+        return uuid;
+    }
 }

1_13/src/main/java/me/illusion/skyblockcore/v1_13/LocationGrabber.java

@@ -1,4 +1,4 @@
-package me.illusion.skyblockcore.shared.packet;
+package me.illusion.skyblockcore.common.communication.packet;
 
 public interface PacketHandler<T extends Packet> {
 

src/main/java/me/illusion/skyblockcore/shared/packet/Packet.java SkyblockCore-Common/src/main/java/me/illusion/skyblockcore/common/communication/packet/Packet.java

@@ -0,0 +1,147 @@
+package me.illusion.skyblockcore.common.communication.packet;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+
+public class PacketManager {
+
+
+    private static final Map<Byte, Class<? extends Packet>> identifiers = new HashMap<>();
+    private final List<PacketProcessor> processors = new ArrayList<>();
+    private final Map<Byte, List<PacketHandler<Packet>>> handlers = new HashMap<>();
+
+    private final Cache<UUID, Boolean> ignoredPackets = CacheBuilder.newBuilder()
+        .expireAfterWrite(5, TimeUnit.SECONDS)
+        .build();
+
+    private final PacketWaiter waiter;
+
+    public PacketManager() {
+        waiter = new PacketWaiter(this);
+
+
+    }
+
+    public static void registerPacket(int packetId, Class<? extends Packet> packetClass) {
+        registerPacket((byte) packetId, packetClass);
+    }
+
+    public static void registerPacket(byte packetId, Class<? extends Packet> packetClass) {
+        if (identifiers.containsKey(packetId)) {
+            throw new UnsupportedOperationException(
+                "Packet identifier for packet " + packetClass.getSimpleName()
+                    + " is already registered. ");
+        }
+
+        identifiers.put(packetId, packetClass);
+    }
+
+
+    public static byte getIdentifier(Class<? extends Packet> clazz) {
+        for (Map.Entry<Byte, Class<? extends Packet>> entry : identifiers.entrySet()) {
+            if (clazz.equals(entry.getValue())) {
+                return entry.getKey();
+            }
+        }
+
+        // If it isn't registered, just register it.
+        registerPacket(identifiers.size(), clazz);
+
+        return getIdentifier(clazz);
+    }
+
+    public Class<? extends Packet> getPacketClass(byte identifier) {
+        return identifiers.get(identifier);
+    }
+
+    public void registerProcessor(PacketProcessor processor) {
+        processors.add(processor);
+        processor.addCallback(this::read);
+    }
+
+    public CompletableFuture<Void> send(Packet packet) {
+
+        ignoredPackets.put(packet.getPacketId(), true);
+
+        Set<CompletableFuture<Void>> futures = new HashSet<>();
+
+        try {
+            for (PacketProcessor processor : processors) {
+                futures.add(processor.send(packet));
+            }
+
+            byte id = packet.getIdentifier();
+            List<PacketHandler<Packet>> handler = handlers.get(id);
+
+            if (handler == null) {
+                System.out.println("No handlers for packet " + packet.getClass().getSimpleName() + " " + id);
+                return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
+            }
+
+            for (PacketHandler<Packet> packetHandler : handler) {
+                packetHandler.onSend(packet);
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
+    }
+
+    public Packet read(byte[] bytes) {
+        Class<? extends Packet> type = getPacketClass(bytes[0]);
+
+        if (type == null) {
+            return null;
+        }
+
+        try {
+            Packet packet = type.getConstructor(byte[].class).newInstance(bytes);
+
+            UUID packetId = packet.getPacketId();
+
+            if (ignoredPackets.getIfPresent(packetId) != null) {
+                ignoredPackets.invalidate(packetId);
+                return null;
+            }
+
+            List<PacketHandler<Packet>> handler = handlers.get(bytes[0]);
+
+            if (handler != null) {
+                for (PacketHandler<Packet> packetHandler : handler) {
+                    packetHandler.onReceive(packet);
+                }
+            }
+
+            return packet;
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException |
+                 NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public <T extends Packet> void subscribe(Class<T> packetClass, PacketHandler<T> handler) {
+        byte identifier = getIdentifier(packetClass);
+
+        handlers.putIfAbsent(identifier, new ArrayList<>());
+        handlers.get(identifier).add((PacketHandler<Packet>) handler);
+    }
+
+    public <T extends Packet> CompletableFuture<T> await(Class<T> clazz, Predicate<T> predicate) {
+        return waiter.await(clazz, predicate);
+    }
+}

src/main/java/me/illusion/skyblockcore/shared/packet/PacketHandler.java SkyblockCore-Common/src/main/java/me/illusion/skyblockcore/common/communication/packet/PacketHandler.java

@@ -0,0 +1,13 @@
+package me.illusion.skyblockcore.common.communication.packet;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+
+public interface PacketProcessor {
+
+    CompletableFuture<Void> send(Packet packet);
+
+    void addCallback(Consumer<byte[]> receivedPacket);
+
+
+}