packet-events-js 1.0.0

package/src/protocol/packets/play/ChatPacket.js

@@ -0,0 +1,238 @@
+import { Packet } from '../Packet.js';
+import { TextComponent } from '../../types/TextComponent.js';
+import { UUID } from '../../types/UUID.js';
+
+export class ChatMessageServerboundPacket extends Packet {
+    static get packetId() { return 0x06; } 
+    static get packetName() { return 'ChatMessageServerbound'; }
+
+    constructor() {
+        super();
+
+        this.message = '';
+
+        this.messageTimestamp = 0n;
+
+        this.salt = 0n;
+
+        this.signature = null;
+
+        this.messageCount = 0;
+
+        this.acknowledged = Buffer.alloc(0);
+    }
+
+    read(buffer, context) {
+        this.message = buffer.readString(256);
+        this.messageTimestamp = buffer.readLong();
+        this.salt = buffer.readLong();
+        this.signature = buffer.readOptional(() => buffer.readBytes(256));
+        this.messageCount = buffer.readVarInt();
+        this.acknowledged = buffer.readBytes(3); 
+    }
+
+    write(buffer, context) {
+        buffer.writeString(this.message);
+        buffer.writeLong(this.messageTimestamp);
+        buffer.writeLong(this.salt);
+        buffer.writeOptional(this.signature, (sig) => buffer.writeBytes(sig));
+        buffer.writeVarInt(this.messageCount);
+        buffer.writeBytes(this.acknowledged);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            message: this.message,
+            messageTimestamp: this.messageTimestamp.toString(),
+            hasSignature: this.signature !== null
+        };
+    }
+}
+
+export class SystemChatMessagePacket extends Packet {
+    static get packetId() { return 0x6C; } 
+    static get packetName() { return 'SystemChatMessage'; }
+
+    constructor() {
+        super();
+
+        this.content = null;
+
+        this.overlay = false;
+    }
+
+    read(buffer, context) {
+        const jsonStr = buffer.readString(262144);
+        
+        try {
+            const json = JSON.parse(jsonStr);
+            this.content = TextComponent.fromJSON(json);
+        } catch (e) {
+            this.content = TextComponent.text(jsonStr);
+        }
+        
+        this.overlay = buffer.readBoolean();
+    }
+
+    write(buffer, context) {
+        const json = this.content instanceof TextComponent ? 
+            JSON.stringify(this.content.toJSON()) : 
+            JSON.stringify(this.content);
+        
+        buffer.writeString(json);
+        buffer.writeBoolean(this.overlay);
+    }
+
+    getPlainText() {
+        if (this.content instanceof TextComponent) {
+            return this.content.toPlainText();
+        }
+        return String(this.content);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            content: this.content instanceof TextComponent ? 
+                this.content.toJSON() : this.content,
+            overlay: this.overlay
+        };
+    }
+}
+
+export class PlayerChatMessagePacket extends Packet {
+    static get packetId() { return 0x39; } 
+    static get packetName() { return 'PlayerChatMessage'; }
+
+    constructor() {
+        super();
+
+        this.sender = null;
+
+        this.index = 0;
+
+        this.signature = null;
+
+        this.body = '';
+
+        this.timestamp = 0n;
+
+        this.salt = 0n;
+
+        this.unsignedContent = null;
+
+        this.filterType = 0;
+
+        this.chatType = 0;
+
+        this.networkName = null;
+
+        this.networkTargetName = null;
+    }
+
+    read(buffer, context) {
+        this.sender = buffer.readUUID();
+        this.index = buffer.readVarInt();
+        this.signature = buffer.readOptional(() => buffer.readBytes(256));
+        this.body = buffer.readString(256);
+        this.timestamp = buffer.readLong();
+        this.salt = buffer.readLong();
+
+        const prevCount = buffer.readVarInt();
+        for (let i = 0; i < prevCount; i++) {
+            buffer.readVarInt(); 
+            buffer.readBytes(256); 
+        }
+
+        this.unsignedContent = buffer.readOptional(() => {
+            const json = buffer.readString(262144);
+            try {
+                return TextComponent.fromJSON(JSON.parse(json));
+            } catch (e) {
+                return TextComponent.text(json);
+            }
+        });
+        
+        this.filterType = buffer.readVarInt();
+        
+        if (this.filterType === 2) {
+            
+            buffer.readByteArray();
+        }
+        
+        this.chatType = buffer.readVarInt();
+        
+        const networkNameJson = buffer.readString(262144);
+        try {
+            this.networkName = TextComponent.fromJSON(JSON.parse(networkNameJson));
+        } catch (e) {
+            this.networkName = TextComponent.text(networkNameJson);
+        }
+        
+        this.networkTargetName = buffer.readOptional(() => {
+            const json = buffer.readString(262144);
+            try {
+                return TextComponent.fromJSON(JSON.parse(json));
+            } catch (e) {
+                return TextComponent.text(json);
+            }
+        });
+    }
+
+    write(buffer, context) {
+        
+        buffer.writeUUID(this.sender);
+        buffer.writeVarInt(this.index);
+        buffer.writeOptional(this.signature, (sig) => buffer.writeBytes(sig));
+        buffer.writeString(this.body);
+        buffer.writeLong(this.timestamp);
+        buffer.writeLong(this.salt);
+        buffer.writeVarInt(0); 
+        
+        buffer.writeOptional(this.unsignedContent, (content) => {
+            const json = content instanceof TextComponent ? 
+                JSON.stringify(content.toJSON()) : JSON.stringify(content);
+            buffer.writeString(json);
+        });
+        
+        buffer.writeVarInt(this.filterType);
+        buffer.writeVarInt(this.chatType);
+        
+        const nameJson = this.networkName instanceof TextComponent ?
+            JSON.stringify(this.networkName.toJSON()) : 
+            JSON.stringify({ text: String(this.networkName) });
+        buffer.writeString(nameJson);
+        
+        buffer.writeOptional(this.networkTargetName, (name) => {
+            const json = name instanceof TextComponent ?
+                JSON.stringify(name.toJSON()) : JSON.stringify({ text: String(name) });
+            buffer.writeString(json);
+        });
+    }
+
+    getMessage() {
+        if (this.unsignedContent) {
+            return this.unsignedContent instanceof TextComponent ?
+                this.unsignedContent.toPlainText() : String(this.unsignedContent);
+        }
+        return this.body;
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            sender: this.sender?.toString(),
+            body: this.body,
+            unsignedContent: this.unsignedContent instanceof TextComponent ?
+                this.unsignedContent.toJSON() : this.unsignedContent,
+            chatType: this.chatType
+        };
+    }
+}
+
+export default {
+    ChatMessageServerboundPacket,
+    SystemChatMessagePacket,
+    PlayerChatMessagePacket
+};

