Add vanilla PM support

Author: dries-c

PMUtils.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace libproxy;
+
+use Exception;
+use pocketmine\network\mcpe\convert\TypeConverter;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
+use pocketmine\network\mcpe\PacketBroadcaster;
+use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
+use pocketmine\network\mcpe\raklib\RakLibInterface;
+use pocketmine\Server;
+use ReflectionClass;
+use function method_exists;
+
+class PMUtils
+{
+    public static function getPacketSerializerContext(Server $server): PacketSerializerContext
+    {
+        if (method_exists($server, 'getPacketSerializerContext')) {
+            return $server->getPacketSerializerContext(TypeConverter::getInstance());
+        }
+
+        $packetSerializerContext = self::getRaklibInterfacePropertyValue($server, 'packetSerializerContext');
+        if ($packetSerializerContext instanceof PacketSerializerContext) {
+            return $packetSerializerContext;
+        }
+
+        throw new Exception("PacketSerializerContext isn't valid");
+    }
+
+    public static function getPacketBroadcaster(Server $server): PacketBroadcaster
+    {
+        if (method_exists($server, 'getPacketBroadcaster')) {
+            return $server->getPacketBroadcaster(self::getPacketSerializerContext($server));
+        }
+
+        $packetBroadcaster = self::getRaklibInterfacePropertyValue($server, 'packetBroadcaster');
+        if ($packetBroadcaster instanceof PacketBroadcaster) {
+            return $packetBroadcaster;
+        }
+
+        throw new Exception("PacketBroadcaster isn't valid");
+    }
+
+    public static function getEntityEventBroadcaster(Server $server): EntityEventBroadcaster
+    {
+        if (method_exists($server, 'getEntityEventBroadcaster')) {
+            return $server->getEntityEventBroadcaster(self::getPacketBroadcaster($server), TypeConverter::getInstance());
+        }
+
+        $entityEventBroadcaster = self::getRaklibInterfacePropertyValue($server, 'entityEventBroadcaster');
+        if ($entityEventBroadcaster instanceof EntityEventBroadcaster) {
+            return $entityEventBroadcaster;
+        }
+
+        throw new Exception("EntityEventBroadcaster isn't valid");
+    }
+
+    private static function getRaklibInterfacePropertyValue(Server $server, string $propertyName): mixed
+    {
+        $interface = self::getRaklibInterface($server);
+        $reflection = new ReflectionClass($interface);
+        $property = $reflection->getProperty($propertyName);
+
+        return $property->getValue($interface);
+    }
+
+    /**
+     * @throws Exception
+     */
+    private static function getRaklibInterface(Server $server): RakLibInterface
+    {
+        foreach ($server->getNetwork()->getInterfaces() as $interface) {
+            if ($interface instanceof RakLibInterface) {
+                return $interface;
+            }
+        }
+
+        throw new Exception("Raklib interface hasn't been registered");
+    }
+}

ProxyListener.php

@@ -39,12 +39,14 @@ public function onDataPacketReceive(DataPacketReceiveEvent $event): void
                 break;
             case RequestNetworkSettingsPacket::NETWORK_ID:
                 /** @var RequestNetworkSettingsPacket $packet USED TO SIMULATE VANILLA BEHAVIOUR, SINCE IT'S NOT USED BY US */
-                if (!in_array($protocolVersion = $packet->getProtocolVersion(), ProtocolInfo::ACCEPTED_PROTOCOL, true)) {
+                $multiProtocol = method_exists($origin, 'setProtocolId');
+
+                if (!in_array($protocolVersion = $packet->getProtocolVersion(), $multiProtocol ? ProtocolInfo::ACCEPTED_PROTOCOL : ProtocolInfo::CURRENT_PROTOCOL, true)) {
                     $origin->disconnectIncompatibleProtocol($protocolVersion);
                     return;
                 }
 
-                if (method_exists($origin, 'setProtocolId')) {
+                if ($multiProtocol) {
                     $origin->setProtocolId($packet->getProtocolVersion());
                 }
 

ProxyNetworkInterface.php

@@ -18,8 +18,11 @@
 use pmmp\thread\Thread as NativeThread;
 use pmmp\thread\ThreadSafeArray;
 use pocketmine\network\mcpe\convert\TypeConverter;
+use pocketmine\network\mcpe\EntityEventBroadcaster;
 use pocketmine\network\mcpe\NetworkSession;
+use pocketmine\network\mcpe\PacketBroadcaster;
 use pocketmine\network\mcpe\protocol\PacketPool;
+use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
 use pocketmine\network\mcpe\raklib\PthreadsChannelReader;
 use pocketmine\network\mcpe\raklib\PthreadsChannelWriter;
 use pocketmine\network\NetworkInterface;
@@ -67,6 +70,13 @@ final class ProxyNetworkInterface implements NetworkInterface
     /** @var PthreadsChannelReader */
     private PthreadsChannelReader $threadToMainReader;
 
+    /** @var PacketSerializerContext */
+    private PacketSerializerContext $packetSerializerContext;
+    /** @var PacketBroadcaster */
+    private PacketBroadcaster $packetBroadcaster;
+    /** @var EntityEventBroadcaster */
+    private EntityEventBroadcaster $entityEventBroadcaster;
+
     /** @var int */
     private int $receiveBytes = 0;
     /** @var int */
@@ -119,6 +129,10 @@ public function __construct(PluginBase $plugin, int $port, ?string $composerPath
         $this->mainToThreadWriter = new PthreadsChannelWriter($mainToThreadBuffer);
         $this->threadToMainReader = new PthreadsChannelReader($threadToMainBuffer);
 
+        $this->packetSerializerContext = PMUtils::getPacketSerializerContext($server);
+        $this->packetBroadcaster = PMUtils::getPacketBroadcaster($server);
+        $this->entityEventBroadcaster = PMUtils::getEntityEventBroadcaster($server);
+
         PacketPool::getInstance()->registerPacket(new TickSyncPacket());
 
         $bandwidthTracker = $plugin->getServer()->getNetwork()->getBandwidthTracker();
@@ -273,19 +287,14 @@ public function putPacket(int $socketId, ProxyPacket $pk): void
 
     public function createSession(int $socketId, string $ip, int $port): NetworkSession
     {
-        $typeConverter = TypeConverter::getInstance();
-        $packetSerializerContext = $this->server->getPacketSerializerContext($typeConverter);
-        $packetBroadcaster = $this->server->getPacketBroadcaster($packetSerializerContext);
-        $entityEventBroadcaster = $this->server->getEntityEventBroadcaster($packetBroadcaster, $typeConverter);
-
         $session = new NetworkSession(
             $this->server,
             $this->server->getNetwork()->getSessionManager(),
             PacketPool::getInstance(),
-            $packetSerializerContext,
+            $this->packetSerializerContext,
             new ProxyPacketSender($socketId, $this),
-            $packetBroadcaster,
-            $entityEventBroadcaster,
+            $this->packetBroadcaster,
+            $this->entityEventBroadcaster,
             MultiCompressor::getInstance(),
             TypeConverter::getInstance(),
             $ip,