Add support for initial inbound connections on velocity

Author: Exceptionflug

protocolize-velocity/src/main/java/dev/simplix/protocolize/velocity/player/InitialInboundConnectionProtocolizePlayer.java

@@ -0,0 +1,110 @@
+package dev.simplix.protocolize.velocity.player;
+
+import com.velocitypowered.proxy.connection.MinecraftConnection;
+import com.velocitypowered.proxy.connection.client.InitialInboundConnection;
+import dev.simplix.protocolize.api.*;
+import dev.simplix.protocolize.api.inventory.Inventory;
+import dev.simplix.protocolize.api.inventory.PlayerInventory;
+import dev.simplix.protocolize.api.packet.AbstractPacket;
+import dev.simplix.protocolize.api.player.ProtocolizePlayer;
+import dev.simplix.protocolize.api.providers.ProtocolRegistrationProvider;
+import dev.simplix.protocolize.velocity.packet.VelocityProtocolizePacket;
+import lombok.extern.slf4j.Slf4j;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+@Slf4j
+public class InitialInboundConnectionProtocolizePlayer implements ProtocolizePlayer {
+
+    private static final ProtocolRegistrationProvider REGISTRATION_PROVIDER = Protocolize.protocolRegistration();
+    private static Field connectionField;
+
+    static {
+        try {
+            connectionField = InitialInboundConnection.class.getDeclaredField("connection");
+            connectionField.setAccessible(true);
+        } catch (ReflectiveOperationException e) {
+            log.error("Unable to initialize InitialInboundConnectionProtocolizePlayer. Maybe your velocity version is unsupported.", e);
+        }
+    }
+
+    private final InitialInboundConnection connection;
+
+    public InitialInboundConnectionProtocolizePlayer(InitialInboundConnection connection) {
+        this.connection = connection;
+    }
+
+    @Override
+    public UUID uniqueId() {
+        throw new IllegalStateException("Not possible for initial inbound connections");
+    }
+
+    @Override
+    public PlayerInventory proxyInventory() {
+        throw new IllegalStateException("Not possible for initial inbound connections");
+    }
+
+    @Override
+    public void sendPacket(Object packet) {
+        if (packet instanceof AbstractPacket) {
+            VelocityProtocolizePacket pack = (VelocityProtocolizePacket) REGISTRATION_PROVIDER.createPacket((Class<? extends AbstractPacket>) packet.getClass(),
+                Protocol.STATUS, PacketDirection.CLIENTBOUND, protocolVersion());
+            if (pack == null) {
+                throw new IllegalStateException("Cannot send " + packet.getClass().getName() + " to players with protocol version " + protocolVersion());
+            }
+            pack.wrapper((AbstractPacket) packet);
+            packet = pack;
+        }
+        Object finalPacket = packet;
+        try {
+            MinecraftConnection minecraftConnection = (MinecraftConnection) connectionField.get(connection);
+            minecraftConnection.write(finalPacket);
+        } catch (IllegalAccessException e) {
+            log.error("Unable to send packet to InitialInboundConnectionProtocolizePlayer. Maybe your velocity version is unsupported.", e);
+        }
+    }
+
+    @Override
+    public void sendPacketToServer(Object packet) {
+        throw new IllegalStateException("Not possible for initial inbound connections");
+    }
+
+    @Override
+    public Map<Integer, Inventory> registeredInventories() {
+        return Collections.emptyMap();
+    }
+
+    @Override
+    public int generateWindowId() {
+        throw new IllegalStateException("Not possible for initial inbound connections");
+    }
+
+    @Override
+    public int protocolVersion() {
+        return connection.getProtocolVersion().getProtocol();
+    }
+
+    @Override
+    public <T> T handle() {
+        return (T) connection;
+    }
+
+    @Override
+    public Location location() {
+        throw new IllegalStateException("Not possible for initial inbound connections");
+    }
+
+    @Override
+    public void onInteract(Consumer<PlayerInteract> interactConsumer) {
+        throw new IllegalStateException("Not possible for initial inbound connections");
+    }
+
+    @Override
+    public void handleInteract(PlayerInteract interact) {
+        throw new IllegalStateException("Not possible for initial inbound connections");
+    }
+}

protocolize-velocity/src/main/java/dev/simplix/protocolize/velocity/providers/VelocityPacketListenerProvider.java

@@ -6,6 +6,7 @@
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ServerConnection;
 import com.velocitypowered.api.proxy.server.ServerInfo;
+import com.velocitypowered.proxy.connection.client.InitialInboundConnection;
 import com.velocitypowered.proxy.protocol.MinecraftPacket;
 import com.velocitypowered.proxy.protocol.StateRegistry;
 import dev.simplix.protocolize.api.Direction;
@@ -19,6 +20,7 @@
 import dev.simplix.protocolize.api.providers.ProtocolizePlayerProvider;
 import dev.simplix.protocolize.api.util.ReflectionUtil;
 import dev.simplix.protocolize.velocity.packet.VelocityProtocolizePacket;
+import dev.simplix.protocolize.velocity.player.InitialInboundConnectionProtocolizePlayer;
 import io.netty.util.collection.IntObjectMap;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
@@ -249,9 +251,16 @@ private PacketSendEvent<?> createSendEvent(InboundConnection connection, ServerC
             Player player = serverConnection.getPlayer();
             return new PacketSendEvent<>(player != null ? PLAYER_PROVIDER.player(player.getUniqueId()) : null, serverConnection.getServerInfo(), apiPacket, false);
         } else if (connection != null) {
-            Player player = (Player) connection;
-            ServerInfo info = player.getCurrentServer().isPresent() ? player.getCurrentServer().get().getServerInfo() : null;
-            return new PacketSendEvent<>(PLAYER_PROVIDER.player(player.getUniqueId()), info, apiPacket, false);
+            if (connection instanceof Player) {
+                Player player = (Player) connection;
+                ServerInfo info = player.getCurrentServer().isPresent() ? player.getCurrentServer().get().getServerInfo() : null;
+                return new PacketSendEvent<>(PLAYER_PROVIDER.player(player.getUniqueId()), info, apiPacket, false);
+            } else if (connection instanceof InitialInboundConnection) {
+                return new PacketSendEvent<>(new InitialInboundConnectionProtocolizePlayer((InitialInboundConnection) connection),
+                    null, apiPacket, false);
+            } else {
+                throw new IllegalArgumentException("Unsupported connection type: " + connection.getClass().getName());
+            }
         } else {
             return new PacketSendEvent<>(null, null, apiPacket, false);
         }