@vaitosoi/minejs 0.2.2 → 0.4.0

package/src/client/client.ts

@@ -1,115 +1,238 @@
-import { EventEmitter } from "node:stream";
-import { BlockManager, BlockState } from "../base/block";
-import { EntitiesManager } from "../base/entity";
-import { MoveDirection, Player } from "../base/player";
-import { TickLoop } from "../base/tick";
-import { Entity, Message, TCPClient, TCPClientEvents, TCPClientOption, TextComponent } from "./tcp";
-import { TypedEmmiter } from "../base/event";
-import { BlockRegistry, EntityRegistry } from "../base/registry";
-import { BaseVec3, Vec3 } from "../base/direction";
+import { EventEmitter } from "node:events";
+import { BlockManager, BlockState } from "../world/block";
+import { EntitiesManager } from "../world/entity";
+import { Input, Player } from "../physics/player";
+import { TickLoop } from "../world/tick";
+import { Message, TCPClient, TCPClientOption } from "./tcp";
+import { TypedEmmiter as TypedEmitter } from "../base/event";
+import { BlockRegistry, EntityRegistry, PacketRegistry, ProtocolVersionMapping } from "../version/registry";
+import { BaseVec3, Vec3 } from "../physics/direction";
+import { TextComponent } from "../base/typing";
+import { ClientStatus, ConnectionState, EmittedEvent as EmittedEvent, Entity, SharedState } from "../world/state";
+import { Dispatcher } from "../packet/dispatcher";
+import { VersionCodec } from "../version/codec";
+import { AuthClient } from "./auth";
+import { computeUUID } from "../base/math";
+import { HaveSignatureButNotIndex } from "../base/error";
+
+export type ClientOption = Omit<TCPClientOption, "protocolVersion"> & {
+    version: string,
+
+    /**
+     * Whenever should the client verify the message against the signature, if any
+     * 
+     * When set this option to true, you HAVE TO set `shouldVerifyMessageOrder` to true
+     */
+    shouldVerifyMessageSignature?: boolean
+
+    /**
+     * Should verify the message orders to keep the sync with server.
+     */
+    shouldVerifyMessageOrder?: boolean
+}
 
 export interface ClientEvents {
-    ready: [readyClient: Client<true>],
+    // TCP Events
+    /** When the TCP socket connect is initted sucessfully */
+    connect: [],
+    /** When the TCP socket connection is destroyed */
+    destroy: [],
+
+    /**
+     * When the client is ready.
+     * 
+     * Specifically, when the packet `Login (play)` is received
+     */
+    ready: [],
+    /**
+     * When the client got disconnected from sevrer
+     */
     disconnect: [reason: string],
+    /**
+     * When the disconection come with the raw Text Component
+     */
     disconnectRaw: [textComponent: TextComponent],
 
+    /**
+     * When server send `Player Position Synchronization` packet
+     * 
+     * Note: this event is not fired when the client is moved by holding the input
+     */
     playerPosition: [position: BaseVec3],
 
+    /** When the chunk is loaded */
     loadChunk: [chunkX: number, sectionY: number, chunkZ: number],
+    /** When the chunk got deleted by the server */
     unloadChunk: [chunkX: number, chunkZ: number],
 
+    /** When an entity is spawned or appeared in the client view distance */
     spawnEntity: [entity: Entity],
-    updateEntity: [entity: Entity],
+    /** When an entity is updated, including position, rotation, etc... */
+    updateEntity: [entityId: number],
+    /** When an entity go out of client view distance or despawned */
     removeEntity: [entityId: number],
 
     // Chat
+    /** When a chat message got broadcasted */
     message: [message: Message],
+    /** When a message is failed to be verified against the signature sent with it */
+    failedMessage: [message: Message],
+    /** The system message */
     systemMessage: [message: string],
+    /** The raw system message */
     systemMessageRaw: [textComponent: TextComponent],
+    /** The action bar */
     actionBar: [message: string],
+    /** The raw action bar */
     actionBarRaw: [textComponent: TextComponent],
 }
 
 /**
  * High-level client.
  */
