different travel function in water

azalea-client/src/movement.rs

@@ -325,8 +325,8 @@ pub fn local_player_ai_step(
 ) {
     for (physics_state, mut physics, mut sprinting, mut attributes) in query.iter_mut() {
         // server ai step
-        physics.xxa = physics_state.left_impulse;
-        physics.zza = physics_state.forward_impulse;
+        physics.x_acceleration = physics_state.left_impulse;
+        physics.z_acceleration = physics_state.forward_impulse;
 
         // TODO: food data and abilities
         // let has_enough_food_to_sprint = self.food_data().food_level ||

azalea-entity/src/attributes.rs

@@ -11,6 +11,7 @@ use thiserror::Error;
 pub struct Attributes {
     pub speed: AttributeInstance,
     pub attack_speed: AttributeInstance,
+    pub water_movement_efficiency: AttributeInstance,
 }
 
 #[derive(Clone, Debug)]

azalea-entity/src/lib.rs

@@ -257,12 +257,14 @@ pub struct Physics {
     pub velocity: Vec3,
     pub vec_delta_codec: VecDeltaCodec,
 
-    /// X acceleration.
-    pub xxa: f32,
-    /// Y acceleration.
-    pub yya: f32,
-    /// Z acceleration.
-    pub zza: f32,
+    /// The acceleration here is the force that will be attempted to be added to
+    /// the entity's velocity next tick.
+    ///
+    /// You should typically not set this yourself, since it's controlled by how
+    /// the entity is trying to move.
+    pub x_acceleration: f32,
+    pub y_acceleration: f32,
+    pub z_acceleration: f32,
 
     on_ground: bool,
     last_on_ground: bool,
@@ -295,9 +297,9 @@ impl Physics {
             velocity: Vec3::default(),
             vec_delta_codec: VecDeltaCodec::new(pos),
 
-            xxa: 0.,
-            yya: 0.,
-            zza: 0.,
+            x_acceleration: 0.,
+            y_acceleration: 0.,
+            z_acceleration: 0.,
 
             on_ground: false,
             last_on_ground: false,
@@ -345,6 +347,14 @@ impl Physics {
     pub fn clear_fire(&mut self) {
         self.remaining_fire_ticks = 0;
     }
+
+    pub fn is_in_water(&self) -> bool {
+        self.was_touching_water
+    }
+    pub fn is_in_lava(&self) -> bool {
+        // TODO: also check `!this.firstTick &&`
+        self.lava_fluid_height > 0.
+    }
 }
 
 /// Marker component for entities that are dead.
@@ -444,6 +454,7 @@ impl EntityBundle {
                 // entities have different defaults
                 speed: AttributeInstance::new(0.1),
                 attack_speed: AttributeInstance::new(4.0),
+                water_movement_efficiency: AttributeInstance::new(0.0),
             },
 
             jumping: Jumping(false),

azalea-physics/src/collision/mod.rs

@@ -22,6 +22,7 @@ use tracing::warn;
 
 use self::world_collisions::get_block_collisions;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MoverType {
     Own,
     Player,
@@ -143,8 +144,10 @@ fn collide(movement: &Vec3, world: &Instance, physics: &azalea_entity::Physics)
 }
 
 /// Move an entity by a given delta, checking for collisions.
+///
+/// In Mojmap, this is `Entity.move`.
 pub fn move_colliding(
-    _mover_type: &MoverType,
+    _mover_type: MoverType,
     movement: &Vec3,
     world: &Instance,
     position: &mut Mut<azalea_entity::Position>,

azalea-physics/src/fluids.rs

@@ -25,15 +25,11 @@ pub fn update_in_water_state_and_do_fluid_pushing(
             .expect("All entities should be in a valid world");
         let world = world_lock.read();
 
-        println!("update_in_water_state_and_do_fluid_pushing");
-
         physics.water_fluid_height = 0.;
         physics.lava_fluid_height = 0.;
 
         update_in_water_state_and_do_water_current_pushing(&mut physics, &world, &position);
 
-        println!("physics.water_fluid_height: {}", physics.water_fluid_height);
-
         // let lava_push_factor = world
         //     .registries
         //     .dimension_type()
@@ -117,10 +113,6 @@ fn update_fluid_height_and_do_fluid_pushing(
                 }
                 let mut additional_player_delta_for_fluid =
                     get_fluid_flow(&fluid_at_cur_pos, world, cur_pos);
-                println!(
-                    "additional_player_delta_for_fluid: {}",
-                    additional_player_delta_for_fluid
-                );
                 if min_height_touching < 0.4 {
                     additional_player_delta_for_fluid *= min_height_touching;
                 };
@@ -131,9 +123,6 @@ fn update_fluid_height_and_do_fluid_pushing(
         }
     }
 
-    println!("num_fluids_being_touched: {}", num_fluids_being_touched);
-    println!("additional_player_delta: {}", additional_player_delta);
-
     if additional_player_delta.length() > 0. {
         additional_player_delta /= num_fluids_being_touched as f64;
 
@@ -180,10 +169,6 @@ pub fn get_fluid_flow(fluid: &FluidState, world: &Instance, pos: BlockPos) -> Ve
             .get_fluid_state(&adjacent_block_pos)
             .unwrap_or_default();
         if fluid.affects_flow(&adjacent_fluid_state) {
-            println!(
-                "affects flow {adjacent_block_pos} {:?}",
-                adjacent_fluid_state
-            );
             let mut adjacent_fluid_height = adjacent_fluid_state.height();
             let mut adjacent_height_difference: f32 = 0.;