From a2606569bb79867d07a075bcf7b05730e4264d72 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 11 Jun 2025 22:58:41 -0630 Subject: [PATCH] use owned instead of borrowed Vec3 more --- azalea-block/src/fluid_state.rs | 2 +- azalea-client/src/entity_query.rs | 2 +- azalea-client/src/plugins/interact.rs | 14 +- azalea-client/src/plugins/packet/game/mod.rs | 4 +- azalea-core/src/aabb.rs | 166 ++++++++----------- azalea-core/src/position.rs | 57 +++---- azalea-entity/src/dimensions.rs | 2 +- azalea-entity/src/lib.rs | 26 +-- azalea-entity/src/plugin/mod.rs | 2 +- azalea-physics/src/clip.rs | 28 ++-- azalea-physics/src/collision/mod.rs | 77 ++++----- azalea-physics/src/collision/shape.rs | 16 +- azalea-physics/src/fluids.rs | 4 +- azalea-physics/src/lib.rs | 73 ++++---- azalea-physics/src/travel.rs | 28 ++-- azalea/examples/testbot/killaura.rs | 2 +- azalea/src/bot.rs | 4 +- azalea/src/nearest_entity.rs | 10 +- azalea/src/pathfinder/debug.rs | 2 +- azalea/src/pathfinder/goals.rs | 10 +- azalea/src/pathfinder/mod.rs | 2 +- 21 files changed, 230 insertions(+), 301 deletions(-) diff --git a/azalea-block/src/fluid_state.rs b/azalea-block/src/fluid_state.rs index edceac05..cfddcc7f 100644 --- a/azalea-block/src/fluid_state.rs +++ b/azalea-block/src/fluid_state.rs @@ -20,7 +20,7 @@ pub struct FluidState { /// set (see FlowingFluid.getFlowing) pub falling: bool, } -#[derive(Default, Clone, Debug, PartialEq, Eq)] +#[derive(Default, Clone, Copy, Debug, PartialEq, Eq)] pub enum FluidKind { #[default] Empty, diff --git a/azalea-client/src/entity_query.rs b/azalea-client/src/entity_query.rs index 5b19bb24..ee99d0f4 100644 --- a/azalea-client/src/entity_query.rs +++ b/azalea-client/src/entity_query.rs @@ -162,7 +162,7 @@ where entities.sort_by_cached_key(|(_, position)| { // to_bits is fine here as long as the number is positive - position.distance_squared_to(&nearest_to).to_bits() + position.distance_squared_to(nearest_to).to_bits() }); entities diff --git a/azalea-client/src/plugins/interact.rs b/azalea-client/src/plugins/interact.rs index 31b5acf4..d91597d6 100644 --- a/azalea-client/src/plugins/interact.rs +++ b/azalea-client/src/plugins/interact.rs @@ -363,7 +363,7 @@ pub fn update_hit_result_component( }; let instance = instance_lock.read(); - let hit_result = pick(look_direction, &eye_position, &instance.chunks, pick_range); + let hit_result = pick(*look_direction, eye_position, &instance.chunks, pick_range); if let Some(mut hit_result_ref) = hit_result_ref { **hit_result_ref = hit_result; } else { @@ -384,8 +384,8 @@ pub fn update_hit_result_component( /// /// TODO: does not currently check for entities pub fn pick( - look_direction: &LookDirection, - eye_position: &Vec3, + look_direction: LookDirection, + eye_position: Vec3, chunks: &azalea_world::ChunkStorage, pick_range: f64, ) -> HitResult { @@ -400,18 +400,18 @@ pub fn pick( /// /// Also see [`pick`]. pub fn pick_block( - look_direction: &LookDirection, - eye_position: &Vec3, + look_direction: LookDirection, + eye_position: Vec3, chunks: &azalea_world::ChunkStorage, pick_range: f64, ) -> BlockHitResult { let view_vector = view_vector(look_direction); - let end_position = eye_position + &(view_vector * pick_range); + let end_position = eye_position + (view_vector * pick_range); azalea_physics::clip::clip( chunks, ClipContext { - from: *eye_position, + from: eye_position, to: end_position, block_shape_type: BlockShapeType::Outline, fluid_pick_type: FluidPickType::None, diff --git a/azalea-client/src/plugins/packet/game/mod.rs b/azalea-client/src/plugins/packet/game/mod.rs index b2a4abc4..e1477d21 100644 --- a/azalea-client/src/plugins/packet/game/mod.rs +++ b/azalea-client/src/plugins/packet/game/mod.rs @@ -428,7 +428,7 @@ impl GamePacketHandler<'_> { p.relative .apply(&p.change, &mut position, &mut direction, &mut physics); // old_pos is set to the current position when we're teleported - physics.set_old_pos(&position); + physics.set_old_pos(*position); // send the relevant packets commands.trigger(SendPacketEvent::new( @@ -828,7 +828,7 @@ impl GamePacketHandler<'_> { &mut physics, ); // old_pos is set to the current position when we're teleported - physics.set_old_pos(&old_position); + physics.set_old_pos(old_position); }); }, )); diff --git a/azalea-core/src/aabb.rs b/azalea-core/src/aabb.rs index 03a754f0..09abf047 100644 --- a/azalea-core/src/aabb.rs +++ b/azalea-core/src/aabb.rs @@ -15,14 +15,16 @@ pub struct AABB { pub struct ClipPointOpts<'a> { pub t: &'a mut f64, pub approach_dir: Option, - pub delta: &'a Vec3, + pub delta: Vec3, pub begin: f64, + pub min_x: f64, pub min_z: f64, pub max_x: f64, pub max_z: f64, + pub result_dir: Direction, - pub start: &'a Vec3, + pub start: Vec3, } impl AABB { @@ -51,85 +53,51 @@ impl AABB { AABB { min, max } } - pub fn expand_towards(&self, other: &Vec3) -> AABB { - let mut min_x = self.min.x; - let mut min_y = self.min.y; - let mut min_z = self.min.z; - - let mut max_x = self.max.x; - let mut max_y = self.max.y; - let mut max_z = self.max.z; + pub fn expand_towards(&self, other: Vec3) -> AABB { + let mut min = self.min; + let mut max = self.max; if other.x < 0.0 { - min_x += other.x; + min.x += other.x; } else if other.x > 0.0 { - max_x += other.x; + max.x += other.x; } if other.y < 0.0 { - min_y += other.y; + min.y += other.y; } else if other.y > 0.0 { - max_y += other.y; + max.y += other.y; } if other.z < 0.0 { - min_z += other.z; + min.z += other.z; } else if other.z > 0.0 { - max_z += other.z; + max.z += other.z; } - AABB { - min: Vec3::new(min_x, min_y, min_z), - max: Vec3::new(max_x, max_y, max_z), - } + AABB { min, max } } pub fn inflate(&self, amount: Vec3) -> AABB { - let min_x = self.min.x - amount.x; - let min_y = self.min.y - amount.y; - let min_z = self.min.z - amount.z; + let min = self.min - amount; + let max = self.max + amount; - let max_x = self.max.x + amount.x; - let max_y = self.max.y + amount.y; - let max_z = self.max.z + amount.z; - - AABB { - min: Vec3::new(min_x, min_y, min_z), - max: Vec3::new(max_x, max_y, max_z), - } + AABB { min, max } } pub fn inflate_all(&self, amount: f64) -> AABB { self.inflate(Vec3::new(amount, amount, amount)) } pub fn intersect(&self, other: &AABB) -> AABB { - let min_x = self.min.x.max(other.min.x); - let min_y = self.min.y.max(other.min.y); - let min_z = self.min.z.max(other.min.z); - - let max_x = self.max.x.min(other.max.x); - let max_y = self.max.y.min(other.max.y); - let max_z = self.max.z.min(other.max.z); - - AABB { - min: Vec3::new(min_x, min_y, min_z), - max: Vec3::new(max_x, max_y, max_z), - } + let min = self.min.max(other.min); + let max = self.max.min(other.max); + AABB { min, max } } pub fn minmax(&self, other: &AABB) -> AABB { - let min_x = self.min.x.min(other.min.x); - let min_y = self.min.y.min(other.min.y); - let min_z = self.min.z.min(other.min.z); - - let max_x = self.max.x.max(other.max.x); - let max_y = self.max.y.max(other.max.y); - let max_z = self.max.z.max(other.max.z); - - AABB { - min: Vec3::new(min_x, min_y, min_z), - max: Vec3::new(max_x, max_y, max_z), - } + let min = self.min.min(other.min); + let max = self.max.max(other.max); + AABB { min, max } } pub fn move_relative(&self, delta: Vec3) -> AABB { @@ -147,22 +115,13 @@ impl AABB { && self.min.z < other.max.z && self.max.z > other.min.z } - pub fn intersects_vec3(&self, corner1: &Vec3, corner2: &Vec3) -> bool { - self.intersects_aabb(&AABB { - min: Vec3::new( - corner1.x.min(corner2.x), - corner1.y.min(corner2.y), - corner1.z.min(corner2.z), - ), - max: Vec3::new( - corner1.x.max(corner2.x), - corner1.y.max(corner2.y), - corner1.z.max(corner2.z), - ), - }) + pub fn intersects_vec3(&self, corner1: Vec3, corner2: Vec3) -> bool { + let min = corner1.min(corner2); + let max = corner1.max(corner2); + self.intersects_aabb(&AABB { min, max }) } - pub fn contains(&self, point: &Vec3) -> bool { + pub fn contains(&self, point: Vec3) -> bool { point.x >= self.min.x && point.x < self.max.x && point.y >= self.min.y @@ -178,6 +137,7 @@ impl AABB { (x + y + z) / 3.0 } + #[inline] pub fn get_size(&self, axis: Axis) -> f64 { axis.choose( self.max.x - self.min.x, @@ -193,24 +153,24 @@ impl AABB { self.deflate(Vec3::new(amount, amount, amount)) } - pub fn clip(&self, min: &Vec3, max: &Vec3) -> Option { + pub fn clip(&self, min: Vec3, max: Vec3) -> Option { let mut t = 1.0; let delta = max - min; - let _dir = Self::get_direction_aabb(self, min, &mut t, None, &delta)?; - Some(min + &(delta * t)) + let _dir = Self::get_direction_aabb(self, min, &mut t, None, delta)?; + Some(min + (delta * t)) } - pub fn clip_with_from_and_to(min: &Vec3, max: &Vec3, from: &Vec3, to: &Vec3) -> Option { + pub fn clip_with_from_and_to(min: Vec3, max: Vec3, from: Vec3, to: Vec3) -> Option { let mut t = 1.0; let delta = to - from; - let _dir = Self::get_direction(min, max, from, &mut t, None, &delta)?; - Some(from + &(delta * t)) + let _dir = Self::get_direction(min, max, from, &mut t, None, delta)?; + Some(from + (delta * t)) } pub fn clip_iterable( - boxes: &Vec, - from: &Vec3, - to: &Vec3, + boxes: &[AABB], + from: Vec3, + to: Vec3, pos: BlockPos, ) -> Option { let mut t = 1.0; @@ -223,12 +183,12 @@ impl AABB { from, &mut t, dir, - &delta, + delta, ); } let dir = dir?; Some(BlockHitResult { - location: from + &(delta * t), + location: from + (delta * t), direction: dir, block_pos: pos, inside: false, @@ -239,32 +199,34 @@ impl AABB { fn get_direction_aabb( &self, - from: &Vec3, + from: Vec3, t: &mut f64, dir: Option, - delta: &Vec3, + delta: Vec3, ) -> Option { - AABB::get_direction(&self.min, &self.max, from, t, dir, delta) + AABB::get_direction(self.min, self.max, from, t, dir, delta) } fn get_direction( - min: &Vec3, - max: &Vec3, - from: &Vec3, + min: Vec3, + max: Vec3, + from: Vec3, t: &mut f64, mut dir: Option, - delta: &Vec3, + delta: Vec3, ) -> Option { if delta.x > EPSILON { dir = Self::clip_point(ClipPointOpts { t, approach_dir: dir, delta, + begin: min.x, min_x: min.y, max_x: max.y, min_z: min.z, max_z: max.z, + result_dir: Direction::West, start: from, }); @@ -273,11 +235,13 @@ impl AABB { t, approach_dir: dir, delta, + begin: max.x, min_x: min.y, max_x: max.y, min_z: min.z, max_z: max.z, + result_dir: Direction::East, start: from, }); @@ -287,7 +251,7 @@ impl AABB { dir = Self::clip_point(ClipPointOpts { t, approach_dir: dir, - delta: &Vec3 { + delta: Vec3 { x: delta.y, y: delta.z, z: delta.x, @@ -298,7 +262,7 @@ impl AABB { min_z: min.x, max_z: max.x, result_dir: Direction::Down, - start: &Vec3 { + start: Vec3 { x: from.y, y: from.z, z: from.x, @@ -308,7 +272,7 @@ impl AABB { dir = Self::clip_point(ClipPointOpts { t, approach_dir: dir, - delta: &Vec3 { + delta: Vec3 { x: delta.y, y: delta.z, z: delta.x, @@ -319,7 +283,7 @@ impl AABB { min_z: min.x, max_z: max.x, result_dir: Direction::Up, - start: &Vec3 { + start: Vec3 { x: from.y, y: from.z, z: from.x, @@ -331,7 +295,7 @@ impl AABB { dir = Self::clip_point(ClipPointOpts { t, approach_dir: dir, - delta: &Vec3 { + delta: Vec3 { x: delta.z, y: delta.x, z: delta.y, @@ -342,7 +306,7 @@ impl AABB { min_z: min.y, max_z: max.y, result_dir: Direction::North, - start: &Vec3 { + start: Vec3 { x: from.z, y: from.x, z: from.y, @@ -352,7 +316,7 @@ impl AABB { dir = Self::clip_point(ClipPointOpts { t, approach_dir: dir, - delta: &Vec3 { + delta: Vec3 { x: delta.z, y: delta.x, z: delta.y, @@ -363,7 +327,7 @@ impl AABB { min_z: min.y, max_z: max.y, result_dir: Direction::South, - start: &Vec3 { + start: Vec3 { x: from.z, y: from.x, z: from.y, @@ -431,7 +395,7 @@ impl AABB { axis.choose(self.min.x, self.min.y, self.min.z) } - pub fn collided_along_vector(&self, vector: Vec3, boxes: &Vec) -> bool { + pub fn collided_along_vector(&self, vector: Vec3, boxes: &[AABB]) -> bool { let center = self.get_center(); let new_center = center + vector; @@ -441,11 +405,11 @@ impl AABB { self.get_size(Axis::Y) * 0.5, self.get_size(Axis::Z) * 0.5, )); - if inflated.contains(&new_center) || inflated.contains(¢er) { + if inflated.contains(new_center) || inflated.contains(center) { return true; } - if inflated.clip(¢er, &new_center).is_some() { + if inflated.clip(center, new_center).is_some() { return true; } } @@ -494,12 +458,12 @@ mod tests { fn test_aabb_clip_iterable() { assert_ne!( AABB::clip_iterable( - &vec![AABB { + &[AABB { min: Vec3::new(0., 0., 0.), max: Vec3::new(1., 1., 1.), }], - &Vec3::new(-1., -1., -1.), - &Vec3::new(1., 1., 1.), + Vec3::new(-1., -1., -1.), + Vec3::new(1., 1., 1.), BlockPos::new(0, 0, 0), ), None diff --git a/azalea-core/src/position.rs b/azalea-core/src/position.rs index d6e67dc2..5a8d3e0c 100644 --- a/azalea-core/src/position.rs +++ b/azalea-core/src/position.rs @@ -34,7 +34,7 @@ macro_rules! vec3_impl { /// Get the squared distance from this position to another position. /// Equivalent to `(self - other).length_squared()`. #[inline] - pub fn distance_squared_to(&self, other: &Self) -> $type { + pub fn distance_squared_to(self, other: Self) -> $type { (self - other).length_squared() } @@ -44,7 +44,7 @@ macro_rules! vec3_impl { } #[inline] - pub fn horizontal_distance_squared_to(&self, other: &Self) -> $type { + pub fn horizontal_distance_squared_to(self, other: Self) -> $type { (self - other).horizontal_distance_squared() } @@ -115,6 +115,23 @@ macro_rules! vec3_impl { self.x * other.x + self.y * other.y + self.z * other.z } + /// Make a new position with the lower coordinates for each axis. + pub fn min(&self, other: Self) -> Self { + Self { + x: self.x.min(other.x), + y: self.x.min(other.y), + z: self.x.min(other.z), + } + } + /// Make a new position with the higher coordinates for each axis. + pub fn max(&self, other: Self) -> Self { + Self { + x: self.x.max(other.x), + y: self.x.max(other.y), + z: self.x.max(other.z), + } + } + /// Replace the Y with 0. #[inline] pub fn xz(&self) -> Self { @@ -298,7 +315,7 @@ impl Vec3 { /// Get the distance from this position to another position. /// Equivalent to `(self - other).length()`. - pub fn distance_to(&self, other: &Self) -> f64 { + pub fn distance_to(self, other: Self) -> f64 { (self - other).length() } @@ -382,40 +399,6 @@ impl BlockPos { (self.x.abs() + self.y.abs() + self.z.abs()) as u32 } - /// Make a new BlockPos with the lower coordinates for each axis. - /// - /// ``` - /// # use azalea_core::position::BlockPos; - /// assert_eq!( - /// BlockPos::min(&BlockPos::new(1, 20, 300), &BlockPos::new(50, 40, 30),), - /// BlockPos::new(1, 20, 30), - /// ); - /// ``` - pub fn min(&self, other: &Self) -> Self { - Self { - x: self.x.min(other.x), - y: self.y.min(other.y), - z: self.z.min(other.z), - } - } - - /// Make a new BlockPos with the higher coordinates for each axis. - /// - /// ``` - /// # use azalea_core::position::BlockPos; - /// assert_eq!( - /// BlockPos::max(&BlockPos::new(1, 20, 300), &BlockPos::new(50, 40, 30),), - /// BlockPos::new(50, 40, 300), - /// ); - /// ``` - pub fn max(&self, other: &Self) -> Self { - Self { - x: self.x.max(other.x), - y: self.y.max(other.y), - z: self.z.max(other.z), - } - } - pub fn offset_with_direction(self, direction: Direction) -> Self { self + direction.normal() } diff --git a/azalea-entity/src/dimensions.rs b/azalea-entity/src/dimensions.rs index 8d9a1eae..8770fa94 100644 --- a/azalea-entity/src/dimensions.rs +++ b/azalea-entity/src/dimensions.rs @@ -12,7 +12,7 @@ impl EntityDimensions { Self { width, height } } - pub fn make_bounding_box(&self, pos: &Vec3) -> AABB { + pub fn make_bounding_box(&self, pos: Vec3) -> AABB { let radius = (self.width / 2.0) as f64; let height = self.height as f64; AABB { diff --git a/azalea-entity/src/lib.rs b/azalea-entity/src/lib.rs index 0058708f..cf2222d4 100644 --- a/azalea-entity/src/lib.rs +++ b/azalea-entity/src/lib.rs @@ -39,15 +39,15 @@ pub use crate::plugin::*; pub fn move_relative( physics: &mut Physics, - direction: &LookDirection, + direction: LookDirection, speed: f32, - acceleration: &Vec3, + acceleration: Vec3, ) { let input_vector = input_vector(direction, speed, acceleration); physics.velocity += input_vector; } -pub fn input_vector(direction: &LookDirection, speed: f32, acceleration: &Vec3) -> Vec3 { +pub fn input_vector(direction: LookDirection, speed: f32, acceleration: Vec3) -> Vec3 { let distance = acceleration.length_squared(); if distance < 1.0E-7 { return Vec3::ZERO; @@ -55,7 +55,7 @@ pub fn input_vector(direction: &LookDirection, speed: f32, acceleration: &Vec3) let acceleration = if distance > 1.0 { acceleration.normalize() } else { - *acceleration + acceleration } .scale(speed as f64); let y_rot = math::sin(direction.y_rot * 0.017453292f32); @@ -67,7 +67,7 @@ pub fn input_vector(direction: &LookDirection, speed: f32, acceleration: &Vec3) } } -pub fn view_vector(look_direction: &LookDirection) -> Vec3 { +pub fn view_vector(look_direction: LookDirection) -> Vec3 { let x_rot = look_direction.x_rot * 0.017453292; let y_rot = -look_direction.y_rot * 0.017453292; let y_rot_cos = math::cos(y_rot); @@ -82,7 +82,7 @@ pub fn view_vector(look_direction: &LookDirection) -> Vec3 { } /// Get the position of the block below the entity, but a little lower. -pub fn on_pos_legacy(chunk_storage: &ChunkStorage, position: &Position) -> BlockPos { +pub fn on_pos_legacy(chunk_storage: &ChunkStorage, position: Position) -> BlockPos { on_pos(0.2, chunk_storage, position) } @@ -98,7 +98,7 @@ pub fn on_pos_legacy(chunk_storage: &ChunkStorage, position: &Position) -> Block // } // } // return var5; -pub fn on_pos(offset: f32, chunk_storage: &ChunkStorage, pos: &Position) -> BlockPos { +pub fn on_pos(offset: f32, chunk_storage: &ChunkStorage, pos: Position) -> BlockPos { let x = pos.x.floor() as i32; let y = (pos.y - offset as f64).floor() as i32; let z = pos.z.floor() as i32; @@ -323,7 +323,7 @@ impl Physics { no_jump_delay: 0, - bounding_box: dimensions.make_bounding_box(&pos), + bounding_box: dimensions.make_bounding_box(pos), dimensions, has_impulse: false, @@ -375,8 +375,8 @@ impl Physics { self.lava_fluid_height > 0. } - pub fn set_old_pos(&mut self, pos: &Position) { - self.old_position = **pos; + pub fn set_old_pos(&mut self, pos: Position) { + self.old_position = *pos; } } @@ -496,10 +496,10 @@ impl EntityBundle { /// If this is for a client then all of our clients will have this. /// /// This component is not removed from clients when they disconnect. -#[derive(Component, Clone, Debug, Default)] +#[derive(Component, Clone, Copy, Debug, Default)] pub struct LocalEntity; -#[derive(Component, Clone, Debug, PartialEq, Deref, DerefMut)] +#[derive(Component, Clone, Copy, Debug, PartialEq, Deref, DerefMut)] pub struct FluidOnEyes(FluidKind); impl FluidOnEyes { @@ -508,5 +508,5 @@ impl FluidOnEyes { } } -#[derive(Component, Clone, Debug, PartialEq, Deref, DerefMut)] +#[derive(Component, Clone, Copy, Debug, PartialEq, Deref, DerefMut)] pub struct OnClimbable(bool); diff --git a/azalea-entity/src/plugin/mod.rs b/azalea-entity/src/plugin/mod.rs index e64f9823..65b28a59 100644 --- a/azalea-entity/src/plugin/mod.rs +++ b/azalea-entity/src/plugin/mod.rs @@ -199,7 +199,7 @@ pub fn clamp_look_direction(mut query: Query<&mut LookDirection>) { /// Cached position in the world must be updated. pub fn update_bounding_box(mut query: Query<(&Position, &mut Physics), Changed>) { for (position, mut physics) in query.iter_mut() { - let bounding_box = physics.dimensions.make_bounding_box(position); + let bounding_box = physics.dimensions.make_bounding_box(**position); physics.bounding_box = bounding_box; } } diff --git a/azalea-physics/src/clip.rs b/azalea-physics/src/clip.rs index 2cef15c4..8d2b5dd1 100644 --- a/azalea-physics/src/clip.rs +++ b/azalea-physics/src/clip.rs @@ -101,22 +101,22 @@ pub fn clip(chunk_storage: &ChunkStorage, context: ClipContext) -> BlockHitResul let block_shape = ctx.block_shape(block_state); let interaction_clip = clip_with_interaction_override( - &ctx.from, - &ctx.to, + ctx.from, + ctx.to, block_pos, block_shape, - &block_state, + block_state, ); let fluid_shape = ctx.fluid_shape(fluid_state, chunk_storage, block_pos); - let fluid_clip = fluid_shape.clip(&ctx.from, &ctx.to, block_pos); + let fluid_clip = fluid_shape.clip(ctx.from, ctx.to, block_pos); let distance_to_interaction = interaction_clip .as_ref() - .map(|hit| ctx.from.distance_squared_to(&hit.location)) + .map(|hit| ctx.from.distance_squared_to(hit.location)) .unwrap_or(f64::MAX); let distance_to_fluid = fluid_clip .as_ref() - .map(|hit| ctx.from.distance_squared_to(&hit.location)) + .map(|hit| ctx.from.distance_squared_to(hit.location)) .unwrap_or(f64::MAX); if distance_to_interaction <= distance_to_fluid { @@ -137,11 +137,11 @@ pub fn clip(chunk_storage: &ChunkStorage, context: ClipContext) -> BlockHitResul } fn clip_with_interaction_override( - from: &Vec3, - to: &Vec3, + from: Vec3, + to: Vec3, block_pos: BlockPos, block_shape: &VoxelShape, - _block_state: &BlockState, + _block_state: BlockState, ) -> Option { let block_hit_result = block_shape.clip(from, to, block_pos); @@ -255,7 +255,7 @@ pub fn traverse_blocks( } } -pub fn box_traverse_blocks(from: &Vec3, to: &Vec3, aabb: &AABB) -> HashSet { +pub fn box_traverse_blocks(from: Vec3, to: Vec3, aabb: &AABB) -> HashSet { let delta = to - from; let traversed_blocks = BlockPos::between_closed_aabb(aabb); if delta.length_squared() < (0.99999_f32 * 0.99999) as f64 { @@ -346,10 +346,10 @@ pub fn add_collisions_along_travel( step_count += 1; let Some(clip_location) = AABB::clip_with_from_and_to( - &Vec3::new(min_x as f64, min_y as f64, min_z as f64), - &Vec3::new((min_x + 1) as f64, (min_y + 1) as f64, (min_z + 1) as f64), - &from, - &to, + Vec3::new(min_x as f64, min_y as f64, min_z as f64), + Vec3::new((min_x + 1) as f64, (min_y + 1) as f64, (min_z + 1) as f64), + from, + to, ) else { continue; }; diff --git a/azalea-physics/src/collision/mod.rs b/azalea-physics/src/collision/mod.rs index ef994deb..41fc6c85 100644 --- a/azalea-physics/src/collision/mod.rs +++ b/azalea-physics/src/collision/mod.rs @@ -35,7 +35,7 @@ pub enum MoverType { // Entity.collide fn collide( - movement: &Vec3, + movement: Vec3, world: &Instance, physics: &azalea_entity::Physics, source_entity: Option, @@ -51,7 +51,7 @@ fn collide( collidable_entity_query, ); let collided_delta = if movement.length_squared() == 0.0 { - *movement + movement } else { collide_bounding_box(movement, &entity_bounding_box, world, &entity_collisions) }; @@ -65,20 +65,20 @@ fn collide( let max_up_step = 0.6; if max_up_step > 0. && on_ground && (x_collision || z_collision) { let mut step_to_delta = collide_bounding_box( - &movement.with_y(max_up_step), + movement.with_y(max_up_step), &entity_bounding_box, world, &entity_collisions, ); let directly_up_delta = collide_bounding_box( - &Vec3::ZERO.with_y(max_up_step), - &entity_bounding_box.expand_towards(&Vec3::new(movement.x, 0., movement.z)), + Vec3::ZERO.with_y(max_up_step), + &entity_bounding_box.expand_towards(Vec3::new(movement.x, 0., movement.z)), world, &entity_collisions, ); if directly_up_delta.y < max_up_step { let target_movement = collide_bounding_box( - &movement.with_y(0.), + movement.with_y(0.), &entity_bounding_box.move_relative(directly_up_delta), world, &entity_collisions, @@ -95,7 +95,7 @@ fn collide( > collided_delta.horizontal_distance_squared() { return step_to_delta.add(collide_bounding_box( - &Vec3::ZERO.with_y(-step_to_delta.y + movement.y), + Vec3::ZERO.with_y(-step_to_delta.y + movement.y), &entity_bounding_box.move_relative(step_to_delta), world, &entity_collisions, @@ -112,7 +112,7 @@ fn collide( #[allow(clippy::too_many_arguments)] pub fn move_colliding( _mover_type: MoverType, - movement: &Vec3, + movement: Vec3, world: &Instance, position: &mut Mut, physics: &mut azalea_entity::Physics, @@ -180,7 +180,7 @@ pub fn move_colliding( // TODO: minecraft checks for a "minor" horizontal collision here - let _block_pos_below = azalea_entity::on_pos_legacy(&world.chunks, position); + let _block_pos_below = azalea_entity::on_pos_legacy(&world.chunks, **position); // let _block_state_below = self // .world // .get_block_state(&block_pos_below) @@ -239,7 +239,7 @@ pub fn move_colliding( } fn collide_bounding_box( - movement: &Vec3, + movement: Vec3, entity_bounding_box: &AABB, world: &Instance, entity_collisions: &[VoxelShape], @@ -259,63 +259,44 @@ fn collide_bounding_box( } fn collide_with_shapes( - movement: &Vec3, + mut movement: Vec3, mut entity_box: AABB, - collision_boxes: &Vec, + collision_boxes: &[VoxelShape], ) -> Vec3 { if collision_boxes.is_empty() { - return *movement; + return movement; } - let mut x_movement = movement.x; - let mut y_movement = movement.y; - let mut z_movement = movement.z; - if y_movement != 0. { - y_movement = Shapes::collide(&Axis::Y, &entity_box, collision_boxes, y_movement); - if y_movement != 0. { - entity_box = entity_box.move_relative(Vec3 { - x: 0., - y: y_movement, - z: 0., - }); + if movement.y != 0. { + movement.y = Shapes::collide(Axis::Y, &entity_box, collision_boxes, movement.y); + if movement.y != 0. { + entity_box = entity_box.move_relative(Vec3::new(0., movement.y, 0.)); } } // whether the player is moving more in the z axis than x // this is done to fix a movement bug, minecraft does this too - let more_z_movement = x_movement.abs() < z_movement.abs(); + let more_z_movement = movement.x.abs() < movement.z.abs(); - if more_z_movement && z_movement != 0. { - z_movement = Shapes::collide(&Axis::Z, &entity_box, collision_boxes, z_movement); - if z_movement != 0. { - entity_box = entity_box.move_relative(Vec3 { - x: 0., - y: 0., - z: z_movement, - }); + if more_z_movement && movement.z != 0. { + movement.z = Shapes::collide(Axis::Z, &entity_box, collision_boxes, movement.z); + if movement.z != 0. { + entity_box = entity_box.move_relative(Vec3::new(0., 0., movement.z)); } } - if x_movement != 0. { - x_movement = Shapes::collide(&Axis::X, &entity_box, collision_boxes, x_movement); - if x_movement != 0. { - entity_box = entity_box.move_relative(Vec3 { - x: x_movement, - y: 0., - z: 0., - }); + if movement.x != 0. { + movement.x = Shapes::collide(Axis::X, &entity_box, collision_boxes, movement.x); + if movement.x != 0. { + entity_box = entity_box.move_relative(Vec3::new(movement.x, 0., 0.)); } } - if !more_z_movement && z_movement != 0. { - z_movement = Shapes::collide(&Axis::Z, &entity_box, collision_boxes, z_movement); + if !more_z_movement && movement.z != 0. { + movement.z = Shapes::collide(Axis::Z, &entity_box, collision_boxes, movement.z); } - Vec3 { - x: x_movement, - y: y_movement, - z: z_movement, - } + movement } /// Get the [`VoxelShape`] for the given fluid state. diff --git a/azalea-physics/src/collision/shape.rs b/azalea-physics/src/collision/shape.rs index 4d430ee7..9caae590 100644 --- a/azalea-physics/src/collision/shape.rs +++ b/azalea-physics/src/collision/shape.rs @@ -98,9 +98,9 @@ impl Shapes { } pub fn collide( - axis: &Axis, + axis: Axis, entity_box: &AABB, - collision_boxes: &Vec, + collision_boxes: &[VoxelShape], mut movement: f64, ) -> f64 { for shape in collision_boxes { @@ -408,7 +408,7 @@ impl VoxelShape { } } - pub fn clip(&self, from: &Vec3, to: &Vec3, block_pos: BlockPos) -> Option { + pub fn clip(&self, from: Vec3, to: Vec3, block_pos: BlockPos) -> Option { if self.is_empty() { return None; } @@ -416,7 +416,7 @@ impl VoxelShape { if vector.length_squared() < EPSILON { return None; } - let right_after_start = from + &(vector * 0.001); + let right_after_start = from + (vector * 0.001); if self.shape().is_full_wide( self.find_index(Axis::X, right_after_start.x - block_pos.x as f64), @@ -436,8 +436,8 @@ impl VoxelShape { } } - pub fn collide(&self, axis: &Axis, entity_box: &AABB, movement: f64) -> f64 { - self.collide_x(AxisCycle::between(*axis, Axis::X), entity_box, movement) + pub fn collide(&self, axis: Axis, entity_box: &AABB, movement: f64) -> f64 { + self.collide_x(AxisCycle::between(axis, Axis::X), entity_box, movement) } pub fn collide_x(&self, axis_cycle: AxisCycle, entity_box: &AABB, mut movement: f64) -> f64 { if self.shape().is_empty() { @@ -753,8 +753,8 @@ mod tests { let block_shape = &*BLOCK_SHAPE; let block_hit_result = block_shape .clip( - &Vec3::new(-0.3, 0.5, 0.), - &Vec3::new(5.3, 0.5, 0.), + Vec3::new(-0.3, 0.5, 0.), + Vec3::new(5.3, 0.5, 0.), BlockPos::new(0, 0, 0), ) .unwrap(); diff --git a/azalea-physics/src/fluids.rs b/azalea-physics/src/fluids.rs index 5ea6194a..ea0f12e2 100644 --- a/azalea-physics/src/fluids.rs +++ b/azalea-physics/src/fluids.rs @@ -32,7 +32,7 @@ pub fn 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); + update_in_water_state_and_do_water_current_pushing(&mut physics, &world, *position); // right now doing registries.dimension_type() clones the entire registry which // is very inefficient, so for now we're doing this instead @@ -63,7 +63,7 @@ pub fn update_in_water_state_and_do_fluid_pushing( fn update_in_water_state_and_do_water_current_pushing( physics: &mut Physics, world: &Instance, - _position: &Position, + _position: Position, ) { // TODO: implement vehicles and boats // if vehicle == AbstractBoat { diff --git a/azalea-physics/src/lib.rs b/azalea-physics/src/lib.rs index 1f381174..d0db3c22 100644 --- a/azalea-physics/src/lib.rs +++ b/azalea-physics/src/lib.rs @@ -18,6 +18,7 @@ use azalea_entity::{ Attributes, InLoadedChunk, Jumping, LocalEntity, LookDirection, OnClimbable, Physics, Pose, Position, metadata::Sprinting, move_relative, }; +use azalea_registry::Block; use azalea_world::{Instance, InstanceContainer, InstanceName}; use bevy_app::{App, Plugin}; use bevy_ecs::prelude::*; @@ -110,9 +111,9 @@ pub fn ai_step( { jump_from_ground( &mut physics, - position, - look_direction, - sprinting, + *position, + *look_direction, + *sprinting, instance_name, &instance_container, ); @@ -187,11 +188,11 @@ fn check_inside_blocks( for movement in movements { let bounding_box_at_target = physics .dimensions - .make_bounding_box(&movement.to) + .make_bounding_box(movement.to) .deflate_all(1.0E-5); for traversed_block in - box_traverse_blocks(&movement.from, &movement.to, &bounding_box_at_target) + box_traverse_blocks(movement.from, movement.to, &bounding_box_at_target) { // if (!this.isAlive()) { // return; @@ -221,8 +222,8 @@ fn check_inside_blocks( if entity_inside_collision_shape != &*BLOCK_SHAPE && !collided_with_shape_moving_from( - &movement.from, - &movement.to, + movement.from, + movement.to, traversed_block, entity_inside_collision_shape, physics, @@ -241,8 +242,8 @@ fn check_inside_blocks( } fn collided_with_shape_moving_from( - from: &Vec3, - to: &Vec3, + from: Vec3, + to: Vec3, traversed_block: BlockPos, entity_inside_collision_shape: &VoxelShape, physics: &Physics, @@ -304,9 +305,9 @@ pub struct EntityMovement { pub fn jump_from_ground( physics: &mut Physics, - position: &Position, - look_direction: &LookDirection, - sprinting: &Sprinting, + position: Position, + look_direction: LookDirection, + sprinting: Sprinting, instance_name: &InstanceName, instance_container: &InstanceContainer, ) { @@ -322,7 +323,7 @@ pub fn jump_from_ground( y: jump_power, z: old_delta_movement.z, }; - if **sprinting { + if *sprinting { // sprint jumping gives some extra velocity let y_rot = look_direction.y_rot * 0.017453292; physics.velocity += Vec3 { @@ -337,11 +338,11 @@ pub fn jump_from_ground( pub fn update_old_position(mut query: Query<(&mut Physics, &Position)>) { for (mut physics, position) in &mut query { - physics.set_old_pos(position); + physics.set_old_pos(*position); } } -fn get_block_pos_below_that_affects_movement(position: &Position) -> BlockPos { +fn get_block_pos_below_that_affects_movement(position: Position) -> BlockPos { BlockPos::new( position.x.floor() as i32, // TODO: this uses bounding_box.min_y instead of position.y @@ -355,13 +356,13 @@ struct HandleRelativeFrictionAndCalculateMovementOpts<'a, 'b, 'world, 'state> { block_friction: f32, world: &'a Instance, physics: &'a mut Physics, - direction: &'a LookDirection, + direction: LookDirection, position: Mut<'a, Position>, attributes: &'a Attributes, is_sprinting: bool, - on_climbable: &'a OnClimbable, - pose: Option<&'a Pose>, - jumping: &'a Jumping, + on_climbable: OnClimbable, + pose: Option, + jumping: Jumping, entity: Entity, physics_query: &'a PhysicsQuery<'world, 'state, 'b>, collidable_entity_query: &'a CollidableEntityQuery<'world, 'state>, @@ -387,18 +388,18 @@ fn handle_relative_friction_and_calculate_movement( physics, direction, get_friction_influenced_speed(physics, attributes, block_friction, is_sprinting), - &Vec3 { - x: physics.x_acceleration as f64, - y: physics.y_acceleration as f64, - z: physics.z_acceleration as f64, - }, + Vec3::new( + physics.x_acceleration as f64, + physics.y_acceleration as f64, + physics.z_acceleration as f64, + ), ); - physics.velocity = handle_on_climbable(physics.velocity, on_climbable, &position, world, pose); + physics.velocity = handle_on_climbable(physics.velocity, on_climbable, *position, world, pose); move_colliding( MoverType::Own, - &physics.velocity.clone(), + physics.velocity, world, &mut position, physics, @@ -414,14 +415,14 @@ fn handle_relative_friction_and_calculate_movement( // PowderSnowBlock.canEntityWalkOnPowderSnow(entity))) { var3 = new // Vec3(var3.x, 0.2D, var3.z); } - if physics.horizontal_collision || **jumping { - let block_at_feet: azalea_registry::Block = world + if physics.horizontal_collision || *jumping { + let block_at_feet: Block = world .chunks .get_block_state((*position).into()) .unwrap_or_default() .into(); - if **on_climbable || block_at_feet == azalea_registry::Block::PowderSnow { + if *on_climbable || block_at_feet == Block::PowderSnow { physics.velocity.y = 0.2; } } @@ -431,12 +432,12 @@ fn handle_relative_friction_and_calculate_movement( fn handle_on_climbable( velocity: Vec3, - on_climbable: &OnClimbable, - position: &Position, + on_climbable: OnClimbable, + position: Position, world: &Instance, - pose: Option<&Pose>, + pose: Option, ) -> Vec3 { - if !**on_climbable { + if !*on_climbable { return velocity; } @@ -450,7 +451,7 @@ fn handle_on_climbable( // sneaking on ladders/vines if y < 0.0 - && pose.copied() == Some(Pose::Sneaking) + && pose == Some(Pose::Sneaking) && azalea_registry::Block::from( world .chunks @@ -485,7 +486,7 @@ fn get_friction_influenced_speed( /// Returns the what the entity's jump should be multiplied by based on the /// block they're standing on. -fn block_jump_factor(world: &Instance, position: &Position) -> f32 { +fn block_jump_factor(world: &Instance, position: Position) -> f32 { let block_at_pos = world.chunks.get_block_state(position.into()); let block_below = world .chunks @@ -513,7 +514,7 @@ fn block_jump_factor(world: &Instance, position: &Position) -> f32 { // public double getJumpBoostPower() { // return this.hasEffect(MobEffects.JUMP) ? (double)(0.1F * // (float)(this.getEffect(MobEffects.JUMP).getAmplifier() + 1)) : 0.0D; } -fn jump_power(world: &Instance, position: &Position) -> f32 { +fn jump_power(world: &Instance, position: Position) -> f32 { 0.42 * block_jump_factor(world, position) } diff --git a/azalea-physics/src/travel.rs b/azalea-physics/src/travel.rs index a442f629..dba991d5 100644 --- a/azalea-physics/src/travel.rs +++ b/azalea-physics/src/travel.rs @@ -73,7 +73,7 @@ pub fn travel( &world, entity, &mut physics, - &direction, + *direction, position, attributes, sprinting, @@ -86,13 +86,13 @@ pub fn travel( &world, entity, &mut physics, - &direction, + *direction, position, attributes, sprinting, - on_climbable, + *on_climbable, pose, - jumping, + *jumping, &physics_query, &collidable_entity_query, ); @@ -106,19 +106,19 @@ fn travel_in_air( world: &Instance, entity: Entity, physics: &mut Physics, - direction: &LookDirection, + direction: LookDirection, position: Mut, attributes: &Attributes, sprinting: Sprinting, - on_climbable: &OnClimbable, + on_climbable: OnClimbable, pose: Option<&Pose>, - jumping: &Jumping, + jumping: Jumping, physics_query: &PhysicsQuery, collidable_entity_query: &CollidableEntityQuery, ) { let gravity = get_effective_gravity(); - let block_pos_below = get_block_pos_below_that_affects_movement(&position); + let block_pos_below = get_block_pos_below_that_affects_movement(*position); let block_state_below = world .chunks @@ -144,7 +144,7 @@ fn travel_in_air( attributes, is_sprinting: *sprinting, on_climbable, - pose, + pose: pose.copied(), jumping, entity, physics_query, @@ -177,7 +177,7 @@ fn travel_in_fluid( world: &Instance, entity: Entity, physics: &mut Physics, - direction: &LookDirection, + direction: LookDirection, mut position: Mut, attributes: &Attributes, sprinting: Sprinting, @@ -212,10 +212,10 @@ fn travel_in_fluid( // waterMovementSpeed = 0.96F; // } - move_relative(physics, direction, speed, &acceleration); + move_relative(physics, direction, speed, acceleration); move_colliding( MoverType::Own, - &physics.velocity.clone(), + physics.velocity.clone(), world, &mut position, physics, @@ -236,10 +236,10 @@ fn travel_in_fluid( physics.velocity = get_fluid_falling_adjusted_movement(gravity, moving_down, new_velocity, sprinting); } else { - move_relative(physics, direction, 0.02, &acceleration); + move_relative(physics, direction, 0.02, acceleration); move_colliding( MoverType::Own, - &physics.velocity.clone(), + physics.velocity, world, &mut position, physics, diff --git a/azalea/examples/testbot/killaura.rs b/azalea/examples/testbot/killaura.rs index 5458ea4e..586d90b2 100644 --- a/azalea/examples/testbot/killaura.rs +++ b/azalea/examples/testbot/killaura.rs @@ -31,7 +31,7 @@ pub fn tick(bot: Client, state: State) -> anyhow::Result<()> { continue; } - let distance = bot_position.distance_to(position); + let distance = bot_position.distance_to(**position); if distance < 4. && distance < nearest_distance { nearest_entity = Some(entity_id); nearest_distance = distance; diff --git a/azalea/src/bot.rs b/azalea/src/bot.rs index 9e8566bf..745f3fdb 100644 --- a/azalea/src/bot.rs +++ b/azalea/src/bot.rs @@ -229,7 +229,7 @@ fn look_at_listener( for event in events.read() { if let Ok((position, eye_height, mut look_direction)) = query.get_mut(event.entity) { let new_look_direction = - direction_looking_at(&position.up(eye_height.into()), &event.position); + direction_looking_at(position.up(eye_height.into()), event.position); trace!("look at {} (currently at {})", event.position, **position); *look_direction = new_look_direction; } @@ -238,7 +238,7 @@ fn look_at_listener( /// Return the look direction that would make a client at `current` be /// looking at `target`. -pub fn direction_looking_at(current: &Vec3, target: &Vec3) -> LookDirection { +pub fn direction_looking_at(current: Vec3, target: Vec3) -> LookDirection { // borrowed from mineflayer's Bot.lookAt because i didn't want to do math let delta = target - current; let y_rot = (PI - f64::atan2(-delta.x, -delta.z)) * (180.0 / PI); diff --git a/azalea/src/nearest_entity.rs b/azalea/src/nearest_entity.rs index 7ac4fff0..df54273a 100644 --- a/azalea/src/nearest_entity.rs +++ b/azalea/src/nearest_entity.rs @@ -69,7 +69,7 @@ where /// multiple entities are within range, only the closest one is returned. pub fn nearest_to_position( &'a self, - position: &Position, + position: Position, instance_name: &InstanceName, max_distance: f64, ) -> Option { @@ -81,7 +81,7 @@ where continue; } - let target_distance = position.distance_to(e_pos); + let target_distance = position.distance_to(**e_pos); if target_distance < min_distance { nearest_entity = Some(target_entity); min_distance = target_distance; @@ -111,7 +111,7 @@ where continue; } - let target_distance = position.distance_to(e_pos); + let target_distance = position.distance_to(**e_pos); if target_distance < min_distance { nearest_entity = Some(target_entity); min_distance = target_distance; @@ -140,7 +140,7 @@ where return None; } - let distance = position.distance_to(e_pos); + let distance = position.distance_to(**e_pos); if distance < max_distance { Some((target_entity, distance)) } else { @@ -181,7 +181,7 @@ where return None; } - let distance = position.distance_to(e_pos); + let distance = position.distance_to(**e_pos); if distance < max_distance { Some((target_entity, distance)) } else { diff --git a/azalea/src/pathfinder/debug.rs b/azalea/src/pathfinder/debug.rs index 6b319531..d0d264d3 100644 --- a/azalea/src/pathfinder/debug.rs +++ b/azalea/src/pathfinder/debug.rs @@ -65,7 +65,7 @@ pub fn debug_render_path_with_particles( let start_vec3 = start.center(); let end_vec3 = end.center(); - let step_count = (start_vec3.distance_squared_to(&end_vec3).sqrt() * 4.0) as usize; + let step_count = (start_vec3.distance_to(end_vec3) * 4.0) as usize; let target_block_state = chunks.get_block_state(movement.target).unwrap_or_default(); let above_target_block_state = chunks diff --git a/azalea/src/pathfinder/goals.rs b/azalea/src/pathfinder/goals.rs index c19bf504..95786561 100644 --- a/azalea/src/pathfinder/goals.rs +++ b/azalea/src/pathfinder/goals.rs @@ -230,16 +230,16 @@ impl Goal for ReachBlockPosGoal { } // only do the expensive check if we're close enough - let distance = self.pos.distance_squared_to(&n); - if distance > self.max_check_distance.pow(2) { + let distance_squared = self.pos.distance_squared_to(n); + if distance_squared > self.max_check_distance.pow(2) { return false; } let eye_position = n.center_bottom().up(1.62); - let look_direction = crate::direction_looking_at(&eye_position, &self.pos.center()); + let look_direction = crate::direction_looking_at(eye_position, self.pos.center()); let block_hit_result = azalea_client::interact::pick_block( - &look_direction, - &eye_position, + look_direction, + eye_position, &self.chunk_storage, self.distance, ); diff --git a/azalea/src/pathfinder/mod.rs b/azalea/src/pathfinder/mod.rs index e75c99c4..9786e1de 100644 --- a/azalea/src/pathfinder/mod.rs +++ b/azalea/src/pathfinder/mod.rs @@ -641,7 +641,7 @@ pub fn timeout_movement( // don't timeout if we're mining if let Some(mining) = mining { // also make sure we're close enough to the block that's being mined - if mining.pos.distance_squared_to(&BlockPos::from(position)) < 6_i32.pow(2) { + if mining.pos.distance_squared_to(position.into()) < 6_i32.pow(2) { // also reset the last_node_reached_at so we don't timeout after we finish // mining executing_path.last_node_reached_at = Instant::now();