Merge pull request #74 from ferrumc-rs/rewrite/v3_sweatyplams

ecs helper methods and outgoing #[packet] attribute

Author: Sweattypalms

src/bin/src/packet_handlers/handshake.rs

@@ -5,6 +5,7 @@ use ferrumc_net::errors::{NetError, PacketError};
 use ferrumc_net::packets::incoming::handshake::HandshakeEvent;
 use ferrumc_net::GlobalState;
 use tracing::trace;
+use ferrumc_net::utils::ecs_helpers::EntityExt;
 
 #[event_handler]
 async fn handle_handshake(
@@ -15,9 +16,9 @@ async fn handle_handshake(
     let handshake = &handshake_event.handshake;
 
     // set connection state to handshake
-    let mut connection_state = state
-        .universe
-        .get_mut::<ConnectionState>(handshake_event.conn_id)?;
+    let entity = handshake_event.conn_id;
+    let mut connection_state = entity
+        .get_mut::<ConnectionState>(state)?;
 
     trace!(
         "conn state: {} -> {}",

src/bin/src/packet_handlers/transform/update_player_position.rs

@@ -1,8 +1,9 @@
 use ferrumc_core::transform::position::Position;
 use ferrumc_macros::event_handler;
 use ferrumc_net::errors::NetError;
-use ferrumc_net::GlobalState;
 use ferrumc_net::packets::incoming::set_player_position::SetPlayerPositionEvent;
+use ferrumc_net::GlobalState;
+use ferrumc_net::utils::ecs_helpers::EntityExt;
 
 #[event_handler]
 async fn handle_player_move(
@@ -12,11 +13,13 @@ async fn handle_player_move(
     let new_position = &event.data;
     let conn_id = event.conn_id;
 
-    let mut position = state
-        .universe
-        .get_mut::<Position>(conn_id)?;
-
-    *position = Position::new(new_position.x, new_position.feet_y, new_position.z);
-
+    let mut position = conn_id.get_mut::<Position>(state)?;
+    
+    *position = Position::new(
+        new_position.x,
+        new_position.feet_y,
+        new_position.z
+    );
+    
     Ok(event)
 }

src/lib/core/src/identity/mod.rs

@@ -0,0 +1 @@
+pub mod player_identity;

src/lib/core/src/identity/player_identity.rs

@@ -0,0 +1,5 @@
+#[derive(Debug)]
+pub struct PlayerIdentity {
+    pub username: String,
+    pub uuid: u128,
+}

src/lib/core/src/lib.rs

@@ -2,4 +2,5 @@ pub mod errors;
 
 
 // Core structs/types. Usually used in ECS Components.
-pub mod transform;
+pub mod transform;
+pub mod identity;

src/lib/derive_macros/src/net/decode.rs

@@ -62,6 +62,7 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
         (type_cast, type_cast_handler)
     };
 
+
     // So for enums we can simply read the type and then cast it directly.
     if let Some(type_cast) = type_cast {
         let Some(repr_attr) = repr_attr else {

src/lib/derive_macros/src/net/encode.rs

@@ -1,7 +1,7 @@
-use crate::helpers::StructInfo;
+use crate::helpers::{get_derive_attributes, StructInfo};
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, DeriveInput};
+use syn::{parse_macro_input, DeriveInput, LitInt};
 
 pub(crate) fn derive(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
@@ -12,6 +12,55 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
         unimplemented!("NetEncode can only be derived for structs");
     };
 
+    let packet_attr = get_derive_attributes(&input, "packet");
+
+    let (packet_id_snippet, async_packet_id_snippet) = {
+        let mut packet_id = None;
+        packet_attr.iter().for_each(|attr| {
+            attr.parse_nested_meta(|meta| {
+                let Some(ident) = meta.path.get_ident() else {
+                    return Ok(());
+                };
+
+                match ident.to_string().as_str() {
+                    "packet_id" => {
+                        let value = meta.value().expect("value failed");
+                        let value = value.parse::<LitInt>().expect("parse failed");
+                        let n = value.base10_parse::<u8>().expect("base10_parse failed");
+                        packet_id = Some(n);
+                    }
+                    &_ => {
+                        return Ok(());
+                    }
+                }
+
+                Ok(())
+            }).unwrap();
+        });
+
+        let sync_impl = if let Some(packet_id) = packet_id {
+            quote! {
+                // encode a varint of packet_id
+                // varint is at ferrumc_net_codec::net_types::var_int::VarInt
+                <ferrumc_net_codec::net_types::var_int::VarInt as ferrumc_net_codec::encode::NetEncode>::encode(&#packet_id.into(), writer, &ferrumc_net_codec::encode::NetEncodeOpts::None)?;
+            }
+        } else {
+            quote! {  }
+        };
+
+        let async_impl = if let Some(packet_id) = packet_id {
+            quote! {
+                // encode a varint of packet_id
+                // varint is at ferrumc_net_codec::net_types::var_int::VarInt
+                <ferrumc_net_codec::net_types::var_int::VarInt as ferrumc_net_codec::encode::NetEncode>::encode_async(&#packet_id.into(), writer, &ferrumc_net_codec::encode::NetEncodeOpts::None).await?;
+            }
+        } else {
+            quote! {  }
+        };
+
+        (sync_impl, async_impl)
+    };
+
     let sync_encode_fields = fields.iter().map(|field| {
         let field_name = field.ident.as_ref().unwrap();
         let field_ty = &field.ty;
@@ -21,6 +70,7 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
         }
     });
 
+
     let sync_impl = {
         // These exist only because we cannot move value LMAO, they're both the same
         let normal_fields = sync_encode_fields.clone();
@@ -31,6 +81,7 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
             fn encode<W: std::io::Write>(&self, writer: &mut W, opts: &ferrumc_net_codec::encode::NetEncodeOpts) -> ferrumc_net_codec::encode::NetEncodeResult<()> {
                 match opts {
                     ferrumc_net_codec::encode::NetEncodeOpts::None => {
+                        #packet_id_snippet
                         #(#normal_fields)*
                     }
                     ferrumc_net_codec::encode::NetEncodeOpts::WithLength => {
@@ -39,6 +90,7 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
                         let mut writer = &mut writer;
 
 
+                        #packet_id_snippet
                         #(#length_prefixed_fields)*
 
 
@@ -60,6 +112,7 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
                         // Get compression threshold from config
                         let compression_threshold = ferrumc_config::get_global_config().network_compression_threshold;
 
+                        #packet_id_snippet
                         #(#compressed_fields)*
 
                         // if size >= threshold, compress, otherwise, send uncompressed and set Data Length to 0
@@ -129,6 +182,7 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
             async fn encode_async<W: tokio::io::AsyncWrite + std::marker::Unpin>(&self, writer: &mut W, opts: &ferrumc_net_codec::encode::NetEncodeOpts) -> ferrumc_net_codec::encode::NetEncodeResult<()> {
                 match opts {
                     ferrumc_net_codec::encode::NetEncodeOpts::None => {
+                        #async_packet_id_snippet
                         #(#normal_fields)*
                     }
                     ferrumc_net_codec::encode::NetEncodeOpts::WithLength => {
@@ -137,6 +191,7 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
                         let mut writer = Vec::new();
                         let mut writer = &mut writer;
 
+                        #async_packet_id_snippet
                         #(#length_prefixed_fields)*
 
                         let len: ferrumc_net_codec::net_types::var_int::VarInt = writer.len().into();
@@ -156,6 +211,7 @@ pub(crate) fn derive(input: TokenStream) -> TokenStream {
                         // Get compression threshold from config
                         let compression_threshold = ferrumc_config::get_global_config().network_compression_threshold;
 
+                        #async_packet_id_snippet
                         #(#compressed_fields)*
 
                         // if size >= threshold, compress, otherwise, send uncompressed and set Data Length to 0

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

@@ -142,7 +142,7 @@ pub fn bake_registry(input: TokenStream) -> TokenStream {
 }
 
 
-/// `#[packet]` attribute is used to declare an incoming packet.
+/// `#[packet]` attribute is used to declare an incoming/outgoing packet.
 ///
 /// <b>packet_id</b> => The packet id of the packet. In hexadecimal.
 /// <b>state</b> => The state of the packet. Can be: "handshake", "status", "login", "play".
@@ -158,12 +158,22 @@ pub fn bake_registry(input: TokenStream) -> TokenStream {
 ///     pub timestamp: i64,
 /// }
 /// ```
+/// 
+/// ```
+/// use ferrumc_macros::NetEncode;
+/// 
+/// #[derive(NetEncode)]
+/// #[packet(packet_id = 0x05)]
+/// pub struct PacketChatMessage {
+///    pub message: String,
+///    pub timestamp: i64,
+/// }
 pub fn attribute(args: TokenStream, input: TokenStream) -> TokenStream {
     // These are just some checks to make sure the packet attribute is used correctly.
     // This is not actual functionality.
     // The actual functionality is in the `bake_registry` function.
 
-    const E: &str = "packet attribute must have the packet_id and state fields";
+    const E: &str = "packet attribute must have the packet_id and/or state fields. In case of incoming: both. In case of outgoing: only packet_id.";
     if args.is_empty() {
         return TokenStream::from(quote! {
             compile_error!(#E);
@@ -172,7 +182,7 @@ pub fn attribute(args: TokenStream, input: TokenStream) -> TokenStream {
 
     if !&["packet_id", "state"]
         .iter()
-        .all(|x| args.to_string().contains(x))
+        .any(|x| args.to_string().contains(x))
     {
         return TokenStream::from(quote! {
             compile_error!(#E);

src/lib/ecs/src/components/mod.rs

@@ -123,6 +123,22 @@ pub struct ComponentRefMut<'a, T: Component> {
     write_guard: RwLockWriteGuard<'a, Box<dyn Component>>,
     _phantom: PhantomData<&'a mut T>,
 }
+mod debug {
+    use std::fmt::Debug;
+    use crate::components::{Component, ComponentRef, ComponentRefMut};
+
+    impl<'a, T: Component + Debug> Debug for ComponentRef<'a, T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            Debug::fmt(&**self, f)
+        }
+    }
+    
+    impl<'a, T: Component + Debug> Debug for ComponentRefMut<'a, T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            Debug::fmt(&**self, f)
+        }
+    }
+}
 
 impl<'a, T: Component> Deref for ComponentRef<'a, T> {
     type Target = T;

src/lib/events/src/infrastructure.rs

@@ -81,6 +81,8 @@ pub trait Event: Sized + Send + Sync + 'static {
 
         // Convert listeners iterator into Stream
         stream::iter(listeners.iter())
+            // TODO: Remove this since it's not possible to have a wrong type in the map of the event???
+            // Maybe some speedup?
             // Filter only listeners we can downcast into the correct type
             .filter_map(
                 |dyn_list| async { dyn_list.downcast_ref::<EventListener<Self>>() },