protocol-classicube 0.6.1

package/packets/LevelDataChunk.js

@@ -0,0 +1,47 @@
+/**
+ * Packet 0x03 - Level Data Chunk (Server -> Client)
+ *
+ * Sends a chunk of gzipped level data.
+ * The level data itself is: Int (block count) + raw block IDs,
+ * all gzipped, then split into 1024-byte chunks.
+ *
+ * Layout:
+ *   Byte      - Packet ID (0x03)
+ *   Short     - Chunk length (number of meaningful bytes in this chunk, 0–1024)
+ *   ByteArray - 1024 bytes of chunk data (padded with 0x00 if needed)
+ *   Byte      - Percent complete (0–100)
+ *
+ * Total: 1028 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+/**
+ * @param {object} opts
+ * @param {Buffer} opts.chunkData    - Raw chunk bytes (up to 1024)
+ * @param {number} opts.chunkLength  - Actual meaningful bytes in chunkData
+ * @param {number} opts.percent      - 0-100 completion percent
+ */
+function serialize({ chunkData, chunkLength, percent }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.LEVEL_DATA_CHUNK)
+    .writeShort(chunkLength)
+    .writeByteArray(chunkData)
+    .writeByte(percent)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.LEVEL_DATA_CHUNK) {
+    throw new Error(`Expected LevelDataChunk (0x03), got 0x${packetId.toString(16)}`);
+  }
+  const chunkLength = r.readShort();
+  const chunkData = r.readByteArray();
+  const percent = r.readByte();
+  return { packetId, chunkLength, chunkData, percent };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 1028 };

package/packets/LevelFinalize.js

@@ -0,0 +1,44 @@
+/**
+ * Packet 0x04 - Level Finalize (Server -> Client)
+ *
+ * Sent after all LevelDataChunk packets. Gives the world dimensions.
+ * Layout:
+ *   Byte  - Packet ID (0x04)
+ *   Short - X size (width)
+ *   Short - Y size (height)
+ *   Short - Z size (depth)
+ *
+ * Total: 7 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+/**
+ * @param {object} opts
+ * @param {number} opts.xSize
+ * @param {number} opts.ySize
+ * @param {number} opts.zSize
+ */
+function serialize({ xSize, ySize, zSize }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.LEVEL_FINALIZE)
+    .writeShort(xSize)
+    .writeShort(ySize)
+    .writeShort(zSize)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.LEVEL_FINALIZE) {
+    throw new Error(`Expected LevelFinalize (0x04), got 0x${packetId.toString(16)}`);
+  }
+  const xSize = r.readShort();
+  const ySize = r.readShort();
+  const zSize = r.readShort();
+  return { packetId, xSize, ySize, zSize };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 7 };

package/packets/LevelInitialize.js

@@ -0,0 +1,29 @@
+/**
+ * Packet 0x02 - Level Initialize (Server -> Client)
+ *
+ * Tells the client that level data is about to be sent.
+ * Layout:
+ *   Byte - Packet ID (0x02)
+ *
+ * Total: 1 byte
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+function serialize() {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.LEVEL_INITIALIZE)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.LEVEL_INITIALIZE) {
+    throw new Error(`Expected LevelInitialize (0x02), got 0x${packetId.toString(16)}`);
+  }
+  return { packetId };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 1 };

package/packets/Ping.js

@@ -0,0 +1,29 @@
+/**
+ * Packet 0x01 - Ping (Server -> Client)
+ *
+ * A single-byte keep-alive packet. No payload.
+ * Layout:
+ *   Byte - Packet ID (0x01)
+ *
+ * Total: 1 byte
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+function serialize() {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.PING)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.PING) {
+    throw new Error(`Expected Ping (0x01), got 0x${packetId.toString(16)}`);
+  }
+  return { packetId };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 1 };

package/packets/PlayerIdentification.js

@@ -0,0 +1,48 @@
+/**
+ * Packet 0x00 - Player Identification (Client -> Server)
+ *
+ * Primer paquete que envia el cliente al conectar.
+ * Layout:
+ *   Byte   - Packet ID (0x00)
+ *   Byte   - Protocol version (siempre 7)
+ *   String - Username (64 bytes)
+ *   String - Verification key (64 bytes, '-' si no hay auth)
+ *   Byte   - Unused (siempre 0x00)
+ *
+ * Total: 131 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+const PROTOCOL_VERSION = 7;
+
+/**
+ * @param {object} opts
+ * @param {string} opts.username
+ * @param {string} [opts.verificationKey]
+ */
+function serialize({ username, verificationKey = '-' }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.CLIENT.PLAYER_IDENTIFICATION)
+    .writeByte(PROTOCOL_VERSION)
+    .writeString(username)
+    .writeString(verificationKey)
+    .writeByte(0x00)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.CLIENT.PLAYER_IDENTIFICATION) {
+    throw new Error(`Expected PlayerIdentification (0x00), got 0x${packetId.toString(16)}`);
+  }
+  const protocolVersion = r.readByte();
+  const username = r.readString();
+  const verificationKey = r.readString();
+  r.readByte(); // unused
+  return { packetId, protocolVersion, username, verificationKey };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 131, PROTOCOL_VERSION };

