baltica 0.0.8 → 0.0.10

package/README.md

@@ -0,0 +1,303 @@
+# Baltica
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/SanctumTerra/Baltica/master/.extra/logo.png" alt="Baltica Logo" width="200"/>
+</p>
+
+---
+**Supported Versions**   `1.21.80` `1.21.70` `1.21.60` `1.21.50`
+---
+
+Baltica is a high-performance Minecraft Bedrock Edition networking toolkit built with TypeScript. It serves three main purposes:
+1. A powerful bridge/proxy that can modify, intercept, and manipulate network traffic between Minecraft Bedrock clients and servers
+2. A robust client library for creating Minecraft Bedrock bots and automated players
+3. A flexible server implementation for creating custom Minecraft Bedrock servers
+
+## Features
+
+- 🚀 High-performance packet handling and forwarding
+- 🤖 Bot creation and automation
+- 🔒 Support for encryption and compression
+- 🎮 Multiple protocol version support (1.21.50 - 1.21.80)
+- 🌐 Customizable packet manipulation
+- 🔄 Packet caching for improved performance
+- 📦 Resource pack handling
+- 🎯 Event-driven architecture
+- 🤝 Multi-client support for running multiple bots
+- 🖥️ Custom server implementation
+- ⚡ Bun runtime support for enhanced performance
+
+## Prerequisites
+
+- Node.js (v16 or higher recommended) or Bun runtime
+- TypeScript
+- npm, yarn, or bun
+
+## Installation
+
+### Using Package Manager (Recommended)
+
+```bash
+# Using npm
+npm install baltica
+
+# Using yarn
+yarn add baltica
+
+# Using bun
+bun add baltica
+```
+
+### From Source
+
+If you want to contribute or modify the source code:
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/baltica.git
+cd baltica
+```
+
+2. Install dependencies:
+```bash
+# Using npm
+npm install
+
+# Using yarn
+yarn install
+
+# Using bun
+bun install
+```
+
+3. Build the project:
+```bash
+# Using npm
+npm run build
+
+# Using yarn
+yarn build
+
+# Using bun
+bun run build
+```
+
+## Quick Start
+
+```typescript
+import { Client, Server, Bridge } from 'baltica';
+
+// Create a bot
+const bot = new Client({
+    host: 'server-address',
+    port: 19132,
+    version: '1.21.80',
+    username: 'MyBot'
+});
+
+// Create a server
+const server = new Server({
+    host: '0.0.0.0',
+    port: 19132,
+    maxPlayers: 20
+});
+
+// Create a bridge
+const bridge = new Bridge({
+    host: '0.0.0.0',
+    port: 19132,
+    destination: {
+        host: 'target-server.com',
+        port: 19132
+    }
+});
+```
+
+## Usage
+
+### Creating a Custom Server
+
+```typescript
+import { Server } from './src/server/server';
+
+const server = new Server({
+    host: '0.0.0.0',
+    port: 19132,
+    version: '1.21.80',
+    maxPlayers: 20
+});
+
+// Handle player connections
+server.on('playerConnect', (player) => {
+    console.log(`Player ${player.profile.name} connected!`);
+    
+    // Handle player packets
+    player.on('TextPacket', (packet) => {
+        // Broadcast chat messages
+        if (packet.type === TextPacketType.Chat) {
+            server.broadcast(`${player.profile.name}: ${packet.message}`);
+        }
+    });
+});
+
+// Handle disconnections
+server.on('disconnect', (displayName, player) => {
+    console.log(`Player ${displayName} disconnected`);
+});
+
+server.start();
+```
+
+### Creating Minecraft Bots
+
+```typescript
+import { Client } from './src/client/client';
+
+// Create a basic bot
+const bot = new Client({
+    host: 'server-address',
+    port: 19132,
+    version: '1.21.80',
+    username: 'MyBot',
+    tokensFolder: 'tokens',
+    viewDistance: 10
+});
+
+// Connect and handle events
+await bot.connect();
+
+// Listen for chat messages
+bot.on('TextPacket', (packet) => {
+    if (packet.type === TextPacketType.Chat) {
+        console.log(`${packet.source}: ${packet.message}`);
+        
+        // Respond to messages
+        if (packet.message.startsWith('!hello')) {
+            bot.sendMessage('Hello there!');
+        }
+    }
+});
+
+// Handle player movement
+bot.on('MovePlayerPacket', (packet) => {
+    // React to player movements
+    console.log(`Player ${packet.runtimeEntityId} moved to ${packet.position}`);
+});
+```
+
+### Running Multiple Bots
+
+```typescript
+async function createBots(count: number) {
+    const bots = [];
+    
+    for (let i = 0; i < count; i++) {
+        const bot = new Client({
+            host: 'server-address',
+            port: 19132,
+            version: '1.21.80',
+            username: `Bot${i}`,
+            tokensFolder: 'tokens',
+            viewDistance: 2,  // Lower view distance for better performance
+            worker: true      // Enable worker mode for better performance
+        });
+        
+        await bot.connect();
+        bots.push(bot);
+    }
+    
+    return bots;
+}
+
+// Create 5 bots
+const myBots = await createBots(5);
+```
+
+### Basic Bridge Setup
+
+```typescript
+import { Bridge } from './src/bridge/bridge';
+
+const bridge = new Bridge({
+    host: '0.0.0.0',
+    port: 19132,
+    destination: {
+        host: 'target-server.com',
+        port: 19132
+    },
+    version: '1.21.80',
+    maxPlayers: 20
+});
+
+bridge.start();
+```
+
+## Configuration Options
+
+### Server Options
+- `host`: The IP address to bind the server to
+- `port`: The port to listen on
+- `version`: Minecraft protocol version
+- `maxPlayers`: Maximum number of concurrent players
+- `motd`: Message of the day
+
+### Client/Bot Options
+- `host`: Target server address
+- `port`: Target server port
+- `version`: Protocol version
+- `username`: Bot username
+- `tokensFolder`: Directory for authentication tokens
+- `viewDistance`: Render distance (lower values improve performance)
+- `offline`: Enable offline mode
+- `worker`: Enable worker mode for improved performance with multiple bots
+- `deviceOS`: Device OS to emulate (defaults to Nintendo Switch)
+- `skinData`: Custom skin data for the bot
+
+### Bridge Options
+- `host`: The IP address to bind the bridge server to
+- `port`: The port to listen on
+- `destination`: Target server configuration (host and port)
+- `version`: Minecraft protocol version
+- `maxPlayers`: Maximum number of concurrent players
+
+## Events
+
+Baltica uses an event-driven architecture across all its components. Each component (Server, Client/Bot, Bridge) emits events that you can listen to for various game events and packet handling.
+
+```typescript
+// Example of event handling
+client.on('packet', (packet) => {
+    // Handle any packet
+});
+
+bridge.on('connect', (player) => {
+    // Handle player connection
+});
+
+server.on('playerConnect', (player) => {
+    // Handle new player
+});
+```
+
+For detailed event documentation, please refer to our [API Documentation](https://github.com/SanctumTerra/Baltica/wiki).
+
+## Performance
+
+Baltica supports both Node.js and Bun runtimes, with Bun offering significant performance improvements:
+- Faster startup times
+- Lower memory usage
+- Better packet processing performance
+- Improved concurrent connections handling
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+- Built with [@serenityjs/protocol](https://github.com/SerenityJS/protocol) for Minecraft protocol implementation
+- Uses [@sanctumterra/raknet](https://github.com/sanctumterra/raknet) for RakNet networking

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

@@ -5,17 +5,26 @@ import { type ServerOptions } from "../server/server-options";
 export type BridgePlayerEvents = {
     [K in PacketNames as `clientbound-${K}`]: [
         packet: InstanceType<(typeof Protocol)[K]>,
-        cancelled: boolean
+        eventStatus: {
+            cancelled: boolean;
+            modified: boolean;
+        }
     ];
 } & {
     [K in PacketNames as `serverbound-${K}`]: [
         packet: InstanceType<(typeof Protocol)[K]>,
-        cancelled: boolean
+        eventStatus: {
+            cancelled: boolean;
+            modified: boolean;
+        }
     ];
 } & {
     "serverbound-ClientCacheStatusPacket": [
         packet: ClientCacheStatusPacket,
-        cancelled: boolean
+        eventStatus: {
+            cancelled: boolean;
+            modified: boolean;
+        }
     ];
 };
 export type BridgeOptions = ServerOptions & {

package/dist/bridge/bridge-options.js

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

package/dist/bridge/bridge-player.js

@@ -10,16 +10,11 @@ class BridgePlayer extends libs_1.Emitter {
         this.player = player;
         this.postStartGame = false;
         this.levelChunkQueue = [];
-        this.once("clientbound-StartGamePacket", (packet) => {
+        this.once("clientbound-StartGamePacket", (packet, eventStatus) => {
             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);
+                this.emit(eventName, chunk, { cancelled: false, modified: false });
             }
         });
     }

package/dist/bridge/bridge.js

@@ -77,52 +77,110 @@ class Bridge extends server_1.Server {
         const id = (0, protocol_1.getPacketId)(buffer);
         const PacketClass = protocol_1.Packets[id];
         const packetName = PacketClass?.name ?? "ClientCacheStatusPacket";
+        console.log(packetName);
         const eventName = `${isClientbound ? "clientbound" : "serverbound"}-${packetName}`;
         if (!PacketClass && id !== 129) {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`Passing through unknown packet ID: ${id}`);
+            }
             sender.send(buffer);
             return;
         }
         if (packetName === "LevelChunkPacket" && !player.postStartGame) {
-            player.levelChunkQueue.push(new level_chunk_packet_1.LevelChunkPacket(buffer).deserialize());
+            try {
+                player.levelChunkQueue.push(new level_chunk_packet_1.LevelChunkPacket(buffer).deserialize());
+            }
+            catch (e) {
+                raknet_1.Logger.error("Failed to deserialize LevelChunkPacket for queueing", e);
+                sender.send(buffer);
+            }
+            return;
+        }
+        if (packetName === "ItemStackRequestPacket") {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`Passing through ItemStackRequestPacket (ID: ${id}) without processing.`);
+            }
+            sender.send(buffer);
+            return;
+        }
+        const hasListeners = player.hasListeners(eventName);
+        const isClientCachePacket = packetName === "ClientCacheStatusPacket";
+        const needsProcessing = hasListeners || isClientCachePacket;
+        if (!needsProcessing) {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (No listeners/special handling, sending original)`);
+            }
+            sender.send(buffer);
             return;
         }
