baltica 0.0.6 → 0.0.8

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

@@ -1,6 +1,6 @@
 import type * as Protocol from "@serenityjs/protocol";
 import type { PacketNames } from "../client";
-import type { ClientCacheStatusPacket } from "../network/client-cache-status";
+import type { ClientCacheStatusPacket } from "../network/packets/client-cache-status";
 import { type ServerOptions } from "../server/server-options";
 export type BridgePlayerEvents = {
     [K in PacketNames as `clientbound-${K}`]: [

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

@@ -1,4 +1,4 @@
-import type { LevelChunkPacket } from "../network/level-chunk-packet";
+import type { LevelChunkPacket } from "../network/packets/level-chunk-packet";
 import type { Client } from "../client";
 import { Emitter } from "../libs";
 import type { Player } from "../server";

package/dist/bridge/bridge.js

@@ -41,8 +41,7 @@ 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 level_chunk_packet_1 = require("../network/packets/level-chunk-packet");
 const server_1 = require("../server");
 const bridge_options_1 = require("./bridge-options");
 const bridge_player_1 = require("./bridge-player");
@@ -60,7 +59,7 @@ 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);
+        this.packetClassCache.set(CLIENT_CACHE_STATUS_ID, protocol_1.ClientCacheStatusPacket);
         const levelChunkId = level_chunk_packet_1.LevelChunkPacket.id;
         if (levelChunkId !== undefined) {
             this.packetClassCache.set(levelChunkId, level_chunk_packet_1.LevelChunkPacket);
@@ -105,8 +104,8 @@ class Bridge extends server_1.Server {
             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;
+                if (packet instanceof protocol_1.ClientCacheStatusPacket) {
+                    packet.enabled = false;
                     raknet_1.Logger.warn("Ignoring ClientCacheStatusPacket");
                     return;
                 }
@@ -157,7 +156,7 @@ class Bridge extends server_1.Server {
         this.clients.set(playerKey, bridgePlayer);
         this.emit("connect", bridgePlayer);
         bridgePlayer.player.once("ClientCacheStatusPacket", (packet) => {
-            bridgePlayer.cacheStatus = packet.supported;
+            bridgePlayer.cacheStatus = packet.enabled;
         });
         bridgePlayer.player.on("ClientToServerHandshakePacket", () => {
             this.onLogin(bridgePlayer);
@@ -167,25 +166,31 @@ class Bridge extends server_1.Server {
         const client = new client_1.Client({
             host: this.options.destination.host,
             port: this.options.destination.port,
-            version: "1.21.50",
+            version: this.options.version,
             tokensFolder: "tokens",
             viewDistance: 2,
             worker: true,
             offline: this.options.offline,
         });
+        console.log(this.options);
         player.client = client;
         client.cancelPastLogin = true;
         client.removeAllListeners("ResourcePackStackPacket");
         client.removeAllListeners("ResourcePacksInfoPacket");
         client.removeAllListeners("PlayStatusPacket");
         client.once("ResourcePacksInfoPacket", () => {
-            client.send(client_cache_status_1.ClientCacheStatusPacket.create(false));
+            const packet = new protocol_1.ClientCacheStatusPacket();
+            packet.enabled = false;
+            client.send(packet.serialize());
         });
         player.once("serverbound-ResourcePackClientResponsePacket", () => {
-            player.player.send(client_cache_status_1.ClientCacheStatusPacket.create(false));
+            const packet = new protocol_1.ClientCacheStatusPacket();
+            packet.enabled = false;
+            player.player.send(packet.serialize());
         });
         client.once("PlayStatusPacket", (packet) => {
             if (packet.status !== protocol_1.PlayStatus.LoginSuccess) {
+                console.log(packet);
                 throw new Error("Login failed");
             }
             client.processPacket = (buffer) => {

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

@@ -1,9 +1,9 @@
-import { KeyObject } from "node:crypto";
 import { LoginPacket } from "@serenityjs/protocol";
-import type { Player } from "src/server/player";
 import type { Client } from "./client";
-import { type LoginData } from "./types/login-data";
 import { type Payload } from "./types/payload";
+import { KeyObject } from "node:crypto";
+import { type LoginData } from "./types/login-data";
+import type { Player } from "../server/player";
 declare class ClientData {
     client: Client | Player;
     /** This Contains a lot of Data for the Login Packet */
@@ -21,8 +21,8 @@ declare class ClientData {
     createClientUserChain(privateKey: KeyObject): Promise<string>;
     createSharedSecret(privateKey: KeyObject, publicKey: KeyObject): Buffer;
     private validateKeys;
-    static nextUUID(): string;
-    static generateId(): number;
+    static nextUUID(username: string): string;
     static OnlineId(): string;
+    static generateId(): number;
 }
 export { ClientData };

package/dist/client/client-data.js

@@ -1,13 +1,46 @@
 "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;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientData = void 0;
-const node_crypto_1 = require("node:crypto");
-const raknet_1 = require("@sanctumterra/raknet");
 const protocol_1 = require("@serenityjs/protocol");
-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");
+const jose = __importStar(require("jose"));
+const node_crypto_1 = require("node:crypto");
+const login_data_1 = require("./types/login-data");
+const raknet_1 = require("@sanctumterra/raknet");
 const PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAECRXueJeTDqNRRgJi/vlRufByu/2G0i2Ebt6YMar5QX/R0DIIyrJMcUpruK4QveTfJSTp3Shlq4Gk34cD/4GUWwkv0DVuzeuB+tXija7HBxii03NHDbPAD0AKnLr2wdAp";
 const algorithm = "ES384";
 const curve = "secp384r1";
@@ -34,24 +67,25 @@ class ClientData {
     async createClientChainInternal(mojangKey, offline) {
         const { clientX509, ecdhKeyPair } = this.loginData;
         let payload;
-        let signOptions;
+        let header;
         if (offline) {
             payload = {
+                nbf: Math.floor(Date.now() / 1000),
+                randomNonce: Math.floor(Math.random() * 100000),
+                iat: Math.floor(Date.now() / 1000),
+                exp: Math.floor(Date.now() / 1000) + 3600,
                 extraData: {
                     displayName: this.client.profile.name,
                     identity: this.client.profile.uuid,
                     titleId: "89692877",
-                    XUID: "0",
+                    XUID: "",
                 },
                 certificateAuthority: true,
                 identityPublicKey: clientX509,
             };
-            signOptions = {
-                algorithm: algorithm,
-                notBefore: 0,
-                issuer: "self",
-                expiresIn: 60 * 60,
-                header: { alg: algorithm, x5u: clientX509, typ: undefined },
+            header = {
+                alg: algorithm,
+                x5u: clientX509,
             };
         }
         else {
@@ -59,20 +93,15 @@ class ClientData {
                 identityPublicKey: mojangKey || PUBLIC_KEY,
                 certificateAuthority: true,
             };
-            signOptions = {
-                algorithm: algorithm,
-                header: { alg: algorithm, x5u: clientX509, typ: undefined },
+            header = {
+                alg: algorithm,
+                x5u: clientX509,
             };
         }
-        const privateKeyPem = ecdhKeyPair.privateKey.export({
-            format: "pem",
-            type: "pkcs8",
-        });
-        const signer = (0, fast_jwt_1.createSigner)({
-            ...signOptions,
-            key: privateKeyPem,
-        });
-        return signer(payload);
+        const privateKey = await jose.importPKCS8(ecdhKeyPair.privateKey.export({ format: "pem", type: "pkcs8" }), algorithm);
+        return new jose.SignJWT(payload)
+            .setProtectedHeader(header)
+            .sign(privateKey);
     }
     async createClientUserChain(privateKey) {
         const { clientX509 } = this.loginData;
@@ -82,28 +111,16 @@ class ClientData {
             ...customPayload,
             ServerAddress: `${this.client.options.host}:${this.client.options.port}`,
             ClientRandomId: Date.now(),
-            DeviceId: ClientData.nextUUID(),
-            PlayFabId: ClientData.nextUUID().replace(/-/g, "").slice(0, 16),
-            SelfSignedId: ClientData.nextUUID(),
+            DeviceId: ClientData.nextUUID(this.client.profile?.name),
+            PlayFabId: ClientData.nextUUID(this.client.profile?.name)
+                .replace(/-/g, "")
+                .slice(0, 16),
+            SelfSignedId: ClientData.nextUUID(this.client.profile?.name),
         };
-        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);
+        const josePrivateKey = await jose.importPKCS8(privateKey.export({ format: "pem", type: "pkcs8" }), algorithm);
+        return new jose.SignJWT(payload)
+            .setProtectedHeader({ alg: algorithm, x5u: clientX509 })
+            .sign(josePrivateKey);
     }
     createSharedSecret(privateKey, publicKey) {
         this.validateKeys(privateKey, publicKey);
@@ -112,8 +129,7 @@ class ClientData {
             throw new Error("Invalid private key format. Named curve is missing.");
         }
         try {
-            const normalizedCurve = curve === "p384" ? "secp384r1" : curve;
-            const ecdh = (0, node_crypto_1.createECDH)(normalizedCurve);
+            const ecdh = (0, node_crypto_1.createECDH)(curve);
             const privateKeyJwk = privateKey.export({ format: "jwk" });
             const publicKeyJwk = publicKey.export({ format: "jwk" });
             if (!privateKeyJwk.d || !publicKeyJwk.x || !publicKeyJwk.y) {
@@ -142,19 +158,19 @@ class ClientData {
             throw new Error("Invalid key types. Expected private and public keys.");
         }
     }
-    static nextUUID() {
+    static nextUUID(username) {
         return (0, uuid_1345_1.v3)({
             namespace: "6ba7b811-9dad-11d1-80b4-00c04fd430c8",
-            name: Date.now().toString(),
+            name: username,
         });
     }
-    static generateId() {
-        const randomNum = Math.floor(Math.random() * 9000000000000000000) + 1000000000000000000;
-        return -randomNum;
-    }
     static OnlineId() {
         const randomNum = Math.floor(Math.random() * 9000000000000000000) + 1000000000000000000;
         return `${randomNum}`;
     }
+    static generateId() {
+        const randomNum = Math.floor(Math.random() * 9000000000000000000) + 1000000000000000000;
+        return -randomNum;
+    }
 }
 exports.ClientData = ClientData;

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

@@ -1,11 +1,13 @@
 import { CompressionMethod, InputMode } from "@serenityjs/protocol";
 import type * as Protocol from "@serenityjs/protocol";
-import type { ClientCacheStatusPacket } from "../network/client-cache-status";
+import type { ClientCacheStatusPacket } from "../network/packets/client-cache-status";
 import type { Advertisement } from "@sanctumterra/raknet";
-import type { AddPaintingPacket } from "../network/packets";
+import { AddPaintingPacket, UpdateSubchunkBlocksPacket, MotionPredictHintsPacket, SetLastHurtByPacket, SetDefaultGamemodePacket, UpdatePlayerGameTypePacket, UpdateBlockSyncPacket } from "../network/packets";
+import { LevelChunkPacket } from "../network/packets/level-chunk-packet";
 export declare enum ProtocolList {
     "1.21.50" = 766,
-    "1.21.60" = 776
+    "1.21.60" = 776,
+    "1.21.70" = 786
 }
 export declare enum DeviceOS {
     Undefined = 0,
@@ -55,10 +57,35 @@ type ClientEvents = {
     [K in PacketNames]: [packet: InstanceType<(typeof Protocol)[K]>];
 } & {
     session: [];
-    ClientCacheStatus: [packet: ClientCacheStatusPacket];
-    AddPaintingPacket: [packet: AddPaintingPacket];
+    ClientCacheStatusPacket: [
+        packet: InstanceType<typeof ClientCacheStatusPacket>
+    ];
+    UpdateSubchunkBlocksPacket: [
+        packet: InstanceType<typeof UpdateSubchunkBlocksPacket>
+    ];
+    MotionPredictHintsPacket: [
+        packet: InstanceType<typeof MotionPredictHintsPacket>
+    ];
+    SetLastHurtByPacket: [packet: InstanceType<typeof SetLastHurtByPacket>];
+    SetDefaultGamemodePacket: [
+        packet: InstanceType<typeof SetDefaultGamemodePacket>
+    ];
+    UpdatePlayerGameTypePacket: [
+        packet: InstanceType<typeof UpdatePlayerGameTypePacket>
+    ];
+    UpdateBlockSyncPacket: [packet: InstanceType<typeof UpdateBlockSyncPacket>];
 } & {
     packet: [packet: InstanceType<(typeof Protocol)[PacketNames]>];
     connect: [packet: Advertisement];
 };
 export { type ClientOptions, defaultClientOptions, type ClientEvents, type PacketNames, };
+export declare const ExtraPackets: {
+    58: typeof LevelChunkPacket;
+    22: typeof AddPaintingPacket;
+    172: typeof UpdateSubchunkBlocksPacket;
+    157: typeof MotionPredictHintsPacket;
+    96: typeof SetLastHurtByPacket;
+    105: typeof SetDefaultGamemodePacket;
+    151: typeof UpdatePlayerGameTypePacket;
+    110: typeof UpdateBlockSyncPacket;
+};

package/dist/client/client-options.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultClientOptions = exports.DeviceOS = exports.ProtocolList = void 0;
+exports.ExtraPackets = exports.defaultClientOptions = exports.DeviceOS = exports.ProtocolList = void 0;
 const protocol_1 = require("@serenityjs/protocol");
+const packets_1 = require("../network/packets");
+const level_chunk_packet_1 = require("../network/packets/level-chunk-packet");
 var ProtocolList;
 (function (ProtocolList) {
     ProtocolList[ProtocolList["1.21.50"] = 766] = "1.21.50";
     ProtocolList[ProtocolList["1.21.60"] = 776] = "1.21.60";
+    ProtocolList[ProtocolList["1.21.70"] = 786] = "1.21.70";
 })(ProtocolList || (exports.ProtocolList = ProtocolList = {}));
 var DeviceOS;
 (function (DeviceOS) {
@@ -33,7 +36,7 @@ const defaultClientOptions = {
     compressionMethod: protocol_1.CompressionMethod.Zlib,
     compressionLevel: 7,
     deviceOS: DeviceOS.NintendoSwitch,
-    version: "1.21.60",
+    version: "1.21.70",
     username: "SanctumTerra",
     tokensFolder: "tokens",
     viewDistance: 10,
@@ -48,3 +51,13 @@ const defaultClientOptions = {
     betaAuth: false,
 };
 exports.defaultClientOptions = defaultClientOptions;
+exports.ExtraPackets = {
+    [58]: level_chunk_packet_1.LevelChunkPacket,
+    [22]: packets_1.AddPaintingPacket,
+    [172]: packets_1.UpdateSubchunkBlocksPacket,
+    [157]: packets_1.MotionPredictHintsPacket,
+    [96]: packets_1.SetLastHurtByPacket,
+    [105]: packets_1.SetDefaultGamemodePacket,
+    [151]: packets_1.UpdatePlayerGameTypePacket,
+    [110]: packets_1.UpdateBlockSyncPacket,
+};

package/dist/client/client.d.ts

@@ -27,14 +27,12 @@ declare class Client extends Emitter<ClientEvents> {
     constructor(options: Partial<ClientOptions>);
     connect(): Promise<[Advertisement, StartGamePacket]>;
     private handleStartGamePacket;
-    private handleSetLocalPlayerAsInitializedPacket;
     private handleEncapsulated;
     private sendPacket;
     send(packet: DataPacket | Buffer): void;
     queue(packet: DataPacket | Buffer): void;
     /** Already decompressed packets */
     processPacket(buffer: Buffer): void;
-    private handleSession;
     listen(): void;
     private handlePlayStatusPacket;
     private handleResourcePacksInfoPacket;

package/dist/client/client.js

@@ -1,7 +1,4 @@
 "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");
@@ -10,14 +7,11 @@ const raknet_1 = require("@sanctumterra/raknet");
 const protocol_1 = require("@serenityjs/protocol");
 const emitter_1 = require("../libs/emitter");
 const network_1 = require("../network");
-const client_cache_status_1 = require("../network/client-cache-status");
-const level_chunk_packet_1 = require("../network/level-chunk-packet");
+const client_cache_status_1 = require("../network/packets/client-cache-status");
 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();
@@ -38,7 +32,9 @@ class Client extends emitter_1.Emitter {
         this._compressionEnabled = false;
         this.cancelPastLogin = false;
         this.data = new client_data_1.ClientData(this);
-        this.once("session", this.handleSession.bind(this));
+        this.once("session", () => {
+            this.sessionReady = true;
+        });
         this.options.offline ? (0, network_1.createOfflineSession)(this) : (0, network_1.authenticate)(this);
     }
     async connect() {
@@ -52,8 +48,9 @@ class Client extends emitter_1.Emitter {
         this.raknet.on("encapsulated", this.handleEncapsulated.bind(this));
         return new Promise((resolve, reject) => {
             this.once("StartGamePacket", this.handleStartGamePacket.bind(this));
-            this.once("SetLocalPlayerAsInitializedPacket", this.handleSetLocalPlayerAsInitializedPacket.bind(this));
-            this.once("AvailableCommandsPacket", () => { });
+            this.once("SetLocalPlayerAsInitializedPacket", () => {
+                this.status = raknet_1.Status.Connected;
+            });
             const interval = setInterval(() => {
                 if (this.status === raknet_1.Status.Connected &&
                     this.startGamePacket &&
@@ -75,9 +72,6 @@ class Client extends emitter_1.Emitter {
         radius.maxRadius = this.options.viewDistance;
         this.send(radius);
     }
-    handleSetLocalPlayerAsInitializedPacket(packet) {
-        this.status = raknet_1.Status.Connected;
-    }
     handleEncapsulated(buffer) {
         try {
             const packets = this.packetCompressor.decompress(buffer);
@@ -115,47 +109,40 @@ class Client extends emitter_1.Emitter {
     processPacket(buffer) {
         const id = (0, protocol_1.getPacketId)(buffer);
         let PacketClass = protocol_1.Packets[id];
+        // Logger.info(`Processing packet ${PacketClass.name ?? "unknown"} - ${id}`);
         try {
-            if (id === protocol_1.Packet.LevelChunk) {
-                PacketClass = level_chunk_packet_1.LevelChunkPacket;
-            }
-            if (id === 22) {
-                PacketClass = packets_1.AddPaintingPacket;
-            }
-            if (!protocol_1.Packets && !protocol_1.Packets[id])
+            // @ts-ignore
+            if (id in client_options_1.ExtraPackets)
+                PacketClass = client_options_1.ExtraPackets[id];
+            if ((!protocol_1.Packets && !protocol_1.Packets[id]) || !PacketClass || !PacketClass.name)
                 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");
+            let deserializedPacket;
             if (hasSpecificListener || hasGenericListener) {
                 deserializedPacket = new PacketClass(buffer).deserialize();
-                if (hasSpecificListener) {
+                if (hasSpecificListener)
                     this.emit(PacketClass.name, deserializedPacket);
-                }
-                if (hasGenericListener) {
+                if (hasGenericListener)
                     this.emit("packet", deserializedPacket);
-                }
             }
         }
         catch (error) {
             raknet_1.Logger.error(`Failed to process packet ${PacketClass.name}`, error);
         }
     }
-    handleSession() {
-        this.sessionReady = true;
-    }
     listen() {
         this.raknet.once("connect", () => {
             const timer = setInterval(() => {
-                if (this.sessionReady) {
-                    const request = new protocol_1.RequestNetworkSettingsPacket();
-                    request.protocol = this.protocol;
-                    this.send(request);
-                    clearInterval(timer);
-                }
+                if (!this.sessionReady)
+                    return;
+                const request = new protocol_1.RequestNetworkSettingsPacket();
+                request.protocol = this.protocol;
+                this.send(request);
+                clearInterval(timer);
             }, 50);
         });
+        this.raknet.on("close", () => this.disconnect());
         this.once("NetworkSettingsPacket", (packet) => {
             this._compressionEnabled = true;
             this.options.compressionMethod = this.packetCompressor.getMethod(packet.compressionMethod);
@@ -186,7 +173,6 @@ class Client extends emitter_1.Emitter {
             this.send(handshake);
         });
         this.once("ResourcePacksInfoPacket", this.handleResourcePacksInfoPacket.bind(this));
-        // this.once("ResourcePackStackPacket", this.handleResourcePacksInfoPacket.bind(this));
         this.on("PlayStatusPacket", this.handlePlayStatusPacket.bind(this));
     }
     handlePlayStatusPacket(packet) {
@@ -202,6 +188,7 @@ class Client extends emitter_1.Emitter {
                 protocol_1.ServerboundLoadingScreenType.EndLoadingScreen;
             ServerBoundLoadingScreen.hasScreenId = false;
             this.send(init);
+            this.send(ServerBoundLoadingScreen);
             this.emit("SetLocalPlayerAsInitializedPacket", init);
         }
     }
@@ -212,32 +199,26 @@ class Client extends emitter_1.Emitter {
         response.packs = [];
         response.response = protocol_1.ResourcePackResponse.Completed;
         this.send(response);
-        if (packet instanceof protocol_1.ResourcePacksInfoPacket) {
+        if (packet instanceof protocol_1.ResourcePacksInfoPacket)
             this.send(client_cache_status_1.ClientCacheStatusPacket.create(false));
-        }
     }
     startEncryption(iv) {
         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();
+        try {
+            this.removeAllListeners();
+            this.destroy();
+            this.raknet.disconnect();
+            this.packetEncryptor.destroy();
+            this._encryptionEnabled = false;
+            raknet_1.Logger.cleanup();
         }
-        else {
-            this.raknet.dispose();
+        catch (error) {
+            raknet_1.Logger.error("Error during disconnect:", error);
         }
-        return;
     }
     sendMessage(text) {
         const textPacket = new protocol_1.TextPacket();

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

@@ -46,5 +46,6 @@ export type Payload = {
     ThirdPartyNameOnly: boolean;
     TrustedSkin: boolean;
     UIProfile: number;
+    GraphicsMode: number;
 };
 export declare const createDefaultPayload: (client: Client | Player) => Payload;

package/dist/client/types/payload.js

@@ -38,7 +38,8 @@ const client_data_1 = require("../client-data");
 const client_options_1 = require("../client-options");
 const skin = __importStar(require("./skin/Skin.json"));
 const createDefaultPayload = (client) => {
-    return {
+    const username = client.profile?.name ?? client.options.username;
+    const payload = {
         AnimatedImageData: skin.skinData.AnimatedImageData,
         ArmSize: skin.skinData.ArmSize,
         CapeData: skin.skinData.CapeData,
@@ -50,7 +51,7 @@ const createDefaultPayload = (client) => {
         CompatibleWithClientSideChunkGen: false,
         CurrentInputMode: client.options.loginOptions.CurrentInputMode,
         DefaultInputMode: client.options.loginOptions.DefaultInputMode,
-        DeviceId: client_data_1.ClientData.nextUUID(),
+        DeviceId: client_data_1.ClientData.nextUUID(username),
         DeviceModel: client.options.loginOptions.DeviceModel,
         DeviceOS: client.options.deviceOS ?? client_options_1.DeviceOS.NintendoSwitch,
         GameVersion: client.options?.version,
@@ -63,27 +64,30 @@ const createDefaultPayload = (client) => {
         PersonaPieces: skin.skinData.PersonaPieces,
         PersonaSkin: skin.skinData.PersonaSkin,
         PieceTintColors: skin.skinData.PieceTintColors,
-        PlatformOfflineId: client_data_1.ClientData.nextUUID().replace(/-/g, ""),
+        PlatformOfflineId: client_data_1.ClientData.nextUUID(username).replace(/-/g, ""),
         PlatformOnlineId: client_data_1.ClientData.OnlineId(),
         PlatformType: 2,
-        PlayFabId: client_data_1.ClientData.nextUUID().replace(/-/g, "").slice(0, 16),
+        // PlatformUserId: "",
+        PlayFabId: client_data_1.ClientData.nextUUID(username).replace(/-/g, "").slice(0, 16),
         PremiumSkin: skin.skinData.PremiumSkin,
-        SelfSignedId: client_data_1.ClientData.nextUUID(),
+        SelfSignedId: client_data_1.ClientData.nextUUID(username),
         ServerAddress: `${client.options.host}:${client.options.port}`,
         SkinAnimationData: skin.skinData.SkinAnimationData,
         SkinColor: skin.skinData.SkinColor,
-        SkinGeometryDataEngineVersion: skin.skinData.SkinGeometryDataEngineVersion,
         SkinData: skin.skinData.SkinData,
         SkinGeometryData: skin.skinData.SkinGeometryData,
+        SkinGeometryDataEngineVersion: skin.skinData.SkinGeometryDataEngineVersion,
         SkinId: skin.skinData.SkinId,
         SkinImageHeight: skin.skinData.SkinImageHeight,
         SkinImageWidth: skin.skinData.SkinImageWidth,
         SkinResourcePatch: skin.skinData.SkinResourcePatch,
-        ThirdPartyName: client.profile?.name || "Player",
+        ThirdPartyName: username,
         ThirdPartyNameOnly: false,
         TrustedSkin: skin.skinData.TrustedSkin,
         UIProfile: 0,
+        GraphicsMode: 0,
     };
+    return payload;
 };
 exports.createDefaultPayload = createDefaultPayload;
 const getRandomId = () => {

package/dist/client/worker/WorkerClient.d.ts

@@ -11,6 +11,7 @@ declare class WorkerClient extends Emitter<ClientEvents> {
     private handleEvents;
     connect(): Promise<Advertisement>;
     dispose(): void;
+    disconnect(): void;
     cleanup(): void;
     frameAndSend(payload: Buffer, priority?: Priority): void;
     sendFrame(frame: Frame, priority?: Priority): void;