feat: basic unsigned chat

src/bin/src/packet_handlers/chat_message.rs

@@ -0,0 +1,24 @@
+use ferrumc_core::identity::player_identity::PlayerIdentity;
+use ferrumc_macros::event_handler;
+use ferrumc_net::{
+    packets::{
+        incoming::chat_message::ChatMessageEvent, outgoing::system_message::SystemMessagePacket,
+    },
+    utils::broadcast::{BroadcastOptions, BroadcastToAll},
+    NetResult,
+};
+use ferrumc_state::GlobalState;
+use ferrumc_text::TextComponentBuilder;
+
+#[event_handler]
+async fn chat_message(event: ChatMessageEvent, state: GlobalState) -> NetResult<ChatMessageEvent> {
+    let identity = state.universe.get::<PlayerIdentity>(event.player_conn_id)?;
+    let message =
+        TextComponentBuilder::new(format!("<{}> {}", identity.username, event.message)).build();
+    let packet = SystemMessagePacket::new(message, false);
+    state
+        .broadcast(&packet, BroadcastOptions::default().all())
+        .await?;
+
+    Ok(event)
+}

src/bin/src/packet_handlers/mod.rs

@@ -1,3 +1,4 @@
+mod chat_message;
 mod commands;
 mod handshake;
 mod login_process;

src/lib/net/crates/codec/src/decode/primitives.rs

@@ -83,6 +83,24 @@ where
     }
 }
 
+/// This implementation assumes that the optional was written using PacketByteBuf#writeNullable and has a leading bool.
+impl<T> NetDecode for Option<T>
+where
+    T: NetDecode,
+{
+    fn decode<R: Read>(reader: &mut R, opts: &NetDecodeOpts) -> NetDecodeResult<Self> {
+        let is_some = <bool as NetDecode>::decode(reader, opts)?;
+
+        if !is_some {
+            return Ok(None);
+        }
+
+        let value = <T as NetDecode>::decode(reader, opts)?;
+
+        Ok(Some(value))
+    }
+}
+
 /// This isn't actually a type in the Minecraft Protocol. This is just for saving data/ or for general use.
 /// It was created for saving/reading chunks!
 impl<K, V> NetDecode for HashMap<K, V>

src/lib/net/src/packets/incoming/chat_message.rs

@@ -0,0 +1,41 @@
+use std::sync::Arc;
+
+use ferrumc_events::infrastructure::Event;
+use ferrumc_macros::{packet, Event, NetDecode};
+use ferrumc_net_codec::net_types::var_int::VarInt;
+use ferrumc_state::ServerState;
+
+use crate::packets::IncomingPacket;
+
+#[derive(NetDecode, Debug, Clone)]
+#[packet(packet_id = 0x06, state = "play")]
+pub struct ChatMessagePacket {
+    pub message: String,
+    pub timestamp: u64,
+    pub salt: u64,
+    pub has_signature: bool,
+    pub signature: Option<Vec<u64>>,
+    pub message_count: VarInt,
+    pub acknowledged: Vec<u8>,
+}
+
+impl IncomingPacket for ChatMessagePacket {
+    async fn handle(self, conn_id: usize, state: Arc<ServerState>) -> crate::NetResult<()> {
+        ChatMessageEvent::trigger(ChatMessageEvent::new(conn_id, self.message), state).await
+    }
+}
+
+#[derive(Debug, Event, Clone)]
+pub struct ChatMessageEvent {
+    pub player_conn_id: usize,
+    pub message: String,
+}
+
+impl ChatMessageEvent {
+    pub fn new(player_conn_id: usize, message: String) -> Self {
+        Self {
+            player_conn_id,
+            message,
+        }
+    }
+}

src/lib/net/src/packets/incoming/mod.rs

@@ -15,4 +15,5 @@ pub mod set_player_position;
 pub mod set_player_position_and_rotation;
 pub mod set_player_rotation;
 
+pub mod chat_message;
 pub mod command;