package/src/protocol/packets/play/ChunkPacket.js

@@ -0,0 +1,122 @@
+import { Packet } from '../Packet.js';
+import { NBTReader, NBTCompound } from '../../types/NBT.js';
+
+export class ChunkDataPacket extends Packet {
+    static get packetId() { return 0x27; } 
+    static get packetName() { return 'ChunkData'; }
+
+    constructor() {
+        super();
+
+        this.chunkX = 0;
+
+        this.chunkZ = 0;
+
+        this.heightmaps = null;
+
+        this.data = Buffer.alloc(0);
+
+        this.blockEntities = [];
+
+        this.lightData = null;
+    }
+
+    read(buffer, context) {
+        this.chunkX = buffer.readInt();
+        this.chunkZ = buffer.readInt();
+
+        this.heightmaps = buffer.readNBT(false);
+
+        this.data = buffer.readByteArray();
+
+        const blockEntityCount = buffer.readVarInt();
+        this.blockEntities = [];
+        
+        for (let i = 0; i < blockEntityCount; i++) {
+            const packedXZ = buffer.readUByte();
+            const y = buffer.readShort();
+            const type = buffer.readVarInt();
+            const nbt = buffer.readNBT(false);
+            
+            this.blockEntities.push({
+                localX: packedXZ >> 4,
+                localZ: packedXZ & 0xF,
+                y,
+                type,
+                data: nbt
+            });
+        }
+
+        if (buffer.isReadable(1)) {
+            this.lightData = buffer.readRemainingBytes();
+        }
+    }
+
+    write(buffer, context) {
+        buffer.writeInt(this.chunkX);
+        buffer.writeInt(this.chunkZ);
+        
+        buffer.writeNBT(this.heightmaps || new NBTCompound(), false);
+        buffer.writeByteArray(this.data);
+        
+        buffer.writeVarInt(this.blockEntities.length);
+        
+        for (const entity of this.blockEntities) {
+            buffer.writeUByte((entity.localX << 4) | (entity.localZ & 0xF));
+            buffer.writeShort(entity.y);
+            buffer.writeVarInt(entity.type);
+            buffer.writeNBT(entity.data || new NBTCompound(), false);
+        }
+        
+        if (this.lightData) {
+            buffer.writeBytes(this.lightData);
+        }
+    }
+
+    getChunkPos() {
+        return [this.chunkX, this.chunkZ];
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            chunkX: this.chunkX,
+            chunkZ: this.chunkZ,
+            dataSize: this.data.length,
+            blockEntityCount: this.blockEntities.length
+        };
+    }
+}
+
+export class UnloadChunkPacket extends Packet {
+    static get packetId() { return 0x21; } 
+    static get packetName() { return 'UnloadChunk'; }
+
+    constructor() {
+        super();
+
+        this.chunkX = 0;
+
+        this.chunkZ = 0;
+    }
+
+    read(buffer, context) {
+        this.chunkX = buffer.readInt();
+        this.chunkZ = buffer.readInt();
+    }
+
+    write(buffer, context) {
+        buffer.writeInt(this.chunkX);
+        buffer.writeInt(this.chunkZ);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            chunkX: this.chunkX,
+            chunkZ: this.chunkZ
+        };
+    }
+}
+
+export default { ChunkDataPacket, UnloadChunkPacket };

