azalea

18 files changed, 0 insertions, 1086 deletions

diff --git a/minecraft-protocol/Cargo.toml b/minecraft-protocol/Cargo.toml
deleted file mode 100644
index 3cbf663b..00000000
--- a/minecraft-protocol/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-edition = "2021"
-name = "minecraft-protocol"
-version = "0.1.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-async-recursion = "^0.3.2"
-async-trait = "0.1.51"
-byteorder = "^1.4.3"
-bytes = "^1.1.0"
-minecraft-chat = {path = "../minecraft-chat"}
-serde = {version = "1.0.130", features = ["serde_derive"]}
-serde_json = "^1.0.72"
-thiserror = "^1.0.30"
-tokio = {version = "^1.14.0", features = ["io-util", "net", "macros"]}
-tokio-util = "^0.6.9"
-trust-dns-resolver = "^0.20.3"
diff --git a/minecraft-protocol/src/connect.rs b/minecraft-protocol/src/connect.rs
deleted file mode 100644
index f6dd9fe7..00000000
--- a/minecraft-protocol/src/connect.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-//! parse sending and receiving packets with a server.
-
-use crate::packets::game::GamePacket;
-use crate::packets::handshake::HandshakePacket;
-use crate::packets::login::LoginPacket;
-use crate::packets::status::StatusPacket;
-use crate::read::read_packet;
-use crate::write::write_packet;
-use crate::ServerIpAddress;
-use tokio::net::TcpStream;
-
-pub enum PacketFlow {
-    ClientToServer,
-    ServerToClient,
-}
-
-pub struct HandshakeConnection {
-    pub flow: PacketFlow,
-    /// The buffered writer
-    pub stream: TcpStream,
-}
-
-pub struct GameConnection {
-    pub flow: PacketFlow,
-    /// The buffered writer
-    pub stream: TcpStream,
-}
-
-pub struct StatusConnection {
-    pub flow: PacketFlow,
-    /// The buffered writer
-    pub stream: TcpStream,
-}
-
-pub struct LoginConnection {
-    pub flow: PacketFlow,
-    /// The buffered writer
-    pub stream: TcpStream,
-}
-
-impl HandshakeConnection {
-    pub async fn new(address: &ServerIpAddress) -> Result<HandshakeConnection, String> {
-        let ip = address.ip;
-        let port = address.port;
-
-        let stream = TcpStream::connect(format!("{}:{}", ip, port))
-            .await
-            .map_err(|_| "Failed to connect to server")?;
-
-        // enable tcp_nodelay
-        stream
-            .set_nodelay(true)
-            .expect("Error enabling tcp_nodelay");
-
-        Ok(HandshakeConnection {
-            flow: PacketFlow::ServerToClient,
-            stream,
-        })
-    }
-
-    pub fn login(self) -> LoginConnection {
-        LoginConnection {
-            flow: self.flow,
-            stream: self.stream,
-        }
-    }
-
-    pub fn status(self) -> StatusConnection {
-        StatusConnection {
-            flow: self.flow,
-            stream: self.stream,
-        }
-    }
-
-    pub async fn read(&mut self) -> Result<HandshakePacket, String> {
-        read_packet::<HandshakePacket>(&self.flow, &mut self.stream).await
-    }
-
-    /// Write a packet to the server
-    pub async fn write(&mut self, packet: HandshakePacket) {
-        write_packet(packet, &mut self.stream).await;
-    }
-}
-
-impl GameConnection {
-    pub async fn read(&mut self) -> Result<GamePacket, String> {
-        read_packet::<GamePacket>(&self.flow, &mut self.stream).await
-    }
-
-    /// Write a packet to the server
-    pub async fn write(&mut self, packet: GamePacket) {
-        write_packet(packet, &mut self.stream).await;
-    }
-}
-
-impl StatusConnection {
-    pub async fn read(&mut self) -> Result<StatusPacket, String> {
-        read_packet::<StatusPacket>(&self.flow, &mut self.stream).await
-    }
-
-    /// Write a packet to the server
-    pub async fn write(&mut self, packet: StatusPacket) {
-        write_packet(packet, &mut self.stream).await;
-    }
-}
-
-impl LoginConnection {
-    pub async fn read(&mut self) -> Result<LoginPacket, String> {
-        read_packet::<LoginPacket>(&self.flow, &mut self.stream).await
-    }
-
-    /// Write a packet to the server
-    pub async fn write(&mut self, packet: LoginPacket) {
-        write_packet(packet, &mut self.stream).await;
-    }
-}
diff --git a/minecraft-protocol/src/lib.rs b/minecraft-protocol/src/lib.rs
deleted file mode 100644
index 684add45..00000000
--- a/minecraft-protocol/src/lib.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-//! This lib is responsible for parsing Minecraft packets.
-
-use std::net::IpAddr;
-use std::str::FromStr;
-
-pub mod connect;
-pub mod mc_buf;
-pub mod packets;
-pub mod read;
-pub mod resolver;
-pub mod write;
-
-#[derive(Debug)]
-pub struct ServerAddress {
-    pub host: String,
-    pub port: u16,
-}
-
-#[derive(Debug)]
-pub struct ServerIpAddress {
-    pub ip: IpAddr,
-    pub port: u16,
-}
-
-// impl try_from for ServerAddress
-impl<'a> TryFrom<&'a str> for ServerAddress {
-    type Error = String;
-
-    /// Convert a Minecraft server address (host:port, the port is optional) to a ServerAddress
-    fn try_from(string: &str) -> Result<Self, Self::Error> {
-        if string.is_empty() {
-            return Err("Empty string".to_string());
-        }
-        let mut parts = string.split(':');
-        let host = parts.next().ok_or("No host specified")?.to_string();
-        // default the port to 25565
-        let port = parts.next().unwrap_or("25565");
-        let port = u16::from_str(port).map_err(|_| "Invalid port specified")?;
-        Ok(ServerAddress { host, port })
-    }
-}
-
-pub async fn connect(address: ServerAddress) -> Result<(), Box<dyn std::error::Error>> {
-    let resolved_address = resolver::resolve_address(&address).await;
-    println!("Resolved address: {:?}", resolved_address);
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        let result = 2 + 2;
-        assert_eq!(result, 4);
-    }
-}
diff --git a/minecraft-protocol/src/mc_buf.rs b/minecraft-protocol/src/mc_buf.rs
deleted file mode 100644
index 54ba1f7d..00000000
--- a/minecraft-protocol/src/mc_buf.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-//! Utilities for reading and writing for the Minecraft protocol
-
-use std::io::Write;
-
-use async_trait::async_trait;
-use byteorder::{BigEndian, WriteBytesExt};
-use tokio::io::{AsyncRead, AsyncReadExt};
-
-// const DEFAULT_NBT_QUOTA: u32 = 2097152;
-const MAX_STRING_LENGTH: u16 = 32767;
-// const MAX_COMPONENT_STRING_LENGTH: u32 = 262144;
-
-#[async_trait]
-pub trait Writable {
-    fn write_byte(&mut self, n: u8) -> Result<(), std::io::Error>;
-    fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
-    fn write_varint(&mut self, value: i32) -> Result<(), std::io::Error>;
-    fn write_utf_with_len(&mut self, string: &str, len: usize) -> Result<(), std::io::Error>;
-    fn write_utf(&mut self, string: &str) -> Result<(), std::io::Error>;
-    fn write_short(&mut self, n: u16) -> Result<(), std::io::Error>;
-    fn write_byte_array(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
-}
-
-#[async_trait]
-impl Writable for Vec<u8> {
-    fn write_byte(&mut self, n: u8) -> Result<(), std::io::Error> {
-        WriteBytesExt::write_u8(self, n)
-    }
-
-    fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
-        Ok(self.extend_from_slice(bytes))
-    }
-
-    fn write_varint(&mut self, mut value: i32) -> Result<(), std::io::Error> {
-        let mut buffer = [0];
-        if value == 0 {
-            self.write_all(&buffer).unwrap();
-        }
-        while value != 0 {
-            buffer[0] = (value & 0b0111_1111) as u8;
-            value = (value >> 7) & (i32::max_value() >> 6);
-            if value != 0 {
-                buffer[0] |= 0b1000_0000;
-            }
-            self.write_all(&buffer)?;
-        }
-        Ok(())
-    }
-
-    fn write_utf_with_len(&mut self, string: &str, len: usize) -> Result<(), std::io::Error> {
-        if string.len() > len {
-            panic!(
-                "String too big (was {} bytes encoded, max {})",
-                string.len(),
-                len
-            );
-        }
-        self.write_varint(string.len() as i32);
-        self.write_bytes(string.as_bytes())
-    }
-
-    fn write_utf(&mut self, string: &str) -> Result<(), std::io::Error> {
-        self.write_utf_with_len(string, MAX_STRING_LENGTH.into())
-    }
-
-    fn write_short(&mut self, n: u16) -> Result<(), std::io::Error> {
-        WriteBytesExt::write_u16::<BigEndian>(self, n)
-    }
-
-    fn write_byte_array(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
-        self.write_varint(bytes.len() as i32);
-        self.write_bytes(bytes)
-    }
-}
-
-#[async_trait]
-pub trait Readable {
-    async fn read_varint(&mut self) -> Result<(i32, u8), String>;
-    async fn read_byte_array(&mut self) -> Result<Vec<u8>, String>;
-    async fn read_bytes(&mut self, n: usize) -> Result<Vec<u8>, String>;
-    async fn read_utf(&mut self) -> Result<String, String>;
-    async fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String>;
-    async fn read_byte(&mut self) -> Result<u8, String>;
-}
-
-#[async_trait]
-impl<R> Readable for R
-where
-    R: AsyncRead + std::marker::Unpin + std::marker::Send,
-{
-    // fast varints stolen from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L67
-    /// Read a single varint from the reader and return the value, along with the number of bytes read
-    async fn read_varint(&mut self) -> Result<(i32, u8), String> {
-        let mut buffer = [0];
-        let mut ans = 0;
-        for i in 0..4 {
-            self.read_exact(&mut buffer)
-                .await
-                .map_err(|_| "Invalid VarInt".to_string())?;
-            ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i);
-            if buffer[0] & 0b1000_0000 == 0 {
-                return Ok((ans, i + 1));
-            }
-        }
-        Ok((ans, 5))
-    }
-
-    async fn read_byte_array(&mut self) -> Result<Vec<u8>, String> {
-        let length = self.read_varint().await?.0 as usize;
-        Ok(self.read_bytes(length).await?)
-    }
-
-    async fn read_bytes(&mut self, n: usize) -> Result<Vec<u8>, String> {
-        let mut bytes = vec![0; n];
-        match AsyncReadExt::read_exact(self, &mut bytes).await {
-            Ok(_) => Ok(bytes),
-            Err(_) => Err("Error reading bytes".to_string()),
-        }
-    }
-
-    async fn read_utf(&mut self) -> Result<String, String> {
-        self.read_utf_with_len(MAX_STRING_LENGTH.into()).await
-    }
-
-    async fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String> {
-        let (length, _length_varint_length) = self.read_varint().await?;
-        // i don't know why it's multiplied by 4 but it's like that in mojang's code so
-        if length < 0 {
-            return Err(
-                "The received encoded string buffer length is less than zero! Weird string!"
-                    .to_string(),
-            );
-        }
-        if length as u32 > max_length * 4 {
-            return Err(format!(
-                "The received encoded string buffer length is longer than maximum allowed ({} > {})",
-                length,
-                max_length * 4
-            ));
-        }
-
-        // this is probably quite inefficient, idk how to do it better
-        let mut string = String::new();
-        let mut buffer = vec![0; length as usize];
-        self.read_exact(&mut buffer)
-            .await
-            .map_err(|_| "Invalid UTF-8".to_string())?;
-
-        string.push_str(std::str::from_utf8(&buffer).unwrap());
-        if string.len() > length as usize {
-            return Err(format!(
-                "The received string length is longer than maximum allowed ({} > {})",
-                length, max_length
-            ));
-        }
-
-        Ok(string)
-    }
-
-    /// Read a single byte from the reader
-    async fn read_byte(&mut self) -> Result<u8, String> {
-        match AsyncReadExt::read_u8(self).await {
-            Ok(r) => Ok(r),
-            Err(_) => Err("Error reading byte".to_string()),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::io::Cursor;
-    use tokio::io::BufReader;
-
-    #[test]
-    fn test_write_varint() {
-        let mut buf = Vec::new();
-        buf.write_varint(123456);
-        assert_eq!(buf, vec![192, 196, 7]);
-
-        let mut buf = Vec::new();
-        buf.write_varint(0);
-        assert_eq!(buf, vec![0]);
-    }
-
-    #[tokio::test]
-    async fn test_read_varint() {
-        let mut buf = BufReader::new(Cursor::new(vec![192, 196, 7]));
-        assert_eq!(buf.read_varint().await.unwrap(), (123456, 3));
-
-        let mut buf = BufReader::new(Cursor::new(vec![0]));
-        assert_eq!(buf.read_varint().await.unwrap(), (0, 1));
-
-        let mut buf = BufReader::new(Cursor::new(vec![1]));
-        assert_eq!(buf.read_varint().await.unwrap(), (1, 1));
-    }
-
-    #[tokio::test]
-    async fn test_read_varint_longer() {
-        let mut buf = BufReader::new(Cursor::new(vec![138, 56, 0, 135, 56, 123]));
-        assert_eq!(buf.read_varint().await.unwrap(), (7178, 2));
-    }
-}
diff --git a/minecraft-protocol/src/packets/game/mod.rs b/minecraft-protocol/src/packets/game/mod.rs
deleted file mode 100644
index a3ef2541..00000000
--- a/minecraft-protocol/src/packets/game/mod.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-use async_trait::async_trait;
-use tokio::io::BufReader;
-
-use crate::connect::PacketFlow;
-
-use super::ProtocolPacket;
-
-#[derive(Clone, Debug)]
-pub enum GamePacket
-where
-    Self: Sized, {}
-
-#[async_trait]
-impl ProtocolPacket for GamePacket {
-    fn id(&self) -> u32 {
-        0x00
-    }
-
-    fn write(&self, _buf: &mut Vec<u8>) {}
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        _id: u32,
-        flow: &PacketFlow,
-        _buf: &mut BufReader<T>,
-    ) -> Result<GamePacket, String>
-    where
-        Self: Sized,
-    {
-        match flow {
-            PacketFlow::ServerToClient => Err("HandshakePacket::read not implemented".to_string()),
-            PacketFlow::ClientToServer => Err("HandshakePacket::read not implemented".to_string()),
-        }
-    }
-}
diff --git a/minecraft-protocol/src/packets/handshake/client_intention_packet.rs b/minecraft-protocol/src/packets/handshake/client_intention_packet.rs
deleted file mode 100644
index 868626b3..00000000
--- a/minecraft-protocol/src/packets/handshake/client_intention_packet.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use std::hash::Hash;
-
-use tokio::io::BufReader;
-
-use crate::{mc_buf::Writable, packets::ConnectionProtocol};
-
-use super::HandshakePacket;
-
-#[derive(Hash, Clone, Debug)]
-pub struct ClientIntentionPacket {
-    pub protocol_version: u32,
-    pub hostname: String,
-    pub port: u16,
-    /// 1 for status, 2 for login
-    pub intention: ConnectionProtocol,
-}
-
-impl ClientIntentionPacket {
-    pub fn get(self) -> HandshakePacket {
-        HandshakePacket::ClientIntentionPacket(self)
-    }
-
-    pub fn write(&self, buf: &mut Vec<u8>) {
-        buf.write_varint(self.protocol_version as i32).unwrap();
-        buf.write_utf(&self.hostname).unwrap();
-        buf.write_short(self.port).unwrap();
-        buf.write_varint(self.intention.clone() as i32).unwrap();
-    }
-
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        _buf: &mut BufReader<T>,
-    ) -> Result<HandshakePacket, String> {
-        Err("ClientIntentionPacket::parse not implemented".to_string())
-        // Ok(ClientIntentionPacket {}.get())
-    }
-}
diff --git a/minecraft-protocol/src/packets/handshake/mod.rs b/minecraft-protocol/src/packets/handshake/mod.rs
deleted file mode 100644
index 01010e1e..00000000
--- a/minecraft-protocol/src/packets/handshake/mod.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-pub mod client_intention_packet;
-
-use async_trait::async_trait;
-use tokio::io::BufReader;
-
-use crate::connect::PacketFlow;
-
-use super::ProtocolPacket;
-
-#[derive(Clone, Debug)]
-pub enum HandshakePacket
-where
-    Self: Sized,
-{
-    ClientIntentionPacket(client_intention_packet::ClientIntentionPacket),
-}
-
-#[async_trait]
-impl ProtocolPacket for HandshakePacket {
-    fn id(&self) -> u32 {
-        match self {
-            HandshakePacket::ClientIntentionPacket(_packet) => 0x00,
-        }
-    }
-
-    fn write(&self, buf: &mut Vec<u8>) {
-        match self {
-            HandshakePacket::ClientIntentionPacket(packet) => packet.write(buf),
-        }
-    }
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut BufReader<T>,
-    ) -> Result<HandshakePacket, String>
-    where
-        Self: Sized,
-    {
-        match flow {
-            PacketFlow::ServerToClient => Err("HandshakePacket::read not implemented".to_string()),
-            PacketFlow::ClientToServer => match id {
-                0x00 => Ok(client_intention_packet::ClientIntentionPacket::read(buf).await?),
-                _ => Err(format!("Unknown ClientToServer status packet id: {}", id)),
-            },
-        }
-    }
-}
diff --git a/minecraft-protocol/src/packets/login/clientbound_custom_query_packet.rs b/minecraft-protocol/src/packets/login/clientbound_custom_query_packet.rs
deleted file mode 100644
index 093176eb..00000000
--- a/minecraft-protocol/src/packets/login/clientbound_custom_query_packet.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use std::hash::Hash;
-use tokio::io::BufReader;
-
-use crate::mc_buf::{self, Readable, Writable};
-
-use super::LoginPacket;
-
-#[derive(Hash, Clone, Debug)]
-pub struct ClientboundCustomQueryPacket {
-    pub transaction_id: u32,
-    // TODO: this should be a resource location
-    pub identifier: String,
-    pub data: Vec<u8>,
-}
-
-impl ClientboundCustomQueryPacket {
-    pub fn get(self) -> LoginPacket {
-        LoginPacket::ClientboundCustomQueryPacket(self)
-    }
-
-    pub fn write(&self, buf: &mut Vec<u8>) {
-        buf.write_varint(self.transaction_id as i32).unwrap();
-        buf.write_utf(&self.identifier).unwrap();
-        buf.write_bytes(&self.data).unwrap();
-    }
-
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        buf: &mut BufReader<T>,
-    ) -> Result<LoginPacket, String> {
-        let transaction_id = buf.read_varint().await?.0 as u32;
-        // TODO: this should be a resource location
-        let identifier = buf.read_utf().await?;
-        let data = buf.read_bytes(1048576).await?;
-        Ok(ClientboundCustomQueryPacket {
-            transaction_id,
-            identifier,
-            data,
-        }
-        .get())
-    }
-}
diff --git a/minecraft-protocol/src/packets/login/clientbound_hello_packet.rs b/minecraft-protocol/src/packets/login/clientbound_hello_packet.rs
deleted file mode 100644
index 36a48706..00000000
--- a/minecraft-protocol/src/packets/login/clientbound_hello_packet.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use std::hash::Hash;
-use tokio::io::BufReader;
-
-use crate::mc_buf::Readable;
-
-use super::LoginPacket;
-
-#[derive(Hash, Clone, Debug)]
-pub struct ClientboundHelloPacket {
-    pub server_id: String,
-    pub public_key: Vec<u8>,
-    pub nonce: Vec<u8>,
-}
-
-impl ClientboundHelloPacket {
-    pub fn get(self) -> LoginPacket {
-        LoginPacket::ClientboundHelloPacket(self)
-    }
-
-    pub fn write(&self, _buf: &mut Vec<u8>) {
-        panic!("ClientboundHelloPacket::write not implemented")
-    }
-
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        buf: &mut BufReader<T>,
-    ) -> Result<LoginPacket, String> {
-        let server_id = buf.read_utf_with_len(20).await?;
-        let public_key = buf.read_byte_array().await?;
-        let nonce = buf.read_byte_array().await?;
-
-        Ok(ClientboundHelloPacket {
-            server_id,
-            public_key,
-            nonce,
-        }
-        .get())
-    }
-}
diff --git a/minecraft-protocol/src/packets/login/mod.rs b/minecraft-protocol/src/packets/login/mod.rs
deleted file mode 100644
index f0ed6717..00000000
--- a/minecraft-protocol/src/packets/login/mod.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-pub mod clientbound_custom_query_packet;
-pub mod clientbound_hello_packet;
-pub mod serverbound_hello_packet;
-
-use async_trait::async_trait;
-use tokio::io::BufReader;
-
-use crate::connect::PacketFlow;
-
-use super::ProtocolPacket;
-
-#[derive(Clone, Debug)]
-pub enum LoginPacket
-where
-    Self: Sized,
-{
-    ClientboundCustomQueryPacket(clientbound_custom_query_packet::ClientboundCustomQueryPacket),
-    ServerboundHelloPacket(serverbound_hello_packet::ServerboundHelloPacket),
-    ClientboundHelloPacket(clientbound_hello_packet::ClientboundHelloPacket),
-}
-
-#[async_trait]
-impl ProtocolPacket for LoginPacket {
-    fn id(&self) -> u32 {
-        match self {
-            LoginPacket::ClientboundCustomQueryPacket(_packet) => 0x04,
-            LoginPacket::ServerboundHelloPacket(_packet) => 0x00,
-            LoginPacket::ClientboundHelloPacket(_packet) => 0x01,
-        }
-    }
-
-    fn write(&self, buf: &mut Vec<u8>) {
-        match self {
-            LoginPacket::ClientboundCustomQueryPacket(packet) => packet.write(buf),
-            LoginPacket::ServerboundHelloPacket(packet) => packet.write(buf),
-            LoginPacket::ClientboundHelloPacket(packet) => packet.write(buf),
-        }
-    }
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut BufReader<T>,
-    ) -> Result<LoginPacket, String>
-    where
-        Self: Sized,
-    {
-        Ok(match flow {
-            PacketFlow::ServerToClient => match id {
-                0x01 => clientbound_hello_packet::ClientboundHelloPacket::read(buf).await?,
-                0x04 => {
-                    clientbound_custom_query_packet::ClientboundCustomQueryPacket::read(buf).await?
-                }
-                _ => return Err(format!("Unknown ServerToClient status packet id: {}", id)),
-            },
-            PacketFlow::ClientToServer => match id {
-                0x00 => serverbound_hello_packet::ServerboundHelloPacket::read(buf).await?,
-                _ => return Err(format!("Unknown ClientToServer status packet id: {}", id)),
-            },
-        })
-    }
-}
diff --git a/minecraft-protocol/src/packets/login/serverbound_hello_packet.rs b/minecraft-protocol/src/packets/login/serverbound_hello_packet.rs
deleted file mode 100644
index 32a6dadc..00000000
--- a/minecraft-protocol/src/packets/login/serverbound_hello_packet.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use std::hash::Hash;
-use tokio::io::BufReader;
-
-use crate::mc_buf::Writable;
-
-use super::LoginPacket;
-
-#[derive(Hash, Clone, Debug)]
-pub struct ServerboundHelloPacket {
-    pub username: String,
-}
-
-impl ServerboundHelloPacket {
-    pub fn get(self) -> LoginPacket {
-        LoginPacket::ServerboundHelloPacket(self)
-    }
-
-    pub fn write(&self, buf: &mut Vec<u8>) {
-        buf.write_utf(&self.username).unwrap();
-    }
-
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        _buf: &mut BufReader<T>,
-    ) -> Result<LoginPacket, String> {
-        Err("ServerboundHelloPacket::read not implemented".to_string())
-    }
-}
diff --git a/minecraft-protocol/src/packets/mod.rs b/minecraft-protocol/src/packets/mod.rs
deleted file mode 100644
index a074b570..00000000
--- a/minecraft-protocol/src/packets/mod.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-pub mod game;
-pub mod handshake;
-pub mod login;
-pub mod status;
-
-use async_trait::async_trait;
-use tokio::io::BufReader;
-
-use crate::connect::PacketFlow;
-
-pub const PROTOCOL_VERSION: u32 = 757;
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ConnectionProtocol {
-    Handshake = -1,
-    Game = 0,
-    Status = 1,
-    Login = 2,
-}
-
-#[derive(Clone, Debug)]
-pub enum Packet {
-    Game(game::GamePacket),
-    Handshake(handshake::HandshakePacket),
-    Login(login::LoginPacket),
-    Status(Box<status::StatusPacket>),
-}
-
-/// An enum of packets for a certain protocol
-#[async_trait]
-pub trait ProtocolPacket
-where
-    Self: Sized,
-{
-    fn id(&self) -> u32;
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut BufReader<T>,
-    ) -> Result<Self, String>
-    where
-        Self: Sized;
-
-    fn write(&self, buf: &mut Vec<u8>);
-}
-
-// impl Packet {
-//     fn get_inner_packet(&self) -> &dyn PacketTrait {
-//         match self {
-//             Packet::ClientIntentionPacket(packet) => packet,
-//             Packet::ServerboundStatusRequestPacket(packet) => packet,
-//             Packet::ClientboundStatusResponsePacket(packet) => packet,
-//             Packet::ServerboundHelloPacket(packet) => packet,
-//             Packet::ClientboundHelloPacket(packet) => packet,
-//         }
-//     }
-
-//     pub fn id(&self) -> u32 {
-//         match self {
-//             Packet::ClientIntentionPacket(_packet) => 0x00,
-//             Packet::ServerboundStatusRequestPacket(_packet) => 0x00,
-//             Packet::ClientboundStatusResponsePacket(_packet) => 0x00,
-//             Packet::ServerboundHelloPacket(_packet) => 0x00,
-//             Packet::ClientboundHelloPacket(_packet) => 0x01,
-//         }
-//     }
-
-//     /// Read a packet by its id, ConnectionProtocol, and flow
-//     pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-//         id: u32,
-//         protocol: &ConnectionProtocol,
-//         flow: &PacketFlow,
-//         buf: &mut BufReader<T>,
-//     ) -> Result<Packet, String> {
-//         match protocol {
-//             ConnectionProtocol::Handshake => match flow {
-//                 PacketFlow::ClientToServer => match id {
-//                     0x00 => Ok(
-//                         handshake::client_intention_packet::ClientIntentionPacket::read(buf).await?,
-//                     ),
-//                     _ => Err(format!("Unknown ClientToServer handshake packet id: {}", id)),
-//                 }
-//                 PacketFlow::ServerToClient => Err("ServerToClient handshake packets not implemented".to_string()),
-//             },
-
-//             ConnectionProtocol::Game => Err("Game protocol not implemented yet".to_string()),
-
-//             ConnectionProtocol::Status => match flow {
-//                 PacketFlow::ServerToClient => match id {
-//                     0x00 => Ok(
-//                         status::clientbound_status_response_packet::ClientboundStatusResponsePacket
-//                             ::read(buf)
-//                             .await?,
-//                     ),
-//                     _ => Err(format!("Unknown ServerToClient status packet id: {}", id)),
-//                 },
-//                 PacketFlow::ClientToServer => match id {
-//                     0x00 => Ok(
-//                         status::serverbound_status_request_packet::ServerboundStatusRequestPacket
-//                             ::read(buf)
-//                             .await?,
-//                     ),
-//                     _ => Err(format!("Unknown ClientToServer status packet id: {}", id)),
-//                 },
-//             },
-
-//             ConnectionProtocol::Login => match flow {
-//                 PacketFlow::ServerToClient => match id {
-//                     0x01 => Ok(
-//                         login::clientbound_hello_packet::ClientboundHelloPacket::read(buf).await?,
-//                     ),
-//                     _ => Err(format!("Unknown ServerToClient login packet id: {}", id)),
-//                 },
-//                 PacketFlow::ClientToServer => match id {
-//                     0x00 => Ok(
-//                         login::serverbound_hello_packet::ServerboundHelloPacket::read(buf).await?,
-//                     ),
-//                     _ => Err(format!("Unknown ClientToServer login packet id: {}", id)),
-//                 },
-//             },
-//         }
-//     }
-
-//     pub fn write(&self, buf: &mut Vec<u8>) {
-//         self.get_inner_packet().write(buf);
-//     }
-// }
-
-// #[async_trait]
-// pub trait PacketTrait
-// where
-//     Self: Sized,
-// {
-//     /// Return a version of the packet that you can actually use for stuff
-//     fn get(self) -> dyn ProtocolPacket;
-
-//     fn write(&self, buf: &mut Vec<u8>);
-
-//     async fn read<T: AsyncRead + std::marker::Unpin + std::marker::Send, P: ProtocolPacket>(
-//         buf: &mut BufReader<T>,
-//     ) -> Result<P, String>
-//     where
-//         Self: Sized;
-// }
diff --git a/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs b/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs
deleted file mode 100644
index 920e3484..00000000
--- a/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use minecraft_chat::component::Component;
-use serde::Deserialize;
-use serde_json::Value;
-use tokio::io::BufReader;
-
-use crate::mc_buf::Readable;
-
-use super::StatusPacket;
-
-#[derive(Clone, Debug, Deserialize)]
-pub struct Version {
-    pub name: Component,
-    pub protocol: u32,
-}
-
-#[derive(Clone, Debug, Deserialize)]
-pub struct SamplePlayer {
-    pub id: String,
-    pub name: String,
-}
-
-#[derive(Clone, Debug, Deserialize)]
-pub struct Players {
-    pub max: u32,
-    pub online: u32,
-    pub sample: Vec<SamplePlayer>,
-}
-
-// the entire packet is just json, which is why it has deserialize
-#[derive(Clone, Debug, Deserialize)]
-pub struct ClientboundStatusResponsePacket {
-    pub description: Component,
-    pub favicon: Option<String>,
-    pub players: Players,
-    pub version: Version,
-}
-
-impl ClientboundStatusResponsePacket {
-    pub fn get(self) -> StatusPacket {
-        StatusPacket::ClientboundStatusResponsePacket(Box::new(self))
-    }
-
-    pub fn write(&self, _buf: &mut Vec<u8>) {}
-
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        buf: &mut BufReader<T>,
-    ) -> Result<StatusPacket, String> {
-        let status_string = buf.read_utf().await?;
-        let status_json: Value =
-            serde_json::from_str(status_string.as_str()).expect("Server status isn't valid JSON");
-
-        let packet = ClientboundStatusResponsePacket::deserialize(status_json)
-            .map_err(|e| e.to_string())?
-            .get();
-
-        Ok(packet)
-    }
-}
diff --git a/minecraft-protocol/src/packets/status/mod.rs b/minecraft-protocol/src/packets/status/mod.rs
deleted file mode 100644
index ac6a34e1..00000000
--- a/minecraft-protocol/src/packets/status/mod.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-pub mod clientbound_status_response_packet;
-pub mod serverbound_status_request_packet;
-
-use async_trait::async_trait;
-use tokio::io::BufReader;
-
-use crate::connect::PacketFlow;
-
-use super::ProtocolPacket;
-
-#[derive(Clone, Debug)]
-pub enum StatusPacket
-where
-    Self: Sized,
-{
-    ServerboundStatusRequestPacket(
-        serverbound_status_request_packet::ServerboundStatusRequestPacket,
-    ),
-    ClientboundStatusResponsePacket(
-        Box<clientbound_status_response_packet::ClientboundStatusResponsePacket>,
-    ),
-}
-
-#[async_trait]
-impl ProtocolPacket for StatusPacket {
-    fn id(&self) -> u32 {
-        match self {
-            StatusPacket::ServerboundStatusRequestPacket(_packet) => 0x00,
-            StatusPacket::ClientboundStatusResponsePacket(_packet) => 0x00,
-        }
-    }
-
-    fn write(&self, buf: &mut Vec<u8>) {
-        match self {
-            StatusPacket::ServerboundStatusRequestPacket(packet) => packet.write(buf),
-            StatusPacket::ClientboundStatusResponsePacket(packet) => packet.write(buf),
-        }
-    }
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut BufReader<T>,
-    ) -> Result<StatusPacket, String>
-    where
-        Self: Sized,
-    {
-        match flow {
-            PacketFlow::ServerToClient => match id {
-                0x00 => Ok(
-                    clientbound_status_response_packet::ClientboundStatusResponsePacket::read(buf)
-                        .await?,
-                ),
-                _ => Err(format!("Unknown ServerToClient status packet id: {}", id)),
-            },
-            PacketFlow::ClientToServer => match id {
-                0x00 => Ok(
-                    serverbound_status_request_packet::ServerboundStatusRequestPacket::read(buf)
-                        .await?,
-                ),
-                _ => Err(format!("Unknown ClientToServer status packet id: {}", id)),
-            },
-        }
-    }
-}
diff --git a/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs b/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs
deleted file mode 100644
index 6a58da1f..00000000
--- a/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use std::hash::Hash;
-use tokio::io::BufReader;
-
-use super::StatusPacket;
-
-#[derive(Hash, Clone, Debug)]
-pub struct ServerboundStatusRequestPacket {}
-
-impl ServerboundStatusRequestPacket {
-    pub fn get(self) -> StatusPacket {
-        StatusPacket::ServerboundStatusRequestPacket(self)
-    }
-
-    pub fn write(&self, _buf: &mut Vec<u8>) {
-        panic!("ServerboundStatusRequestPacket::write not implemented")
-    }
-
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        _buf: &mut BufReader<T>,
-    ) -> Result<StatusPacket, String> {
-        Err("ServerboundStatusRequestPacket::read not implemented".to_string())
-    }
-}
diff --git a/minecraft-protocol/src/read.rs b/minecraft-protocol/src/read.rs
deleted file mode 100644
index 6f242e8b..00000000
--- a/minecraft-protocol/src/read.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use tokio::{io::BufReader, net::TcpStream};
-
-use crate::{connect::PacketFlow, mc_buf::Readable, packets::ProtocolPacket};
-
-pub async fn read_packet<P: ProtocolPacket>(
-    flow: &PacketFlow,
-    stream: &mut TcpStream,
-) -> Result<P, String> {
-    // what this does:
-    // 1. reads the first 5 bytes, probably only some of this will be used to get the packet length
-    // 2. how much we should read = packet length - 5
-    // 3. read the rest of the packet and add it to the cursor
-    // 4. figure out what packet this is and parse it
-
-    // the first thing minecraft sends us is the length as a varint, which can be up to 5 bytes long
-    let mut buf = BufReader::with_capacity(4 * 1024 * 1024, stream);
-
-    let (_packet_size, _packet_size_varint_size) = buf.read_varint().await?;
-
-    // then, minecraft tells us the packet id as a varint
-    let (packet_id, _packet_id_size) = buf.read_varint().await?;
-
-    // if we recognize the packet id, parse it
-
-    let packet = P::read(packet_id.try_into().unwrap(), flow, &mut buf).await?;
-
-    Ok(packet)
-}
diff --git a/minecraft-protocol/src/resolver.rs b/minecraft-protocol/src/resolver.rs
deleted file mode 100644
index 24687a6e..00000000
--- a/minecraft-protocol/src/resolver.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use std::net::IpAddr;
-
-use crate::{ServerAddress, ServerIpAddress};
-use async_recursion::async_recursion;
-use trust_dns_resolver::{
-    config::{ResolverConfig, ResolverOpts},
-    TokioAsyncResolver,
-};
-
-/// Resolve a Minecraft server address into an IP address and port.
-/// If it's already an IP address, it's returned as-is.
-#[async_recursion]
-pub async fn resolve_address(address: &ServerAddress) -> Result<ServerIpAddress, String> {
-    // If the address.host is already in the format of an ip address, return it.
-    if let Ok(ip) = address.host.parse::<IpAddr>() {
-        return Ok(ServerIpAddress {
-            ip,
-            port: address.port,
-        });
-    }
-
-    // we specify Cloudflare instead of the default resolver because trust_dns_resolver has an issue on Windows where it's really slow using the default resolver
-    let resolver =
-        TokioAsyncResolver::tokio(ResolverConfig::cloudflare(), ResolverOpts::default()).unwrap();
-
-    // first, we do a srv lookup for _minecraft._tcp.<host>
-    let srv_redirect_result = resolver
-        .srv_lookup(format!("_minecraft._tcp.{}", address.host).as_str())
-        .await;
-
-    // if it resolves that means it's a redirect so we call resolve_address again with the new host
-    if let Ok(redirect_result) = srv_redirect_result {
-        let redirect_srv = redirect_result
-            .iter()
-            .next()
-            .ok_or_else(|| "No SRV record found".to_string())?;
-        let redirect_address = ServerAddress {
-            host: redirect_srv.target().to_utf8(),
-            port: redirect_srv.port(),
-        };
-
-        println!("redirecting to {:?}", redirect_address);
-
-        return resolve_address(&redirect_address).await;
-    }
-
-    // there's no redirect, try to resolve this as an ip address
-    let lookup_ip_result = resolver.lookup_ip(address.host.clone()).await;
-    let lookup_ip = lookup_ip_result.map_err(|_| "No IP found".to_string())?;
-
-    Ok(ServerIpAddress {
-        ip: lookup_ip.iter().next().unwrap(),
-        port: address.port,
-    })
-}
diff --git a/minecraft-protocol/src/write.rs b/minecraft-protocol/src/write.rs
deleted file mode 100644
index 3d8540eb..00000000
--- a/minecraft-protocol/src/write.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use tokio::{io::AsyncWriteExt, net::TcpStream};
-
-use crate::{mc_buf::Writable, packets::ProtocolPacket};
-
-pub async fn write_packet(packet: impl ProtocolPacket, stream: &mut TcpStream) {
-    // TODO: implement compression
-
-    // packet structure:
-    // length (varint) + id (varint) + data
-
-    // write the packet id
-    let mut id_and_data_buf = vec![];
-    id_and_data_buf.write_varint(packet.id() as i32);
-    packet.write(&mut id_and_data_buf);
-
-    // write the packet data
-
-    // make a new buffer that has the length at the beginning
-    // and id+data at the end
-    let mut complete_buf: Vec<u8> = Vec::new();
-    complete_buf.write_varint(id_and_data_buf.len() as i32);
-    complete_buf.append(&mut id_and_data_buf);
-
-    // finally, write and flush to the stream
-    stream.write_all(&complete_buf).await.unwrap();
-    stream.flush().await.unwrap();
-}