package/packets/PlayerMove.js

@@ -0,0 +1,52 @@
+/**
+ * Packet 0x0A - Player Move (Server -> Client)
+ *
+ * Movimiento relativo (delta) de posicion SIN cambio de orientacion.
+ * Mas eficiente que PlayerUpdate cuando el jugador no gira.
+ *
+ * Los deltas son SByte en fixed-point: valor / 32
+ *
+ * Layout:
+ *   Byte   - Packet ID (0x0A)
+ *   SByte  - Player ID
+ *   SByte  - Delta X (fixed-point * 32)
+ *   SByte  - Delta Y (fixed-point * 32)
+ *   SByte  - Delta Z (fixed-point * 32)
+ *
+ * Total: 5 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+/**
+ * @param {object} opts
+ * @param {number} opts.playerId
+ * @param {number} opts.dx
+ * @param {number} opts.dy
+ * @param {number} opts.dz
+ */
+function serialize({ playerId, dx, dy, dz }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.PLAYER_MOVE)
+    .writeSByte(playerId)
+    .writeSByte(Math.round(dx * 32))
+    .writeSByte(Math.round(dy * 32))
+    .writeSByte(Math.round(dz * 32))
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.PLAYER_MOVE) {
+    throw new Error(`Expected PlayerMove (0x0A), got 0x${packetId.toString(16)}`);
+  }
+  const playerId = r.readSByte();
+  const dx = r.readSByte() / 32;
+  const dy = r.readSByte() / 32;
+  const dz = r.readSByte() / 32;
+  return { packetId, playerId, dx, dy, dz };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 5 };

package/packets/PlayerRotate.js

@@ -0,0 +1,46 @@
+/**
+ * Packet 0x0B - Player Rotate (Server -> Client)
+ *
+ * Cambio de orientacion SIN movimiento de posicion.
+ * Mas eficiente que PlayerUpdate cuando el jugador solo gira en sitio.
+ *
+ * Layout:
+ *   Byte  - Packet ID (0x0B)
+ *   SByte - Player ID
+ *   Byte  - Yaw   (0-255 = 0-360 grados)
+ *   Byte  - Pitch (0-255 = 0-360 grados)
+ *
+ * Total: 4 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+/**
+ * @param {object} opts
+ * @param {number} opts.playerId
+ * @param {number} opts.yaw   - 0-255
+ * @param {number} opts.pitch - 0-255
+ */
+function serialize({ playerId, yaw, pitch }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.PLAYER_ROTATE)
+    .writeSByte(playerId)
+    .writeByte(yaw & 0xFF)
+    .writeByte(pitch & 0xFF)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.PLAYER_ROTATE) {
+    throw new Error(`Expected PlayerRotate (0x0B), got 0x${packetId.toString(16)}`);
+  }
+  const playerId = r.readSByte();
+  const yaw = r.readByte();
+  const pitch = r.readByte();
+  return { packetId, playerId, yaw, pitch };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 4 };

package/packets/PlayerTeleport.js

