Java Edition Protocol

pub struct TCPNetworkEncoder<W: AsyncWrite + Unpin> {
    writer: EncryptionWriter<W>,
    compression: Option<(CompressionThreshold, CompressionLevel)>,
    compressor: Option<(CompressionLevel, Compress)>,
    compression_scratch: Vec<u8>,
}

let mut encoder = TCPNetworkEncoder::new(writer);

// Enable compression (threshold: 256 bytes, level: 6)
encoder.set_compression((256, 6));

// Enable encryption
encoder.set_encryption(&key);

// Write packet
encoder.write_packet(packet_data).await?;
encoder.flush().await?;

pub struct TCPNetworkDecoder<R: AsyncRead + Unpin> {
    reader: DecryptionReader<R>,
    compression: Option<CompressionThreshold>,
    payload_scratch: BytesMut,
}

let mut decoder = TCPNetworkDecoder::new(reader);

// Enable compression
decoder.set_compression(256);

// Enable encryption
decoder.set_encryption(&key);

// Read packet
let raw_packet = decoder.get_raw_packet().await?;

Raw Packet Data
      ↓
  Compression (if enabled and size > threshold)
      ↓
  Add Packet Length Prefix
      ↓
  Encryption (if enabled)
      ↓
  TCP Socket

  TCP Socket
      ↓
  Decryption (if enabled)
      ↓
  Read Packet Length
      ↓
  Decompression (if enabled)
      ↓
  Extract Packet ID and Payload
      ↓
  Raw Packet Data

pub trait ClientPacket: MultiVersionJavaPacket {
    fn write_packet_data(
        &self,
        write: impl Write,
        version: &MinecraftVersion,
    ) -> Result<(), WritingError>;
}

pub trait ServerPacket: MultiVersionJavaPacket + Sized {
    fn read(read: impl Read, version: &MinecraftVersion) -> Result<Self, ReadingError>;
}

pub enum PacketEncodeError {
    TooLong(usize),
    CompressionFailed(String),
    Message(String),
}

pub enum PacketDecodeError {
    DecodeID,
    TooLong,
    OutOfBounds,
    MalformedLength(String),
    FailedDecompression(String),
    NotCompressed,
    ConnectionClosed,
}

pub struct VarInt(pub i32);

impl VarInt {
    pub const MAX_SIZE: NonZeroUsize = NonZeroUsize::new(5).unwrap();
    
    pub const fn written_size(&self) -> usize {
        match self.0 {
            0 => 1,
            n => (31 - n.leading_zeros() as usize) / 7 + 1,
        }
    }
    
    pub fn encode(&self, write: &mut impl Write) -> Result<(), WritingError>;
    pub fn decode(read: &mut impl Read) -> Result<Self, ReadingError>;
    pub async fn decode_async(read: &mut impl AsyncRead) -> Result<Self, ReadingError>;
    pub async fn encode_async(&self, write: &mut impl AsyncWrite) -> Result<(), WritingError>;
}

pub struct StatusResponse {
    pub version: Option<Version>,
    pub players: Option<Players>,
    pub description: String,
    pub favicon: Option<String>,
    pub enforce_secure_chat: bool,
}