-        if (!player.hasListeners(eventName) &&
-            packetName !== "ClientCacheStatusPacket") {
+        const cacheKey = `${id}-${buffer.toString("hex")}`;
+        const cachedSerializedBuffer = this.packetSerializationCache.get(cacheKey);
+        if (cachedSerializedBuffer) {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Sending cached serialized)`);
+            }
+            sender.send(cachedSerializedBuffer);
+            return;
+        }
+        const CachedPacketClass = this.getPacketClass(id, PacketClass);
+        if (!CachedPacketClass) {
+            raknet_1.Logger.warn(`Could not get packet class for ${packetName} (ID: ${id}) despite needing processing. Sending original.`);
             sender.send(buffer);
             return;
         }
+        let packet;
         try {
-            const CachedPacketClass = this.getPacketClass(id, PacketClass);
-            if (!CachedPacketClass) {
-                sender.send(buffer);
+            packet = new CachedPacketClass(buffer).deserialize();
+        }
+        catch (e) {
+            raknet_1.Logger.error(`Failed to deserialize ${packetName} (ID: ${id}). Sending original buffer.`, e);
+            sender.send(buffer);
+            return;
+        }
+        if (packet instanceof protocol_1.ClientCacheStatusPacket) {
+            packet.enabled = false;
+            raknet_1.Logger.warn(`Modified and dropping ClientCacheStatusPacket (ID: ${id})`);
+            return;
+        }
+        const eventStatus = { cancelled: false, modified: false };
+        if (hasListeners) {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Emitting event)`);
+            }
+            player.emit(eventName, packet, eventStatus);
+            if (eventStatus.cancelled) {
+                if (this.debugLog) {
+                    raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Cancelled by listener)`);
+                }
                 return;
             }
+        }
+        let bridgeMadeModifications = false;
+        if ("binary" in packet && packet.binary !== undefined) {
+            if (!Array.isArray(packet.binary) || packet.binary.length > 0) {
+                packet.binary = [];
+                bridgeMadeModifications = true;
+            }
+        }
+        const requiresSerialization = eventStatus.modified || bridgeMadeModifications;
+        if (requiresSerialization) {
             if (this.debugLog) {
-                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName}`);
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Re-serializing after modification)`);
             }
-            const cacheKey = `${id}-${buffer.toString("hex")}`;
-            let newBuffer = this.packetSerializationCache.get(cacheKey);
-            if (!newBuffer) {
-                const packet = new CachedPacketClass(buffer).deserialize();
-                if (packet instanceof protocol_1.ClientCacheStatusPacket) {
-                    packet.enabled = 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);
+            try {
+                const newSerializedBuffer = packet.serialize();
+                this.packetSerializationCache.set(cacheKey, newSerializedBuffer);
+                sender.send(newSerializedBuffer);
+            }
+            catch (e) {
+                raknet_1.Logger.error(`Failed to serialize modified ${packetName} (ID: ${id}). Sending original buffer.`, e);
+                sender.send(buffer);
             }
-            sender.send(newBuffer);
         }
-        catch (e) {
-            raknet_1.Logger.error(`Failed to process ${packetName}`, e);
+        else {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Processed, not modified, sending original)`);
+            }
             sender.send(buffer);
         }
     }
