packet-events-js 1.0.0

package/src/protocol/packets/index.js

@@ -0,0 +1,265 @@
+export { Packet, PacketInfo } from './Packet.js';
+export { PacketRegistry, defaultRegistry } from './PacketRegistry.js';
+
+export { HandshakePacket } from './handshake/HandshakePacket.js';
+
+export { StatusRequestPacket } from './status/StatusRequestPacket.js';
+export { StatusResponsePacket } from './status/StatusResponsePacket.js';
+export { PingPacket } from './status/PingPacket.js';
+export { PongPacket } from './status/PongPacket.js';
+
+export { LoginStartPacket } from './login/LoginStartPacket.js';
+export { EncryptionRequestPacket } from './login/EncryptionRequestPacket.js';
+export { EncryptionResponsePacket } from './login/EncryptionResponsePacket.js';
+export { LoginSuccessPacket } from './login/LoginSuccessPacket.js';
+export { SetCompressionPacket } from './login/SetCompressionPacket.js';
+export { DisconnectPacket, LoginDisconnectPacket, PlayDisconnectPacket } from './login/DisconnectPacket.js';
+
+export { KeepAliveClientboundPacket, KeepAliveServerboundPacket } from './play/KeepAlivePacket.js';
+
+export { 
+    ChatMessageServerboundPacket, 
+    SystemChatMessagePacket, 
+    PlayerChatMessagePacket 
+} from './play/ChatPacket.js';
+
+export {
+    SetPlayerPositionPacket,
+    SetPlayerPositionAndRotationPacket,
+    SetPlayerRotationPacket,
+    SetPlayerOnGroundPacket,
+    SynchronizePlayerPositionPacket,
+    ConfirmTeleportationPacket
+} from './play/PlayerPositionPacket.js';
+
+export { ChunkDataPacket, UnloadChunkPacket } from './play/ChunkPacket.js';
+
+export {
+    SpawnEntityPacket,
+    RemoveEntitiesPacket,
+    UpdateEntityPositionPacket,
+    SetEntityMetadataPacket
+} from './play/EntityPacket.js';
+
+import { ConnectionState } from '../ConnectionState.js';
+import { PacketDirection } from '../PacketDirection.js';
+
+import { HandshakePacket } from './handshake/HandshakePacket.js';
+import { StatusRequestPacket } from './status/StatusRequestPacket.js';
+import { StatusResponsePacket } from './status/StatusResponsePacket.js';
+import { PingPacket } from './status/PingPacket.js';
+import { PongPacket } from './status/PongPacket.js';
+import { LoginStartPacket } from './login/LoginStartPacket.js';
+import { EncryptionRequestPacket } from './login/EncryptionRequestPacket.js';
+import { EncryptionResponsePacket } from './login/EncryptionResponsePacket.js';
+import { LoginSuccessPacket } from './login/LoginSuccessPacket.js';
+import { SetCompressionPacket } from './login/SetCompressionPacket.js';
+import { LoginDisconnectPacket } from './login/DisconnectPacket.js';
+import { KeepAliveClientboundPacket, KeepAliveServerboundPacket } from './play/KeepAlivePacket.js';
+import { ChatMessageServerboundPacket, SystemChatMessagePacket, PlayerChatMessagePacket } from './play/ChatPacket.js';
+import { SetPlayerPositionPacket, SetPlayerPositionAndRotationPacket, SetPlayerRotationPacket, SetPlayerOnGroundPacket, SynchronizePlayerPositionPacket, ConfirmTeleportationPacket } from './play/PlayerPositionPacket.js';
+import { ChunkDataPacket, UnloadChunkPacket } from './play/ChunkPacket.js';
+import { SpawnEntityPacket, RemoveEntitiesPacket, UpdateEntityPositionPacket, SetEntityMetadataPacket } from './play/EntityPacket.js';
+
+import { defaultRegistry as registry } from './PacketRegistry.js';
+
+export function registerDefaultPackets() {
+    
+    registry.register({
+        packetClass: HandshakePacket,
+        state: ConnectionState.HANDSHAKING,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x00
+    });
+
+    registry.register({
+        packetClass: StatusRequestPacket,
+        state: ConnectionState.STATUS,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x00
+    });
+
+    registry.register({
+        packetClass: PingPacket,
+        state: ConnectionState.STATUS,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x01
+    });
+
+    registry.register({
+        packetClass: StatusResponsePacket,
+        state: ConnectionState.STATUS,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x00
+    });
+
+    registry.register({
+        packetClass: PongPacket,
+        state: ConnectionState.STATUS,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x01
+    });
+
+    registry.register({
+        packetClass: LoginStartPacket,
+        state: ConnectionState.LOGIN,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x00
+    });
+
+    registry.register({
+        packetClass: EncryptionResponsePacket,
+        state: ConnectionState.LOGIN,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x01
+    });
+
+    registry.register({
+        packetClass: LoginDisconnectPacket,
+        state: ConnectionState.LOGIN,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x00
+    });
+
+    registry.register({
+        packetClass: EncryptionRequestPacket,
+        state: ConnectionState.LOGIN,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x01
+    });
+
+    registry.register({
+        packetClass: LoginSuccessPacket,
+        state: ConnectionState.LOGIN,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x02
+    });
+
+    registry.register({
+        packetClass: SetCompressionPacket,
+        state: ConnectionState.LOGIN,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x03
+    });
+
+    registry.register({
+        packetClass: ConfirmTeleportationPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x00
+    });
+
+    registry.register({
+        packetClass: ChatMessageServerboundPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x06
+    });
+
+    registry.register({
+        packetClass: KeepAliveServerboundPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x18
+    });
+
+    registry.register({
+        packetClass: SetPlayerPositionPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x1A
+    });
+
+    registry.register({
+        packetClass: SetPlayerPositionAndRotationPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x1B
+    });
+
+    registry.register({
+        packetClass: SetPlayerRotationPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x1C
+    });
+
+    registry.register({
+        packetClass: SetPlayerOnGroundPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.SERVERBOUND,
+        packetId: 0x1D
+    });
+
+    registry.register({
+        packetClass: SpawnEntityPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x01
+    });
+
+    registry.register({
+        packetClass: UnloadChunkPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x21
+    });
+
+    registry.register({
+        packetClass: KeepAliveClientboundPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x26
+    });
+
+    registry.register({
+        packetClass: ChunkDataPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x27
+    });
+
+    registry.register({
+        packetClass: UpdateEntityPositionPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x2E
+    });
+
+    registry.register({
+        packetClass: PlayerChatMessagePacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x39
+    });
+
+    registry.register({
+        packetClass: SynchronizePlayerPositionPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x40
+    });
+
+    registry.register({
+        packetClass: RemoveEntitiesPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x42
+    });
+
+    registry.register({
+        packetClass: SetEntityMetadataPacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x58
+    });
+
+    registry.register({
+        packetClass: SystemChatMessagePacket,
+        state: ConnectionState.PLAY,
+        direction: PacketDirection.CLIENTBOUND,
+        packetId: 0x6C
+    });
+}
+
+registerDefaultPackets();

