packet-events-js 1.0.0

package/src/protocol/types/NBT.js

@@ -0,0 +1,594 @@
+import { encodeVarInt, decodeVarInt } from './VarInt.js';
+
+export const NBTTagType = Object.freeze({
+    END: 0,
+    BYTE: 1,
+    SHORT: 2,
+    INT: 3,
+    LONG: 4,
+    FLOAT: 5,
+    DOUBLE: 6,
+    BYTE_ARRAY: 7,
+    STRING: 8,
+    LIST: 9,
+    COMPOUND: 10,
+    INT_ARRAY: 11,
+    LONG_ARRAY: 12
+});
+
+export class NBTTag {
+    
+    constructor(type, name = '') {
+        this.type = type;
+        this.name = name;
+    }
+
+    getSize() {
+        throw new Error('Not implemented');
+    }
+}
+
+export class NBTCompound extends NBTTag {
+    
+    constructor(name = '', children = new Map()) {
+        super(NBTTagType.COMPOUND, name);
+        this.children = children;
+    }
+
+    set(name, tag) {
+        tag.name = name;
+        this.children.set(name, tag);
+        return this;
+    }
+
+    get(name) {
+        return this.children.get(name);
+    }
+
+    has(name) {
+        return this.children.has(name);
+    }
+
+    delete(name) {
+        return this.children.delete(name);
+    }
+
+    setByte(name, value) {
+        return this.set(name, new NBTByte(name, value));
+    }
+
+    setShort(name, value) {
+        return this.set(name, new NBTShort(name, value));
+    }
+
+    setInt(name, value) {
+        return this.set(name, new NBTInt(name, value));
+    }
+
+    setLong(name, value) {
+        return this.set(name, new NBTLong(name, value));
+    }
+
+    setFloat(name, value) {
+        return this.set(name, new NBTFloat(name, value));
+    }
+
+    setDouble(name, value) {
+        return this.set(name, new NBTDouble(name, value));
+    }
+
+    setString(name, value) {
+        return this.set(name, new NBTString(name, value));
+    }
+
+    setByteArray(name, value) {
+        return this.set(name, new NBTByteArray(name, value));
+    }
+
+    setIntArray(name, value) {
+        return this.set(name, new NBTIntArray(name, value));
+    }
+
+    setLongArray(name, value) {
+        return this.set(name, new NBTLongArray(name, value));
+    }
+
+    setList(name, listType, values) {
+        return this.set(name, new NBTList(name, listType, values));
+    }
+
+    setCompound(name, compound) {
+        compound.name = name;
+        this.children.set(name, compound);
+        return this;
+    }
+
+    toJSON() {
+        const obj = {};
+        for (const [key, tag] of this.children) {
+            if (tag instanceof NBTCompound) {
+                obj[key] = tag.toJSON();
+            } else if (tag instanceof NBTList) {
+                obj[key] = tag.toJSON();
+            } else {
+                obj[key] = tag.value;
+            }
+        }
+        return obj;
+    }
+}
+
+export class NBTByte extends NBTTag {
+    constructor(name = '', value = 0) {
+        super(NBTTagType.BYTE, name);
+        this.value = value << 24 >> 24;
+    }
+}
+
+export class NBTShort extends NBTTag {
+    constructor(name = '', value = 0) {
+        super(NBTTagType.SHORT, name);
+        this.value = value << 16 >> 16;
+    }
+}
+
+export class NBTInt extends NBTTag {
+    constructor(name = '', value = 0) {
+        super(NBTTagType.INT, name);
+        this.value = value | 0;
+    }
+}
+
+export class NBTLong extends NBTTag {
+    constructor(name = '', value = 0n) {
+        super(NBTTagType.LONG, name);
+        this.value = BigInt(value);
+    }
+}
+
+export class NBTFloat extends NBTTag {
+    constructor(name = '', value = 0.0) {
+        super(NBTTagType.FLOAT, name);
+        this.value = value;
+    }
+}
+
+export class NBTDouble extends NBTTag {
+    constructor(name = '', value = 0.0) {
+        super(NBTTagType.DOUBLE, name);
+        this.value = value;
+    }
+}
+
+export class NBTString extends NBTTag {
+    constructor(name = '', value = '') {
+        super(NBTTagType.STRING, name);
+        this.value = value;
+    }
+}
+
+export class NBTByteArray extends NBTTag {
+    constructor(name = '', value = []) {
+        super(NBTTagType.BYTE_ARRAY, name);
+        this.value = Array.isArray(value) ? value : Array.from(value);
+    }
+}
+
+export class NBTIntArray extends NBTTag {
+    constructor(name = '', value = []) {
+        super(NBTTagType.INT_ARRAY, name);
+        this.value = value;
+    }
+}
+
+export class NBTLongArray extends NBTTag {
+    constructor(name = '', value = []) {
+        super(NBTTagType.LONG_ARRAY, name);
+        this.value = value.map(v => BigInt(v));
+    }
+}
+
+export class NBTList extends NBTTag {
+    constructor(name = '', listType = NBTTagType.END, values = []) {
+        super(NBTTagType.LIST, name);
+        this.listType = listType;
+        this.values = values;
+    }
+
+    push(value) {
+        this.values.push(value);
+    }
+
+    get(index) {
+        return this.values[index];
+    }
+
+    get length() {
+        return this.values.length;
+    }
+
+    toJSON() {
+        return this.values.map(tag => {
+            if (tag instanceof NBTCompound) return tag.toJSON();
+            if (tag instanceof NBTList) return tag.toJSON();
+            return tag.value;
+        });
+    }
+}
+
+export class NBTReader {
+    constructor(buffer, offset = 0) {
+        this.buffer = buffer;
+        this.offset = offset;
+    }
+
+    readByte() {
+        return this.buffer.readInt8(this.offset++);
+    }
+
+    readUByte() {
+        return this.buffer.readUInt8(this.offset++);
+    }
+
+    readShort() {
+        const value = this.buffer.readInt16BE(this.offset);
+        this.offset += 2;
+        return value;
+    }
+
+    readInt() {
+        const value = this.buffer.readInt32BE(this.offset);
+        this.offset += 4;
+        return value;
+    }
+
+    readLong() {
+        const value = this.buffer.readBigInt64BE(this.offset);
+        this.offset += 8;
+        return value;
+    }
+
+    readFloat() {
+        const value = this.buffer.readFloatBE(this.offset);
+        this.offset += 4;
+        return value;
+    }
+
+    readDouble() {
+        const value = this.buffer.readDoubleBE(this.offset);
+        this.offset += 8;
+        return value;
+    }
+
+    readString() {
+        const length = this.readShort();
+        const value = this.buffer.toString('utf8', this.offset, this.offset + length);
+        this.offset += length;
+        return value;
+    }
+
+    read(named = true) {
+        const type = this.readUByte();
+        
+        if (type === NBTTagType.END) {
+            return null;
+        }
+        
+        if (type !== NBTTagType.COMPOUND) {
+            throw new Error(`Expected compound tag, got ${type}`);
+        }
+        
+        const name = named ? this.readString() : '';
+        return this.readCompound(name);
+    }
+
+    readTag(type, name = '') {
+        switch (type) {
+            case NBTTagType.END:
+                return null;
+            case NBTTagType.BYTE:
+                return new NBTByte(name, this.readByte());
+            case NBTTagType.SHORT:
+                return new NBTShort(name, this.readShort());
+            case NBTTagType.INT:
+                return new NBTInt(name, this.readInt());
+            case NBTTagType.LONG:
+                return new NBTLong(name, this.readLong());
+            case NBTTagType.FLOAT:
+                return new NBTFloat(name, this.readFloat());
+            case NBTTagType.DOUBLE:
+                return new NBTDouble(name, this.readDouble());
+            case NBTTagType.BYTE_ARRAY:
+                return this.readByteArray(name);
+            case NBTTagType.STRING:
+                return new NBTString(name, this.readString());
+            case NBTTagType.LIST:
+                return this.readList(name);
+            case NBTTagType.COMPOUND:
+                return this.readCompound(name);
+            case NBTTagType.INT_ARRAY:
+                return this.readIntArray(name);
+            case NBTTagType.LONG_ARRAY:
+                return this.readLongArray(name);
+            default:
+                throw new Error(`Unknown NBT tag type: ${type}`);
+        }
+    }
+
+    readCompound(name = '') {
+        const compound = new NBTCompound(name);
+        
+        while (true) {
+            const type = this.readUByte();
+            
+            if (type === NBTTagType.END) {
+                break;
+            }
+            
+            const tagName = this.readString();
+            const tag = this.readTag(type, tagName);
+            compound.children.set(tagName, tag);
+        }
+        
+        return compound;
+    }
+
+    readList(name = '') {
+        const listType = this.readUByte();
+        const length = this.readInt();
+        const values = [];
+        
+        for (let i = 0; i < length; i++) {
+            values.push(this.readTag(listType, ''));
+        }
+        
+        return new NBTList(name, listType, values);
+    }
+
+    readByteArray(name = '') {
+        const length = this.readInt();
+        const values = [];
+        
+        for (let i = 0; i < length; i++) {
+            values.push(this.readByte());
+        }
+        
+        return new NBTByteArray(name, values);
+    }
+
+    readIntArray(name = '') {
+        const length = this.readInt();
+        const values = [];
+        
+        for (let i = 0; i < length; i++) {
+            values.push(this.readInt());
+        }
+        
+        return new NBTIntArray(name, values);
+    }
+
+    readLongArray(name = '') {
+        const length = this.readInt();
+        const values = [];
+        
+        for (let i = 0; i < length; i++) {
+            values.push(this.readLong());
+        }
+        
+        return new NBTLongArray(name, values);
+    }
+}
+
+export class NBTWriter {
+    constructor() {
+        this.buffers = [];
+    }
+
+    writeByte(value) {
+        const buf = Buffer.alloc(1);
+        buf.writeInt8(value);
+        this.buffers.push(buf);
+    }
+
+    writeUByte(value) {
+        const buf = Buffer.alloc(1);
+        buf.writeUInt8(value);
+        this.buffers.push(buf);
+    }
+
+    writeShort(value) {
+        const buf = Buffer.alloc(2);
+        buf.writeInt16BE(value);
+        this.buffers.push(buf);
+    }
+
+    writeInt(value) {
+        const buf = Buffer.alloc(4);
+        buf.writeInt32BE(value);
+        this.buffers.push(buf);
+    }
+
+    writeLong(value) {
+        const buf = Buffer.alloc(8);
+        buf.writeBigInt64BE(BigInt(value));
+        this.buffers.push(buf);
+    }
+
+    writeFloat(value) {
+        const buf = Buffer.alloc(4);
+        buf.writeFloatBE(value);
+        this.buffers.push(buf);
+    }
+
+    writeDouble(value) {
+        const buf = Buffer.alloc(8);
+        buf.writeDoubleBE(value);
+        this.buffers.push(buf);
+    }
+
+    writeString(value) {
+        const strBuf = Buffer.from(value, 'utf8');
+        this.writeShort(strBuf.length);
+        this.buffers.push(strBuf);
+    }
+
+    write(compound, named = true) {
+        this.writeUByte(NBTTagType.COMPOUND);
+        
+        if (named) {
+            this.writeString(compound.name);
+        }
+        
+        this.writeCompound(compound);
+        
+        return Buffer.concat(this.buffers);
+    }
+
+    writeTag(tag) {
+        switch (tag.type) {
+            case NBTTagType.BYTE:
+                this.writeByte(tag.value);
+                break;
+            case NBTTagType.SHORT:
+                this.writeShort(tag.value);
+                break;
+            case NBTTagType.INT:
+                this.writeInt(tag.value);
+                break;
+            case NBTTagType.LONG:
+                this.writeLong(tag.value);
+                break;
+            case NBTTagType.FLOAT:
+                this.writeFloat(tag.value);
+                break;
+            case NBTTagType.DOUBLE:
+                this.writeDouble(tag.value);
+                break;
+            case NBTTagType.BYTE_ARRAY:
+                this.writeByteArray(tag);
+                break;
+            case NBTTagType.STRING:
+                this.writeString(tag.value);
+                break;
+            case NBTTagType.LIST:
+                this.writeList(tag);
+                break;
+            case NBTTagType.COMPOUND:
+                this.writeCompound(tag);
+                break;
+            case NBTTagType.INT_ARRAY:
+                this.writeIntArray(tag);
+                break;
+            case NBTTagType.LONG_ARRAY:
+                this.writeLongArray(tag);
+                break;
+        }
+    }
+
+    writeCompound(compound) {
+        for (const [name, tag] of compound.children) {
+            this.writeUByte(tag.type);
+            this.writeString(name);
+            this.writeTag(tag);
+        }
+        
+        this.writeUByte(NBTTagType.END);
+    }
+
+    writeList(list) {
+        this.writeUByte(list.listType);
+        this.writeInt(list.values.length);
+        
+        for (const tag of list.values) {
+            this.writeTagOfType(list.listType, tag);
+        }
+    }
+
+    writeTagOfType(type, tag) {
+        const value = tag.value !== undefined ? tag.value : tag;
+        
+        switch (type) {
+            case NBTTagType.BYTE:
+                this.writeByte(value);
+                break;
+            case NBTTagType.SHORT:
+                this.writeShort(value);
+                break;
+            case NBTTagType.INT:
+                this.writeInt(value);
+                break;
+            case NBTTagType.LONG:
+                this.writeLong(value);
+                break;
+            case NBTTagType.FLOAT:
+                this.writeFloat(value);
+                break;
+            case NBTTagType.DOUBLE:
+                this.writeDouble(value);
+                break;
+            case NBTTagType.BYTE_ARRAY:
+                this.writeByteArray(tag);
+                break;
+            case NBTTagType.STRING:
+                this.writeString(value);
+                break;
+            case NBTTagType.LIST:
+                this.writeList(tag);
+                break;
+            case NBTTagType.COMPOUND:
+                this.writeCompound(tag);
+                break;
+            case NBTTagType.INT_ARRAY:
+                this.writeIntArray(tag);
+                break;
+            case NBTTagType.LONG_ARRAY:
+                this.writeLongArray(tag);
+                break;
+        }
+    }
+
+    writeByteArray(tag) {
+        this.writeInt(tag.value.length);
+        for (const byte of tag.value) {
+            
+            this.writeUByte(byte & 0xFF);
+        }
+    }
+
+    writeIntArray(tag) {
+        this.writeInt(tag.value.length);
+        for (const int of tag.value) {
+            this.writeInt(int);
+        }
+    }
+
+    writeLongArray(tag) {
+        this.writeInt(tag.value.length);
+        for (const long of tag.value) {
+            this.writeLong(long);
+        }
+    }
+
+    getBuffer() {
+        return Buffer.concat(this.buffers);
+    }
+}
+
+export default {
+    NBTTagType,
+    NBTTag,
+    NBTCompound,
+    NBTByte,
+    NBTShort,
+    NBTInt,
+    NBTLong,
+    NBTFloat,
+    NBTDouble,
+    NBTString,
+    NBTByteArray,
+    NBTIntArray,
+    NBTLongArray,
+    NBTList,
+    NBTReader,
+    NBTWriter
+};