-export class Client<IsTCPReady extends boolean = boolean> extends (EventEmitter as new () => TypedEmmiter<ClientEvents>) {
+export class Client<IsReady extends boolean = boolean> extends (EventEmitter as new () => TypedEmitter<ClientEvents>) {
+    private static loadRegistry: boolean = false;
+
     private tickLoop: TickLoop;
 
-    private tcp: TCPClient<IsTCPReady>;
     private blocks: BlockManager;
     private entities: EntitiesManager;
     private player: Player;
 
-    constructor(options: TCPClientOption) {
+    private tcp: TCPClient;
+    private state: SharedState<IsReady>;
+
+    constructor(private options: ClientOption) {
+        if (options.shouldVerifyMessageSignature === true && options.shouldVerifyMessageOrder !== true)
+            throw new HaveSignatureButNotIndex();
+
         super();
-        BlockRegistry.load();
-        EntityRegistry.load();
-
-        this.tcp = new TCPClient(options);
-        this.blocks = new BlockManager(this.tcp);
-        this.entities = new EntitiesManager(this.tcp);
-        this.player = new Player(this.entities, this.blocks, this.tcp);
-        this.tickLoop = new TickLoop(() => this.player.tick());
-        this.forwardEvents();
+
+        // For managing shared data
+        this.state = new SharedState(options);
+        // For handling packet
+        const dispatcher = new Dispatcher(this.state, this.emit.bind(this));
+        // For reading packet
+        const versionCodec = new VersionCodec(this.state);
+        // For throwing packet through internet
+        this.tcp = new TCPClient(
+            this.state,
+            {
+                ...options,
+                protocolVersion: ProtocolVersionMapping[options.version]!
+            }
+        );
+
+        this.tcp.forwardPacket = versionCodec.handlePacket.bind(versionCodec);
+        this.tcp.parsePacket = versionCodec.encodePacket.bind(versionCodec);
+        this.tcp.sendInitPacket = () => {
+            dispatcher.sendHandshake();
+            dispatcher.sendLoginStart();
+        };
+        dispatcher.sendPacket = this.tcp.sendPacket.bind(this.tcp);
+        dispatcher.disconnect = this.disconnect.bind(this);
+        versionCodec.consumePacket = dispatcher.handlePacket.bind(dispatcher);
+
+        // For querying data
+        this.blocks = new BlockManager(this.state);
+        this.entities = new EntitiesManager(this.state);
+        // For physics things
+        this.player = new Player(
+            this.state,
+            this.on,
+            this.entities,
+            this.blocks,
+        );
+        this.player.sendPlayerPos = dispatcher.sendPlayerPos;
+        this.player.sendPlayerPosRot = dispatcher.sendPlayerPosRot;
+        this.player.sendPlayerRot = dispatcher.sendPlayerRot;
+        this.player.sendPlayerStatus = dispatcher.sendPlayerStatus;
+
+        // For tick-tock tick-tock
+        this.tickLoop = new TickLoop(() => {
+            this.state.drainMutation();
+            this.state.drainEvent()
+                .forEach(event => this.emitEvent(event));
+            this.state.drainPacket()
+                .forEach((packet) => this.tcp.sendPacket(packet.id, packet.data));
+            this.player.tick();
+        });
+
+        // Forward TCP events
+        this.tcp.on("connect", () => this.emit("connect"));
+        this.tcp.on("destroy", () => this.emit("destroy"));
     }
 
-    private forwardEvent(eventName: keyof ClientEvents & keyof TCPClientEvents) {
-        this.tcp.on(eventName, (...args) => this.emit(eventName, ...args));
+    private emitEvent(event: EmittedEvent) {
+        this.emit(event.event, ...event.args);
     }
-    private forwardEvents() {
-        this.forwardEvent("disconnect");
-        this.forwardEvent("disconnectRaw");
-        this.forwardEvent("loadChunk");
-        this.forwardEvent("unloadChunk");
-        this.forwardEvent("playerPosition");
-        this.forwardEvent("spawnEntity");
-        this.forwardEvent("updateEntity");
-        this.forwardEvent("removeEntity");
-        this.forwardEvent("message");
-        this.forwardEvent("systemMessage");
-        this.forwardEvent("systemMessageRaw");
-        this.forwardEvent("actionBar");
-        this.forwardEvent("actionBarRaw");
+
+    private async loadRegistries() {
+        if (Client.loadRegistry) return;
+        Client.loadRegistry = true;
+        await BlockRegistry.load(this.options.version);
+        await EntityRegistry.load(this.options.version);
+        await PacketRegistry.load(this.options.version);
     }
 
     // Start / stop
+
     /**
      * Create a connection to the server
      */
-    public connect() {
+    public async connect() {
+        await this.loadRegistries();
+        if (!this.state.playerUUID) {
+            if (this.options.auth) {
+                this.state.authClient = new AuthClient(this.options.auth);
+                const { uuid } = await this.state.authClient.getUUID();
+                this.state.playerUUID = uuid.replaceAll("-", "");
+                await this.state.startSignatureLoop();
+            } else
+                this.state.playerUUID = computeUUID(this.options.playerName);
+        }
+
         this.tcp.connect();
 
-        this.tcp.once("ready", () => {
-            this.emit("ready", this as Client<true>);
+        this.once("ready", () => {
             this.player.pruneInitialVal();
             this.player.setInitialVal();
             this.tickLoop.start();
         });
-        this.tcp.once("disconnect", () => {
-            this.tickLoop.stop();
-            this.player.pruneInitialVal();
+        this.tcp.once("destroy", () => {
+            if (this.state.state === ConnectionState.Disconnected) return;
+            this.disconnect("socket close");
         });
     }
     /**
      * Destroy the connection
      */
-    public disconnect() {
+    public disconnect(reason: string = "Disconnect", raw?: TextComponent) {
+        this.state.state = ConnectionState.Disconnected;
+        this.state.status = ClientStatus.Disconnected;
+        this.tickLoop.stop();
+        this.player.pruneInitialVal();
+        this.state.pruneStates();
+        this.emit("disconnect", reason);
+        if (raw)
+            this.emit("disconnectRaw", raw);
         this.tcp.disconnect();
+        if (this.options.auth)
+            this.state.stopSignatureLoop();
     }
 
     // Inputs
     /**
      * Press and hold a key
      */
-    public hold(direction: MoveDirection) {
-        this.player.input(direction);
+    public hold(inout: Input) {
+        this.player.input(inout);
     }
     /**
      * Release a key
      */
-    public release(direction: MoveDirection) {
-        this.player.releaseInput(direction);
+    public release(input: Input) {
+        this.player.releaseInput(input);
     }
     /**
      * Release all key
@@ -128,4 +251,13 @@ export class Client<IsTCPReady extends boolean = boolean> extends (EventEmitter
         const vec3 = Vec3.loadArgs(a, b, c);
         return this.blocks.at(vec3);
     }
+
+    /**
+     * Rotate your face
+     * @param yaw In degree
+     * @param pitch In degree
+     */
+    public lookAt(yaw: number, pitch: number) {
+        this.player.setAngle(yaw, pitch);
+    }
 }