package/src/protocol/packets/login/DisconnectPacket.js

@@ -0,0 +1,71 @@
+import { Packet } from '../Packet.js';
+import { TextComponent } from '../../types/TextComponent.js';
+
+export class DisconnectPacket extends Packet {
+    static get packetId() { return 0x00; }
+    static get packetName() { return 'Disconnect'; }
+
+    constructor() {
+        super();
+
+        this.reason = null;
+    }
+
+    read(buffer, context) {
+        const jsonStr = buffer.readString(262144);
+        
+        try {
+            const json = JSON.parse(jsonStr);
+            this.reason = TextComponent.fromJSON(json);
+        } catch (e) {
+            this.reason = TextComponent.text(jsonStr);
+        }
+    }
+
+    write(buffer, context) {
+        let json;
+        
+        if (this.reason instanceof TextComponent) {
+            json = JSON.stringify(this.reason.toJSON());
+        } else if (typeof this.reason === 'string') {
+            json = JSON.stringify({ text: this.reason });
+        } else {
+            json = JSON.stringify(this.reason);
+        }
+        
+        buffer.writeString(json);
+    }
+
+    getReasonText() {
+        if (this.reason instanceof TextComponent) {
+            return this.reason.toPlainText();
+        }
+        if (typeof this.reason === 'string') {
+            return this.reason;
+        }
+        if (this.reason?.text) {
+            return this.reason.text;
+        }
+        return JSON.stringify(this.reason);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            reason: this.reason instanceof TextComponent ? 
+                this.reason.toJSON() : this.reason
+        };
+    }
+}
+
+export class LoginDisconnectPacket extends DisconnectPacket {
+    static get packetId() { return 0x00; }
+    static get packetName() { return 'LoginDisconnect'; }
+}
+
+export class PlayDisconnectPacket extends DisconnectPacket {
+    static get packetId() { return 0x1D; }
+    static get packetName() { return 'PlayDisconnect'; }
+}
+
+export default DisconnectPacket;

package/src/protocol/packets/login/EncryptionRequestPacket.js

