@vaitosoi/minejs 0.2.2 → 0.3.1

package/src/{translator → packet}/encoder.ts

@@ -1,8 +1,17 @@
-import { Vec3 } from "../base/direction";
+import { Vec3 } from "../physics/direction";
 import { CONTINUATION_FLAG, CONTINUE_BIT, isFixedSizeTag, isTag, MAX_QUANTIZED_VALUE, SCALE_BITS, SEGMENT_BITS } from "./static";
 import { InvalidValue, NumberTooBig, UnexpectedValue } from "../base/error";
 import { FixedSizeTag, Tag } from "./static";
 
+export function makeMovementFlag(onGround: boolean, pushingWall: boolean) {
+    let flag = 0;
+    if (onGround)
+        flag &= 1;
+    if (pushingWall)
+        flag |= 1 << 2;
+    return flag;
+}
+
 export class BinaryEncoder {
     private buffer = Buffer.alloc(0);
 
@@ -14,8 +23,9 @@ export class BinaryEncoder {
         this.buffer = Buffer.alloc(0);
     }
 
-    public concat(buf: Buffer) {
+    public writeRaw(buf: Buffer) {
         this.buffer = Buffer.concat([this.buffer, buf]);
+        return this;
     }
 
 
@@ -27,7 +37,7 @@ export class BinaryEncoder {
     public write(size: number, val: any, writeFunc: (buf: Buffer) => ((val: any) => void)) {
         const buf = Buffer.alloc(size);
         writeFunc(buf).bind(buf)(val);
-        this.concat(buf);
+        this.writeRaw(buf);
         return this;
     }
 
@@ -129,7 +139,7 @@ export class BinaryEncoder {
      */
     public writeString(str: string) {
         this.writeVarInt(str.length);
-        this.concat(Buffer.from(str));
+        this.writeRaw(Buffer.from(str));
         return this;
     }
 
@@ -171,7 +181,7 @@ export class BinaryEncoder {
             else return val;
         });
         this.writeVarInt(length);
-        this.concat(Buffer.concat(array));
+        this.writeRaw(Buffer.concat(array));
         return this;
     }
 
@@ -187,7 +197,7 @@ export class BinaryEncoder {
     public writeRawPrefixedArray(data: Buffer, size: number) {
         const length = Math.ceil(data.length / size);
         this.writeVarInt(length);
-        this.concat(data);
+        this.writeRaw(data);
         return this;
     }
 
@@ -224,8 +234,9 @@ export class BinaryEncoder {
                 this.writeVarInt(Number(scaleFactor >> 2n));
             }
         }
-    }
 
+        return this;
+    }
 }
 
 type CompoundField = any | {
@@ -306,7 +317,7 @@ export class NBTEncoder extends BinaryEncoder {
     public writeString(str: string) {
         this.writeUShort(str.length);
         if (str.length === 0) return this;
-        this.concat(Buffer.from(str));
+        this.writeRaw(Buffer.from(str));
         return this;
     }
 
@@ -322,7 +333,7 @@ export class NBTEncoder extends BinaryEncoder {
             for (const item of arr)
                 this.writeString(item);
         else
-            this.concat(Buffer.from(arr));
+            this.writeRaw(Buffer.from(arr));
         return this;
     }
 

package/src/{base → physics}/aabb.ts

@@ -1,9 +1,9 @@
-import { BitSet } from "./bitset";
+import { BitSet } from "../base/bitset";
 import { Axis, AxisCycle, BaseAxis, BaseVec3, Direction, Vec3 } from "./direction";
-import { RegistryItemNotFound } from "./error";
-import { EntityRegistry } from "./registry";
-import { Epsilon, lowerBoundBinarySearch } from "./math";
-import { BlockHitResult } from "./block";
+import { RegistryItemNotFound } from "../base/error";
+import { EntityRegistry } from "../version/registry";
+import { Epsilon, lowerBoundBinarySearch } from "../base/math";
+import { BlockHitResult } from "../world/block";
 
 export interface BaseAABB {
     minX: number;

package/src/{base → physics}/player.ts

@@ -1,11 +1,14 @@
-import { EntitiesManager } from "./entity";
+import { EntitiesManager } from "../world/entity";
 import { Angle, Axis, BaseAxis, BaseVec3, Vec3 } from "./direction";
 import { AABB, Shapes, VoxelShape } from "./aabb";
-import { BlockGetter, BlockManager, BlockState } from "./block";
-import { clamp, Epsilon, equal, lerp } from "./math";
-import { TCPClient } from "../client/tcp";
-import { ClientNotReady } from "./error";
+import { BlockGetter, BlockManager, BlockState } from "../world/block";
+import { clamp, Epsilon, equal, lerp } from "../base/math";
+import { ClientNotReady } from "../base/error";
 import { LevelHeightLimit } from "../client/static";
+import { SharedState } from "../world/state";
+import { TypedEmmiter } from "../base/event";
+import { ClientEvents } from "../client/client";
+import { makeMovementFlag } from "../packet/encoder";
 
 export enum MoveDirection {
     Forward = "W",
@@ -54,15 +57,16 @@ export class Player {
     private lastOnGround: boolean = true;
 
     constructor(
+        private state: SharedState,
+        private on: TypedEmmiter<ClientEvents>["on"],
         private entities: EntitiesManager,
         private blocks: BlockManager,
-        private tcp: TCPClient
     ) {
-        this.tcp.on("playerPosition", () => {
+        this.on("playerPosition", () => {
             this.onGround = true;
             this.horizontalCollision = false;
             this.fallDistance = 0;
-            this.deltaMovement = new Vec3(this.tcp.player!.velocity);
+            this.deltaMovement = new Vec3(this.state.player!.velocity);
         });
     }
 
@@ -132,20 +136,20 @@ export class Player {
 
     /* Getting helper, from TCP client */
     private getPos() {
-        this.tcp.checkReady();
-        return new Vec3(this.tcp.player!.position);
+        this.state.checkReady();
+        return new Vec3(this.state.player!.position);
     }
     private setPos(pos: Vec3) {
-        this.tcp.checkReady();
-        this.tcp.player!.position = pos.copyBase();
+        this.state.checkReady();
+        this.state.player!.position = pos.copyBase();
     }
     private getAngle() {
-        this.tcp.checkReady();
-        return this.tcp.player!.angle;
+        this.state.checkReady();
+        return this.state.player!.angle;
     }
     private getDimension() {
-        this.tcp.checkReady();
-        return this.tcp.player!.dimension;
+        this.state.checkReady();
+        return this.state.player!.dimension;
     }
 
     private setDeltaMovement(x: number, y: number, z: number): void;
@@ -217,7 +221,7 @@ export class Player {
      * Ticking
      */
     public tick() {
-        if (!this.tcp.isReady()) return;
+        if (!this.state.isReady()) return;
         if (!this.lastPos || !this.lastAngle) throw new ClientNotReady();
 
         // console.log("tick");
@@ -226,7 +230,7 @@ export class Player {
         this.aiStep();
         const { x, y, z } = this.getPos(),
             { x: xLast, y: yLast, z: zLast } = this.lastPos,
-            { yaw: xRot, pitch: yRot } = this.getAngle(),
+            { yaw, yaw: xRot, pitch, pitch: yRot } = this.getAngle(),
             { yaw: xRotLast, pitch: yRotLast } = this.lastAngle;
         const deltaX = x - xLast,
             deltaY = y - yLast,
@@ -237,16 +241,28 @@ export class Player {
         const move = new Vec3(deltaX, deltaY, deltaZ).lengthSqr() > (2e-4 * 2e-4) || this.positionReminder > 20,
             rot = deltaXRot !== 0 || deltaYRot !== 0;
         if (move && rot)
-            this.tcp.sendPlayerPosRot(this.getPos(), this.getAngle(), this.onGround, this.horizontalCollision);
+            this.state.enqueuePacket("move_player_pos_rot", {
+                x, feet_y: y, z,
+                yaw, pitch,
+                flags: makeMovementFlag(this.onGround, this.horizontalCollision)
+            });
         else if (move)
-            this.tcp.sendPlayerPos(this.getPos(), this.onGround, this.horizontalCollision);
+            this.state.enqueuePacket("move_player_pos", {
+                x, feet_y: y, z,
+                flags: makeMovementFlag(this.onGround, this.horizontalCollision)
+            });
         else if (rot)
-            this.tcp.sendPlayerRot(this.getAngle(), this.onGround, this.horizontalCollision);
+            this.state.enqueuePacket("move_player_rot", {
+                yaw, pitch,
+                flags: makeMovementFlag(this.onGround, this.horizontalCollision)
+            });
         else if (
             this.onGround !== this.lastOnGround ||
             this.horizontalCollision !== this.lastHorizontalCollision
         )
-            this.tcp.sendPlayerStatus(this.onGround, this.horizontalCollision);
+            this.state.enqueuePacket("move_player_status_only", {
+                flags: makeMovementFlag(this.onGround, this.horizontalCollision)
+            });
 
         if (move) {
             this.lastPos = this.getPos();
@@ -503,7 +519,7 @@ export class Player {
 
     private collide(movement: Vec3): Vec3 {
         // Get player's bounding box
-        const { x: playerX, y: playerY, z: playerZ } = this.tcp.player!.position;
+        const { x: playerX, y: playerY, z: playerZ } = this.state.player!.position;
         const playerBB = AABB.fromEntityType("minecraft:player")
             .move(playerX, playerY, playerZ);
         const expandedBB = playerBB.expandTowards(movement);
@@ -515,7 +531,7 @@ export class Player {
         // });
 
         // Collect all colliders
-        const colliders = this.collectColliders(expandedBB, [this.tcp.player!.entityId]);
+        const colliders = this.collectColliders(expandedBB, [this.state.player!.entityId]);
         // // console.log('nonEmptyColliders', colliders.filter(c => !c.isEmpty()).length);
 
         // Get the farest distance can move
@@ -535,7 +551,7 @@ export class Player {
             if (!onGroundAfterCollision)
                 stepUpAABB = stepUpAABB.expandTowards(0, -1e-5, 0);
 
-            const colliders = this.collectColliders(stepUpAABB, [this.tcp.player!.entityId]);
+            const colliders = this.collectColliders(stepUpAABB, [this.state.player!.entityId]);
             const stepHeightToSkip = movementStep.y;
             const stepUpCandidateSet: Set<number> = new Set();
             for (const collider of colliders) {

package/src/version/codec.ts

@@ -0,0 +1,227 @@
+import z, { file } from "zod";
+import { MissingField, MissingPacketField, UnexpectedValue } from "../base/error";
+import { BinaryDecoder } from "../packet/decoder";
+import { ConnectionState, SharedState } from "../world/state";
+import { FieldNode, PacketObject, PacketRegistry, VersionDefinitions } from "./registry";
+import { Dispatcher } from "../packet/dispatcher";
+import { BinaryEncoder } from "../packet/encoder";
+
+const TCPStateMapping: Record<ConnectionState, keyof z.infer<typeof VersionDefinitions> | null> = {
+    [ConnectionState.Disconnected]: null,
+    [ConnectionState.Handshake]: "handshaking",
+    [ConnectionState.Login]: "login",
+    [ConnectionState.Configure]: "configuration",
+    [ConnectionState.Play]: "play",
+};
+
+export interface EncodeResult {
+    buffer: Buffer,
+    packet: z.infer<typeof PacketObject>,
+}
+
+export class VersionCodec {
+    constructor(private readonly state: SharedState) { }
+
+    public consumePacket: (packetId: string, data: object) => void = (...args) => { throw new Error("method not implemented"); };
+
+    public handlePacket(packetId: number, decoder: BinaryDecoder) {
+        const mappedState = TCPStateMapping[this.state.state];
+        if (!mappedState) return; // console.log("no state");
+        const packet = PacketRegistry.getPacket(mappedState, "clientbound", packetId);
+        if (!packet) return; // console.log("no packet");
+
+        const { name, structure, skipForNow } = packet;
+        if (skipForNow) return;
+        // console.log(`> packet ${name}`);
+        const resolvedObject: Record<string, any> = {};
+        for (const [name, field] of Object.entries(structure)) {
+            // console.log({ name, resolvedObject });
+            resolvedObject[name] = this.readField(packetId, resolvedObject, name, field, decoder);
+        }
+
+        this.consumePacket(`${TCPStateMapping[this.state.state]}:${name}`, resolvedObject);
+    }
+
+    public encodePacket(packetId: number | string, data: Record<string, any>): EncodeResult {
+        const mappedState = TCPStateMapping[this.state.state];
+        if (!mappedState) throw new UnexpectedValue("map-able state", this.state.state.toString());
+        const packet = PacketRegistry.getPacket(mappedState, "serverbound", packetId);
+        if (!packet) throw new UnexpectedValue("valid serverbound packet id", packetId.toString());
+
+        const { name: packetName, structure } = packet;
+        let encoder = new BinaryEncoder();
+        for (const [name, field] of Object.entries(structure)) {
+            if (!(name in data))
+                throw new MissingField(name, `packet ${packetName}`);
+            if (typeof data[name] === "object")
+                if ("value" in data[name])
+                    if ("metadata" in data[name])
+                        encoder = this.writeField(field, encoder, data[name]["value"], data[name]["metadata"]);
+                    else if ("length" in data[name])
+                        encoder = this.writeField(field, encoder, data[name]["value"], { length: data[name]["length"] });
+                    else
+                        encoder = this.writeField(field, encoder, data[name]["value"]);
+                else
+                    encoder = this.writeField(field, encoder, data[name]);
+            else
+                encoder = this.writeField(field, encoder, data[name]);
+        }
+        return { buffer: encoder.getBuffer(), packet };
+    }
+
+    private readField(
+        // Current reading state
+        packetId: number,
+        readObject: Record<string, any>,
+
+        // Current field
+        fieldName: string,
+        field: FieldNode,
+        decoder: BinaryDecoder
+    ): any {
+        switch (field.type) {
+            case "string": return decoder.readString();
+            case "boolean": return decoder.readBoolean();
+            case "byte": return decoder.readByte();
+            case "unsigned_byte": return decoder.readUByte();
+            case "short": return decoder.readShort();
+            case "unsigned_short": return decoder.readUShort();
+            case "int": return decoder.readInt();
+            case "long": return decoder.readLong();
+            case "float": return decoder.readFloat();
+            case "double": return decoder.readDouble();
+            case "var_int": return decoder.readVarInt();
+            case "var_long": return decoder.readVarLong();
+            case "uuid": return decoder.readUUID();
+            case "position": return decoder.readPosition();
+            case "array": {
+                let length;
+                if (!isNaN(Number(field.length)))
+                    length = Number(field.length);
+                else 
+                    length = readObject[field.length];
+                if (length === undefined) throw new MissingPacketField(packetId, fieldName, field.length.toString());
+                return decoder.readArray(length, (decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            }
+            case "prefixed_array": return decoder.readPrefixedArray((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            case "teleport_flag": return decoder.readTeleportFlag();
+            case "prefixed_optional": return decoder.readPrefixedOptional((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            case "nbt": return decoder.readNBT();
+            case "lpvec3": return decoder.readLpVec3();
+            case "fixed_point": {
+                const value = this.readField(packetId, readObject, fieldName, field.subType, decoder);
+                return decoder.readFixedPoint(value, field.fractionBits);
+            }
+            case "angle": return decoder.readAngle();
+            case "id_or_x": return decoder.readIdOrX((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            case "chat_type_decoration": return decoder.readChatTypeDecoration();
+            case "chat_type": return decoder.readChatType();
+            case "enum": return this.readField(packetId, readObject, fieldName, field.subType, decoder);
+            case "json_text": return JSON.parse(decoder.readString());
+            case "object": {
+                const obj: Record<string, any> = {};
+                for (const [key, type] of Object.entries(field.fields))
+                    obj[key] = this.readField(packetId, readObject, key, type, decoder);
+                return obj;
+            }
+            case "game_profile": {
+                return {
+                    uuid: decoder.readUUID(),
+                    username: decoder.readString(),
+                    pproperties: decoder.readPrefixedArray((decoder) => ({
+                        name: decoder.readString(),
+                        value: decoder.readString(),
+                        signature: decoder.readPrefixedOptional((decoder) => decoder.readString())
+                    }))
+                };
+            }
+            case "heightmap": {
+                return {
+                    type: decoder.readVarInt(),
+                    data: decoder.readPrefixedArray((decoder) => decoder.readLong())
+                };
+            }
+            case "bitset": return decoder.readPrefixedArray((decoder) => decoder.readLong());
+            case "teleport_flags": return decoder.readTeleportFlag();
+            case "null": return null;
+            case "switch": {
+                if (!(field.dependsOn in readObject)) throw new MissingPacketField(packetId, fieldName, field.dependsOn);
+                const dependencyValue = readObject[field.dependsOn];
+                for (const [value, type] of field.cases)
+                    if (dependencyValue === value)
+                        return this.readField(packetId, readObject, fieldName, type, decoder);
+                if (field.default)
+                    return this.readField(packetId, readObject, fieldName, field.default, decoder);
+                return null;
+            }
+        }
+    }
+
+
+    private writeField(
+        field: FieldNode,
+        encoder: BinaryEncoder,
+        value: any,
+        metadata: Record<string, any> = {}
+    ): BinaryEncoder {
+        switch (field.type) {
+            case "string": return encoder.writeString(value);
+            case "boolean": return encoder.writeBoolean(value);
+            case "byte": return encoder.writeByte(value);
+            case "unsigned_byte": return encoder.writeUByte(value);
+            case "short": return encoder.writeShort(value);
+            case "unsigned_short": return encoder.writeUShort(value);
+            case "int": return encoder.writeInt(value);
+            case "long": return encoder.writeLong(value);
+            case "float": return encoder.writeFloat(value);
+            case "double": return encoder.writeDouble(value);
+            case "var_int": return encoder.writeVarInt(value);
+            case "var_long": return encoder.writeVarLong(value);
+            case "uuid": return encoder.writeRaw(value);
+            case "position": return encoder.writePosition(value);
+            // case "array": {
+            //     const length = metadata["length"];
+            //     // if (!length) throw new MissingField(packetId, fieldName, field.length);
+            //     return encoder.writeArray(length, (decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            // }
+            case "prefixed_array": {
+                const length = metadata["length"];
+                if (!length) throw new MissingField("length", "prefixed array metadata object");
+                if (!Array.isArray(value))
+                    throw new UnexpectedValue("an array for prefixed array", typeof value);
+                return encoder.writePrefixedArray(length, (encoder, index) => this.writeField(field.subType, encoder, value[index], metadata));
+            }
+            // case "teleport_flag": return encoder.writeTeleportFlag();
+            // case "prefixed_optional": return encoder.writePrefixedOptional((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            // case "nbt": return encoder.writeNBT(value);
+            case "lpvec3": return encoder.writeLpVec3(value);
+            // case "fixed_point": {
+            //     const value = this.readField(packetId, readObject, fieldName, field.subType, encoder);
+            //     return encoder.writeFixedPoint(value, field.fractionBits);
+            // }
+            // case "angle": return encoder.writeAngle();
+            // case "id_or_x": return encoder.writeIdOrX((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            // case "chat_type_decoration": return encoder.writeChatTypeDecoration();
+            // case "chat_type": return encoder.writeChatType();
+            case "enum": return this.writeField(field.subType, encoder, value, metadata);
+            case "json_text": return encoder.writeString(JSON.parse(value));
+            case "object": {
+                for (const [name, subField] of Object.entries(field.fields))
+                    encoder = this.writeField(subField, encoder, value[name], metadata);
+                return encoder;
+            }
+            // case "switch": {
+            //     const dependencyValue = readObject[field.dependsOn];
+            //     if (!dependencyValue) throw new MissingField(packetId, fieldName, field.dependsOn);
+            //     for (const [value, type] of field.cases)
+            //         if (dependencyValue === value)
+            //             return this.readField(packetId, readObject, fieldName, type, encoder);
+            //     if (field.default)
+            //         return this.readField(packetId, readObject, fieldName, field.default, encoder);
+            //     break;
+            // }
+            default:
+                throw new UnexpectedValue("encoding type", field.type);
+        }
+    }
+}