baltica 0.1.32 → 2.0.0

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

@@ -1,13 +1,13 @@
+import { Emitter } from "@baltica/utils";
 import { Client } from "../client";
 import type { Player } from "../server";
 import type { Bridge } from "./bridge";
 import type { BridgePlayerEvents } from "./types";
-import { Emitter } from "../shared";
 export declare class BridgePlayer extends Emitter<BridgePlayerEvents> {
     bridge: Bridge;
     player: Player;
     client: Client;
     constructor(player: Player, bridge: Bridge);
     private onHandshake;
-    handlePacket(rawBuffer: Buffer, clientBound: boolean): void;
+    routePacket(rawBuffer: Buffer, clientBound: boolean): void;
 }

package/dist/bridge/bridge-player.js

@@ -2,48 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BridgePlayer = void 0;
 const protocol_1 = require("@serenityjs/protocol");
+const utils_1 = require("@baltica/utils");
 const client_1 = require("../client");
-const shared_1 = require("../shared");
-class BridgePlayer extends shared_1.Emitter {
+class BridgePlayer extends utils_1.Emitter {
+    bridge;
+    player;
+    client;
     constructor(player, bridge) {
         super();
         this.player = player;
         this.bridge = bridge;
-        this.player.once("ClientToServerHandshakePacket", this.onHandshake.bind(this));
+        this.player.once("ClientToServerHandshakePacket", (packet) => this.onHandshake(packet));
     }
-    onHandshake(packet) {
+    onHandshake(_packet) {
         this.client = new client_1.Client({
             address: this.bridge.options.destination.address,
             port: this.bridge.options.destination.port,
             offline: this.bridge.options.offline,
         });
-        this.client.cancelPastLogin = true;
+        this.client.stopPastLogin = true;
         this.client.once("PlayStatusPacket", (packet) => {
-            if (packet.status !== protocol_1.PlayStatus.LoginSuccess)
-                throw new Error("Login failed");
-            this.client.processPacket = (buffer) => {
-                this.handlePacket(buffer, true);
+            if (packet.status !== protocol_1.PlayStatus.LoginSuccess) {
+                utils_1.Logger.error("Bridge login failed");
+                return;
+            }
+            this.client.handlePacket = (buffer) => {
+                this.routePacket(buffer, true);
             };
-            this.player.processPacket = (buffer) => {
-                this.handlePacket(buffer, false);
+            this.player.handlePacket = (buffer) => {
+                this.routePacket(buffer, false);
             };
         });
-        this.client.on("DisconnectPacket", (packet) => this.bridge.disconnect(this));
-        this.player.on("DisconnectPacket", (packet) => this.bridge.disconnect(this));
-        this.on("clientBound-DisconnectPacket", (signal) => this.bridge.disconnect(this));
-        this.on("serverBound-DisconnectPacket", (signal) => this.bridge.disconnect(this));
-        this.bridge.on("disconnect", () => this.bridge.disconnect(this));
+        this.client.on("DisconnectPacket", () => this.bridge.disconnect(this));
+        this.player.on("DisconnectPacket", () => this.bridge.disconnect(this));
+        this.on("clientBound-DisconnectPacket", () => this.bridge.disconnect(this));
+        this.on("serverBound-DisconnectPacket", () => this.bridge.disconnect(this));
         this.client.connect();
     }
-    handlePacket(rawBuffer, clientBound) {
+    routePacket(rawBuffer, clientBound) {
         let buffer = rawBuffer;
         const id = (0, protocol_1.getPacketId)(rawBuffer);
         const PacketClass = protocol_1.Packets[id];
-        const event = PacketClass
-            ? `${clientBound ? "client" : "server"}Bound-${PacketClass.name}`
-            : "Unknown";
-        if (this.hasListeners(event) &&
-            event !== "Unknown") {
+        if (!PacketClass) {
+            if (clientBound)
+                this.player.send(buffer);
+            else
+                this.client.send(buffer);
+            return;
+        }
+        const event = `${clientBound ? "client" : "server"}Bound-${PacketClass.name}`;
+        if (this.listenerCount(event) > 0) {
             const ctx = {
                 packet: new PacketClass(buffer).deserialize(),
                 cancelled: false,

package/dist/bridge/bridge.d.ts

@@ -1,15 +1,13 @@
-import type { ForceArray } from "../shared/emitter";
+import { Emitter } from "@baltica/utils";
 import { Server } from "../server";
 import { BridgePlayer } from "./bridge-player";
 import { type BridgeOptions } from "./types";
 import type { BridgeEvents } from "./types/bridge-events";
-export declare class Bridge extends Server {
+export declare class Bridge extends Emitter<BridgeEvents> {
     options: BridgeOptions;
+    server: Server;
     private clients;
     constructor(options: Partial<BridgeOptions>);
     start(): Promise<void>;
     disconnect(player: BridgePlayer): void;
-    emit: <K extends keyof BridgeEvents>(name: K, ...args: ForceArray<BridgeEvents[K]>) => void;
-    on: <K extends keyof BridgeEvents>(name: K, callback: (...args: ForceArray<BridgeEvents[K]>) => void) => void;
-    once: <K extends keyof BridgeEvents>(name: K, callback: (...args: ForceArray<BridgeEvents[K]>) => void) => void;
 }

package/dist/bridge/bridge.js

@@ -1,41 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bridge = void 0;
+const utils_1 = require("@baltica/utils");
 const protocol_1 = require("@serenityjs/protocol");
 const server_1 = require("../server");
 const bridge_player_1 = require("./bridge-player");
 const types_1 = require("./types");
-class Bridge extends server_1.Server {
+class Bridge extends utils_1.Emitter {
+    options;
+    server;
+    clients = new Map();
     constructor(options) {
-        super(options);
-        this.clients = new Map();
-        this.options = {
-            ...types_1.defaultBridgeOptions,
-            ...options,
-        };
+        super();
+        this.options = { ...types_1.defaultBridgeOptions, ...options };
+        this.server = new server_1.Server(this.options);
     }
     async start() {
-        super.start();
-        // @ts-ignore
-        this.on("playerConnect", (player) => {
+        await this.server.start();
+        this.server.on("playerConnect", (player) => {
             const bridgePlayer = new bridge_player_1.BridgePlayer(player, this);
-            console.log(`Player ${player.connection.getAddress().address} connected to bridge`);
-            const key = `${player.connection.getAddress().address}:${player.connection.getAddress().port}`;
+            const key = player.connection.identifier;
+            utils_1.Logger.info(`Player ${key} connected to bridge`);
             this.clients.set(key, bridgePlayer);
             this.emit("connect", bridgePlayer);
         });
     }
     disconnect(player) {
-        console.log("Disconnecting player", player.player.username);
-        const disconnect = new protocol_1.DisconnectPacket();
-        disconnect.hideDisconnectScreen = false;
-        disconnect.message = new protocol_1.DisconnectMessage("Client leaving", "");
-        disconnect.reason = protocol_1.DisconnectReason.LegacyDisconnect;
-        player.client.send(disconnect.serialize());
+        utils_1.Logger.info(`Disconnecting player ${player.player.username}`);
+        try {
+            const packet = new protocol_1.DisconnectPacket();
+            packet.hideDisconnectScreen = false;
+            packet.message = new protocol_1.DisconnectMessage("Client leaving", "");
+            packet.reason = protocol_1.DisconnectReason.LegacyDisconnect;
+            player.client?.send(packet.serialize());
+        }
+        catch { }
         this.emit("disconnect", player);
-        const key = `${player.player.connection.getAddress().address}:${player.player.connection.getAddress().port}`;
+        const key = player.player.connection.identifier;
         this.clients.delete(key);
-        this.onDisconnect(player.player);
+        this.server.onDisconnect(player.player);
     }
 }
 exports.Bridge = Bridge;

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

@@ -1,4 +1,4 @@
-import { type ServerOptions } from "../../index";
+import { type ServerOptions } from "../../server";
 export type BridgeOptions = ServerOptions & {
     destination: {
         address: string;

package/dist/bridge/types/bridge-options.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultBridgeOptions = void 0;
-const index_1 = require("../../index");
+const server_1 = require("../../server");
 exports.defaultBridgeOptions = {
-    ...index_1.defaultServerOptions,
+    ...server_1.defaultServerOptions,
     destination: {
-        address: "193.180.211.84",
+        address: "127.0.0.1",
         port: 19132,
     },
     offline: false,

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

@@ -1,24 +1,12 @@
 import type * as Protocol from "@serenityjs/protocol";
 import type { PacketNames } from "../../shared/types";
-export type BridgeEventSignal = {
-    packet: InstanceType<(typeof Protocol)[PacketNames]>;
+export type BridgePacketSignal<T = Protocol.DataPacket> = {
+    packet: T;
     cancelled: boolean;
     modified: boolean;
 };
 export type BridgePlayerEvents = {
-    [K in PacketNames as `clientBound-${K}`]: [
-        signal: {
-            packet: InstanceType<(typeof Protocol)[K]>;
-            cancelled: boolean;
-            modified: boolean;
-        }
-    ];
+    [K in PacketNames as `clientBound-${K}`]: [signal: BridgePacketSignal<InstanceType<(typeof Protocol)[K]>>];
 } & {
-    [K in PacketNames as `serverBound-${K}`]: [
-        signal: {
-            packet: InstanceType<(typeof Protocol)[K]>;
-            cancelled: boolean;
-            modified: boolean;
-        }
-    ];
+    [K in PacketNames as `serverBound-${K}`]: [signal: BridgePacketSignal<InstanceType<(typeof Protocol)[K]>>];
 };

package/dist/bridge/types/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./bridge-options";
+export * from "./bridge-events";
 export * from "./bridge-player-events";

package/dist/bridge/types/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./bridge-options"), exports);
+__exportStar(require("./bridge-events"), exports);
 __exportStar(require("./bridge-player-events"), exports);

package/dist/client/client.d.ts

@@ -1,70 +1,37 @@
-import { Client as RaknetClient, ConnectionStatus } from "@sanctumterra/raknet";
-import { DataPacket, type StartGamePacket } from "@serenityjs/protocol";
-import { Emitter, PacketCompressor, PacketEncryptor, type Profile } from "../shared";
-import { ClientData, type ClientEvents, type ClientOptions } from "./types";
-import { WorkerClient } from "./worker";
-/**
- * Client class represents a Minecraft Bedrock Edition client.
- * It handles connection, authentication, packet processing, encryption, and communication with the server.
- * It supports both online and offline modes, as well as worker threads for networking.
- * It emits various events for packet handling and connection status changes.
- * It does not handle game logic; that is left to the user of the class.
- * It is designed to be extensible and customizable through options and event listeners.
- * Thanks for reading my yap session. :)
- */
+import { Priority, Client as Raknet } from "@baltica/raknet";
+import { Emitter } from "@baltica/utils";
+import { ClientEvents, ClientOptions, LoginData, PlayerProfile } from "./types";
+import { PacketEncryptor } from "../shared/serializer/packet-encryptor";
+import { PacketCompressor } from "../shared/serializer/packet-compressor";
+import { CompressionMethod, StartGamePacket } from "@serenityjs/protocol";
 export declare class Client extends Emitter<ClientEvents> {
-    /** Client Options that change decisions duh. */
     options: ClientOptions;
-    /** Raknet Connection (Normal or Worker) */
-    raknet: RaknetClient | WorkerClient;
-    /** Whether session is ready and we are set to go and connect. */
-    sessionReady: boolean;
-    /** Authentication profile */
-    profile: Profile;
-    /** Whether encryption is enabled or not */
-    _encryptionEnabled: boolean;
-    /** Whether compression is enabled or not */
-    _compressionEnabled: boolean;
-    /** Client username (This will be set automatically based on authentication and offline mode) */
-    username: string;
-    /** Client Data for auth and login. */
-    data: ClientData;
-    /** Client status in this attempted connection */
-    status: ConnectionStatus;
-    /** Packet Compression (class for simplicfication) */
+    raknet: Raknet;
+    packetEncryptor: PacketEncryptor | null;
     packetCompressor: PacketCompressor;
-    /** Packet Encryptor (class for simplification) */
-    packetEncryptor: PacketEncryptor;
-    /** Secret Key bytes */
-    secretKeyBytes: Buffer;
-    /** IV bytes for Encryption */
-    iv: Buffer;
-    /** StartGameData that includes a lot of importand data */
+    profile: PlayerProfile;
+    loginData: LoginData;
+    stopPastLogin: boolean;
     startGameData: StartGamePacket;
-    /** Whether we should continue after sending Login (Proxy use) */
-    cancelPastLogin: boolean;
-    private disconnectReason?;
     constructor(options: Partial<ClientOptions>);
-    /** Connect to the server and start sending/receiving packets. */
-    connect(): Promise<[StartGamePacket]>;
-    private handleEncapsulated;
-    /**
-     * Packets must be decompressed and decrypted already
-     */
-    processPacket(buffer: Buffer): void;
-    /** Do not call this, leaving it public incase someone needs to override this for some reason. */
-    handleGamePackets(): void;
-    disconnect(reason?: string): void;
-    private cleanup;
-    startEncryption(iv: Buffer): void;
-    /**
-     * Sends Packets to the server.
-     *
-     * Please use send for important packets and queue for less important packets.
-     */
-    private sendPacket;
-    send(packet: DataPacket | Buffer): void;
-    queue(packet: DataPacket | Buffer): void;
-    /** Fully destroy the client and clean up all resources */
-    destroy(): void;
+    connect(): Promise<void>;
+    private registerHandshakeHandlers;
+    private onNetworkSettings;
+    private onServerHandshake;
+    enableEncryption(secretKeyBytes: Buffer, iv: Buffer): void;
+    private registerLoginSequenceHandlers;
+    private onResourcePacksInfo;
+    private onResourcePackStack;
+    private onStartGame;
+    private onPlayStatus;
+    private registerDiagnosticHandlers;
+    private authenticate;
+    private authenticateOffline;
+    private authenticateOnline;
+    private applyAuthResult;
+    private requestNetworkSettings;
+    send(packet: Buffer | Buffer[], priority?: Priority, compressionMethod?: CompressionMethod): void;
+    onEncapsulated(packet: Buffer): void;
+    handlePacket(buffer: Buffer): void;
+    sendUncompressed(packet: Buffer, priority?: Priority): void;
 }