@@ -163,14 +221,49 @@ class Bridge extends server_1.Server {
         });
     }
     onLogin(player) {
+        console.log("Creating Client");
+        const payload = player.player.data.payload;
         const client = new client_1.Client({
             host: this.options.destination.host,
             port: this.options.destination.port,
             version: this.options.version,
             tokensFolder: "tokens",
-            viewDistance: 2,
+            viewDistance: payload.MaxViewDistance,
             worker: true,
             offline: this.options.offline,
+            deviceOS: payload.DeviceOS,
+            skinData: {
+                AnimatedImageData: payload.AnimatedImageData,
+                ArmSize: payload.ArmSize,
+                SkinData: payload.SkinData,
+                TrustedSkin: payload.TrustedSkin,
+                CapeData: payload.CapeData,
+                CapeId: payload.CapeId,
+                CapeImageHeight: payload.CapeImageHeight,
+                CapeImageWidth: payload.CapeImageWidth,
+                CapeOnClassicSkin: payload.CapeOnClassicSkin,
+                PersonaPieces: payload.PersonaPieces,
+                PieceTintColors: payload.PieceTintColors,
+                PersonaSkin: payload.PersonaSkin,
+                PremiumSkin: payload.PremiumSkin,
+                SkinAnimationData: payload.SkinAnimationData,
+                SkinColor: payload.SkinColor,
+                SkinGeometryData: payload.SkinGeometryData,
+                SkinGeometryDataEngineVersion: payload.SkinGeometryDataEngineVersion,
+                SkinId: payload.SkinId,
+                SkinImageHeight: payload.SkinImageHeight,
+                SkinImageWidth: payload.SkinImageWidth,
+                SkinResourcePatch: payload.SkinResourcePatch,
+            },
+            loginOptions: {
+                CurrentInputMode: payload.CurrentInputMode,
+                DefaultInputMode: payload.DefaultInputMode,
+                DeviceModel: payload.DeviceModel,
+            },
+            platformType: payload.PlatformType,
+            memoryTier: payload.MemoryTier,
+            uiProfile: payload.UIProfile,
+            graphicsMode: payload.GraphicsMode,
         });
         console.log(this.options);
         player.client = client;
@@ -183,10 +276,10 @@ class Bridge extends server_1.Server {
             packet.enabled = false;
             client.send(packet.serialize());
         });
