nbt?

src/data/async_reader.rs

@@ -32,10 +32,6 @@ pub trait AsyncReader {
 		Ok(self.read_bytes(1).await?[0])
 	}
 
-	async fn read_signed_byte(&mut self) -> Result<i8, DataError> {
-		Ok(self.read_byte().await? as i8)
-	}
-
 	async fn read_varint_size(&mut self) -> Result<(i32, usize), DataError> {
 		let mut value = 0;
 		let mut position = 0;
@@ -71,36 +67,4 @@ pub trait AsyncReader {
 		let id = cursor.read_varint()?;
 		Ok(Packet::new(id as u8, cursor))
 	}
-
-	async fn read_short(&mut self) -> Result<u16, DataError> {
-		Ok(u16::from_be_bytes(
-			self.read_bytes(2).await?.try_into().unwrap()
-		))
-	}
-
-	async fn read_signed_short(&mut self) -> Result<i16, DataError> {
-		Ok(self.read_short().await? as i16)
-	}
-
-	async fn read_string(&mut self) -> Result<String, DataError> {
-		let size = self.read_varint().await?;
-		let vec = self.read_bytes(size as usize).await?;
-		String::from_utf8(vec).or( Err(DataError::StringDecodeError))
-	}
-
-	async fn read_long(&mut self) -> Result<u64, DataError> {
-		Ok(u64::from_be_bytes(
-			self.read_bytes(8).await?.try_into().unwrap()
-		))
-	}
-
-	async fn read_signed_long(&mut self) -> Result<i64, DataError> {
-		Ok(self.read_long().await? as i64)
-	}
-
-	async fn read_uuid(&mut self) -> Result<u128, DataError> {
-		Ok(u128::from_be_bytes(
-			self.read_bytes(16).await?.try_into().unwrap()
-		))
-	}
 }

src/data/async_writer.rs

@@ -15,30 +15,6 @@ impl AsyncWriter for TcpStream {
 pub trait AsyncWriter {
 	async fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), DataError>;
 
-	async fn write_byte(&mut self, value: u8) -> Result<(), DataError> {
-		self.write_bytes(&[value]).await
-	}
-
-	async fn write_signed_byte(&mut self, value: i8) -> Result<(), DataError> {
-		self.write_byte(value as u8).await
-	}
-
-	async fn write_varint_size(&mut self, value: i32) -> Result<usize, DataError> {
-		let mut _value = value as u32;
-		let mut position = 0;
-		loop {
-			let mut byte = (_value & 127) as u8;
-			position += 1; _value >>= 7;
-			if _value != 0 { byte += 128; };
-			self.write_byte(byte).await?;
-			if _value == 0 { return Ok(position) }
-		}
-	}
-
-	async fn write_varint(&mut self, value: i32) -> Result<(), DataError> {
-		self.write_varint_size(value).await?; Ok(())
-	}
-
 	async fn write_packet(&mut self, packet: Packet, threshold: Option<usize>)
 	-> Result<(), DataError> {
 		let mut buf = Vec::new();
@@ -67,30 +43,4 @@ pub trait AsyncWriter {
 		self.write_bytes(&buf).await?;
 		Ok(())
 	}
-
-	async fn write_short(&mut self, value: u16) -> Result<(), DataError> {
-		self.write_bytes(&value.to_be_bytes()).await
-	}
-
-	async fn write_signed_short(&mut self, value: i16) -> Result<(), DataError> {
-		self.write_short(value as u16).await
-	}
-
-	async fn write_string(&mut self, value: &str) -> Result<(), DataError> {
-		self.write_varint(value.len() as i32).await?;
-		self.write_bytes(value.as_bytes()).await?;
-		Ok(())
-	}
-
-	async fn write_long(&mut self, value: u64) -> Result<(), DataError> {
-		self.write_bytes(&value.to_be_bytes()).await
-	}
-
-	async fn write_signed_long(&mut self, value: i64) -> Result<(), DataError> {
-		self.write_long(value as u64).await
-	}
-
-	async fn write_uuid(&mut self, value: u128) -> Result<(), DataError> {
-		self.write_bytes(&value.to_be_bytes()).await
-	}
 }

src/data/mod.rs

@@ -12,6 +12,7 @@ mod writer;
 mod packet;
 mod packet_id;
 mod component;
+mod nbt;
 
 #[derive(Debug)]
 pub enum DataError {
@@ -45,3 +46,4 @@ pub use writer::*;
 pub use packet::*;
 pub use packet_id::{clientbound, serverbound};
 pub use component::*;
+pub use nbt::*;

src/data/nbt.rs

@@ -0,0 +1,53 @@
+use std::io::Cursor;
+
+
+
+
+const TAG_END:        u8 =  0;
+const TAG_BYTE:       u8 =  1;
+const TAG_SHORT:      u8 =  2;
+const TAG_INT:        u8 =  3;
+const TAG_LONG:       u8 =  4;
+const TAG_FLOAT:      u8 =  5;
+const TAG_DOUBLE:     u8 =  6;
+const TAG_BYTE_ARRAY: u8 =  7;
+const TAG_STRING:     u8 =  8;
+const TAG_LIST:       u8 =  9;
+const TAG_COMPOUND:   u8 = 10;
+const TAG_INT_ARRAY:  u8 = 11;
+const TAG_LONG_ARRAY: u8 = 12;
+
+enum TAG {
+	END,
+	COMPOUND(Vec<NBT>),
+	STRING(String),
+	BYTE(i8),
+	SHORT(i16),
+	INT(i32),
+	LONG(i64),
+	FLOAT(f32),
+	DOUBLE(f64),
+	// LIST
+	// BYTE_ARRAY
+	// INT_ARRAY
+	// LONG_ARRAY
+}
+
+struct NBT {
+	key: String,
+	value: TAG,
+}
+
+impl NBT {
+	fn new(key: String, value: TAG) -> Self {
+		Self { key, value }
+	}
+}
+
+pub trait NBT_Reader {
+
+}
+
+impl NBT_Reader for Cursor<Vec<u8>> {
+
+}

src/main.rs

@@ -9,14 +9,16 @@ mod cycle;
 
 #[tokio::main]
 async fn main() {
-	let Ok(server) = Server::new("127.0.0.1:25565").await else {
-		println!("Не удалось забиндить сервер");
-		return;
-	};
+	// let Ok(server) = Server::new("127.0.0.1:25565").await else {
+	// 	println!("Не удалось забиндить сервер");
+	// 	return;
+	// };
+
+	// loop {
+	// 	let stream = server.accept().await;
+	// 	tokio::spawn(cycle::main(stream));
+	// }
+
 	
-	loop {
-		let stream = server.accept().await;
-		tokio::spawn(cycle::main(stream));
-	}
 }