@@ -0,0 +1,59 @@
+/**
+ * Packet 0x08 - Player Teleport (Server -> Client / Client -> Server)
+ *
+ * Teleports a player to an absolute position.
+ * When sent by the client, Player ID is always 255 (0xFF = self).
+ * When sent by the server, Player ID identifies which player to move.
+ *
+ * Layout:
+ *   Byte   - Packet ID (0x08)
+ *   SByte  - Player ID
+ *   Short  - X (fixed-point * 32)
+ *   Short  - Y (fixed-point * 32)
+ *   Short  - Z (fixed-point * 32)
+ *   Byte   - Yaw
+ *   Byte   - Pitch
+ *
+ * Total: 10 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+/**
+ * @param {object} opts
+ * @param {number} opts.playerId
+ * @param {number} opts.x
+ * @param {number} opts.y
+ * @param {number} opts.z
+ * @param {number} opts.yaw
+ * @param {number} opts.pitch
+ */
+function serialize({ playerId, x, y, z, yaw, pitch }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.PLAYER_TELEPORT)
+    .writeSByte(playerId)
+    .writeShort(Math.round(x * 32))
+    .writeShort(Math.round(y * 32))
+    .writeShort(Math.round(z * 32))
+    .writeByte(yaw & 0xFF)
+    .writeByte(pitch & 0xFF)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.PLAYER_TELEPORT) {
+    throw new Error(`Expected PlayerTeleport (0x08), got 0x${packetId.toString(16)}`);
+  }
+  const playerId = r.readSByte();
+  const x = r.readShort() / 32;
+  const y = r.readShort() / 32;
+  const z = r.readShort() / 32;
+  const yaw = r.readByte();
+  const pitch = r.readByte();
+  return { packetId, playerId, x, y, z, yaw, pitch };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 10 };

package/packets/PlayerUpdate.js

@@ -0,0 +1,62 @@
+/**
+ * Packet 0x09 - Player Update (Server -> Client)
+ *
+ * Movimiento relativo (delta) de posicion + cambio de orientacion.
+ * Se usa para actualizaciones pequenas de posicion (< 4 bloques).
+ * Para movimientos grandes usar PlayerTeleport (0x08).
+ *
+ * Los deltas son SByte en fixed-point: valor / 32
+ * Rango util: -4 a +3.96875 bloques por eje.
+ *
+ * Layout:
+ *   Byte   - Packet ID (0x09)
+ *   SByte  - Player ID
+ *   SByte  - Delta X (fixed-point * 32)
+ *   SByte  - Delta Y (fixed-point * 32)
+ *   SByte  - Delta Z (fixed-point * 32)
+ *   Byte   - Yaw   (0-255)
+ *   Byte   - Pitch (0-255)
+ *
+ * Total: 7 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+/**
+ * @param {object} opts
+ * @param {number} opts.playerId
+ * @param {number} opts.dx  - Delta X en bloques (se multiplica * 32)
+ * @param {number} opts.dy  - Delta Y en bloques
+ * @param {number} opts.dz  - Delta Z en bloques
+ * @param {number} opts.yaw   - 0-255
+ * @param {number} opts.pitch - 0-255
+ */
+function serialize({ playerId, dx, dy, dz, yaw, pitch }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.PLAYER_UPDATE)
+    .writeSByte(playerId)
+    .writeSByte(Math.round(dx * 32))
+    .writeSByte(Math.round(dy * 32))
+    .writeSByte(Math.round(dz * 32))
+    .writeByte(yaw & 0xFF)
+    .writeByte(pitch & 0xFF)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.PLAYER_UPDATE) {
+    throw new Error(`Expected PlayerUpdate (0x09), got 0x${packetId.toString(16)}`);
+  }
+  const playerId = r.readSByte();
+  const dx = r.readSByte() / 32;
+  const dy = r.readSByte() / 32;
+  const dz = r.readSByte() / 32;
+  const yaw = r.readByte();
+  const pitch = r.readByte();
+  return { packetId, playerId, dx, dy, dz, yaw, pitch };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 7 };

package/packets/ServerIdentification.js

