Merge pull request #147 from teoscura/feat/entityanimation

feat/entityanimation

Author: Sweattypalms

scripts/new_packet.py

@@ -0,0 +1,64 @@
+import os.path
+
+incoming_template = """
+use crate::packets::IncomingPacket;
+use crate::NetResult;
+use ferrumc_macros::{packet, NetDecode};
+use ferrumc_state::ServerState;
+use std::sync::Arc;
+
+#[derive(NetDecode)]
+#[packet(packet_id = ++id++, state = "play")]
+pub struct ++name++ {
+}
+
+impl IncomingPacket for ++name++ {
+    async fn handle(self, conn_id: usize, state: Arc<ServerState>) -> NetResult<()> {
+        todo!()
+    }
+}
+"""
+
+outgoing_template = """
+use ferrumc_macros::{packet, NetEncode};\
+use std::io::Write;
+
+#[derive(NetEncode)]
+#[packet(packet_id = ++id++)]
+pub struct ++name++ {}
+"""
+
+
+def to_snake_case(string) -> str:
+    return string.lower().replace(" ", "_")
+
+
+def to_camel_case(string) -> str:
+    return string.title().replace(" ", "")
+
+
+packet_type_input = input("Incoming or outgoing packet? (i/o): ")
+packet_type = ""
+if packet_type_input == "i":
+    packet_type = "incoming"
+elif packet_type_input == "o":
+    packet_type = "outgoing"
+else:
+    print("Invalid input")
+    exit()
+
+packet_name = input("Packet name: ")
+packets_dir = os.path.join(os.path.join(os.path.dirname(__file__), ".."), "src/lib/net/src/packets")
+
+packet_id = input("Packet ID (formatted like 0x01): ")
+packet_id = packet_id[:-2] + packet_id[-2:].upper()
+
+with open(f"{packets_dir}/{packet_type}/{to_snake_case(packet_name)}.rs", "x") as f:
+    if packet_type == "incoming":
+        f.write(incoming_template.replace("++name++", to_camel_case(packet_name)).replace("++id++", packet_id))
+        with open(f"{packets_dir}/incoming/mod.rs", "a") as modfile:
+            modfile.write(f"\npub mod {to_snake_case(packet_name)};")
+    else:
+        f.write(outgoing_template.replace("++name++", to_camel_case(packet_name)).replace("++id++", packet_id))
+        with open(f"{packets_dir}/outgoing/mod.rs", "a") as modfile:
+            modfile.write(f"\npub mod {to_snake_case(packet_name)};")

src/bin/src/packet_handlers/animations.rs

@@ -0,0 +1,21 @@
+use ferrumc_macros::event_handler;
+use ferrumc_net::errors::NetError;
+use ferrumc_net::packets::outgoing::entity_animation::EntityAnimationEvent;
+use ferrumc_net::utils::broadcast::{broadcast, BroadcastOptions};
+use ferrumc_state::GlobalState;
+
+#[event_handler]
+async fn entity_animation(
+    event: EntityAnimationEvent,
+    state: GlobalState,
+) -> Result<EntityAnimationEvent, NetError> {
+    //TODO change this global broadcast to a broadcast that affects only players in the view distance
+    //      of the player doing it, but as long as we still cant see other players, this will be fine.
+    broadcast(
+        &event.packet,
+        &state,
+        BroadcastOptions::default().except([event.entity]),
+    )
+    .await?;
+    Ok(event)
+}

src/bin/src/packet_handlers/mod.rs

@@ -1,3 +1,4 @@
+mod animations;
 mod handshake;
 mod login_process;
 mod tick_handler;

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

@@ -35,6 +35,7 @@ impl_for_primitives!(
     u32 | i32,
     u64 | i64,
     u128 | i128,
+    usize | isize,
     f32,
     f64
 );

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

@@ -40,6 +40,7 @@ impl_for_primitives!(
     u32 | i32,
     u64 | i64,
     u128 | i128,
+    usize | isize,
     f32,
     f64
 );

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

@@ -14,3 +14,5 @@ pub mod packet_skeleton;
 pub mod set_player_position;
 pub mod set_player_position_and_rotation;
 pub mod set_player_rotation;
+
+pub mod swing_arm;

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

