feat : rebase on upstream + add ferrumc_data dependency + soud system for pig

Author: Tonguechaude

src/bin/src/register_events.rs

@@ -3,9 +3,8 @@ use bevy_ecs::prelude::World;
 use ferrumc_commands::events::{CommandDispatchEvent, ResolvedCommandDispatchEvent};
 use ferrumc_core::chunks::cross_chunk_boundary_event::CrossChunkBoundaryEvent;
 use ferrumc_core::conn::force_player_recount_event::ForcePlayerRecountEvent;
-use ferrumc_events::*;
-use ferrumc_entities::SpawnEntityEvent;
 use ferrumc_entities::{DamageEvent, SpawnEntityEvent};
+use ferrumc_events::*;
 use ferrumc_net::packets::packet_events::TransformEvent;
 
 pub fn register_events(world: &mut World) {

src/bin/src/systems/entities/entity_damage.rs

@@ -1,18 +1,24 @@
 use bevy_ecs::prelude::*;
-use ferrumc_entities::components::{EntityId, Health, Velocity};
+use ferrumc_core::identity::player_identity::PlayerIdentity;
+use ferrumc_entities::components::{EntityId, EntityType, Health, Velocity};
 use ferrumc_entities::DamageEvent;
+use ferrumc_net::connection::StreamWriter;
+use ferrumc_net::packets::outgoing::entity_sound_effect::EntitySoundEffectPacket;
 use ferrumc_state::GlobalStateResource;
 use tracing::{debug, info};
 
 /// System that processes damage events and applies damage + knockback to entities
 pub fn entity_damage_system(
     mut damage_events: EventReader<DamageEvent>,
-    mut entity_query: Query<(&EntityId, &mut Health, &mut Velocity)>,
-    _state: Res<GlobalStateResource>,
+    mut entity_query: Query<(&EntityId, &EntityType, &mut Health, &mut Velocity)>,
+    player_query: Query<(Entity, &StreamWriter), With<PlayerIdentity>>,
+    state: Res<GlobalStateResource>,
 ) {
     for event in damage_events.read() {
         // Get the target entity's components
-        let Ok((entity_id, mut health, mut velocity)) = entity_query.get_mut(event.target) else {
+        let Ok((entity_id, entity_type, mut health, mut velocity)) =
+            entity_query.get_mut(event.target)
+        else {
             debug!(
                 "Damage event target entity {:?} not found or missing components",
                 event.target
@@ -47,8 +53,33 @@ pub fn entity_damage_system(
             );
         }
 
+        // Send hurt sound effect to all connected players
+        let sound_id = match entity_type {
+            EntityType::Pig => 1114, // entity.pig.hurt
+            // TODO: Add more entity types and their hurt sounds
+            _ => {
+                debug!("No hurt sound defined for {:?}", entity_type);
+                continue; // Skip sound if not defined
+            }
+        };
+
+        let sound_packet = EntitySoundEffectPacket::hurt(sound_id, entity_id.to_network_id());
+
+        for (player_entity, stream_writer) in player_query.iter() {
+            if state.0.players.is_connected(player_entity) {
+                if let Err(e) = stream_writer.send_packet_ref(&sound_packet) {
+                    debug!("Failed to send hurt sound to player: {}", e);
+                }
+            }
+        }
+
+        debug!(
+            "Sent hurt sound {} for entity {}",
+            sound_id,
+            entity_id.to_network_id()
+        );
+
         // TODO: Send damage animation packet to nearby players
-        // TODO: Send hurt sound effect
         // TODO: Apply invulnerability ticks (prevent damage spam)
     }
 }

src/bin/src/systems/entities/entity_movement.rs

@@ -7,7 +7,7 @@ use ferrumc_state::GlobalStateResource;
 
 const GRAVITY: f64 = -0.08; // Blocks per tick^2
 const TERMINAL_VELOCITY: f64 = -3.92; // Max fall speed
-const WATER_BUOYANCY: f64 = 0.10; // Upward force in water (stronger than gravity to make entities float)
+const WATER_BUOYANCY: f64 = 0.09; // Upward force in water (slightly stronger than gravity for gentle floating)
 const WATER_DRAG: f64 = 0.8; // Water friction multiplier
 
 /// System that apply basic physics to entity
@@ -24,9 +24,9 @@ pub fn entity_physics_system(
 
         // Apply gravity and buoyancy
         if in_water {
-            // In water: buoyancy force is stronger than gravity, so entities float up
+            // In water: buoyancy force is slightly stronger than gravity for gentle floating
             vel.y += GRAVITY + WATER_BUOYANCY;
-            // Net force: -0.08 + 0.10 = +0.02 (upward), causing floating
+            // Net force: -0.08 + 0.09 = +0.01 (upward), causing gentle floating
         } else if !on_ground.0 {
             // In air: normal gravity
             vel.y = (vel.y + GRAVITY).max(TERMINAL_VELOCITY);
@@ -45,32 +45,35 @@ pub fn entity_physics_system(
         // Check collision at the new position (considering all movement)
         if !check_collision(&state.0, new_x, new_y, new_z, &bbox) {
             // No collision, move freely
-            pos.x = new_x;
-            pos.y = new_y;
-            pos.z = new_z;
+            *pos = Position::new(new_x, new_y, new_z);
         } else {
             // Collision detected, try each axis separately
+            let mut final_x = pos.x;
+            let mut final_y = pos.y;
+            let mut final_z = pos.z;
 
             // Try Y movement first (jumping/falling)
             if !check_collision(&state.0, pos.x, new_y, pos.z, &bbox) {
-                pos.y = new_y;
+                final_y = new_y;
             } else {
                 vel.y = 0.0;
             }
 
             // Try X movement with updated Y position
-            if !check_collision(&state.0, new_x, pos.y, pos.z, &bbox) {
-                pos.x = new_x;
+            if !check_collision(&state.0, new_x, final_y, pos.z, &bbox) {
+                final_x = new_x;
             } else {
                 vel.x = 0.0;
             }
 
             // Try Z movement with updated X and Y positions
-            if !check_collision(&state.0, pos.x, pos.y, new_z, &bbox) {
-                pos.z = new_z;
+            if !check_collision(&state.0, final_x, final_y, new_z, &bbox) {
+                final_z = new_z;
             } else {
                 vel.z = 0.0;
             }
+
+            *pos = Position::new(final_x, final_y, final_z);
         }
 
         // Apply friction based on environment

src/lib/entities/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2024"
 bevy_ecs = { workspace = true }
 
 ferrumc-core = { workspace = true }
+ferrumc-data = { workspace = true }
 ferrumc-macros = { workspace = true }
 ferrumc-net = { workspace = true }
 ferrumc-net-codec = { workspace = true }

src/lib/entities/src/collision.rs

@@ -1,4 +1,5 @@
 use ferrumc_core::transform::position::Position;
+use ferrumc_data::generated::entities::EntityType as EntityTypeData;
 use ferrumc_state::GlobalState;
 
 /// Bounding box dimensions for an entity
@@ -9,10 +10,10 @@ pub struct BoundingBox {
 }
 
 impl BoundingBox {
-    /// Pig hitbox (0.9 × 0.9 × 0.9 blocks in Minecraft vanilla)
+    /// Pig hitbox from Minecraft vanilla data (0.9 × 0.9 blocks)
     pub const PIG: BoundingBox = BoundingBox {
-        half_width: 0.45,
-        height: 0.9,
+        half_width: EntityTypeData::PIG.dimension[0] as f64 / 2.0,
+        height: EntityTypeData::PIG.dimension[1] as f64,
     };
 }
 

src/lib/entities/src/types/passive/pig/bundle.rs

@@ -4,6 +4,7 @@ use bevy_ecs::prelude::*;
 use ferrumc_core::transform::grounded::OnGround;
 use ferrumc_core::transform::position::Position;
 use ferrumc_core::transform::rotation::Rotation;
+use ferrumc_data::generated::entities::EntityType as EntityTypeData;
 use uuid::Uuid;
 
 /// Complete bundle for spawning a pig entity
@@ -45,7 +46,7 @@ impl PigBundle {
             position,
             rotation: Rotation::default(),
             velocity: Velocity::zero(),
-            health: Health::new(10.0), // Pigs have 10 HP
+            health: Health::new(EntityTypeData::PIG.max_health.unwrap()), // Pig max health from vanilla data (10.0)
             age: Age::new(),
             on_ground: OnGround(true), // Spawn on ground to prevent falling before sync
             uuid: EntityUuid(Uuid::new_v4()),

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

@@ -0,0 +1,41 @@
+use ferrumc_macros::{packet, NetEncode};
+use ferrumc_net_codec::net_types::var_int::VarInt;
+
+/// Entity Sound Effect packet (0x6D / 109)
+///
+/// Plays a sound effect from an entity.
+#[derive(NetEncode, Clone)]
+#[packet(packet_id = "sound_entity", state = "play")]
+pub struct EntitySoundEffectPacket {
+    /// The sound effect ID
+    pub sound_id: VarInt,
+    /// The sound category (e.g., hostile, neutral, player, etc.)
+    pub sound_category: VarInt,
+    /// The entity emitting the sound
+    pub entity_id: VarInt,
+    /// Volume (1.0 is 100%, can be higher)
+    pub volume: f32,
+    /// Pitch (1.0 is normal pitch, can range from 0.5 to 2.0)
+    pub pitch: f32,
+    /// Random seed for sound variations
+    pub seed: i64,
+}
+
+impl EntitySoundEffectPacket {
+    /// Create a new entity sound effect packet
+    pub fn new(sound_id: i32, entity_id: i32, volume: f32, pitch: f32) -> Self {
+        Self {
+            sound_id: VarInt::new(sound_id),
+            sound_category: VarInt::new(5), // 5 = neutral category for entities
+            entity_id: VarInt::new(entity_id),
+            volume,
+            pitch,
+            seed: rand::random(),
+        }
+    }
+
+    /// Create a hurt sound for an entity at normal volume and pitch
+    pub fn hurt(sound_id: i32, entity_id: i32) -> Self {
+        Self::new(sound_id, entity_id, 1.0, 1.0)
+    }
+}

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

@@ -25,6 +25,7 @@ pub mod spawn_entity;
 pub mod entity_animation;
 pub mod entity_event;
 pub mod entity_metadata;
+pub mod entity_sound_effect;
 pub mod player_info_update;
 
 // --------- Movement ----------