feat: allow player to swim

Author: Tonguechaude

src/bin/src/systems/mod.rs

@@ -6,6 +6,7 @@ pub mod lan_pinger;
 pub mod listeners;
 mod mq;
 pub mod new_connections;
+mod player_swimming;
 pub mod shutdown_systems;
 pub mod world_sync;
 
@@ -15,6 +16,7 @@ pub fn register_game_systems(schedule: &mut bevy_ecs::schedule::Schedule) {
     schedule.add_systems(chunk_calculator::handle);
     schedule.add_systems(chunk_sending::handle);
     schedule.add_systems(mq::process);
+    schedule.add_systems(player_swimming::detect_player_swimming);
 
     // Should always be last
     schedule.add_systems(connection_killer::connection_killer);

src/bin/src/systems/new_connections.rs

@@ -10,6 +10,7 @@ use ferrumc_components::{
         gameplay_state::ender_chest::EnderChest,
         hunger::Hunger,
         player_bundle::PlayerBundle,
+        swimming::SwimmingState,
     },
 };
 use ferrumc_core::{
@@ -102,6 +103,7 @@ pub fn accept_new_connections(
             hunger,
             experience,
             active_effects,
+            swimming: SwimmingState::default(),
         };
 
         // --- 3. Spawn the PlayerBundle, then .insert() the network components ---

src/bin/src/systems/player_swimming.rs

@@ -0,0 +1,84 @@
+use bevy_ecs::prelude::*;
+use bevy_math::IVec3;
+use ferrumc_components::player::swimming::SwimmingState;
+use ferrumc_core::identity::player_identity::PlayerIdentity;
+use ferrumc_core::transform::position::Position;
+use ferrumc_net::connection::StreamWriter;
+use ferrumc_net::packets::outgoing::entity_metadata::{EntityMetadata, EntityMetadataPacket};
+use ferrumc_net_codec::net_types::var_int::VarInt;
+use ferrumc_state::GlobalStateResource;
+use tracing::error;
+
+/// Height of player's eyes from feet (blocks)
+const PLAYER_EYE_HEIGHT: f64 = 1.62;
+
+/// Check if a player is in water by testing at eye level
+fn is_player_in_water(state: &ferrumc_state::GlobalState, pos: &Position) -> bool {
+    let eye_pos = IVec3::new(
+        pos.x.floor() as i32,
+        (pos.y + PLAYER_EYE_HEIGHT).floor() as i32,
+        pos.z.floor() as i32,
+    );
+
+    state
+        .world
+        .get_block_and_fetch(eye_pos.x, eye_pos.y, eye_pos.z, "overworld")
+        .map(|block_state| (86..=101).contains(&block_state.0))
+        .unwrap_or(false)
+}
+
+/// System that detects when players enter/exit water and updates their swimming state
+/// Also broadcasts the swimming pose to all connected clients
+pub fn detect_player_swimming(
+    mut swimmers: Query<(&PlayerIdentity, &Position, &mut SwimmingState)>,
+    all_connections: Query<(Entity, &StreamWriter)>,
+    state: Res<GlobalStateResource>,
+) {
+    for (identity, pos, mut swimming_state) in swimmers.iter_mut() {
+        let in_water = is_player_in_water(&state.0, pos);
+
+        if in_water && !swimming_state.is_swimming {
+            swimming_state.start_swimming();
+
+            let entity_id = VarInt::new(identity.short_uuid);
+            let packet = EntityMetadataPacket::new(
+                entity_id,
+                [
+                    EntityMetadata::entity_swimming_state(),
+                    EntityMetadata::entity_swimming_pose(),
+                ],
+            );
+
+            broadcast_metadata(&packet, &all_connections, &state);
+        } else if !in_water && swimming_state.is_swimming {
+            swimming_state.stop_swimming();
+
+            let entity_id = VarInt::new(identity.short_uuid);
+            let packet = EntityMetadataPacket::new(
+                entity_id,
+                [
+                    EntityMetadata::entity_clear_state(),
+                    EntityMetadata::entity_standing(),
+                ],
+            );
+
+            broadcast_metadata(&packet, &all_connections, &state);
+        }
+    }
+}
+
+/// Helper function to broadcast entity metadata to all connected players
+fn broadcast_metadata(
+    packet: &EntityMetadataPacket,
+    connections: &Query<(Entity, &StreamWriter)>,
+    state: &GlobalStateResource,
+) {
+    for (entity, conn) in connections {
+        if !state.0.players.is_connected(entity) {
+            continue;
+        }
+        if let Err(err) = conn.send_packet_ref(packet) {
+            error!("Failed to send entity metadata packet: {:?}", err);
+        }
+    }
+}

src/lib/components/src/player/mod.rs

@@ -5,4 +5,5 @@ pub mod gamemode;
 pub mod gameplay_state;
 pub mod hunger;
 pub mod player_bundle;
+pub mod swimming;
 pub mod view_distance;

src/lib/components/src/player/player_bundle.rs

@@ -3,7 +3,7 @@ use crate::{
     health::Health,
     player::{
         abilities::PlayerAbilities, experience::Experience, gamemode::GameModeComponent,
-        gameplay_state::ender_chest::EnderChest, hunger::Hunger,
+        gameplay_state::ender_chest::EnderChest, hunger::Hunger, swimming::SwimmingState,
     },
 };
 use bevy_ecs::prelude::Bundle;
@@ -40,4 +40,7 @@ pub struct PlayerBundle {
     pub hunger: Hunger,
     pub experience: Experience,
     pub active_effects: ActiveEffects,
+
+    // Movement State
+    pub swimming: SwimmingState,
 }

src/lib/components/src/player/swimming.rs

@@ -0,0 +1,21 @@
+use bevy_ecs::prelude::Component;
+
+/// Component tracking whether a player is currently swimming
+#[derive(Component, Debug, Clone, Copy, Default)]
+pub struct SwimmingState {
+    pub is_swimming: bool,
+}
+
+impl SwimmingState {
+    pub fn new(is_swimming: bool) -> Self {
+        Self { is_swimming }
+    }
+
+    pub fn start_swimming(&mut self) {
+        self.is_swimming = true;
+    }
+
+    pub fn stop_swimming(&mut self) {
+        self.is_swimming = false;
+    }
+}

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

@@ -89,6 +89,32 @@ pub mod constructors {
                 EntityMetadataValue::Entity6(EntityPose::Standing),
             )
         }
+
+        /// Entity state with swimming bit set
+        pub fn entity_swimming_state() -> Self {
+            Self::new(
+                EntityMetadataIndexType::Byte,
+                EntityMetadataValue::Entity0(EntityStateMask::from_state(
+                    EntityState::Swimming,
+                )),
+            )
+        }
+
+        /// Entity in swimming pose
+        pub fn entity_swimming_pose() -> Self {
+            Self::new(
+                EntityMetadataIndexType::Pose,
+                EntityMetadataValue::Entity6(EntityPose::Swimming),
+            )
+        }
+
+        /// Entity state with all flags cleared (default state)
+        pub fn entity_clear_state() -> Self {
+            Self::new(
+                EntityMetadataIndexType::Byte,
+                EntityMetadataValue::Entity0(EntityStateMask::new()),
+            )
+        }
     }
 }