@@ -0,0 +1,63 @@
+/**
+ * Packet 0x00 - Server Identification (Server -> Client)
+ *
+ * Sent immediately after client connects.
+ * Layout:
+ *   Byte   - Packet ID (0x00)
+ *   Byte   - Protocol version (always 7)
+ *   String - Server name (64 bytes)
+ *   String - Server MOTD (64 bytes)
+ *   Byte   - User type (0x00 = normal, 0x64 = op)
+ *
+ * Total: 131 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+const PROTOCOL_VERSION = 7;
+
+/**
+ * Serialize a ServerIdentification packet into a Buffer.
+ * @param {object} opts
+ * @param {string} opts.name    - Server name
+ * @param {string} opts.motd    - Server MOTD
+ * @param {boolean} [opts.op]  - Is the connecting player an operator?
+ * @returns {Buffer}
+ */
+function serialize({ name, motd, op = false }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.SERVER_IDENTIFICATION)
+    .writeByte(PROTOCOL_VERSION)
+    .writeString(name)
+    .writeString(motd)
+    .writeByte(op ? 0x64 : 0x00)
+    .toBuffer();
+}
+
+/**
+ * Deserialize a ServerIdentification packet from a Buffer.
+ * Expects the packet ID byte to already be consumed or present at offset 0.
+ * @param {Buffer} buf
+ * @returns {{ protocolVersion: number, name: string, motd: string, op: boolean }}
+ */
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte(); // 0x00
+  if (packetId !== PacketIDs.SERVER.SERVER_IDENTIFICATION) {
+    throw new Error(`Expected ServerIdentification (0x00), got 0x${packetId.toString(16)}`);
+  }
+  const protocolVersion = r.readByte();
+  const name = r.readString();
+  const motd = r.readString();
+  const userTypeByte = r.readByte();
+  return {
+    packetId,
+    protocolVersion,
+    name,
+    motd,
+    op: userTypeByte === 0x64,
+  };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 131 };

package/packets/SetBlock.js

@@ -0,0 +1,93 @@
+/**
+ * SetBlock packets
+ *
+ * There are TWO different SetBlock packets:
+ *
+ * --- SERVER -> CLIENT (0x06) ---
+ * Tells the client a block changed.
+ *   Byte  - Packet ID (0x06)
+ *   Short - X
+ *   Short - Y
+ *   Short - Z
+ *   Byte  - Block type
+ * Total: 8 bytes
+ *
+ * --- CLIENT -> SERVER (0x05) ---
+ * Client requests placing/destroying a block.
+ *   Byte  - Packet ID (0x05)
+ *   Short - X
+ *   Short - Y
+ *   Short - Z
+ *   Byte  - Mode (0x00 = destroy, 0x01 = create)
+ *   Byte  - Block type
+ * Total: 9 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+// Block placement modes
+const Mode = {
+  DESTROY: 0x00,
+  CREATE:  0x01,
+};
+
+/**
+ * Server->Client: notify block change
+ */
+function serializeServer({ x, y, z, blockType }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.SET_BLOCK)
+    .writeShort(x)
+    .writeShort(y)
+    .writeShort(z)
+    .writeByte(blockType)
+    .toBuffer();
+}
+
+function deserializeServer(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.SET_BLOCK) {
+    throw new Error(`Expected SetBlock server (0x06), got 0x${packetId.toString(16)}`);
+  }
+  const x = r.readShort();
+  const y = r.readShort();
+  const z = r.readShort();
+  const blockType = r.readByte();
+  return { packetId, x, y, z, blockType };
+}
+
+/**
+ * Client->Server: request block change
+ */
+function serializeClient({ x, y, z, mode, blockType }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.CLIENT.SET_BLOCK)
+    .writeShort(x)
+    .writeShort(y)
+    .writeShort(z)
+    .writeByte(mode)
+    .writeByte(blockType)
+    .toBuffer();
+}
+
+function deserializeClient(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.CLIENT.SET_BLOCK) {
+    throw new Error(`Expected SetBlock client (0x05), got 0x${packetId.toString(16)}`);
+  }
+  const x = r.readShort();
+  const y = r.readShort();
+  const z = r.readShort();
+  const mode = r.readByte();
+  const blockType = r.readByte();
+  return { packetId, x, y, z, mode, blockType };
+}
+
+module.exports = {
+  Mode,
+  server: { serialize: serializeServer, deserialize: deserializeServer, PACKET_SIZE: 8 },
+  client: { serialize: serializeClient, deserialize: deserializeClient, PACKET_SIZE: 9 },
+};

