Protocol rewamp from A-Z

gradle.properties

@@ -38,4 +38,6 @@ deploy.imanityLibraries = true
 
 # Minecraft
 adventure.version = 4.9.3
-netty.version = 4.1.69.Final
+netty.version = 4.1.69.Final
+packetevents.v1.version = v1.8-pre-19
+packetevents.v2.version = 2.0-SNAPSHOT

io.fairyproject.modules/platform.mc/module.protocol/.gitignore

@@ -0,0 +1 @@
+/build/

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/.gitignore

@@ -0,0 +1 @@
+/build/

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/build.gradle

@@ -0,0 +1,17 @@
+version = "0.0.1b1"
+
+dependencies {
+    api 'com.github.retrooper.packetevents:spigot:' + findProperty("packetevents.v2.version")
+    api 'com.github.artemisac.artemis-packet-api:spigot:2.0.0-beta-2'
+    api 'com.github.retrooper:packetevents:' + findProperty("packetevents.v1.version")
+
+    compileOnly "io.netty:netty-all:" + findProperty("netty.version")
+    compileOnly project.spigot()
+}
+
+module {
+    platform("mc")
+
+    depend("platform.mc:module.protocol:mc-protocol")
+    depend("module.config")
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/PacketBuilder.java

@@ -0,0 +1,4 @@
+package io.fairyproject.bukkit.protocol;
+
+public interface PacketBuilder<T, W> extends PacketFactoryCreator<T>, PacketFactoryWrapper<T, W> {
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/PacketFactoryCreator.java

@@ -0,0 +1,7 @@
+package io.fairyproject.bukkit.protocol;
+
+public interface PacketFactoryCreator<W> {
+    default W createEmpty() {
+            throw new IllegalStateException("Not Implemented.");
+        }
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/PacketFactoryWrapper.java

@@ -0,0 +1,7 @@
+package io.fairyproject.bukkit.protocol;
+
+import io.fairyproject.mc.MCPlayer;
+
+public interface PacketFactoryWrapper<T, W> {
+    T wrap(final W typeObj, final MCPlayer player);
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/PacketManager.java

@@ -0,0 +1,62 @@
+package io.fairyproject.bukkit.protocol;
+
+import io.fairyproject.bukkit.protocol.packet.packetevents.v2.PacketEventsV2Provider;
+import io.fairyproject.bukkit.protocol.provider.AbstractPacketProviderFactory;
+import io.fairyproject.container.PreInitialize;
+import io.fairyproject.container.Service;
+import io.fairyproject.library.Library;
+import io.fairyproject.mc.MCPlayer;
+import io.fairyproject.mc.protocol.netty.buffer.FairyByteBuf;
+import io.fairyproject.mc.protocol.InternalBufferListener;
+import io.fairyproject.mc.protocol.packet.Packet;
+import io.fairyproject.mc.protocol.InternalPacketListener;
+import io.fairyproject.mc.protocol.PacketProvider;
+import lombok.Getter;
+
+@Service
+public class PacketManager {
+    @Getter
+    private PacketProvider provider;
+
+    @PreInitialize
+    public void load() {
+        Library.builder()
+                .groupId("com.github.retrooper.packetevents")
+                .artifactId("spigot")
+                .version()
+        provider = new AbstractPacketProviderFactory() {
+                @Override
+                public PacketProvider build() {
+                    this.verify();
+
+                    return new PacketEventsV2Provider(packetListener, lowLevelPacketListener);
+                }}
+                .setPacketListener(new InternalPacketListener() {
+                    @Override
+                    public boolean onPacket(MCPlayer data, Packet packet) {
+                        // TODO: Handle logic
+
+                        return false;
+                    }
+                })
+                .setLowLevelPacketListener(new InternalBufferListener() {
+                    @Override
+                    public boolean handle(MCPlayer data, FairyByteBuf byteBuf) {
+                        // TODO: Handle logic
+
+                        return false;
+                    }
+                })
+                .build();
+
+        provider.load();
+    }
+
+    public void init() {
+        provider.init();
+    }
+
+    public void end() {
+        provider.quit();
+    }
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/PacketMap.java

@@ -0,0 +1,11 @@
+package io.fairyproject.bukkit.protocol;
+
+import io.fairyproject.bukkit.protocol.packet.PacketWrapper;
+import io.fairyproject.mc.MCPlayer;
+import io.fairyproject.mc.protocol.packet.Packet;
+
+public interface PacketMap<W, I> {
+    <T extends PacketWrapper<K>, K extends W> Packet wrap(MCPlayer player, I id, W obj);
+
+    void inject();
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/ProtocolConfiguration.java

@@ -0,0 +1,23 @@
+package io.fairyproject.bukkit.protocol;
+
+import io.fairyproject.Fairy;
+import io.fairyproject.config.annotation.Comment;
+import io.fairyproject.config.yaml.YamlConfiguration;
+import lombok.Getter;
+
+import java.io.File;
+import java.nio.file.Path;
+
+@Getter
+public class ProtocolConfiguration extends YamlConfiguration {
+    public ProtocolConfiguration() {
+        super(new File(Fairy.getPlatform().getDataFolder(), "modules/protocol/yml").toPath());
+    }
+
+    @Comment({
+            "PacketEvents v1 configuration"
+    })
+
+
+
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/packet/AbstractPacketMapping.java

@@ -0,0 +1,75 @@
+package io.fairyproject.bukkit.protocol.packet;
+
+import io.fairyproject.bukkit.protocol.PacketBuilder;
+import io.fairyproject.bukkit.protocol.PacketFactoryCreator;
+import io.fairyproject.bukkit.protocol.PacketFactoryWrapper;
+import io.fairyproject.bukkit.protocol.PacketMap;
+import io.fairyproject.mc.MCPlayer;
+import io.fairyproject.mc.protocol.packet.Packet;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class AbstractPacketMapping<W, I> implements PacketMap<W, I> {
+    private final Map<I, PacketFactoryWrapper<?, ?>> idToBuilders = new HashMap<>();
+    private final Map<Class<? extends PacketWrapper<? extends W>>, PacketBuilder<? extends Packet, ? extends W>>  classToBuilders = new HashMap<>();
+
+    protected <T extends PacketWrapper<K>, K extends W> PacketFactory<T, K> create(final I id, final Class<T> clazz) {
+        return new PacketFactory<T, K>(id, clazz);
+    }
+
+    protected <T extends PacketWrapper<K>, K extends W> void create(final I id, Class<T> clazz, PacketBuilder<T, K> generator) {
+        new PacketFactory<T, K>(id, clazz).create(generator);
+    }
+
+    @Override
+    public <T extends PacketWrapper<K>, K extends W> Packet wrap(MCPlayer player, I id, W obj) {
+        final PacketBuilder<T, K> factory = (PacketBuilder<T, K>) idToBuilders.get(id);
+        return factory.wrap((K) obj, player);
+    }
+
+    class PacketFactory<T extends PacketWrapper<K>, K extends W> {
+        private final I id;
+        private final Class<T> wrapperType;
+
+        public PacketFactory(I id, Class<T> wrapperType) {
+            this.id = id;
+            this.wrapperType = wrapperType;
+        }
+
+        private PacketFactoryCreator<T> creator;
+        private PacketFactoryWrapper<T, K> wrapper;
+
+        public PacketFactory<T, K> creator(PacketFactoryCreator<T> creator) {
+            this.creator = creator;
+            return this;
+        }
+
+        public PacketFactory<T, K> wrapper(PacketFactoryWrapper<T, K> wrapper) {
+            this.wrapper = wrapper;
+            return this;
+        }
+
+        public void create() {
+            final PacketBuilder<T, K> builder = new PacketBuilder<T, K>() {
+                @Override
+                public T createEmpty() {
+                    return creator.createEmpty();
+                }
+
+                @Override
+                public T wrap(K typeObj, MCPlayer player) {
+                    return wrapper.wrap(typeObj, player);
+                }
+            };
+
+            create(builder);
+        }
+
+        public void create(final PacketBuilder<T, K> builder) {
+            idToBuilders.put(id, builder);
+            classToBuilders.put(wrapperType, builder);
+        }
+    }
+
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/packet/PacketWrapper.java

@@ -0,0 +1,20 @@
+package io.fairyproject.bukkit.protocol.packet;
+
+import io.fairyproject.mc.MCPlayer;
+import io.fairyproject.mc.MCPlayer;
+import io.fairyproject.mc.protocol.packet.Packet;
+
+public abstract class PacketWrapper<T> implements Packet {
+    protected T wrapper;
+    protected MCPlayer player;
+
+    public PacketWrapper(T wrapper, MCPlayer player) {
+        this.wrapper = wrapper;
+        this.player = player;
+    }
+
+    @Override
+    public io.fairyproject.mc.MCPlayer getPlayer() {
+        return player;
+    }
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/packet/artemispacketapi/ArtemisPacketWrapper.java

@@ -0,0 +1,11 @@
+package io.fairyproject.bukkit.protocol.packet.artemispacketapi;
+
+import io.fairyproject.bukkit.protocol.packet.PacketWrapper;
+import io.fairyproject.mc.MCPlayer;
+import io.fairyproject.mc.MCPlayer;
+
+public abstract class ArtemisPacketWrapper<T> extends PacketWrapper<T> {
+    public ArtemisPacketWrapper(T wrapper, MCPlayer channel) {
+        super(wrapper, channel);
+    }
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/packet/artemispacketapi/PacketArtemisProvider.java

@@ -0,0 +1,72 @@
+package io.fairyproject.bukkit.protocol.packet.artemispacketapi;
+
+import io.fairyproject.bukkit.FairyBukkitPlatform;
+import io.fairyproject.bukkit.protocol.packet.artemispacketapi.netty.ArtemisChannel;
+import io.fairyproject.bukkit.protocol.packet.artemispacketapi.translate.ArtemisPacketTranslationHelper;
+import io.fairyproject.bukkit.protocol.packet.packetevents.v1.injector.PacketEventsInjector;
+import io.fairyproject.mc.MCPlayer;
+import io.fairyproject.mc.protocol.InternalBufferListener;
+import io.fairyproject.mc.protocol.packet.Packet;
+import io.fairyproject.mc.protocol.InternalPacketListener;
+import io.fairyproject.mc.protocol.PacketProvider;
+import ac.artemis.packet.profile.Profile;
+import ac.artemis.packet.spigot.wrappers.GPacket;
+import cc.ghast.packet.PacketAPI;
+import cc.ghast.packet.PacketManager;
+import cc.ghast.packet.utils.Pair;
+
+import java.util.UUID;
+
+public class PacketArtemisProvider extends PacketProvider  {
+    public PacketArtemisProvider(InternalPacketListener highListener, InternalBufferListener lowListener) {
+        super(highListener, lowListener, new PacketEventsInjector());
+    }
+
+    @Override
+    public void load() {
+        // Do nothing
+    }
+
+    @Override
+    public void init() {
+        if (PacketManager.INSTANCE.getApi() == null) {
+            PacketManager.INSTANCE.init(FairyBukkitPlatform.PLUGIN);
+        }
+
+        PacketAPI.addListener(new ac.artemis.packet.PacketListener() {
+            @Override
+            public void onPacket(Profile profile, ac.artemis.packet.wrapper.Packet wrapper) {
+                final MCPlayer data = MCPlayer.find(profile.getUuid());
+
+                if (data == null) {
+                    return;
+                }
+
+                final Packet packet = ArtemisPacketTranslationHelper.PACKET.transform(new Pair<>(profile, (GPacket) wrapper));
+
+                if (packet == null)
+                    return;
+
+                final UUID uuid = profile.getUuid();
+
+                if (!injectQueue.isEmpty() && injectQueue.contains(uuid)) {
+                    injector.inject(data, new ArtemisChannel(packet.getPlayer().getChannel()), lowListener);
+                    injectQueue.remove(uuid);
+                }
+
+                final boolean cancel = highListener.onPacket(data, packet);
+                ((GPacket) wrapper).setCancelled(cancel);
+            }
+        });
+    }
+
+    @Override
+    public void quit() {
+        PacketManager.INSTANCE.destroy();
+    }
+
+    @Override
+    public void inject(MCPlayer data) {
+        injectQueue.add(data.getUUID());
+    }
+}

io.fairyproject.modules/platform.mc/module.protocol/bukkit-protocol/src/main/java/io/fairyproject/bukkit/protocol/packet/artemispacketapi/netty/ArtemisBuffer.java

@@ -0,0 +1,56 @@
+package io.fairyproject.bukkit.protocol.packet.artemispacketapi.netty;
+
+import cc.ghast.packet.wrapper.netty.MutableByteBuf;
+import io.fairyproject.mc.protocol.netty.buffer.FairyByteBuf;
+
+public class ArtemisBuffer implements FairyByteBuf {
+    private final MutableByteBuf byteBuf;
+
+    public ArtemisBuffer(MutableByteBuf byteBuf) {
+        this.byteBuf = byteBuf;
+    }
+
+    @Override
+    public int getSize() {
+        return byteBuf.readableBytes();
+    }
+
+    @Override
+    public byte[] getData() {
+        byte[] bytes = new byte[byteBuf.readableBytes()];
+        int readerIndex = byteBuf.readerIndex();
+        byteBuf.getBytes(readerIndex, bytes);
+
+        return bytes;
+    }
+
+    @Override
+    public int getReferenceCount() {
+        return byteBuf.refCnt();
+    }
+
+    @Override
+    public boolean isReadable() {
+        return byteBuf.isReadable();
+    }
+
+    @Override
+    public boolean isWriteable() {
+        return byteBuf.isWritable();
+    }
+
+    @Override
+    public int getReaderIndex() {
+        return byteBuf.readerIndex();
+    }
+
+    @Override
+    public void release() {
+        byteBuf.release();
+    }
+
+    @Override
+    public void clear() {
+        byteBuf.clear();
+    }
+}