package/src/protocol/packets/play/EntityPacket.js

@@ -0,0 +1,302 @@
+import { Packet } from '../Packet.js';
+import { UUID } from '../../types/UUID.js';
+import { TextComponent } from '../../types/TextComponent.js';
+
+export class SpawnEntityPacket extends Packet {
+    static get packetId() { return 0x01; } 
+    static get packetName() { return 'SpawnEntity'; }
+
+    constructor() {
+        super();
+
+        this.entityId = 0;
+
+        this.entityUUID = null;
+
+        this.type = 0;
+
+        this.x = 0;
+
+        this.y = 0;
+
+        this.z = 0;
+
+        this.pitch = 0;
+
+        this.yaw = 0;
+
+        this.headYaw = 0;
+
+        this.data = 0;
+
+        this.velocityX = 0;
+
+        this.velocityY = 0;
+
+        this.velocityZ = 0;
+    }
+
+    read(buffer, context) {
+        this.entityId = buffer.readVarInt();
+        this.entityUUID = buffer.readUUID();
+        this.type = buffer.readVarInt();
+        this.x = buffer.readDouble();
+        this.y = buffer.readDouble();
+        this.z = buffer.readDouble();
+        this.pitch = buffer.readAngle();
+        this.yaw = buffer.readAngle();
+        this.headYaw = buffer.readAngle();
+        this.data = buffer.readVarInt();
+        this.velocityX = buffer.readShort();
+        this.velocityY = buffer.readShort();
+        this.velocityZ = buffer.readShort();
+    }
+
+    write(buffer, context) {
+        buffer.writeVarInt(this.entityId);
+        buffer.writeUUID(this.entityUUID);
+        buffer.writeVarInt(this.type);
+        buffer.writeDouble(this.x);
+        buffer.writeDouble(this.y);
+        buffer.writeDouble(this.z);
+        buffer.writeAngle(this.pitch);
+        buffer.writeAngle(this.yaw);
+        buffer.writeAngle(this.headYaw);
+        buffer.writeVarInt(this.data);
+        buffer.writeShort(this.velocityX);
+        buffer.writeShort(this.velocityY);
+        buffer.writeShort(this.velocityZ);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            entityId: this.entityId,
+            entityUUID: this.entityUUID?.toString(),
+            type: this.type,
+            x: this.x,
+            y: this.y,
+            z: this.z
+        };
+    }
+}
+
+export class RemoveEntitiesPacket extends Packet {
+    static get packetId() { return 0x42; } 
+    static get packetName() { return 'RemoveEntities'; }
+
+    constructor() {
+        super();
+
+        this.entityIds = [];
+    }
+
+    read(buffer, context) {
+        this.entityIds = buffer.readArray(() => buffer.readVarInt());
+    }
+
+    write(buffer, context) {
+        buffer.writeArray(this.entityIds, (id) => buffer.writeVarInt(id));
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            entityIds: this.entityIds
+        };
+    }
+}
+
+export class UpdateEntityPositionPacket extends Packet {
+    static get packetId() { return 0x2E; } 
+    static get packetName() { return 'UpdateEntityPosition'; }
+
+    constructor() {
+        super();
+
+        this.entityId = 0;
+
+        this.deltaX = 0;
+
+        this.deltaY = 0;
+
+        this.deltaZ = 0;
+
+        this.onGround = false;
+    }
+
+    read(buffer, context) {
+        this.entityId = buffer.readVarInt();
+        this.deltaX = buffer.readShort();
+        this.deltaY = buffer.readShort();
+        this.deltaZ = buffer.readShort();
+        this.onGround = buffer.readBoolean();
+    }
+
+    write(buffer, context) {
+        buffer.writeVarInt(this.entityId);
+        buffer.writeShort(this.deltaX);
+        buffer.writeShort(this.deltaY);
+        buffer.writeShort(this.deltaZ);
+        buffer.writeBoolean(this.onGround);
+    }
+
+    getDeltaXBlocks() {
+        return this.deltaX / 4096;
+    }
+
+    getDeltaYBlocks() {
+        return this.deltaY / 4096;
+    }
+
+    getDeltaZBlocks() {
+        return this.deltaZ / 4096;
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            entityId: this.entityId,
+            deltaX: this.getDeltaXBlocks(),
+            deltaY: this.getDeltaYBlocks(),
+            deltaZ: this.getDeltaZBlocks(),
+            onGround: this.onGround
+        };
+    }
+}
+
+export class SetEntityMetadataPacket extends Packet {
+    static get packetId() { return 0x58; } 
+    static get packetName() { return 'SetEntityMetadata'; }
+
+    constructor() {
+        super();
+
+        this.entityId = 0;
+
+        this.metadata = new Map();
+    }
+
+    read(buffer, context) {
+        this.entityId = buffer.readVarInt();
+
+        while (true) {
+            const index = buffer.readUByte();
+            
+            if (index === 0xFF) {
+                break; 
+            }
+            
+            const type = buffer.readVarInt();
+            const value = this._readMetadataValue(buffer, type);
+            
+            this.metadata.set(index, { type, value });
+        }
+    }
+
+    write(buffer, context) {
+        buffer.writeVarInt(this.entityId);
+        
+        for (const [index, { type, value }] of this.metadata) {
+            buffer.writeUByte(index);
+            buffer.writeVarInt(type);
+            this._writeMetadataValue(buffer, type, value);
+        }
+        
+        buffer.writeUByte(0xFF); 
+    }
+
+    _readMetadataValue(buffer, type) {
+        switch (type) {
+            case 0: return buffer.readByte(); 
+            case 1: return buffer.readVarInt(); 
+            case 2: return buffer.readVarLong(); 
+            case 3: return buffer.readFloat(); 
+            case 4: return buffer.readString(); 
+            case 5: 
+                const json = buffer.readString();
+                try {
+                    return TextComponent.fromJSON(JSON.parse(json));
+                } catch (e) {
+                    return TextComponent.text(json);
+                }
+            case 6: 
+                return buffer.readOptional(() => {
+                    const j = buffer.readString();
+                    try {
+                        return TextComponent.fromJSON(JSON.parse(j));
+                    } catch (e) {
+                        return TextComponent.text(j);
+                    }
+                });
+            case 7: 
+                return buffer.readBoolean() ? {  } : null;
+            case 8: return buffer.readBoolean(); 
+            case 9: 
+                return {
+                    x: buffer.readFloat(),
+                    y: buffer.readFloat(),
+                    z: buffer.readFloat()
+                };
+            case 10: return buffer.readPosition(); 
+            case 11: return buffer.readOptional(() => buffer.readPosition()); 
+            case 12: return buffer.readVarInt(); 
+            case 13: return buffer.readOptional(() => buffer.readUUID()); 
+            case 14: return buffer.readVarInt(); 
+            case 15: return buffer.readVarInt(); 
+            case 16: return buffer.readNBT(); 
+            case 17: 
+                return { type: buffer.readVarInt() };
+            case 18: 
+                return {
+                    villagerType: buffer.readVarInt(),
+                    profession: buffer.readVarInt(),
+                    level: buffer.readVarInt()
+                };
+            case 19: return buffer.readOptional(() => buffer.readVarInt()); 
+            case 20: return buffer.readVarInt(); 
+            default:
+                
+                return null;
+        }
+    }
+
+    _writeMetadataValue(buffer, type, value) {
+        switch (type) {
+            case 0: buffer.writeByte(value); break;
+            case 1: buffer.writeVarInt(value); break;
+            case 2: buffer.writeVarLong(value); break;
+            case 3: buffer.writeFloat(value); break;
+            case 4: buffer.writeString(value); break;
+            case 5:
+                const json = value instanceof TextComponent ?
+                    JSON.stringify(value.toJSON()) : JSON.stringify(value);
+                buffer.writeString(json);
+                break;
+            case 8: buffer.writeBoolean(value); break;
+            
+            default:
+                break;
+        }
+    }
+
+    toJSON() {
+        const metadata = {};
+        for (const [index, { type, value }] of this.metadata) {
+            metadata[index] = { type, value };
+        }
+        
+        return {
+            ...super.toJSON(),
+            entityId: this.entityId,
+            metadata
+        };
+    }
+}
+
+export default {
+    SpawnEntityPacket,
+    RemoveEntitiesPacket,
+    UpdateEntityPositionPacket,
+    SetEntityMetadataPacket
+};

