baltica 0.0.8 → 0.0.9

package/README.md

@@ -0,0 +1,304 @@
+# Baltica
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/SanctumTerra/Baltica/master/.extra/logo.png" alt="Baltica Logo" width="200"/>
+</p>
+
+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
+
+To run with Bun:
+```bash
+bun run start
+```
+
+## 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/client/client-options.d.ts

@@ -7,7 +7,8 @@ import { LevelChunkPacket } from "../network/packets/level-chunk-packet";
 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,

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,

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/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "baltica",
 	"description": "A MCBE Utility Library",
-	"version": "0.0.08",
-	"minecraft": "1.21.70",
+	"version": "0.0.09",
+	"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",