ReadWriteAny trait instead of ton of RWStuff

src/data/component.rs

@@ -7,7 +7,7 @@ use serde_with::skip_serializing_none;
 
 use crate::ServerError;
 
-use super::RWNBT;
+use super::ReadWriteAny;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[skip_serializing_none]
@@ -192,8 +192,8 @@ impl TextComponentBuilder {
 }
 
 // Реализуем читалку-записывалку текст-компонентов для пакета
-impl<'a> RWNBT<'a, TextComponent> for Packet {
+impl ReadWriteAny<TextComponent> for Packet {
-	fn read_nbt(&mut self) -> Result<TextComponent, ServerError> {
+	fn read_any(&mut self) -> Result<TextComponent, ServerError> {
 		let mut data = Vec::new();
 		let pos = self.get_ref().position();
 		self
@@ -208,7 +208,7 @@ impl<'a> RWNBT<'a, TextComponent> for Packet {
 		Ok(value)
 	}
 
-	fn write_nbt(&mut self, val: &TextComponent) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &TextComponent) -> Result<(), ServerError> {
 		craftflow_nbt::to_writer(self.get_mut(), val).map_err(|_| ServerError::SerTextComponent)?;
 		Ok(())
 	}

src/data/mod.rs

@@ -2,7 +2,6 @@ use std::io::Read;
 
 use craftflow_nbt::DynNBT;
 use rust_mc_proto::{DataReader, DataWriter, Packet};
-use serde::{Deserialize, Serialize};
 
 use super::ServerError;
 
@@ -11,13 +10,13 @@ pub mod slot;
 pub mod sound;
 
 // Трейт для чтения NBT-совместимых приколов
-pub trait RWNBT<'a, T: Serialize + Deserialize<'a>>: DataReader + DataWriter {
+pub trait ReadWriteAny<T: Sized> {
-	fn read_nbt(&mut self) -> Result<T, ServerError>;
+	fn read_any(&mut self) -> Result<T, ServerError>;
-	fn write_nbt(&mut self, val: &T) -> Result<(), ServerError>;
+	fn write_any(&mut self, val: &T) -> Result<(), ServerError>;
 }
 
-impl<'a> RWNBT<'a, DynNBT> for Packet {
+impl ReadWriteAny<DynNBT> for Packet {
-	fn read_nbt(&mut self) -> Result<DynNBT, ServerError> {
+	fn read_any(&mut self) -> Result<DynNBT, ServerError> {
 		let mut data = Vec::new();
 		let pos = self.get_ref().position();
 		self
@@ -31,18 +30,18 @@ impl<'a> RWNBT<'a, DynNBT> for Packet {
 		Ok(value)
 	}
 
-	fn write_nbt(&mut self, val: &DynNBT) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &DynNBT) -> Result<(), ServerError> {
 		craftflow_nbt::to_writer(self.get_mut(), val).map_err(|_| ServerError::SerNbt)?;
 		Ok(())
 	}
 }
 
-pub trait RWPosition: DataReader + DataWriter {
+pub trait ReadWritePos: DataReader + DataWriter {
 	fn read_position(&mut self) -> Result<(i64, i64, i64), ServerError>;
 	fn write_position(&mut self, x: i64, y: i64, z: i64) -> Result<(), ServerError>;
 }
 
-impl<T: DataReader + DataWriter> RWPosition for T {
+impl<T: DataReader + DataWriter> ReadWritePos for T {
 	fn read_position(&mut self) -> Result<(i64, i64, i64), ServerError> {
 		let val = self.read_long()?;
 		Ok((val >> 38, val << 52 >> 52, val << 26 >> 38))
@@ -65,13 +64,8 @@ pub enum IdSet {
 	Ids(Vec<u32>),
 }
 
-pub trait RWIdSet: DataReader + DataWriter {
+impl<T: DataReader + DataWriter> ReadWriteAny<IdSet> for T {
-	fn read_id_set(&mut self) -> Result<IdSet, ServerError>;
+	fn read_any(&mut self) -> Result<IdSet, ServerError> {
-	fn write_id_set(&mut self, val: IdSet) -> Result<(), ServerError>;
-}
-
-impl<T: DataReader + DataWriter> RWIdSet for T {
-	fn read_id_set(&mut self) -> Result<IdSet, ServerError> {
 		let ty = self.read_varint()?;
 		if ty == 0 {
 			Ok(IdSet::Tag(self.read_string()?))
@@ -87,7 +81,7 @@ impl<T: DataReader + DataWriter> RWIdSet for T {
 		}
 	}
 
-	fn write_id_set(&mut self, val: IdSet) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &IdSet) -> Result<(), ServerError> {
 		match val {
 			IdSet::Tag(tag) => {
 				self.write_varint(0)?;
@@ -96,7 +90,7 @@ impl<T: DataReader + DataWriter> RWIdSet for T {
 			IdSet::Ids(ids) => {
 				self.write_usize_varint(ids.len() + 1)?;
 				for id in ids {
-					self.write_u32_varint(id)?;
+					self.write_u32_varint(*id)?;
 				}
 			}
 		}
@@ -131,13 +125,8 @@ pub enum DyeColor {
 	Black,
 }
 
-pub trait RWDyeColor: DataReader + DataWriter {
+impl<T: DataReader + DataWriter> ReadWriteAny<DyeColor> for T {
-	fn read_dye_color(&mut self) -> Result<DyeColor, ServerError>;
+	fn read_any(&mut self) -> Result<DyeColor, ServerError> {
-	fn write_dye_color(&mut self, val: DyeColor) -> Result<(), ServerError>;
-}
-
-impl<T: DataReader + DataWriter> RWDyeColor for T {
-	fn read_dye_color(&mut self) -> Result<DyeColor, ServerError> {
 		match self.read_usize_varint()? {
 			0 => Ok(DyeColor::White),
 			1 => Ok(DyeColor::Orange),
@@ -158,8 +147,8 @@ impl<T: DataReader + DataWriter> RWDyeColor for T {
 			_ => Err(ServerError::WrongPacket),
 		}
 	}
-	fn write_dye_color(&mut self, val: DyeColor) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &DyeColor) -> Result<(), ServerError> {
-		self.write_usize_varint(val as usize)?;
+		self.write_usize_varint(val.clone() as usize)?;
 		Ok(())
 	}
 }

src/data/slot.rs

@@ -7,8 +7,7 @@ use uuid::Uuid;
 use crate::ServerError;
 
 use super::{
-	DyeColor, IdOr, IdSet, Property, RWDyeColor, RWIdSet, RWNBT, component::TextComponent,
+	DyeColor, IdOr, IdSet, Property, ReadWriteAny, component::TextComponent, sound::SoundEvent,
-	sound::SoundEvent,
 };
 
 pub const SLOT_COMPONENT_LENGTH: u16 = 96;
@@ -175,26 +174,21 @@ pub enum BannerLayer {
 	},
 }
 
-pub trait RWBannerLayer: DataReader + DataWriter {
+impl<T: DataReader + DataWriter> ReadWriteAny<BannerLayer> for T {
-	fn read_banner_layer(&mut self) -> Result<BannerLayer, ServerError>;
+	fn read_any(&mut self) -> Result<BannerLayer, ServerError> {
-	fn write_banner_layer(&mut self, val: BannerLayer) -> Result<(), ServerError>;
-}
-
-impl<T: DataReader + DataWriter> RWBannerLayer for T {
-	fn read_banner_layer(&mut self) -> Result<BannerLayer, ServerError> {
 		match self.read_varint()? {
 			0 => Ok(BannerLayer::Direct {
 				asset_id: self.read_string()?,
 				translation_key: self.read_string()?,
-				color: self.read_dye_color()?,
+				color: self.read_any()?,
 			}),
 			id => Ok(BannerLayer::Registry {
 				pattern_id: id - 1,
-				color: self.read_dye_color()?,
+				color: self.read_any()?,
 			}),
 		}
 	}
-	fn write_banner_layer(&mut self, val: BannerLayer) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &BannerLayer) -> Result<(), ServerError> {
 		match val {
 			BannerLayer::Direct {
 				asset_id,
@@ -204,11 +198,11 @@ impl<T: DataReader + DataWriter> RWBannerLayer for T {
 				self.write_varint(0)?;
 				self.write_string(&asset_id)?;
 				self.write_string(&translation_key)?;
-				self.write_dye_color(color)?;
+				self.write_any(color)?;
 			}
 			BannerLayer::Registry { pattern_id, color } => {
 				self.write_varint(pattern_id + 1)?;
-				self.write_dye_color(color)?;
+				self.write_any(color)?;
 			}
 		}
 		Ok(())
@@ -240,13 +234,8 @@ pub struct AttributeModifier {
 	pub slot: u8,
 }
 
-pub trait RWAttributeModifier: DataReader + DataWriter {
+impl<T: DataReader + DataWriter> ReadWriteAny<AttributeModifier> for T {
-	fn read_attribute_modifier(&mut self) -> Result<AttributeModifier, ServerError>;
+	fn read_any(&mut self) -> Result<AttributeModifier, ServerError> {
-	fn write_attribute_modifier(&mut self, val: AttributeModifier) -> Result<(), ServerError>;
-}
-
-impl<T: DataReader + DataWriter> RWAttributeModifier for T {
-	fn read_attribute_modifier(&mut self) -> Result<AttributeModifier, ServerError> {
 		Ok(AttributeModifier {
 			attribute_id: self.read_u32_varint()?,
 			modifier_id: self.read_string()?,
@@ -255,7 +244,7 @@ impl<T: DataReader + DataWriter> RWAttributeModifier for T {
 			slot: self.read_u8_varint()?,
 		})
 	}
-	fn write_attribute_modifier(&mut self, val: AttributeModifier) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &AttributeModifier) -> Result<(), ServerError> {
 		self.write_u32_varint(val.attribute_id)?;
 		self.write_string(&val.modifier_id)?;
 		self.write_double(val.value)?;
@@ -272,15 +261,10 @@ pub struct ToolRule {
 	pub correct_drop_for_blocks: Option<bool>,
 }
 
-pub trait RWToolRule: DataReader + DataWriter {
+impl<T: DataReader + DataWriter> ReadWriteAny<ToolRule> for T {
-	fn read_tool_rule(&mut self) -> Result<ToolRule, ServerError>;
+	fn read_any(&mut self) -> Result<ToolRule, ServerError> {
-	fn write_tool_rule(&mut self, val: ToolRule) -> Result<(), ServerError>;
-}
-
-impl<T: DataReader + DataWriter> RWToolRule for T {
-	fn read_tool_rule(&mut self) -> Result<ToolRule, ServerError> {
 		Ok(ToolRule {
-			blocks: self.read_id_set()?,
+			blocks: self.read_any()?,
 			speed: if self.read_boolean()? {
 				Some(self.read_float()?)
 			} else {
@@ -293,8 +277,8 @@ impl<T: DataReader + DataWriter> RWToolRule for T {
 			},
 		})
 	}
-	fn write_tool_rule(&mut self, val: ToolRule) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &ToolRule) -> Result<(), ServerError> {
-		self.write_id_set(val.blocks)?;
+		self.write_any(&val.blocks)?;
 		if let Some(speed) = val.speed {
 			self.write_boolean(true)?;
 			self.write_float(speed)?;
@@ -319,17 +303,12 @@ pub struct DamageReduction {
 	pub factor: f32,
 }
 
-pub trait RWDamageReduction: DataReader + DataWriter {
+impl<T: DataReader + DataWriter> ReadWriteAny<DamageReduction> for T {
-	fn read_damage_reduction(&mut self) -> Result<DamageReduction, ServerError>;
+	fn read_any(&mut self) -> Result<DamageReduction, ServerError> {
-	fn write_damage_reduction(&mut self, val: DamageReduction) -> Result<(), ServerError>;
-}
-
-impl<T: DataReader + DataWriter> RWDamageReduction for T {
-	fn read_damage_reduction(&mut self) -> Result<DamageReduction, ServerError> {
 		Ok(DamageReduction {
 			horizontal_blocking_angle: self.read_float()?,
 			damage_kind: if self.read_boolean()? {
-				Some(self.read_id_set()?)
+				Some(self.read_any()?)
 			} else {
 				None
 			},
@@ -337,11 +316,11 @@ impl<T: DataReader + DataWriter> RWDamageReduction for T {
 			factor: self.read_float()?,
 		})
 	}
-	fn write_damage_reduction(&mut self, val: DamageReduction) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &DamageReduction) -> Result<(), ServerError> {
 		self.write_float(val.horizontal_blocking_angle)?;
-		if let Some(id_set) = val.damage_kind {
+		if let Some(id_set) = val.damage_kind.clone() {
 			self.write_boolean(true)?;
-			self.write_id_set(id_set)?;
+			self.write_any(&id_set)?;
 		} else {
 			self.write_boolean(false)?;
 		}
@@ -573,29 +552,24 @@ pub enum StructuredComponent {
 	ShulkerColor(DyeColor), // 95
 }
 
-pub trait ReadWriteSlotComponent: DataReader + DataWriter {
+impl ReadWriteAny<StructuredComponent> for Packet {
-	fn read_slot_component(&mut self) -> Result<StructuredComponent, ServerError>;
+	fn read_any(&mut self) -> Result<StructuredComponent, ServerError> {
-	fn write_slot_component(&mut self, val: &StructuredComponent) -> Result<(), ServerError>;
-}
-
-impl ReadWriteSlotComponent for Packet {
-	fn read_slot_component(&mut self) -> Result<StructuredComponent, ServerError> {
 		let id = self.read_u16_varint()?; // id
 
 		match id {
-			0 => Ok(StructuredComponent::CustomData(self.read_nbt()?)),
+			0 => Ok(StructuredComponent::CustomData(self.read_any()?)),
 			1 => Ok(StructuredComponent::MaxStackSize(self.read_varint()?)),
 			2 => Ok(StructuredComponent::MaxDamage(self.read_varint()?)),
 			3 => Ok(StructuredComponent::Unbreakable),
-			4 => Ok(StructuredComponent::CustomName(self.read_nbt()?)),
+			4 => Ok(StructuredComponent::CustomName(self.read_any()?)),
-			5 => Ok(StructuredComponent::ItemName(self.read_nbt()?)),
+			5 => Ok(StructuredComponent::ItemName(self.read_any()?)),
 			6 => Ok(StructuredComponent::ItemModel(self.read_string()?)),
 			7 => {
 				let len: usize = self.read_usize_varint()?;
 				let mut lore = Vec::new();
 
 				for _ in 0..len {
-					lore.push(self.read_nbt()?);
+					lore.push(self.read_any()?);
 				}
 
 				Ok(StructuredComponent::Lore(lore))
@@ -615,22 +589,22 @@ impl ReadWriteSlotComponent for Packet {
 		}
 	}
 
-	fn write_slot_component(&mut self, val: &StructuredComponent) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &StructuredComponent) -> Result<(), ServerError> {
 		self.write_usize_varint(val.enum_index())?;
 
 		match val {
-			StructuredComponent::CustomData(val) => self.write_nbt(val)?,
+			StructuredComponent::CustomData(val) => self.write_any(val)?,
 			StructuredComponent::MaxStackSize(val) => self.write_varint(*val)?,
 			StructuredComponent::MaxDamage(val) => self.write_varint(*val)?,
 			StructuredComponent::Unbreakable => {}
-			StructuredComponent::CustomName(val) => self.write_nbt(val)?,
+			StructuredComponent::CustomName(val) => self.write_any(val)?,
-			StructuredComponent::ItemName(val) => self.write_nbt(val)?,
+			StructuredComponent::ItemName(val) => self.write_any(val)?,
 			StructuredComponent::ItemModel(val) => self.write_string(val)?,
 			StructuredComponent::Lore(val) => {
 				self.write_usize_varint(val.len())?;
 
 				for text in val {
-					self.write_nbt(text)?;
+					self.write_any(text)?;
 				}
 			}
 			StructuredComponent::Rarity(val) => self.write_u8_varint(*val)?,
@@ -656,13 +630,8 @@ pub struct Slot {
 	pub components: Vec<StructuredComponent>,
 }
 
-pub trait RWSlot: DataReader + DataWriter {
+impl ReadWriteAny<Option<Slot>> for Packet {
-	fn read_slot(&mut self) -> Result<Option<Slot>, ServerError>;
+	fn read_any(&mut self) -> Result<Option<Slot>, ServerError> {
-	fn write_slot(&mut self, val: Option<Slot>) -> Result<(), ServerError>;
-}
-
-impl RWSlot for Packet {
-	fn read_slot(&mut self) -> Result<Option<Slot>, ServerError> {
 		let amount = self.read_varint()?;
 
 		if amount > 0 {
@@ -671,7 +640,7 @@ impl RWSlot for Packet {
 			self.read_varint()?; // components_to_remove_len
 			let mut components = Vec::new();
 			for _ in 0..components_len {
-				components.push(self.read_slot_component()?);
+				components.push(self.read_any()?);
 			}
 
 			Ok(Some(Slot {
@@ -684,16 +653,16 @@ impl RWSlot for Packet {
 		}
 	}
 
-	fn write_slot(&mut self, val: Option<Slot>) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &Option<Slot>) -> Result<(), ServerError> {
 		if let Some(val) = val {
 			self.write_varint(val.amount)?;
 			self.write_varint(val.id)?;
 			self.write_usize_varint(val.components.len())?;
 			let mut components_to_remove: Vec<u16> = (0..SLOT_COMPONENT_LENGTH).collect();
 			self.write_usize_varint(SLOT_COMPONENT_LENGTH as usize - val.components.len())?;
-			for comp in val.components {
+			for comp in val.components.clone() {
 				let id = comp.enum_index() as u16;
-				self.write_slot_component(&comp)?;
+				self.write_any(&comp)?;
 				if let Some(index) = components_to_remove.iter().position(|v| *v == id) {
 					components_to_remove.swap_remove(index);
 				}
@@ -716,13 +685,8 @@ pub struct HashedSlot {
 	pub components: Vec<(u16, i32)>,
 }
 
-pub trait RWHashedSlot: DataReader + DataWriter {
+impl<T: DataReader + DataWriter> ReadWriteAny<Option<HashedSlot>> for T {
-	fn read_hashed_slot(&mut self) -> Result<Option<HashedSlot>, ServerError>;
+	fn read_any(&mut self) -> Result<Option<HashedSlot>, ServerError> {
-	fn write_hashed_slot(&mut self, val: Option<HashedSlot>) -> Result<(), ServerError>;
-}
-
-impl<T: DataReader + DataWriter> RWHashedSlot for T {
-	fn read_hashed_slot(&mut self) -> Result<Option<HashedSlot>, ServerError> {
 		let amount = self.read_varint()?;
 
 		if amount > 0 {
@@ -744,14 +708,14 @@ impl<T: DataReader + DataWriter> RWHashedSlot for T {
 		}
 	}
 
-	fn write_hashed_slot(&mut self, val: Option<HashedSlot>) -> Result<(), ServerError> {
+	fn write_any(&mut self, val: &Option<HashedSlot>) -> Result<(), ServerError> {
 		if let Some(val) = val {
 			self.write_varint(val.amount)?;
 			self.write_varint(val.id)?;
 			self.write_usize_varint(val.components.len())?;
 			let mut components_to_remove: Vec<u16> = (0..SLOT_COMPONENT_LENGTH).collect();
 			self.write_usize_varint(SLOT_COMPONENT_LENGTH as usize - val.components.len())?;
-			for (id, hash) in val.components {
+			for (id, hash) in val.components.clone() {
 				self.write_u16_varint(id)?;
 				self.write_int(hash)?;
 				if let Some(index) = components_to_remove.iter().position(|v| *v == id) {

src/play/helper.rs

@@ -7,7 +7,7 @@ use rust_mc_proto::{DataReader, DataWriter, Packet};
 
 use crate::{
 	ServerError,
-	data::{RWNBT, component::TextComponent},
+	data::{ReadWriteAny, component::TextComponent},
 	player::context::ClientContext,
 	protocol::packet_id::{clientbound, serverbound},
 };
@@ -153,7 +153,7 @@ pub fn send_system_message(
 	is_action_bar: bool,
 ) -> Result<(), ServerError> {
 	let mut packet = Packet::empty(clientbound::play::SYSTEM_CHAT_MESSAGE);
-	packet.write_nbt(&message)?;
+	packet.write_any(&message)?;
 	packet.write_boolean(is_action_bar)?;
 	client.write_packet(&packet)
 }

src/player/helper.rs

@@ -8,7 +8,7 @@ use rust_mc_proto::{DataReader, DataWriter, Packet};
 
 use crate::{
 	ServerError,
-	data::{RWNBT, component::TextComponent},
+	data::{ReadWriteAny, component::TextComponent},
 	protocol::{
 		packet_id::{clientbound, serverbound},
 		*,
@@ -131,12 +131,12 @@ impl ProtocolHelper {
 			}
 			ConnectionState::Configuration => {
 				let mut packet = Packet::empty(0x02);
-				packet.write_nbt(&reason)?;
+				packet.write_any(&reason)?;
 				packet
 			}
 			ConnectionState::Play => {
 				let mut packet = Packet::empty(0x1C);
-				packet.write_nbt(&reason)?;
+				packet.write_any(&reason)?;
 				packet
 			}
 			_ => {