@vaitosoi/minejs 0.2.1 → 0.3.1

package/src/client/client.ts

@@ -1,15 +1,26 @@
 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 { BlockManager, BlockState } from "../world/block";
+import { EntitiesManager } from "../world/entity";
+import { MoveDirection, 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 { 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";
+
+export type ClientOption = Omit<TCPClientOption, "protocolVersion"> & { version: string }
 
 export interface ClientEvents {
-    ready: [readyClient: Client<true>],
+    connect: [],
+    destroy: [],
+
+    ready: [],
     disconnect: [reason: string],
     disconnectRaw: [textComponent: TextComponent],
 
@@ -19,7 +30,7 @@ export interface ClientEvents {
     unloadChunk: [chunkX: number, chunkZ: number],
 
     spawnEntity: [entity: Entity],
-    updateEntity: [entity: Entity],
+    updateEntity: [entityId: number],
     removeEntity: [entityId: number],
 
     // Chat
@@ -33,60 +44,106 @@ export interface ClientEvents {
 /**
  * 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;
+    private uuid: Buffer = Buffer.alloc(0);
+
+    private tcp: TCPClient;
+    private state: SharedState<IsReady>;
 
-    constructor(options: TCPClientOption) {
+    constructor(private options: ClientOption) {
         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, () => this.uuid);
+        // 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.tcpDisconnect = this.tcp.disconnect.bind(this.tcp);
+        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,
+        );
+
+        // 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();
+        });
     }
 
-    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.uuid.length) {
+            if (this.options.auth) {
+                const authClient = new AuthClient(this.options.auth);
+                const { uuid } = await authClient.auth();
+                this.uuid = Buffer.from(uuid);
+            } else
+                this.uuid = 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.once("disconnect", () => {
             this.tickLoop.stop();
             this.player.pruneInitialVal();
         });