package/src/protocol/types/Position.js

@@ -0,0 +1,125 @@
+export class Position {
+    
+    constructor(x, y, z) {
+        this.x = x | 0;
+        this.y = y | 0;
+        this.z = z | 0;
+    }
+
+    encode() {
+        let x = BigInt(this.x);
+        let y = BigInt(this.y);
+        let z = BigInt(this.z);
+
+        if (x < 0n) x = x + (1n << 26n);
+        if (y < 0n) y = y + (1n << 12n);
+        if (z < 0n) z = z + (1n << 26n);
+
+        return ((x & 0x3FFFFFFn) << 38n) | ((z & 0x3FFFFFFn) << 12n) | (y & 0xFFFn);
+    }
+
+    static decode(value) {
+        value = BigInt(value);
+
+        let x = Number((value >> 38n) & 0x3FFFFFFn);
+        let y = Number(value & 0xFFFn);
+        let z = Number((value >> 12n) & 0x3FFFFFFn);
+
+        if (x >= (1 << 25)) x -= (1 << 26);
+        if (y >= (1 << 11)) y -= (1 << 12);
+        if (z >= (1 << 25)) z -= (1 << 26);
+
+        return new Position(x, y, z);
+    }
+
+    static fromBuffer(buffer, offset = 0) {
+        const value = buffer.readBigUInt64BE(offset);
+        return Position.decode(value);
+    }
+
+    toBuffer(buffer, offset = 0) {
+        buffer.writeBigUInt64BE(this.encode(), offset);
+    }
+
+    toBytes() {
+        const buffer = Buffer.alloc(8);
+        this.toBuffer(buffer);
+        return buffer;
+    }
+
+    toArray() {
+        return [this.x, this.y, this.z];
+    }
+
+    static fromArray(arr) {
+        return new Position(arr[0], arr[1], arr[2]);
+    }
+
+    add(other) {
+        return new Position(
+            this.x + other.x,
+            this.y + other.y,
+            this.z + other.z
+        );
+    }
+
+    subtract(other) {
+        return new Position(
+            this.x - other.x,
+            this.y - other.y,
+            this.z - other.z
+        );
+    }
+
+    distanceTo(other) {
+        const dx = this.x - other.x;
+        const dy = this.y - other.y;
+        const dz = this.z - other.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
+    distanceSquaredTo(other) {
+        const dx = this.x - other.x;
+        const dy = this.y - other.y;
+        const dz = this.z - other.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+
+    equals(other) {
+        if (!(other instanceof Position)) return false;
+        return this.x === other.x && this.y === other.y && this.z === other.z;
+    }
+
+    toString() {
+        return `Position(${this.x}, ${this.y}, ${this.z})`;
+    }
+
+    clone() {
+        return new Position(this.x, this.y, this.z);
+    }
+
+    getChunkCoords() {
+        return {
+            x: Math.floor(this.x / 16),
+            z: Math.floor(this.z / 16)
+        };
+    }
+
+    getChunkX() {
+        return Math.floor(this.x / 16);
+    }
+
+    getChunkZ() {
+        return Math.floor(this.z / 16);
+    }
+
+    getRelativeToChunk() {
+        return new Position(
+            ((this.x % 16) + 16) % 16,
+            this.y,
+            ((this.z % 16) + 16) % 16
+        );
+    }
+}
+
+export default Position;