baltica 0.0.1 → 0.0.3

package/.github/workflows/publish.yml

@@ -0,0 +1,88 @@
+name: Publish and Release
+
+on:
+  push:
+    branches: 
+      - master
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+      - name: Install dependencies
+        run: npm install
+      - name: Run lint
+        run: npm run lint
+
+  build:
+    needs: [lint]    
+    permissions:
+      id-token: write
+      contents: read
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+      - name: Install dependencies
+        run: npm install
+      - name: Build
+        run: npm run build
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: |
+            dist/
+            package.json
+            package-lock.json
+
+  publish-and-release:
+    needs: [build]
+    permissions:
+      id-token: write
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+      - name: Check if package can be published
+        run: npm publish --dry-run --verbose
+      - name: Publish package
+        id: npm-publish
+        run: npm publish --access=public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Get version and Minecraft info
+        if: success()
+        id: package-info
+        run: |
+          echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT
+          echo "minecraft=$(node -p "require('./package.json').minecraft")" >> $GITHUB_OUTPUT
+      - name: Create Release
+        if: success()
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create v${{ steps.package-info.outputs.version }} \
+            --title "Release v${{ steps.package-info.outputs.version }} for Minecraft ${{ steps.package-info.outputs.minecraft }}" \
+            --notes "Release for Baltica v${{ steps.package-info.outputs.version }}
+            Compatible with Minecraft ${{ steps.package-info.outputs.minecraft }}" \
+            --target ${{ github.sha }}

package/dist/bridge/bridge-options.d.ts

@@ -4,19 +4,25 @@ import type { ClientCacheStatusPacket } from "../network/client-cache-status";
 import { type ServerOptions } from "../server/server-options";
 export type BridgePlayerEvents = {
     [K in PacketNames as `clientbound-${K}`]: [
-        packet: InstanceType<(typeof Protocol)[K]>
+        packet: InstanceType<(typeof Protocol)[K]>,
+        cancelled: boolean
     ];
 } & {
     [K in PacketNames as `serverbound-${K}`]: [
-        packet: InstanceType<(typeof Protocol)[K]>
+        packet: InstanceType<(typeof Protocol)[K]>,
+        cancelled: boolean
     ];
 } & {
-    "serverbound-ClientCacheStatusPacket": [packet: ClientCacheStatusPacket];
+    "serverbound-ClientCacheStatusPacket": [
+        packet: ClientCacheStatusPacket,
+        cancelled: boolean
+    ];
 };
 export type BridgeOptions = ServerOptions & {
     destination: {
         host: string;
         port: number;
     };
+    offline: boolean;
 };
 export declare const defaultBridgeOptions: BridgeOptions;

package/dist/bridge/bridge-options.js

@@ -8,4 +8,5 @@ exports.defaultBridgeOptions = {
         host: "127.0.0.1",
         port: 19132,
     },
+    offline: false,
 };

package/dist/bridge/bridge-player.d.ts

@@ -1,3 +1,4 @@
+import type { LevelChunkPacket } from "../network/level-chunk-packet";
 import type { Client } from "../client";
 import { Emitter } from "../libs";
 import type { Player } from "../server";