-        player.once("serverbound-ResourcePackClientResponsePacket", () => {
-            const packet = new protocol_1.ClientCacheStatusPacket();
-            packet.enabled = false;
-            player.player.send(packet.serialize());
+        player.once("serverbound-ResourcePackClientResponsePacket", (packet, eventStatus) => {
+            const responsePacket = new protocol_1.ClientCacheStatusPacket();
+            responsePacket.enabled = false;
+            player.player.send(responsePacket.serialize());
         });
         client.once("PlayStatusPacket", (packet) => {
             if (packet.status !== protocol_1.PlayStatus.LoginSuccess) {

package/dist/client/client-data.js

@@ -105,7 +105,10 @@ class ClientData {
     }
     async createClientUserChain(privateKey) {
         const { clientX509 } = this.loginData;
-        const customPayload = this.client.options.skinData || {};
+        // Partial Payload
+        const customPayload = {
+            ...this.client.options.skinData,
+        };
         const payload = {
             ...this.payload,
             ...customPayload,

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

@@ -4,10 +4,12 @@ import type { ClientCacheStatusPacket } from "../network/packets/client-cache-st
 import type { Advertisement } from "@sanctumterra/raknet";
 import { AddPaintingPacket, UpdateSubchunkBlocksPacket, MotionPredictHintsPacket, SetLastHurtByPacket, SetDefaultGamemodePacket, UpdatePlayerGameTypePacket, UpdateBlockSyncPacket } from "../network/packets";
 import { LevelChunkPacket } from "../network/packets/level-chunk-packet";
+import type { SkinData } from "./types/payload";
 export declare enum ProtocolList {
     "1.21.50" = 766,
     "1.21.60" = 776,
-    "1.21.70" = 786
+    "1.21.70" = 786,
+    "1.21.80" = 800
 }
 export declare enum DeviceOS {
     Undefined = 0,
@@ -43,11 +45,15 @@ type ClientOptions = {
     username: string;
     tokensFolder: string;
     viewDistance: number;
-    skinData: object | undefined;
+    skinData: SkinData | undefined;
     offline: boolean;
     worker: boolean;
     loginOptions: LoginPacketOptions;
     betaAuth: boolean;
+    platformType: number;
+    memoryTier: number;
+    uiProfile: number;
+    graphicsMode: number;
 };
 declare const defaultClientOptions: ClientOptions;
 type PacketNames = {
@@ -79,13 +85,5 @@ type ClientEvents = {
     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;
-};
+export type ExtraPacketType = typeof LevelChunkPacket | typeof AddPaintingPacket | typeof UpdateSubchunkBlocksPacket | typeof MotionPredictHintsPacket | typeof SetLastHurtByPacket | typeof SetDefaultGamemodePacket | typeof UpdatePlayerGameTypePacket | typeof UpdateBlockSyncPacket;
+export declare const ExtraPackets: Record<number, ExtraPacketType>;

package/dist/client/client-options.js

@@ -9,6 +9,7 @@ var 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[ProtocolList["1.21.80"] = 800] = "1.21.80";
 })(ProtocolList || (exports.ProtocolList = ProtocolList = {}));
 var DeviceOS;
 (function (DeviceOS) {
@@ -36,7 +37,7 @@ const defaultClientOptions = {
     compressionMethod: protocol_1.CompressionMethod.Zlib,
     compressionLevel: 7,
     deviceOS: DeviceOS.NintendoSwitch,
-    version: "1.21.70",
+    version: "1.21.80",
     username: "SanctumTerra",
     tokensFolder: "tokens",
     viewDistance: 10,
@@ -44,11 +45,15 @@ const defaultClientOptions = {
     offline: false,
     worker: false,
     loginOptions: {
-        DeviceModel: "SwimmingPool",
+        DeviceModel: "Beans something something",
         CurrentInputMode: protocol_1.InputMode.GamePad,
         DefaultInputMode: protocol_1.InputMode.GamePad,
     },
     betaAuth: false,
+    platformType: 2,
+    memoryTier: 2,
+    uiProfile: 0,
+    graphicsMode: 0,
 };
 exports.defaultClientOptions = defaultClientOptions;
 exports.ExtraPackets = {

package/dist/client/client.d.ts

@@ -25,19 +25,30 @@ declare class Client extends Emitter<ClientEvents> {
     runtimeEntityId: bigint;
     cancelPastLogin: boolean;
     constructor(options: Partial<ClientOptions>);
+    private initializeSession;
     connect(): Promise<[Advertisement, StartGamePacket]>;
+    private waitForSessionReady;
+    private waitForConnection;
     private handleStartGamePacket;
+    private requestChunkRadius;
     private handleEncapsulated;
     private sendPacket;
     send(packet: DataPacket | Buffer): void;
     queue(packet: DataPacket | Buffer): void;
     /** Already decompressed packets */
     processPacket(buffer: Buffer): void;
-    listen(): void;
+    private setupEventListeners;
+    private setupConnectionListeners;
+    private handleRaknetConnect;
+    private setupPacketListeners;
+    private handleNetworkSettingsPacket;
+    private handleServerHandshake;
     private handlePlayStatusPacket;
+    private completePlayerSpawn;
     private handleResourcePacksInfoPacket;
     startEncryption(iv: Buffer): void;
     disconnect(): void;
+    private cleanup;
     sendMessage(text: string): void;
 }
 export { Client };

package/dist/client/client.js

@@ -12,6 +12,9 @@ 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 RETRY_INTERVAL_MS = 50;
+const CONNECTION_CHECK_INTERVAL_MS = 50;
+const NETWORK_SETTINGS_RETRY_INTERVAL_MS = 50;
 class Client extends emitter_1.Emitter {
     constructor(options) {
         super();
@@ -35,17 +38,26 @@ class Client extends emitter_1.Emitter {
         this.once("session", () => {
             this.sessionReady = true;
         });
+        this.initializeSession();
+    }
+    initializeSession() {
         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));
-        }
+        await this.waitForSessionReady();
         this.status = raknet_1.Status.Connecting;
         this.packetCompressor = new network_1.PacketCompressor(this);
-        this.listen();
+        this.setupEventListeners();
         const advertisement = await this.raknet.connect();
         this.raknet.on("encapsulated", this.handleEncapsulated.bind(this));
+        return this.waitForConnection(advertisement);
+    }
+    async waitForSessionReady() {
+        while (!this.sessionReady) {
+            await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
+        }
+    }
+    async waitForConnection(advertisement) {
         return new Promise((resolve, reject) => {
             this.once("StartGamePacket", this.handleStartGamePacket.bind(this));
             this.once("SetLocalPlayerAsInitializedPacket", () => {
@@ -59,7 +71,7 @@ class Client extends emitter_1.Emitter {
                     this.emit("connect", advertisement);
                     resolve([advertisement, this.startGamePacket]);
                 }
-            }, 50);
+            }, CONNECTION_CHECK_INTERVAL_MS);
         });
     }
     handleStartGamePacket(packet) {
@@ -67,6 +79,9 @@ class Client extends emitter_1.Emitter {
         this.runtimeEntityId = packet.runtimeEntityId;
         if (this.cancelPastLogin)
             return;
+        this.requestChunkRadius();
+    }
+    requestChunkRadius() {
         const radius = new protocol_1.RequestChunkRadiusPacket();
         radius.radius = this.options.viewDistance;
         radius.maxRadius = this.options.viewDistance;
@@ -95,103 +110,115 @@ class Client extends emitter_1.Emitter {
             this.raknet.sendFrame(frame, priority);
         }
         catch (error) {
-            raknet_1.Logger.error(`Failed to send packet ${packet.constructor.name}`, error);
+            raknet_1.Logger.error(`Failed to send packet ${packet instanceof protocol_1.DataPacket ? packet.constructor.name : "Buffer"}`, error);
         }
     }
     send(packet) {
         this.sendPacket(packet, raknet_1.Priority.Immediate);
     }
     queue(packet) {
-        raknet_1.Logger.debug(`Queueing packet ${packet.constructor.name}`);
+        raknet_1.Logger.debug(`Queueing packet ${packet instanceof protocol_1.DataPacket ? packet.constructor.name : "Buffer"}`);
         this.sendPacket(packet, raknet_1.Priority.Normal);
     }
     /** Already decompressed packets */
     processPacket(buffer) {
         const id = (0, protocol_1.getPacketId)(buffer);
         let PacketClass = protocol_1.Packets[id];
-        // Logger.info(`Processing packet ${PacketClass.name ?? "unknown"} - ${id}`);
         try {
-            // @ts-ignore
-            if (id in client_options_1.ExtraPackets)
+            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}`);
+            }
+            if (!PacketClass || !PacketClass.name) {
+                raknet_1.Logger.warn(`Unknown Game packet ${id}`);
+                return;
+            }
             const hasSpecificListener = this.hasListeners(PacketClass.name);
             const hasGenericListener = this.hasListeners("packet");
-            let deserializedPacket;
             if (hasSpecificListener || hasGenericListener) {
-                deserializedPacket = new PacketClass(buffer).deserialize();
-                if (hasSpecificListener)
+                const deserializedPacket = new PacketClass(buffer).deserialize();
+                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);
+            raknet_1.Logger.error(`Failed to process packet ${PacketClass?.name || id}`, error);
         }
     }
-    listen() {
-        this.raknet.once("connect", () => {
-            const timer = setInterval(() => {
-                if (!this.sessionReady)
-                    return;
-                const request = new protocol_1.RequestNetworkSettingsPacket();
-                request.protocol = this.protocol;
-                this.send(request);
-                clearInterval(timer);
-            }, 50);
-        });
+    setupEventListeners() {
+        this.setupConnectionListeners();
+        this.setupPacketListeners();
+    }
+    setupConnectionListeners() {
+        this.raknet.once("connect", this.handleRaknetConnect.bind(this));
         this.raknet.on("close", () => this.disconnect());
-        this.once("NetworkSettingsPacket", (packet) => {
-            this._compressionEnabled = true;
-            this.options.compressionMethod = this.packetCompressor.getMethod(packet.compressionMethod);
-            this.options.compressionThreshold = packet.compressionThreshold;
-            const loginPacket = this.data.createLoginPacket();
-            this.send(loginPacket);
-        });
-        this.once("ServerToClientHandshakePacket", (packet) => {
-            const [header, payload] = packet.token
-                .split(".")
-                .map((k) => Buffer.from(k, "base64"));
-            const { x5u } = JSON.parse(header.toString());
-            const { salt } = JSON.parse(payload.toString());
-            const pubKeyDer = (0, node_crypto_2.createPublicKey)({
-                key: Buffer.from(x5u, "base64"),
-                type: "spki",
-                format: "der",
-            });
-            this.data.sharedSecret = this.data.createSharedSecret(this.data.loginData.ecdhKeyPair.privateKey, pubKeyDer);
-            const secretHash = (0, node_crypto_1.createHash)("sha256")
-                .update(new Uint8Array(Buffer.from(salt, "base64")))
-                .update(new Uint8Array(this.data.sharedSecret))
-                .digest();
-            this.secretKeyBytes = secretHash;
-            this.iv = secretHash.slice(0, 16);
-            this.startEncryption(this.iv);
-            const handshake = new protocol_1.ClientToServerHandshakePacket();
-            this.send(handshake);
-        });
+    }
+    handleRaknetConnect() {
+        const timer = setInterval(() => {
+            if (!this.sessionReady)
+                return;
+            const request = new protocol_1.RequestNetworkSettingsPacket();
+            request.protocol = this.protocol;
+            this.send(request);
+            clearInterval(timer);
+        }, NETWORK_SETTINGS_RETRY_INTERVAL_MS);
+    }
+    setupPacketListeners() {
+        this.once("NetworkSettingsPacket", this.handleNetworkSettingsPacket.bind(this));
+        this.once("ServerToClientHandshakePacket", this.handleServerHandshake.bind(this));
         this.once("ResourcePacksInfoPacket", this.handleResourcePacksInfoPacket.bind(this));
         this.on("PlayStatusPacket", this.handlePlayStatusPacket.bind(this));
     }
+    handleNetworkSettingsPacket(packet) {
+        this._compressionEnabled = true;
+        this.options.compressionMethod = this.packetCompressor.getMethod(packet.compressionMethod);
+        this.options.compressionThreshold = packet.compressionThreshold;
+        const loginPacket = this.data.createLoginPacket();
+        this.send(loginPacket);
+    }
+    handleServerHandshake(packet) {
+        const [header, payload] = packet.token
+            .split(".")
+            .map((k) => Buffer.from(k, "base64"));
+        const { x5u } = JSON.parse(header.toString());
+        const { salt } = JSON.parse(payload.toString());
+        const pubKeyDer = (0, node_crypto_2.createPublicKey)({
+            key: Buffer.from(x5u, "base64"),
+            type: "spki",
+            format: "der",
+        });
+        this.data.sharedSecret = this.data.createSharedSecret(this.data.loginData.ecdhKeyPair.privateKey, pubKeyDer);
+        const secretHash = (0, node_crypto_1.createHash)("sha256")
+            .update(new Uint8Array(Buffer.from(salt, "base64")))
+            .update(new Uint8Array(this.data.sharedSecret))
+            .digest();
+        this.secretKeyBytes = secretHash;
+        this.iv = secretHash.slice(0, 16);
+        this.startEncryption(this.iv);
+        const handshake = new protocol_1.ClientToServerHandshakePacket();
+        this.send(handshake);
+    }
     handlePlayStatusPacket(packet) {
         if (packet.status === protocol_1.PlayStatus.LoginSuccess) {
         }
-        if (packet.status === protocol_1.PlayStatus.PlayerSpawn) {
-            if (this.cancelPastLogin)
-                return;
-            const init = new protocol_1.SetLocalPlayerAsInitializedPacket();
-            init.runtimeEntityId = this.runtimeEntityId;
-            const ServerBoundLoadingScreen = new protocol_1.ServerboundLoadingScreenPacketPacket();
-            ServerBoundLoadingScreen.type =
-                protocol_1.ServerboundLoadingScreenType.EndLoadingScreen;
-            ServerBoundLoadingScreen.hasScreenId = false;
-            this.send(init);
-            this.send(ServerBoundLoadingScreen);
-            this.emit("SetLocalPlayerAsInitializedPacket", init);
+        if (packet.status === protocol_1.PlayStatus.PlayerSpawn && !this.cancelPastLogin) {
+            this.completePlayerSpawn();
         }
     }
+    completePlayerSpawn() {
+        const init = new protocol_1.SetLocalPlayerAsInitializedPacket();
+        init.runtimeEntityId = this.runtimeEntityId;
+        const serverBoundLoadingScreen = new protocol_1.ServerboundLoadingScreenPacketPacket();
+        serverBoundLoadingScreen.type =
+            protocol_1.ServerboundLoadingScreenType.EndLoadingScreen;
+        serverBoundLoadingScreen.hasScreenId = false;
+        this.send(init);
+        this.send(serverBoundLoadingScreen);
+        this.emit("SetLocalPlayerAsInitializedPacket", init);
+    }
     handleResourcePacksInfoPacket(packet) {
         if (this.cancelPastLogin)
             return;
@@ -199,27 +226,37 @@ 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() {
+        if (this.status === raknet_1.Status.Disconnected)
+            return;
         this.status = raknet_1.Status.Disconnected;
         try {
-            this.removeAllListeners();
-            this.destroy();
-            this.raknet.disconnect();
-            this.packetEncryptor.destroy();
-            this._encryptionEnabled = false;
-            raknet_1.Logger.cleanup();
+            this.cleanup();
         }
         catch (error) {
             raknet_1.Logger.error("Error during disconnect:", error);
         }
     }
+    cleanup() {
+        this.removeAllListeners();
+        this.destroy();
+        if (this.raknet) {
+            this.raknet.disconnect();
+        }
+        if (this.packetEncryptor) {
+            this.packetEncryptor.destroy();
+            this._encryptionEnabled = false;
+        }
+        raknet_1.Logger.cleanup();
+    }
     sendMessage(text) {
         const textPacket = new protocol_1.TextPacket();
         textPacket.filtered = "";

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

@@ -48,4 +48,27 @@ export type Payload = {
     UIProfile: number;
     GraphicsMode: number;
 };
+export type SkinData = {
+    AnimatedImageData: AnimatedImageData[];
+    ArmSize: string;
+    CapeData: string;
+    CapeId: string;
+    CapeImageHeight: number;
+    CapeImageWidth: number;
+    CapeOnClassicSkin: boolean;
+    PieceTintColors: PieceTintColors[];
+    PersonaPieces: PersonaPieces[];
+    PersonaSkin: boolean;
+    PremiumSkin: boolean;
+    SkinAnimationData: string;
+    SkinColor: string;
+    SkinData: string;
+    SkinGeometryData: string;
+    SkinGeometryDataEngineVersion: string;
+    SkinId: string;
+    SkinImageHeight: number;
+    SkinImageWidth: number;
+    SkinResourcePatch: string;
+    TrustedSkin: boolean;
+};
 export declare const createDefaultPayload: (client: Client | Player) => Payload;

package/dist/client/types/payload.js

@@ -59,14 +59,14 @@ const createDefaultPayload = (client) => {
         IsEditorMode: false,
         LanguageCode: "en_US",
         MaxViewDistance: client.options?.viewDistance,
-        MemoryTier: 2,
+        MemoryTier: client.options.memoryTier,
         OverrideSkin: false,
         PersonaPieces: skin.skinData.PersonaPieces,
         PersonaSkin: skin.skinData.PersonaSkin,
         PieceTintColors: skin.skinData.PieceTintColors,
         PlatformOfflineId: client_data_1.ClientData.nextUUID(username).replace(/-/g, ""),
         PlatformOnlineId: client_data_1.ClientData.OnlineId(),
-        PlatformType: 2,
+        PlatformType: client.options.platformType,
         // PlatformUserId: "",
         PlayFabId: client_data_1.ClientData.nextUUID(username).replace(/-/g, "").slice(0, 16),
         PremiumSkin: skin.skinData.PremiumSkin,
@@ -84,8 +84,8 @@ const createDefaultPayload = (client) => {
         ThirdPartyName: username,
         ThirdPartyNameOnly: false,
         TrustedSkin: skin.skinData.TrustedSkin,
-        UIProfile: 0,
-        GraphicsMode: 0,
+        UIProfile: client.options.uiProfile,
+        GraphicsMode: client.options.graphicsMode,
     };
     return payload;
 };

package/dist/network/packets/level-chunk-packet.d.ts

@@ -1,23 +1,16 @@
+import type { Buffer } from "node:buffer";
 import { DataPacket, type DimensionType } from "@serenityjs/protocol";
 declare class LevelChunkPacket extends DataPacket {
     private static readonly MAX_BLOB_HASHES;
-    private static readonly CLIENT_REQUEST_FULL_COLUMN_FAKE_COUNT;
-    private static readonly CLIENT_REQUEST_TRUNCATED_COLUMN_FAKE_COUNT;
     x: number;
     z: number;
     dimension: DimensionType;
-    client_needs_to_request_subchunks: boolean;
-    client_request_subchunk_limit?: number;
-    sub_chunk_count: number;
-    partial_subchunk_count_when_requesting?: number;
-    subchunk_count_when_requesting?: number;
-    highest_subchunk_count?: number;
-    cache_enabled: boolean;
-    blobs?: Array<bigint>;
-    payload: Buffer;
+    highestSubChunkCount: number;
+    subChunkCount: number;
+    cacheEnabled: boolean;
+    blobs: Array<bigint>;
+    data: Buffer;
     serialize(): Buffer;
     deserialize(): this;
-    private writeByteArray;
-    private readByteArray;
 }
 export { LevelChunkPacket };

package/dist/network/packets/level-chunk-packet.js

@@ -8,20 +8,20 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var LevelChunkPacket_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LevelChunkPacket = void 0;
-const protocol_1 = require("@serenityjs/protocol");
 const raknet_1 = require("@serenityjs/raknet");
+const protocol_1 = require("@serenityjs/protocol");
 let LevelChunkPacket = LevelChunkPacket_1 = class LevelChunkPacket extends protocol_1.DataPacket {
     serialize() {
         this.writeVarInt(protocol_1.Packet.LevelChunk);
         this.writeZigZag(this.x);
         this.writeZigZag(this.z);
         this.writeZigZag(this.dimension);
-        this.writeVarInt(this.sub_chunk_count);
-        if (this.sub_chunk_count === -2) {
-            this.writeUint16(this.highest_subchunk_count ?? 0, 1 /* Endianness.Little */);
+        this.writeVarInt(this.subChunkCount);
+        if (this.subChunkCount === -2) {
+            this.writeUint16(this.highestSubChunkCount ?? 0, 1 /* Endianness.Little */);
         }
-        this.writeBool(this.cache_enabled);
-        if (this.cache_enabled) {
+        this.writeBool(this.cacheEnabled);
+        if (this.cacheEnabled) {
             if (!this.blobs)
                 throw new Error("Blobs required when cache_enabled is true");
             this.writeVarInt(this.blobs.length);
@@ -29,7 +29,8 @@ let LevelChunkPacket = LevelChunkPacket_1 = class LevelChunkPacket extends proto
                 this.writeUint64(hash, 1 /* Endianness.Little */);
             }
         }
-        this.writeByteArray(this.payload);
+        this.writeVarInt(this.data.length);
+        this.writeBuffer(this.data);
         return this.getBuffer();
     }
     deserialize() {
@@ -37,14 +38,14 @@ let LevelChunkPacket = LevelChunkPacket_1 = class LevelChunkPacket extends proto
         this.x = this.readZigZag();
         this.z = this.readZigZag();
         this.dimension = this.readZigZag();
-        this.sub_chunk_count = this.readVarInt();
-        if (this.sub_chunk_count === 4294967294)
-            this.sub_chunk_count = -2;
-        if (this.sub_chunk_count === -2) {
-            this.highest_subchunk_count = this.readUint16(1 /* Endianness.Little */);
+        this.subChunkCount = this.readVarInt();
+        if (this.subChunkCount === 4294967294)
+            this.subChunkCount = -2;
+        if (this.subChunkCount === -2) {
+            this.highestSubChunkCount = this.readUint16(1 /* Endianness.Little */);
         }
-        this.cache_enabled = this.readBool();
-        if (this.cache_enabled) {
+        this.cacheEnabled = this.readBool();
+        if (this.cacheEnabled) {
             const blobCount = this.readVarInt();
             if (blobCount > LevelChunkPacket_1.MAX_BLOB_HASHES) {
                 throw new Error(`Too many blob hashes: ${blobCount}`);
@@ -54,22 +55,13 @@ let LevelChunkPacket = LevelChunkPacket_1 = class LevelChunkPacket extends proto
                 this.blobs.push(this.readLong(1 /* Endianness.Little */));
             }
         }
-        this.payload = this.readByteArray();
+        const dataLength = this.readVarInt();
+        this.data = this.readBuffer(dataLength);
         return this;
     }
-    writeByteArray(buffer) {
-        this.writeVarInt(buffer.length);
-        this.writeBuffer(buffer);
-    }
-    readByteArray() {
-        const length = this.readVarInt();
-        return this.readBuffer(length);
-    }
 };
 exports.LevelChunkPacket = LevelChunkPacket;
 LevelChunkPacket.MAX_BLOB_HASHES = 64;
-LevelChunkPacket.CLIENT_REQUEST_FULL_COLUMN_FAKE_COUNT = 0xffffffff;
-LevelChunkPacket.CLIENT_REQUEST_TRUNCATED_COLUMN_FAKE_COUNT = 0xfffffffe;
 exports.LevelChunkPacket = LevelChunkPacket = LevelChunkPacket_1 = __decorate([
     (0, raknet_1.Proto)(protocol_1.Packet.LevelChunk)
 ], LevelChunkPacket);

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

@@ -2,7 +2,7 @@ import { CompressionMethod, type DataPacket } from "@serenityjs/protocol";
 import type * as Protocol from "@serenityjs/protocol";
 import type { PacketNames } from "../client";
 import type { ClientCacheStatusPacket } from "../network/packets/client-cache-status";
-type Version = "1.21.50" | "1.21.60" | "1.21.70";
+type Version = "1.21.50" | "1.21.60" | "1.21.70" | "1.21.80";
 export type PlayerEvents = {
     [K in PacketNames]: [packet: InstanceType<(typeof Protocol)[K]>];
 } & {

package/dist/server/server-options.js

@@ -6,7 +6,7 @@ exports.defaultServerOptions = {
     host: "127.0.0.1",
     port: 19132,
     offline: true,
-    version: "1.21.70",
+    version: "1.21.80",
     worker: true,
     maxPlayers: 100,
     compressionMethod: protocol_1.CompressionMethod.Zlib,

package/dist/server/server.js

@@ -5,6 +5,7 @@ const raknet_1 = require("@sanctumterra/raknet");
 const libs_1 = require("../libs");
 const player_1 = require("./player");
 const server_options_1 = require("./server-options");
+const protocol_1 = require("@serenityjs/protocol");
 class Server extends libs_1.Emitter {
     constructor(options) {
         super();
@@ -29,13 +30,30 @@ class Server extends libs_1.Emitter {
             if (!(connection instanceof raknet_1.Connection))
                 throw new Error("Connection is not instance of Connection");
             const connectionKey = this.getConnectionKey(connection);
-            if (this.connections.has(connectionKey))
-                return;
+            const existingPlayer = this.connections.get(connectionKey);
+            if (existingPlayer) {
+                raknet_1.Logger.warn(`Disconnecting existing player ${existingPlayer.profile?.name ?? connectionKey} due to new connection from the same address.`);
+                // Send a disconnect packet to the existing player
+                const disconnectPacket = new protocol_1.DisconnectPacket();
+                disconnectPacket.message = new protocol_1.DisconnectMessage("You were disconnected because a new connection was made from your IP address.");
+                disconnectPacket.reason = protocol_1.DisconnectReason.Kicked;
+                disconnectPacket.hideDisconnectScreen = false;
+                try {
+                    existingPlayer.send(disconnectPacket); // Assuming Player class has a send method for Protocol packets
+                    // Optionally, also force close RakNet connection if send isn't enough or player is unresponsive
+                    existingPlayer.connection.disconnect();
+                }
+                catch (error) {
+                    raknet_1.Logger.error(`Error sending disconnect to existing player ${connectionKey}:`, error);
+                }
+                this.onDisconnect(existingPlayer); // Ensure cleanup and event emission
+            }
+            // Proceed to create and connect the new player
             const player = new player_1.Player(this, connection);
             this.connections.set(connectionKey, player);
             this.emit("playerConnect", player);
             const { address, port } = connection.getAddress();
-            raknet_1.Logger.info("Player connected from: ", `${address}:${port}`);
+            raknet_1.Logger.info(`Player connected from: ${address}:${port}`);
         });
         this.raknet.start();
     }

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "baltica",
 	"description": "A MCBE Utility Library",
-	"version": "0.0.08",
-	"minecraft": "1.21.70",
+	"version": "0.0.10",
+	"minecraft": "1.21.80",
 	"type": "commonjs",
 	"main": "dist/index.js",
 	"license": "MIT",
@@ -23,7 +23,9 @@
 	],
 	"dependencies": {
 		"@sanctumterra/raknet": "^1.3.77",
-		"@serenityjs/protocol": "^0.7.0",
+		"@serenityjs/binarystream": "^2.7.0",
+		"@serenityjs/core": "^0.8.2",
+		"@serenityjs/protocol": "0.8.2",
 		"axios": "^1.7.9",
 		"elliptic": "^6.6.1",
 		"jose": "^5.2.3",