@@ -0,0 +1,30 @@
+use crate::packets::outgoing::entity_animation::EntityAnimationEvent;
+use crate::packets::IncomingPacket;
+use crate::NetResult;
+use ferrumc_ecs::entities::Entity;
+use ferrumc_events::infrastructure::Event;
+use ferrumc_macros::{packet, NetDecode};
+use ferrumc_net_codec::net_types::var_int::VarInt;
+use ferrumc_state::ServerState;
+use std::sync::Arc;
+
+#[derive(NetDecode)]
+#[packet(packet_id = 0x36, state = "play")]
+pub struct SwingArmPacket {
+    hand: VarInt,
+}
+
+impl IncomingPacket for SwingArmPacket {
+    async fn handle(self, conn_id: Entity, state: Arc<ServerState>) -> NetResult<()> {
+        let animation = {
+            if self.hand == 0 {
+                0
+            } else {
+                3
+            }
+        };
+        let event = EntityAnimationEvent::new(conn_id, animation);
+        EntityAnimationEvent::trigger(event, state).await?;
+        Ok(())
+    }
+}

src/lib/net/src/packets/outgoing/entity_animation.rs

@@ -0,0 +1,33 @@
+use ferrumc_ecs::entities::Entity;
+use ferrumc_macros::{packet, Event, NetEncode};
+use std::io::Write;
+
+#[derive(NetEncode)]
+#[packet(packet_id = 0x03)]
+pub struct EntityAnimationPacket {
+    pub eid: Entity,
+    pub animation: u8,
+}
+
+#[derive(Event)]
+pub struct EntityAnimationEvent {
+    pub entity: Entity,
+    pub animation: u8,
+    pub packet: EntityAnimationPacket,
+}
+
+impl EntityAnimationPacket {
+    pub fn new(eid: Entity, animation: u8) -> Self {
+        Self { eid, animation }
+    }
+}
+
+impl EntityAnimationEvent {
+    pub fn new(eid: Entity, animation: u8) -> Self {
+        Self {
+            entity: eid,
+            animation,
+            packet: EntityAnimationPacket::new(eid, animation),
+        }
+    }
+}

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

@@ -17,3 +17,5 @@ pub mod set_render_distance;
 pub mod status_response;
 pub mod synchronize_player_position;
 pub mod update_time;
+
+pub mod entity_animation;

src/lib/net/src/utils/broadcast.rs

@@ -5,6 +5,7 @@ use ferrumc_ecs::entities::Entity;
 use ferrumc_net_codec::encode::{NetEncode, NetEncodeOpts};
 use ferrumc_state::GlobalState;
 use futures::StreamExt;
+use std::collections::HashSet;
 use std::future::Future;
 use std::pin::Pin;
 use tracing::debug;
@@ -16,14 +17,26 @@ type SyncCallbackFn = Box<dyn Fn(Entity, &GlobalState) + Send + Sync>;
 
 #[derive(Default)]
 pub struct BroadcastOptions {
-    pub only_entities: Option<Vec<Entity>>,
+    pub only_entities: Option<HashSet<Entity>>,
+    pub except_entities: Option<HashSet<Entity>>,
     pub async_callback: Option<AsyncCallbackFn>,
     pub sync_callback: Option<SyncCallbackFn>,
 }
 
 impl BroadcastOptions {
-    pub fn only(mut self, entities: Vec<Entity>) -> Self {
-        self.only_entities = Some(entities);
+    pub fn only<I>(mut self, entities: I) -> Self
+    where
+        I: IntoIterator<Item = Entity>,
+    {
+        self.only_entities = Some(entities.into_iter().collect());
+        self
+    }
+
+    pub fn except<I>(mut self, entities: I) -> Self
+    where
+        I: IntoIterator<Item = Entity>,
+    {
+        self.except_entities = Some(entities.into_iter().collect());
         self
     }
 
@@ -50,19 +63,35 @@ impl BroadcastOptions {
     }
 }
 
+fn get_all_entities(state: &GlobalState) -> HashSet<Entity> {
+    state
+        .universe
+        .get_component_manager()
+        .get_entities_with::<StreamWriter>()
+        .into_iter()
+        .collect()
+}
+
 pub async fn broadcast(
     packet: &impl NetEncode,
     state: &GlobalState,
     opts: BroadcastOptions,
 ) -> NetResult<()> {
-    let entities = match opts.only_entities {
-        None => state
-            .universe
-            .get_component_manager()
-            .get_entities_with::<StreamWriter>(),
+    let mut entities = match opts.only_entities {
+        None => get_all_entities(state),
         Some(entities) => entities,
     };
 
+    // Remove excluded entities if any
+    if let Some(except_entities) = opts.except_entities {
+        entities.retain(|entity| !except_entities.contains(entity));
+    }
+
+    // No entities to broadcast to
+    if entities.is_empty() {
+        return Ok(());
+    }
+
     // Pre-encode the packet to save resources.
     let packet = {
         let mut buffer = Vec::new();