MeexReay/rust_mc_serv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ReadWriteAny trait instead of ton of RWStuff

Browse Source
This commit is contained in:
MeexReay 2025-05-11 19:45:16 +03:00
parent 20c6481c86
commit 94b8cee580
5 changed files with 68 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/data/component.rs
View File

@ -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 {
fn read_nbt(&mut self) -> Result<TextComponent, ServerError> {
impl ReadWriteAny<TextComponent> for Packet {
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(())
}

43
src/data/mod.rs
View File

@ -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 {
fn read_nbt(&mut self) -> Result<T, ServerError>;
fn write_nbt(&mut self, val: &T) -> Result<(), ServerError>;
pub trait ReadWriteAny<T: Sized> {
fn read_any(&mut self) -> Result<T, ServerError>;
fn write_any(&mut self, val: &T) -> Result<(), ServerError>;
}
impl<'a> RWNBT<'a, DynNBT> for Packet {
fn read_nbt(&mut self) -> Result<DynNBT, ServerError> {
impl ReadWriteAny<DynNBT> for Packet {
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 {
fn read_id_set(&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> {
impl<T: DataReader + DataWriter> ReadWriteAny<IdSet> for T {
fn read_any(&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 {
fn read_dye_color(&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> {
impl<T: DataReader + DataWriter> ReadWriteAny<DyeColor> for T {
fn read_any(&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> {
self.write_usize_varint(val as usize)?;
fn write_any(&mut self, val: &DyeColor) -> Result<(), ServerError> {
self.write_usize_varint(val.clone() as usize)?;
Ok(())
}
}

122
src/data/slot.rs
View File

@ -7,8 +7,7 @@ use uuid::Uuid;
use crate::ServerError;
use super::{
DyeColor, IdOr, IdSet, Property, RWDyeColor, RWIdSet, RWNBT, component::TextComponent,
sound::SoundEvent,
DyeColor, IdOr, IdSet, Property, ReadWriteAny, component::TextComponent, sound::SoundEvent,
};
pub const SLOT_COMPONENT_LENGTH: u16 = 96;
@ -175,26 +174,21 @@ pub enum BannerLayer {
},
}
pub trait RWBannerLayer: DataReader + DataWriter {
fn read_banner_layer(&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> {
impl<T: DataReader + DataWriter> ReadWriteAny<BannerLayer> for T {
fn read_any(&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 {
fn read_attribute_modifier(&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> {
impl<T: DataReader + DataWriter> ReadWriteAny<AttributeModifier> for T {
fn read_any(&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 {
fn read_tool_rule(&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> {
impl<T: DataReader + DataWriter> ReadWriteAny<ToolRule> for T {
fn read_any(&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> {
self.write_id_set(val.blocks)?;
fn write_any(&mut self, val: &ToolRule) -> Result<(), ServerError> {
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 {
fn read_damage_reduction(&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> {
impl<T: DataReader + DataWriter> ReadWriteAny<DamageReduction> for T {
fn read_any(&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 {
fn read_slot_component(&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> {
impl ReadWriteAny<StructuredComponent> for Packet {
fn read_any(&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()?)),
5 => Ok(StructuredComponent::ItemName(self.read_nbt()?)),
4 => Ok(StructuredComponent::CustomName(self.read_any()?)),
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::ItemName(val) => self.write_nbt(val)?,
StructuredComponent::CustomName(val) => self.write_any(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 {
fn read_slot(&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> {
impl ReadWriteAny<Option<Slot>> for Packet {
fn read_any(&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 {
fn read_hashed_slot(&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> {
impl<T: DataReader + DataWriter> ReadWriteAny<Option<HashedSlot>> for T {
fn read_any(&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) {

4
src/play/helper.rs
View File

@ -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)
}

6
src/player/helper.rs
View File

@ -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
}
_ => {