From 20c6481c86b28947740cc361b754faa81c0798d8 Mon Sep 17 00:00:00 2001 From: MeexReay Date: Sun, 11 May 2025 19:30:52 +0300 Subject: [PATCH] move RW traits and blank preparing of slot components --- src/data/component.rs | 4 +- src/data/mod.rs | 81 ++++++++++++++- src/data/slot.rs | 235 ++++++++++++++++++++++++++++++++++++++---- src/lib.rs | 1 + src/play/helper.rs | 2 +- src/player/helper.rs | 2 +- 6 files changed, 299 insertions(+), 26 deletions(-) diff --git a/src/data/component.rs b/src/data/component.rs index 1eab4d9..34c8c67 100644 --- a/src/data/component.rs +++ b/src/data/component.rs @@ -7,7 +7,7 @@ use serde_with::skip_serializing_none; use crate::ServerError; -use super::ReadWriteNBT; +use super::RWNBT; #[derive(Debug, Serialize, Deserialize, Clone)] #[skip_serializing_none] @@ -192,7 +192,7 @@ impl TextComponentBuilder { } // Реализуем читалку-записывалку текст-компонентов для пакета -impl ReadWriteNBT for Packet { +impl<'a> RWNBT<'a, TextComponent> for Packet { fn read_nbt(&mut self) -> Result { let mut data = Vec::new(); let pos = self.get_ref().position(); diff --git a/src/data/mod.rs b/src/data/mod.rs index d45f3d7..da1a7b8 100644 --- a/src/data/mod.rs +++ b/src/data/mod.rs @@ -2,6 +2,7 @@ use std::io::Read; use craftflow_nbt::DynNBT; use rust_mc_proto::{DataReader, DataWriter, Packet}; +use serde::{Deserialize, Serialize}; use super::ServerError; @@ -10,12 +11,12 @@ pub mod slot; pub mod sound; // Трейт для чтения NBT-совместимых приколов -pub trait ReadWriteNBT: DataReader + DataWriter { +pub trait RWNBT<'a, T: Serialize + Deserialize<'a>>: DataReader + DataWriter { fn read_nbt(&mut self) -> Result; fn write_nbt(&mut self, val: &T) -> Result<(), ServerError>; } -impl ReadWriteNBT for Packet { +impl<'a> RWNBT<'a, DynNBT> for Packet { fn read_nbt(&mut self) -> Result { let mut data = Vec::new(); let pos = self.get_ref().position(); @@ -36,12 +37,12 @@ impl ReadWriteNBT for Packet { } } -pub trait ReadWritePosition: DataReader + DataWriter { +pub trait RWPosition: 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 ReadWritePosition for Packet { +impl RWPosition 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)) @@ -64,6 +65,45 @@ pub enum IdSet { Ids(Vec), } +pub trait RWIdSet: DataReader + DataWriter { + fn read_id_set(&mut self) -> Result; + fn write_id_set(&mut self, val: IdSet) -> Result<(), ServerError>; +} + +impl RWIdSet for T { + fn read_id_set(&mut self) -> Result { + let ty = self.read_varint()?; + if ty == 0 { + Ok(IdSet::Tag(self.read_string()?)) + } else { + let len = ty - 1; + let mut ids = Vec::new(); + + for _ in 0..len { + ids.push(self.read_u32_varint()?); + } + + Ok(IdSet::Ids(ids)) + } + } + + fn write_id_set(&mut self, val: IdSet) -> Result<(), ServerError> { + match val { + IdSet::Tag(tag) => { + self.write_varint(0)?; + self.write_string(&tag)?; + } + IdSet::Ids(ids) => { + self.write_usize_varint(ids.len() + 1)?; + for id in ids { + self.write_u32_varint(id)?; + } + } + } + Ok(()) + } +} + #[derive(Clone)] pub struct Property { pub name: String, @@ -90,3 +130,36 @@ pub enum DyeColor { Red, Black, } + +pub trait RWDyeColor: DataReader + DataWriter { + fn read_dye_color(&mut self) -> Result; + fn write_dye_color(&mut self, val: DyeColor) -> Result<(), ServerError>; +} + +impl RWDyeColor for T { + fn read_dye_color(&mut self) -> Result { + match self.read_usize_varint()? { + 0 => Ok(DyeColor::White), + 1 => Ok(DyeColor::Orange), + 2 => Ok(DyeColor::Magenta), + 3 => Ok(DyeColor::LightBlue), + 4 => Ok(DyeColor::Yellow), + 5 => Ok(DyeColor::Lime), + 6 => Ok(DyeColor::Pink), + 7 => Ok(DyeColor::Gray), + 8 => Ok(DyeColor::LightGray), + 9 => Ok(DyeColor::Cyan), + 10 => Ok(DyeColor::Purple), + 11 => Ok(DyeColor::Blue), + 12 => Ok(DyeColor::Brown), + 13 => Ok(DyeColor::Green), + 14 => Ok(DyeColor::Red), + 15 => Ok(DyeColor::Black), + _ => Err(ServerError::WrongPacket), + } + } + fn write_dye_color(&mut self, val: DyeColor) -> Result<(), ServerError> { + self.write_usize_varint(val as usize)?; + Ok(()) + } +} diff --git a/src/data/slot.rs b/src/data/slot.rs index f842053..964648b 100644 --- a/src/data/slot.rs +++ b/src/data/slot.rs @@ -6,7 +6,10 @@ use uuid::Uuid; use crate::ServerError; -use super::{DyeColor, IdOr, IdSet, Property, component::TextComponent, sound::SoundEvent}; +use super::{ + DyeColor, IdOr, IdSet, Property, RWDyeColor, RWIdSet, RWNBT, component::TextComponent, + sound::SoundEvent, +}; pub const SLOT_COMPONENT_LENGTH: u16 = 96; @@ -160,16 +163,61 @@ pub struct HiveBee { } #[derive(Clone)] -pub struct BannerLayer { - pub pattern_type: i32, - pub asset_id: Option, - pub translation_key: Option, - pub color: DyeColor, +pub enum BannerLayer { + Direct { + asset_id: String, + translation_key: String, + color: DyeColor, + }, + Registry { + pattern_id: i32, + color: DyeColor, + }, +} + +pub trait RWBannerLayer: DataReader + DataWriter { + fn read_banner_layer(&mut self) -> Result; + fn write_banner_layer(&mut self, val: BannerLayer) -> Result<(), ServerError>; +} + +impl RWBannerLayer for T { + fn read_banner_layer(&mut self) -> Result { + match self.read_varint()? { + 0 => Ok(BannerLayer::Direct { + asset_id: self.read_string()?, + translation_key: self.read_string()?, + color: self.read_dye_color()?, + }), + id => Ok(BannerLayer::Registry { + pattern_id: id - 1, + color: self.read_dye_color()?, + }), + } + } + fn write_banner_layer(&mut self, val: BannerLayer) -> Result<(), ServerError> { + match val { + BannerLayer::Direct { + asset_id, + translation_key, + color, + } => { + self.write_varint(0)?; + self.write_string(&asset_id)?; + self.write_string(&translation_key)?; + self.write_dye_color(color)?; + } + BannerLayer::Registry { pattern_id, color } => { + self.write_varint(pattern_id + 1)?; + self.write_dye_color(color)?; + } + } + Ok(()) + } } #[derive(Clone)] pub struct AttributeModifier { - pub attribute_id: u64, + pub attribute_id: u32, pub modifier_id: String, pub value: f64, /// The operation to be applied upon the value. Can be one of the following: @@ -192,15 +240,77 @@ pub struct AttributeModifier { pub slot: u8, } +pub trait RWAttributeModifier: DataReader + DataWriter { + fn read_attribute_modifier(&mut self) -> Result; + fn write_attribute_modifier(&mut self, val: AttributeModifier) -> Result<(), ServerError>; +} + +impl RWAttributeModifier for T { + fn read_attribute_modifier(&mut self) -> Result { + Ok(AttributeModifier { + attribute_id: self.read_u32_varint()?, + modifier_id: self.read_string()?, + value: self.read_double()?, + operation: self.read_u8_varint()?, + slot: self.read_u8_varint()?, + }) + } + fn write_attribute_modifier(&mut self, val: AttributeModifier) -> Result<(), ServerError> { + self.write_u32_varint(val.attribute_id)?; + self.write_string(&val.modifier_id)?; + self.write_double(val.value)?; + self.write_u8_varint(val.operation)?; + self.write_u8_varint(val.slot)?; + Ok(()) + } +} + #[derive(Clone)] pub struct ToolRule { pub blocks: IdSet, - pub has_speed: bool, pub speed: Option, - pub has_correct_drop_for_blocks: bool, pub correct_drop_for_blocks: Option, } +pub trait RWToolRule: DataReader + DataWriter { + fn read_tool_rule(&mut self) -> Result; + fn write_tool_rule(&mut self, val: ToolRule) -> Result<(), ServerError>; +} + +impl RWToolRule for T { + fn read_tool_rule(&mut self) -> Result { + Ok(ToolRule { + blocks: self.read_id_set()?, + speed: if self.read_boolean()? { + Some(self.read_float()?) + } else { + None + }, + correct_drop_for_blocks: if self.read_boolean()? { + Some(self.read_boolean()?) + } else { + None + }, + }) + } + fn write_tool_rule(&mut self, val: ToolRule) -> Result<(), ServerError> { + self.write_id_set(val.blocks)?; + if let Some(speed) = val.speed { + self.write_boolean(true)?; + self.write_float(speed)?; + } else { + self.write_boolean(false)?; + } + if let Some(cdfb) = val.correct_drop_for_blocks { + self.write_boolean(true)?; + self.write_boolean(cdfb)?; + } else { + self.write_boolean(false)?; + } + Ok(()) + } +} + #[derive(Clone)] pub struct DamageReduction { pub horizontal_blocking_angle: f32, @@ -209,6 +319,38 @@ pub struct DamageReduction { pub factor: f32, } +pub trait RWDamageReduction: DataReader + DataWriter { + fn read_damage_reduction(&mut self) -> Result; + fn write_damage_reduction(&mut self, val: DamageReduction) -> Result<(), ServerError>; +} + +impl RWDamageReduction for T { + fn read_damage_reduction(&mut self) -> Result { + Ok(DamageReduction { + horizontal_blocking_angle: self.read_float()?, + damage_kind: if self.read_boolean()? { + Some(self.read_id_set()?) + } else { + None + }, + base: self.read_float()?, + factor: self.read_float()?, + }) + } + fn write_damage_reduction(&mut self, val: DamageReduction) -> Result<(), ServerError> { + self.write_float(val.horizontal_blocking_angle)?; + if let Some(id_set) = val.damage_kind { + self.write_boolean(true)?; + self.write_id_set(id_set)?; + } else { + self.write_boolean(false)?; + } + self.write_float(val.base)?; + self.write_float(val.factor)?; + Ok(()) + } +} + /// https://minecraft.wiki/w/Java_Edition_protocol/Slot_data#Structured_components #[derive(Clone, EnumIndex)] pub enum StructuredComponent { @@ -221,7 +363,7 @@ pub enum StructuredComponent { CustomName(TextComponent), // 5 ItemName(TextComponent), // 6 ItemModel(String), // 7 - Lore(TextComponent), // 8 + Lore(Vec), // 8 /// Can be one of the following: /// - 0 - Common (white) /// - 1 - Uncommon (yellow) @@ -230,7 +372,7 @@ pub enum StructuredComponent { Rarity(u8), // 9 /// Key: The ID of the enchantment in the enchantment registry. \ /// Value: The level of the enchantment. - Enchantments(Vec<(u64, i32)>), // 10 + Enchantments(Vec<(u32, i32)>), // 10 CanPlaceOn(Vec), // 11 CanBreak(Vec), // 12 AttributeModifiers(Vec), // 13 @@ -438,15 +580,72 @@ pub trait ReadWriteSlotComponent: DataReader + DataWriter { impl ReadWriteSlotComponent for Packet { fn read_slot_component(&mut self) -> Result { - let _ = self.read_u16_varint()?; // id + let id = self.read_u16_varint()?; // id - todo!() + match id { + 0 => Ok(StructuredComponent::CustomData(self.read_nbt()?)), + 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()?)), + 5 => Ok(StructuredComponent::ItemName(self.read_nbt()?)), + 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()?); + } + + Ok(StructuredComponent::Lore(lore)) + } + 8 => Ok(StructuredComponent::Rarity(self.read_u8_varint()?)), + 9 => { + let len: usize = self.read_usize_varint()?; + let mut enchantments = Vec::new(); + + for _ in 0..len { + enchantments.push((self.read_u32_varint()?, self.read_varint()?)); + } + + Ok(StructuredComponent::Enchantments(enchantments)) + } + _ => Err(ServerError::UnexpectedSlotComponent), + } } fn write_slot_component(&mut self, val: &StructuredComponent) -> Result<(), ServerError> { self.write_usize_varint(val.enum_index())?; - todo!() + match val { + StructuredComponent::CustomData(val) => self.write_nbt(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::ItemName(val) => self.write_nbt(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)?; + } + } + StructuredComponent::Rarity(val) => self.write_u8_varint(*val)?, + StructuredComponent::Enchantments(val) => { + self.write_usize_varint(val.len())?; + + for (id, lvl) in val { + self.write_u32_varint(*id)?; + self.write_varint(*lvl)?; + } + } + _ => {} + } + + Ok(()) } } @@ -457,12 +656,12 @@ pub struct Slot { pub components: Vec, } -pub trait ReadWriteSlot: DataReader + DataWriter { +pub trait RWSlot: DataReader + DataWriter { fn read_slot(&mut self) -> Result, ServerError>; fn write_slot(&mut self, val: Option) -> Result<(), ServerError>; } -impl ReadWriteSlot for Packet { +impl RWSlot for Packet { fn read_slot(&mut self) -> Result, ServerError> { let amount = self.read_varint()?; @@ -517,12 +716,12 @@ pub struct HashedSlot { pub components: Vec<(u16, i32)>, } -pub trait ReadWriteHashedSlot: DataReader + DataWriter { +pub trait RWHashedSlot: DataReader + DataWriter { fn read_hashed_slot(&mut self) -> Result, ServerError>; fn write_hashed_slot(&mut self, val: Option) -> Result<(), ServerError>; } -impl ReadWriteHashedSlot for Packet { +impl RWHashedSlot for T { fn read_hashed_slot(&mut self) -> Result, ServerError> { let amount = self.read_varint()?; diff --git a/src/lib.rs b/src/lib.rs index 21289ff..dc8a8ec 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -26,6 +26,7 @@ pub enum ServerError { DeTextComponent, // Ошибка при десериализации текст-компонента SerNbt, // Ошибка при сериализации nbt DeNbt, // Ошибка при десериализации nbt + UnexpectedSlotComponent, UnexpectedState, // Указывает на то что этот пакет не может быть отправлен в данном режиме (в основном через ProtocolHelper) Other(String), // Другая ошибка, либо очень специфичная, либо хз, лучше не использовать и создавать новое поле ошибки } diff --git a/src/play/helper.rs b/src/play/helper.rs index 05da0b2..ef29c85 100644 --- a/src/play/helper.rs +++ b/src/play/helper.rs @@ -7,7 +7,7 @@ use rust_mc_proto::{DataReader, DataWriter, Packet}; use crate::{ ServerError, - data::{ReadWriteNBT, component::TextComponent}, + data::{RWNBT, component::TextComponent}, player::context::ClientContext, protocol::packet_id::{clientbound, serverbound}, }; diff --git a/src/player/helper.rs b/src/player/helper.rs index 8cdff2e..cf5b075 100644 --- a/src/player/helper.rs +++ b/src/player/helper.rs @@ -8,7 +8,7 @@ use rust_mc_proto::{DataReader, DataWriter, Packet}; use crate::{ ServerError, - data::{ReadWriteNBT, component::TextComponent}, + data::{RWNBT, component::TextComponent}, protocol::{ packet_id::{clientbound, serverbound}, *,