package/packets/SpawnPlayer.js

@@ -0,0 +1,62 @@
+/**
+ * Packet 0x07 - Spawn Player (Server -> Client)
+ *
+ * Spawns a player entity in the world.
+ * Player ID -1 (0xFF) = the local player.
+ *
+ * Layout:
+ *   Byte   - Packet ID (0x07)
+ *   SByte  - Player ID (-1 for self)
+ *   String - Player name (64 bytes)
+ *   Short  - X (fixed-point: value / 32)
+ *   Short  - Y (fixed-point: value / 32)
+ *   Short  - Z (fixed-point: value / 32)
+ *   Byte   - Yaw   (0-255 maps to 0-360°)
+ *   Byte   - Pitch (0-255 maps to 0-360°)
+ *
+ * Total: 74 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+/**
+ * @param {object} opts
+ * @param {number} opts.playerId  - -1 for self, 0-127 for others
+ * @param {string} opts.name      - Player name
+ * @param {number} opts.x         - Block-space X (will be multiplied by 32)
+ * @param {number} opts.y         - Block-space Y
+ * @param {number} opts.z         - Block-space Z
+ * @param {number} opts.yaw       - 0-255
+ * @param {number} opts.pitch     - 0-255
+ */
+function serialize({ playerId, name, x, y, z, yaw, pitch }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.SPAWN_PLAYER)
+    .writeSByte(playerId)
+    .writeString(name)
+    .writeShort(Math.round(x * 32))
+    .writeShort(Math.round(y * 32))
+    .writeShort(Math.round(z * 32))
+    .writeByte(yaw & 0xFF)
+    .writeByte(pitch & 0xFF)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.SPAWN_PLAYER) {
+    throw new Error(`Expected SpawnPlayer (0x07), got 0x${packetId.toString(16)}`);
+  }
+  const playerId = r.readSByte();
+  const name = r.readString();
+  const x = r.readShort() / 32;
+  const y = r.readShort() / 32;
+  const z = r.readShort() / 32;
+  const yaw = r.readByte();
+  const pitch = r.readByte();
+  return { packetId, playerId, name, x, y, z, yaw, pitch };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 74 };

package/packets/UpdateUserType.js

@@ -0,0 +1,51 @@
+/**
+ * Packet 0x0F - Update User Type (Server -> Client)
+ *
+ * Actualiza los permisos del jugador en tiempo real.
+ * Usado para dar/quitar rango de operador sin reconectar.
+ *
+ * User type values:
+ *   0x00 = jugador normal
+ *   0x64 = operador (puede borrar bloques de bedrock, etc.)
+ *
+ * Layout:
+ *   Byte - Packet ID (0x0F)
+ *   Byte - User type (0x00 normal | 0x64 op)
+ *
+ * Total: 2 bytes
+ */
+
+const { BinaryWriter, BinaryReader } = require('../Binary');
+const PacketIDs = require('../PacketIDs');
+
+const UserType = {
+  NORMAL:   0x00,
+  OPERATOR: 0x64,
+};
+
+/**
+ * @param {object} opts
+ * @param {boolean} opts.op - true = operador, false = normal
+ */
+function serialize({ op }) {
+  return new BinaryWriter()
+    .writeByte(PacketIDs.SERVER.UPDATE_USER_TYPE)
+    .writeByte(op ? UserType.OPERATOR : UserType.NORMAL)
+    .toBuffer();
+}
+
+function deserialize(buf) {
+  const r = new BinaryReader(buf);
+  const packetId = r.readByte();
+  if (packetId !== PacketIDs.SERVER.UPDATE_USER_TYPE) {
+    throw new Error(`Expected UpdateUserType (0x0F), got 0x${packetId.toString(16)}`);
+  }
+  const userType = r.readByte();
+  return {
+    packetId,
+    userType,
+    op: userType === UserType.OPERATOR,
+  };
+}
+
+module.exports = { serialize, deserialize, PACKET_SIZE: 2, UserType };