package/src/protocol/packets/play/KeepAlivePacket.js

@@ -0,0 +1,55 @@
+import { Packet } from '../Packet.js';
+
+export class KeepAliveClientboundPacket extends Packet {
+    static get packetId() { return 0x26; } 
+    static get packetName() { return 'KeepAliveClientbound'; }
+
+    constructor() {
+        super();
+
+        this.keepAliveId = 0n;
+    }
+
+    read(buffer, context) {
+        this.keepAliveId = buffer.readLong();
+    }
+
+    write(buffer, context) {
+        buffer.writeLong(this.keepAliveId);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            keepAliveId: this.keepAliveId.toString()
+        };
+    }
+}
+
+export class KeepAliveServerboundPacket extends Packet {
+    static get packetId() { return 0x18; } 
+    static get packetName() { return 'KeepAliveServerbound'; }
+
+    constructor() {
+        super();
+
+        this.keepAliveId = 0n;
+    }
+
+    read(buffer, context) {
+        this.keepAliveId = buffer.readLong();
+    }
+
+    write(buffer, context) {
+        buffer.writeLong(this.keepAliveId);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            keepAliveId: this.keepAliveId.toString()
+        };
+    }
+}
+
+export default { KeepAliveClientboundPacket, KeepAliveServerboundPacket };