@@ -0,0 +1,47 @@
+import { Packet } from '../Packet.js';
+
+export class EncryptionRequestPacket extends Packet {
+    static get packetId() { return 0x01; }
+    static get packetName() { return 'EncryptionRequest'; }
+
+    constructor() {
+        super();
+
+        this.serverId = '';
+
+        this.publicKey = Buffer.alloc(0);
+
+        this.verifyToken = Buffer.alloc(0);
+
+        this.shouldAuthenticate = true;
+    }
+
+    read(buffer, context) {
+        this.serverId = buffer.readString(20);
+        this.publicKey = buffer.readByteArray();
+        this.verifyToken = buffer.readByteArray();
+
+        if (buffer.isReadable(1)) {
+            this.shouldAuthenticate = buffer.readBoolean();
+        }
+    }
+
+    write(buffer, context) {
+        buffer.writeString(this.serverId);
+        buffer.writeByteArray(this.publicKey);
+        buffer.writeByteArray(this.verifyToken);
+        buffer.writeBoolean(this.shouldAuthenticate);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            serverId: this.serverId,
+            publicKeyLength: this.publicKey.length,
+            verifyTokenLength: this.verifyToken.length,
+            shouldAuthenticate: this.shouldAuthenticate
+        };
+    }
+}
+
+export default EncryptionRequestPacket;

package/src/protocol/packets/login/EncryptionResponsePacket.js

@@ -0,0 +1,34 @@
+import { Packet } from '../Packet.js';
+
+export class EncryptionResponsePacket extends Packet {
+    static get packetId() { return 0x01; }
+    static get packetName() { return 'EncryptionResponse'; }
+
+    constructor() {
+        super();
+
+        this.sharedSecret = Buffer.alloc(0);
+
+        this.verifyToken = Buffer.alloc(0);
+    }
+
+    read(buffer, context) {
+        this.sharedSecret = buffer.readByteArray();
+        this.verifyToken = buffer.readByteArray();
+    }
+
+    write(buffer, context) {
+        buffer.writeByteArray(this.sharedSecret);
+        buffer.writeByteArray(this.verifyToken);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            sharedSecretLength: this.sharedSecret.length,
+            verifyTokenLength: this.verifyToken.length
+        };
+    }
+}
+
+export default EncryptionResponsePacket;

package/src/protocol/packets/login/LoginStartPacket.js

@@ -0,0 +1,35 @@
+import { Packet } from '../Packet.js';
+import { UUID } from '../../types/UUID.js';
+
+export class LoginStartPacket extends Packet {
+    static get packetId() { return 0x00; }
+    static get packetName() { return 'LoginStart'; }
+
+    constructor() {
+        super();
+
+        this.username = '';
+
+        this.uuid = null;
+    }
+
+    read(buffer, context) {
+        this.username = buffer.readString(16);
+        this.uuid = buffer.readUUID();
+    }
+
+    write(buffer, context) {
+        buffer.writeString(this.username);
+        buffer.writeUUID(this.uuid || UUID.randomUUID());
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            username: this.username,
+            uuid: this.uuid?.toString()
+        };
+    }
+}
+
+export default LoginStartPacket;

package/src/protocol/packets/login/LoginSuccessPacket.js

@@ -0,0 +1,61 @@
+import { Packet } from '../Packet.js';
+import { UUID } from '../../types/UUID.js';
+
+export class LoginSuccessPacket extends Packet {
+    static get packetId() { return 0x02; }
+    static get packetName() { return 'LoginSuccess'; }
+
+    constructor() {
+        super();
+
+        this.uuid = null;
+
+        this.username = '';
+
+        this.properties = [];
+
+        this.strictErrorHandling = true;
+    }
+
+    read(buffer, context) {
+        this.uuid = buffer.readUUID();
+        this.username = buffer.readString(16);
+
+        this.properties = buffer.readArray(() => {
+            const name = buffer.readString(32767);
+            const value = buffer.readString(32767);
+            const signature = buffer.readOptional(() => buffer.readString(32767));
+            
+            return { name, value, signature };
+        });
+
+        if (buffer.isReadable(1)) {
+            this.strictErrorHandling = buffer.readBoolean();
+        }
+    }
+
+    write(buffer, context) {
+        buffer.writeUUID(this.uuid);
+        buffer.writeString(this.username);
+        
+        buffer.writeArray(this.properties, (prop) => {
+            buffer.writeString(prop.name);
+            buffer.writeString(prop.value);
+            buffer.writeOptional(prop.signature, (sig) => buffer.writeString(sig));
+        });
+        
+        buffer.writeBoolean(this.strictErrorHandling);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            uuid: this.uuid?.toString(),
+            username: this.username,
+            properties: this.properties,
+            strictErrorHandling: this.strictErrorHandling
+        };
+    }
+}
+
+export default LoginSuccessPacket;

package/src/protocol/packets/login/SetCompressionPacket.js

@@ -0,0 +1,29 @@
+import { Packet } from '../Packet.js';
+
+export class SetCompressionPacket extends Packet {
+    static get packetId() { return 0x03; }
+    static get packetName() { return 'SetCompression'; }
+
+    constructor() {
+        super();
+
+        this.threshold = -1;
+    }
+
+    read(buffer, context) {
+        this.threshold = buffer.readVarInt();
+    }
+
+    write(buffer, context) {
+        buffer.writeVarInt(this.threshold);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            threshold: this.threshold
+        };
+    }
+}
+
+export default SetCompressionPacket;