From 08958c2278b15ebeac8a964f392ebb792e479b61 Mon Sep 17 00:00:00 2001 From: mat <27899617+mat-1@users.noreply.github.com> Date: Wed, 27 Nov 2024 19:31:40 -0600 Subject: Refactor azalea-protocol (#190) * start updating to 1.21.4 * fix block codegen and stop using block data from burger * rename packet related modules and structs to be simpler * ItemSlot -> ItemStack for more consistency with mojmap * .get() -> .into_packet() * simplify declare_state_packets by removing packet ids * rename read_from and write_into to azalea_read and azalea_write * rename McBufReadable and McBufWritable to AzaleaRead and AzaleaWrite * McBuf -> AzBuf * remove most uses of into_variant * update codegen and use resourcelocation names for packets * implement #[limit(i)] attribute for AzBuf derive macro * fixes for 1.21.4 * fix examples * update some physics code and fix ChatType * remove unused imports in codegen * re-add some things to migrate.py and update +mc version numbers automatically * downgrade to 1.21.3 lol --- azalea-protocol/src/packets/game/c_player_chat.rs | 160 ++++++++++++++++++++++ 1 file changed, 160 insertions(+) create mode 100644 azalea-protocol/src/packets/game/c_player_chat.rs (limited to 'azalea-protocol/src/packets/game/c_player_chat.rs') diff --git a/azalea-protocol/src/packets/game/c_player_chat.rs b/azalea-protocol/src/packets/game/c_player_chat.rs new file mode 100644 index 00000000..0e9960f2 --- /dev/null +++ b/azalea-protocol/src/packets/game/c_player_chat.rs @@ -0,0 +1,160 @@ +use std::io::{Cursor, Write}; + +use azalea_buf::{AzBuf, AzaleaRead, AzaleaReadVar, AzaleaWrite, AzaleaWriteVar, BufReadError}; +use azalea_chat::{ + translatable_component::{StringOrComponent, TranslatableComponent}, + FormattedText, +}; +use azalea_core::bitset::BitSet; +use azalea_crypto::MessageSignature; +use azalea_protocol_macros::ClientboundGamePacket; +use azalea_registry::{ChatType, OptionalRegistry}; +use uuid::Uuid; + +#[derive(Clone, Debug, AzBuf, ClientboundGamePacket, PartialEq)] +pub struct ClientboundPlayerChat { + pub sender: Uuid, + #[var] + pub index: u32, + pub signature: Option, + pub body: PackedSignedMessageBody, + pub unsigned_content: Option, + pub filter_mask: FilterMask, + pub chat_type: ChatTypeBound, +} + +#[derive(Clone, Debug, PartialEq, AzBuf)] +pub struct PackedSignedMessageBody { + // the error is here, for some reason it skipped a byte earlier and here + // it's reading `0` when it should be `11` + pub content: String, + pub timestamp: u64, + pub salt: u64, + pub last_seen: PackedLastSeenMessages, +} + +#[derive(Clone, Debug, PartialEq, AzBuf)] +pub struct PackedLastSeenMessages { + pub entries: Vec, +} + +/// Messages can be deleted by either their signature or message id. +#[derive(Clone, Debug, PartialEq)] +pub enum PackedMessageSignature { + Signature(Box), + Id(u32), +} + +#[derive(Clone, Debug, PartialEq, AzBuf)] +pub enum FilterMask { + PassThrough, + FullyFiltered, + PartiallyFiltered(BitSet), +} + +#[derive(Clone, Debug, PartialEq)] +pub struct ChatTypeBound { + pub chat_type: ChatType, + pub name: FormattedText, + pub target_name: Option, +} +impl AzaleaRead for ChatTypeBound { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + let Some(chat_type) = OptionalRegistry::::azalea_read(buf)?.0 else { + return Err(BufReadError::Custom("ChatType cannot be None".to_owned())); + }; + let name = FormattedText::azalea_read(buf)?; + let target_name = Option::::azalea_read(buf)?; + + Ok(ChatTypeBound { + chat_type, + name, + target_name, + }) + } +} +impl AzaleaWrite for ChatTypeBound { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + OptionalRegistry(Some(self.chat_type)).azalea_write(buf)?; + self.name.azalea_write(buf)?; + self.target_name.azalea_write(buf)?; + Ok(()) + } +} + +// must be in Client +#[derive(Clone, Debug, PartialEq)] +pub struct MessageSignatureCache { + pub entries: Vec>, +} + +// impl MessageSignatureCache { +// pub fn unpacker(&self) -> impl Fn(u32) -> Option { + +// } +// } + +// impl PackedSignedMessageBody { +// pub fn unpack(&self, unpacker: impl Fn(u32) -> Option) +// {} } + +impl ClientboundPlayerChat { + /// Returns the content of the message. If you want to get the FormattedText + /// for the whole message including the sender part, use + /// [`ClientboundPlayerChat::message`]. + #[must_use] + pub fn content(&self) -> FormattedText { + self.unsigned_content + .clone() + .unwrap_or_else(|| FormattedText::from(self.body.content.clone())) + } + + /// Get the full message, including the sender part. + #[must_use] + pub fn message(&self) -> FormattedText { + let sender = self.chat_type.name.clone(); + let content = self.content(); + let target = self.chat_type.target_name.clone(); + + let translation_key = self.chat_type.chat_type.chat_translation_key(); + + let mut args = vec![ + StringOrComponent::FormattedText(sender), + StringOrComponent::FormattedText(content), + ]; + if let Some(target) = target { + args.push(StringOrComponent::FormattedText(target)); + } + + let component = TranslatableComponent::new(translation_key.to_string(), args); + + FormattedText::Translatable(component) + } +} + +impl AzaleaRead for PackedMessageSignature { + fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result { + let id = u32::azalea_read_var(buf)?; + if id == 0 { + let full_signature = MessageSignature::azalea_read(buf)?; + + Ok(PackedMessageSignature::Signature(Box::new(full_signature))) + } else { + Ok(PackedMessageSignature::Id(id - 1)) + } + } +} +impl AzaleaWrite for PackedMessageSignature { + fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { + match self { + PackedMessageSignature::Signature(full_signature) => { + 0u32.azalea_write_var(buf)?; + full_signature.azalea_write(buf)?; + } + PackedMessageSignature::Id(id) => { + (id + 1).azalea_write_var(buf)?; + } + } + Ok(()) + } +} -- cgit v1.2.3