@@ -8,6 +9,8 @@ export declare class BridgePlayer extends Emitter<BridgePlayerEvents> {
     bridge: Bridge;
     client: Client;
     cacheStatus: boolean;
+    postStartGame: boolean;
+    levelChunkQueue: LevelChunkPacket[];
     constructor(bridge: Bridge, player: Player);
     prepare(): void;
     getClient(): Client;

package/dist/bridge/bridge-player.js

@@ -8,6 +8,20 @@ class BridgePlayer extends libs_1.Emitter {
         super();
         this.bridge = bridge;
         this.player = player;
+        this.postStartGame = false;
+        this.levelChunkQueue = [];
+        this.once("clientbound-StartGamePacket", (packet) => {
+            this.postStartGame = true;
+            for (const chunk of this.levelChunkQueue) {
+                const eventName = "clientbound-LevelChunkPacket";
+                this.emit(eventName, chunk, false);
+                if ("binary" in packet) {
+                    packet.binary = [];
+                }
+                const newBuffer = chunk.serialize();
+                this.player.send(newBuffer);
+            }
+        });
     }
     prepare() {
         this.player.connection.on("disconnect", () => {

package/dist/bridge/bridge.d.ts

@@ -10,6 +10,7 @@ export declare class Bridge extends Server {
     options: BridgeOptions;
     private clients;
     private packetClassCache;
+    private packetSerializationCache;
     private readonly debugLog;
     constructor(options?: Partial<BridgeOptions>);
     private initializePacketCache;

package/dist/bridge/bridge.js

@@ -1,19 +1,58 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bridge = void 0;
 const raknet_1 = require("@sanctumterra/raknet");
 const protocol_1 = require("@serenityjs/protocol");
+const Protocol = __importStar(require("@serenityjs/protocol"));
 const client_1 = require("../client");
 const client_cache_status_1 = require("../network/client-cache-status");
 const level_chunk_packet_1 = require("../network/level-chunk-packet");
 const server_1 = require("../server");
 const bridge_options_1 = require("./bridge-options");
 const bridge_player_1 = require("./bridge-player");
+const disconnect_1 = __importDefault(require("@sanctumterra/raknet/dist/proto/packets/disconnect"));
 class Bridge extends server_1.Server {
     constructor(options = {}) {
         super(options);
         this.clients = new Map();
         this.packetClassCache = new Map();
+        this.packetSerializationCache = new Map();
         this.debugLog = false;
         this.options = { ...bridge_options_1.defaultBridgeOptions, ...options };
         this.prepare();
@@ -22,39 +61,32 @@ class Bridge extends server_1.Server {
     initializePacketCache() {
         const CLIENT_CACHE_STATUS_ID = 129;
         this.packetClassCache.set(CLIENT_CACHE_STATUS_ID, client_cache_status_1.ClientCacheStatusPacket);
-        if ("id" in level_chunk_packet_1.LevelChunkPacket) {
-            const levelChunkId = level_chunk_packet_1.LevelChunkPacket.id;
+        const levelChunkId = level_chunk_packet_1.LevelChunkPacket.id;
+        if (levelChunkId !== undefined) {
             this.packetClassCache.set(levelChunkId, level_chunk_packet_1.LevelChunkPacket);
         }
     }
     getPacketClass(id, PacketClass) {
-        const CLIENT_CACHE_STATUS_ID = 129;
-        let CachedPacketClass = this.packetClassCache.get(id);
-        if (!CachedPacketClass) {
-            if (id === CLIENT_CACHE_STATUS_ID) {
-                CachedPacketClass =
-                    client_cache_status_1.ClientCacheStatusPacket;
-            }
-            else if (PacketClass && typeof PacketClass === "function") {
-                CachedPacketClass = PacketClass;
-            }
-            if (CachedPacketClass) {
-                this.packetClassCache.set(id, CachedPacketClass);
-            }
+        if (!this.packetClassCache.has(id) &&
+            PacketClass &&
+            typeof PacketClass === "function") {
+            this.packetClassCache.set(id, PacketClass);
         }
-        return CachedPacketClass;
+        return this.packetClassCache.get(id);
     }
     processPacketCommon(buffer, player, isClientbound, sender) {
-        const CLIENT_CACHE_STATUS_ID = 129;
         const id = (0, protocol_1.getPacketId)(buffer);
         const PacketClass = protocol_1.Packets[id];
-        // @ts-ignore
-        if (!PacketClass && id !== CLIENT_CACHE_STATUS_ID) {
+        const packetName = PacketClass?.name ?? "ClientCacheStatusPacket";
+        const eventName = `${isClientbound ? "clientbound" : "serverbound"}-${packetName}`;
+        if (!PacketClass && id !== 129) {
             sender.send(buffer);
             return;
         }
-        const packetName = PacketClass?.name ?? "ClientCacheStatusPacket";
-        const eventName = `${isClientbound ? "clientbound" : "serverbound"}-${packetName}`;
+        if (packetName === "LevelChunkPacket" && !player.postStartGame) {
+            player.levelChunkQueue.push(new level_chunk_packet_1.LevelChunkPacket(buffer).deserialize());
+            return;
+        }
         if (!player.hasListeners(eventName) &&
             packetName !== "ClientCacheStatusPacket") {
             sender.send(buffer);
@@ -69,41 +101,66 @@ class Bridge extends server_1.Server {
             if (this.debugLog) {
                 raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName}`);
             }
-            const packet = new CachedPacketClass(buffer).deserialize();
-            if (packet instanceof client_cache_status_1.ClientCacheStatusPacket) {
-                packet.supported = false;
-                raknet_1.Logger.warn("Ignoring ClientCacheStatusPacket");
-                return;
-            }
-            player.emit(eventName, packet);
-            if ("binary" in packet) {
-                packet.binary = [];
+            const cacheKey = `${id}-${buffer.toString("hex")}`;
+            let newBuffer = this.packetSerializationCache.get(cacheKey);
+            if (!newBuffer) {
+                const packet = new CachedPacketClass(buffer).deserialize();
+                if (packet instanceof client_cache_status_1.ClientCacheStatusPacket) {
+                    packet.supported = false;
+                    raknet_1.Logger.warn("Ignoring ClientCacheStatusPacket");
+                    return;
+                }
+                const cancelled = false;
+                player.emit(eventName, packet, cancelled);
+                if (cancelled)
+                    return;
+                if ("binary" in packet) {
+                    packet.binary = [];
+                }
+                newBuffer = packet.serialize();
+                this.packetSerializationCache.set(cacheKey, newBuffer);
             }
-            const newBuffer = packet.serialize();
-            sender.send(buffer.equals(newBuffer) ? buffer : newBuffer);
+            sender.send(newBuffer);
         }
         catch (e) {
-            console.error(`Failed to process ${packetName}`, e);
+            raknet_1.Logger.error(`Failed to process ${packetName}`, e);
             sender.send(buffer);
         }
     }
     prepare() {
         this.on("playerConnect", this.onConnect.bind(this));
         this.raknet.options.maxPacketsPerSecond = 20000;
+        this.on("disconnect", (data, _player) => {
+            const disconnect = new Protocol.DisconnectPacket();
+            disconnect.hideDisconnectScreen = true;
+            disconnect.message = new Protocol.DisconnectMessage("Disconnected");
+            disconnect.reason = Protocol.DisconnectReason.Disconnected;
+            const address = _player.connection.getAddress();
+            const playerKey = `${address.address}:${address.port}`;
+            const player = this.clients.get(playerKey);
+            if (player) {
+                const rakDisconnect = new disconnect_1.default();
+                const frame = new raknet_1.Frame();
+                frame.orderChannel = 0;
+                frame.payload = rakDisconnect.serialize();
+                player.client.raknet.sendFrame(frame, raknet_1.Priority.Immediate);
+                player.client.send(disconnect);
+            }
+        });
     }
     onConnect(player) {
         if (!(player.connection instanceof raknet_1.Connection))
             return;
         const bridgePlayer = new bridge_player_1.BridgePlayer(this, player);
-        this.clients.set(`${player.connection.getAddress().address}:${player.connection.getAddress().port}`, bridgePlayer);
+        const address = player.connection.getAddress();
+        const playerKey = `${address.address}:${address.port}`;
+        this.clients.set(playerKey, bridgePlayer);
         this.emit("connect", bridgePlayer);
         bridgePlayer.player.once("ClientCacheStatusPacket", (packet) => {
             bridgePlayer.cacheStatus = packet.supported;
         });
-        bridgePlayer.player.on("ClientToServerHandshakePacket", (packet) => {
-            console.log("ClientToServerHandshakePacket");
+        bridgePlayer.player.on("ClientToServerHandshakePacket", () => {
             this.onLogin(bridgePlayer);
-            return;
         });
     }
     onLogin(player) {
@@ -111,25 +168,26 @@ class Bridge extends server_1.Server {
             host: this.options.destination.host,
             port: this.options.destination.port,
             version: "1.21.50",
-            offline: false,
             tokensFolder: "tokens",
             viewDistance: 2,
             worker: true,
+            offline: this.options.offline,
         });
         player.client = client;
         client.cancelPastLogin = true;
         client.removeAllListeners("ResourcePackStackPacket");
         client.removeAllListeners("ResourcePacksInfoPacket");
         client.removeAllListeners("PlayStatusPacket");
-        client.once("ResourcePacksInfoPacket", (packet) => {
+        client.once("ResourcePacksInfoPacket", () => {
             client.send(client_cache_status_1.ClientCacheStatusPacket.create(false));
         });
-        player.once("serverbound-ResourcePackClientResponsePacket", (packet) => {
+        player.once("serverbound-ResourcePackClientResponsePacket", () => {
             player.player.send(client_cache_status_1.ClientCacheStatusPacket.create(false));
         });
         client.once("PlayStatusPacket", (packet) => {
-            if (packet.status !== protocol_1.PlayStatus.LoginSuccess)
+            if (packet.status !== protocol_1.PlayStatus.LoginSuccess) {
                 throw new Error("Login failed");
+            }
             client.processPacket = (buffer) => {
                 this.processPacketCommon(buffer, player, true, player.player);
             };

package/dist/client/client-data.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientData = void 0;
 const node_crypto_1 = require("node:crypto");
-const node_util_1 = require("node:util");
 const raknet_1 = require("@sanctumterra/raknet");
 const protocol_1 = require("@serenityjs/protocol");
-const jsonwebtoken_1 = require("jsonwebtoken");
+const fast_jwt_1 = require("fast-jwt");
 const uuid_1345_1 = require("uuid-1345");
 const login_data_1 = require("./types/login-data");
 const payload_1 = require("./types/payload");
@@ -14,7 +13,6 @@ const algorithm = "ES384";
 const curve = "secp384r1";
 const pem = { format: "pem", type: "sec1" };
 const der = { format: "der", type: "spki" };
-const signAsync = (0, node_util_1.promisify)(jsonwebtoken_1.sign);
 class ClientData {
     constructor(client) {
         this.client = client;
@@ -66,7 +64,15 @@ class ClientData {
                 header: { alg: algorithm, x5u: clientX509, typ: undefined },
             };
         }
-        return signAsync(payload, ecdhKeyPair.privateKey.export({ format: "pem", type: "pkcs8" }), signOptions);
+        const privateKeyPem = ecdhKeyPair.privateKey.export({
+            format: "pem",
+            type: "pkcs8",
+        });
+        const signer = (0, fast_jwt_1.createSigner)({
+            ...signOptions,
+            key: privateKeyPem,
+        });
+        return signer(payload);
     }
     async createClientUserChain(privateKey) {
         const { clientX509 } = this.loginData;
@@ -80,11 +86,24 @@ class ClientData {
             PlayFabId: ClientData.nextUUID().replace(/-/g, "").slice(0, 16),
             SelfSignedId: ClientData.nextUUID(),
         };
-        return signAsync(payload, privateKey.export({ format: "pem", type: "pkcs8" }), {
+        if (privateKey.asymmetricKeyDetails?.namedCurve === "p384")
+            privateKey.asymmetricKeyDetails.namedCurve = "secp384r1";
+        // Deno sucks.
+        // Logger.info('Private Key details:', {
+        // 	type: privateKey.type,
+        // 	curve: privateKey.asymmetricKeyDetails?.namedCurve
+        // });
+        const privateKeyPem = privateKey.export({
+            format: "pem",
+            type: "pkcs8",
+        });
+        const signer = (0, fast_jwt_1.createSigner)({
             algorithm,
             header: { alg: algorithm, x5u: clientX509, typ: undefined },
             noTimestamp: true,
+            key: privateKeyPem,
         });
+        return signer(payload);
     }
     createSharedSecret(privateKey, publicKey) {
         this.validateKeys(privateKey, publicKey);
@@ -93,7 +112,8 @@ class ClientData {
             throw new Error("Invalid private key format. Named curve is missing.");
         }
         try {
-            const ecdh = (0, node_crypto_1.createECDH)(curve);
+            const normalizedCurve = curve === "p384" ? "secp384r1" : curve;
+            const ecdh = (0, node_crypto_1.createECDH)(normalizedCurve);
             const privateKeyJwk = privateKey.export({ format: "jwk" });
             const publicKeyJwk = publicKey.export({ format: "jwk" });
             if (!privateKeyJwk.d || !publicKeyJwk.x || !publicKeyJwk.y) {

package/dist/client/client-options.d.ts

@@ -1,6 +1,8 @@
 import { CompressionMethod, InputMode } from "@serenityjs/protocol";
 import type * as Protocol from "@serenityjs/protocol";
 import type { ClientCacheStatusPacket } from "../network/client-cache-status";
+import type { Advertisement } from "@sanctumterra/raknet";
+import type { AddPaintingPacket } from "../network/packets";
 export declare enum ProtocolList {
     "1.21.50" = 766
 }
@@ -42,6 +44,7 @@ type ClientOptions = {
     offline: boolean;
     worker: boolean;
     loginOptions: LoginPacketOptions;
+    betaAuth: boolean;
 };
 declare const defaultClientOptions: ClientOptions;
 type PacketNames = {
@@ -52,7 +55,9 @@ type ClientEvents = {
 } & {
     session: [];
     ClientCacheStatus: [packet: ClientCacheStatusPacket];
+    AddPaintingPacket: [packet: AddPaintingPacket];
 } & {
     packet: [packet: InstanceType<(typeof Protocol)[PacketNames]>];
+    connect: [packet: Advertisement];
 };
 export { type ClientOptions, defaultClientOptions, type ClientEvents, type PacketNames, };

package/dist/client/client-options.js

@@ -44,5 +44,6 @@ const defaultClientOptions = {
         CurrentInputMode: protocol_1.InputMode.GamePad,
         DefaultInputMode: protocol_1.InputMode.GamePad,
     },
+    betaAuth: false,
 };
 exports.defaultClientOptions = defaultClientOptions;

package/dist/client/client.d.ts

@@ -1,5 +1,5 @@
-import { Client as RaknetClient } from "@sanctumterra/raknet";
-import { DataPacket } from "@serenityjs/protocol";
+import { type Advertisement, Client as RaknetClient } from "@sanctumterra/raknet";
+import { DataPacket, type StartGamePacket } from "@serenityjs/protocol";
 import { Emitter } from "../libs/emitter";
 import { type Profile } from "../network";
 import { PacketEncryptor } from "../network/packet-encryptor";
@@ -25,7 +25,7 @@ declare class Client extends Emitter<ClientEvents> {
     runtimeEntityId: bigint;
     cancelPastLogin: boolean;
     constructor(options: Partial<ClientOptions>);
-    connect(): Promise<unknown>;
+    connect(): Promise<[Advertisement, StartGamePacket]>;
     private handleStartGamePacket;
     private handleSetLocalPlayerAsInitializedPacket;
     private handleEncapsulated;
@@ -39,6 +39,7 @@ declare class Client extends Emitter<ClientEvents> {
     private handlePlayStatusPacket;
     private handleResourcePacksInfoPacket;
     startEncryption(iv: Buffer): void;
+    disconnect(): void;
     sendMessage(text: string): void;
 }
 export { Client };

package/dist/client/client.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
 const node_crypto_1 = require("node:crypto");
@@ -13,6 +16,8 @@ const packet_encryptor_1 = require("../network/packet-encryptor");
 const client_data_1 = require("./client-data");
 const client_options_1 = require("./client-options");
 const worker_1 = require("./worker");
+const packets_1 = require("../network/packets");
+const disconnect_1 = __importDefault(require("@sanctumterra/raknet/dist/proto/packets/disconnect"));
 class Client extends emitter_1.Emitter {
     constructor(options) {
         super();
@@ -37,6 +42,10 @@ class Client extends emitter_1.Emitter {
         this.options.offline ? (0, network_1.createOfflineSession)(this) : (0, network_1.authenticate)(this);
     }
     async connect() {
+        while (!this.sessionReady) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        this.status = raknet_1.Status.Connecting;
         this.packetCompressor = new network_1.PacketCompressor(this);
         this.listen();
         const advertisement = await this.raknet.connect();
@@ -50,6 +59,7 @@ class Client extends emitter_1.Emitter {
                     this.startGamePacket &&
                     this.sessionReady) {
                     clearInterval(interval);
+                    this.emit("connect", advertisement);
                     resolve([advertisement, this.startGamePacket]);
                 }
             }, 50);
@@ -63,7 +73,7 @@ class Client extends emitter_1.Emitter {
         const radius = new protocol_1.RequestChunkRadiusPacket();
         radius.radius = this.options.viewDistance;
         radius.maxRadius = this.options.viewDistance;
-        this.queue(radius);
+        this.send(radius);
     }
     handleSetLocalPlayerAsInitializedPacket(packet) {
         this.status = raknet_1.Status.Connected;
@@ -81,6 +91,8 @@ class Client extends emitter_1.Emitter {
     }
     sendPacket(packet, priority = raknet_1.Priority.Normal) {
         try {
+            if (this.status === raknet_1.Status.Disconnected)
+                return;
             const serialized = packet instanceof protocol_1.DataPacket ? packet.serialize() : packet;
             const compressed = this.packetCompressor.compress(serialized, this.options.compressionMethod);
             const frame = new raknet_1.Frame();
@@ -102,20 +114,28 @@ class Client extends emitter_1.Emitter {
     /** Already decompressed packets */
     processPacket(buffer) {
         const id = (0, protocol_1.getPacketId)(buffer);
-        if (!protocol_1.Packets[id])
-            return raknet_1.Logger.warn(`Unknown Game packet ${id}`);
         let PacketClass = protocol_1.Packets[id];
         try {
             if (id === protocol_1.Packet.LevelChunk) {
                 PacketClass = level_chunk_packet_1.LevelChunkPacket;
             }
-            if (this.hasListeners(PacketClass.name)) {
-                const packet = new PacketClass(buffer).deserialize();
-                this.emit(PacketClass.name, packet);
+            if (id === 22) {
+                PacketClass = packets_1.AddPaintingPacket;
             }
-            if (this.hasListeners("packet")) {
-                const packet = new PacketClass(buffer).deserialize();
-                this.emit("packet", packet);
+            if (!protocol_1.Packets && !protocol_1.Packets[id])
+                return raknet_1.Logger.warn(`Unknown Game packet ${id}`);
+            // console.log('X - ', PacketClass.name, readPacket(this.options.version, buffer));
+            let deserializedPacket;
+            const hasSpecificListener = this.hasListeners(PacketClass.name);
+            const hasGenericListener = this.hasListeners("packet");
+            if (hasSpecificListener || hasGenericListener) {
+                deserializedPacket = new PacketClass(buffer).deserialize();
+                if (hasSpecificListener) {
+                    this.emit(PacketClass.name, deserializedPacket);
+                }
+                if (hasGenericListener) {
+                    this.emit("packet", deserializedPacket);
+                }
             }
         }
         catch (error) {
@@ -200,6 +220,25 @@ class Client extends emitter_1.Emitter {
         this.packetEncryptor = new packet_encryptor_1.PacketEncryptor(this, iv);
         this._encryptionEnabled = true;
     }
+    disconnect() {
+        const rakDisconnect = new disconnect_1.default();
+        const frame = new raknet_1.Frame();
+        frame.orderChannel = 0;
+        frame.payload = rakDisconnect.serialize();
+        this.raknet.sendFrame(frame, raknet_1.Priority.Immediate);
+        this.status = raknet_1.Status.Disconnected;
+        this.removeAllListeners();
+        this.raknet.cleanup();
+        if (this.raknet instanceof raknet_1.Client) {
+            this.raknet.removeAll();
+            this.raknet.removeAllAfter();
+            this.raknet.removeAllBefore();
+        }
+        else {
+            this.raknet.dispose();
+        }
+        return;
+    }
     sendMessage(text) {
         const textPacket = new protocol_1.TextPacket();
         textPacket.filtered = "";

package/dist/client/types/payload.d.ts

@@ -1,6 +1,6 @@
-import type { Player } from "src/server/player";
+import type { Player } from "../../server/player";
 import type { Client } from "../client";
-import type { AnimatedImageData, PersonaPieces, PieceTintColors } from "./skin";
+import type { AnimatedImageData, PersonaPieces, PieceTintColors } from "./skin/Skin.d";
 export type Payload = {
     AnimatedImageData: AnimatedImageData[];
     ArmSize: string;

package/dist/client/types/payload.js

@@ -87,5 +87,6 @@ const createDefaultPayload = (client) => {
 };
 exports.createDefaultPayload = createDefaultPayload;
 const getRandomId = () => {
-    return Math.floor(Math.random() * Date.now() * Math.random() * 1000000) ^ Date.now();
+    return (Math.floor(Math.random() * Date.now() * Math.random() * 1000000) ^
+        Date.now());
 };