mat/azalea
1
2
Fork 0
mirror of https://github.com/mat-1/azalea.git synced 2025-08-02 14:26:04 +00:00
Code Issues Projects Releases Packages Activity

use owned instead of borrowed Vec3 more

Browse source
This commit is contained in:
mat 2025-06-11 22:58:41 -06:30
parent 89ddd5e85f
commit a2606569bb
21 changed files with 230 additions and 301 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
azalea-block/src/fluid_state.rs
View file

@ -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,

2
azalea-client/src/entity_query.rs
View file

@ -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

14
azalea-client/src/plugins/interact.rs
View file

@ -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,

4
azalea-client/src/plugins/packet/game/mod.rs
View file

@ -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);
});
},
));

166
azalea-core/src/aabb.rs
View file

@ -15,14 +15,16 @@ pub struct AABB {
pub struct ClipPointOpts<'a> {
pub t: &'a mut f64,
pub approach_dir: Option<Direction>,
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<Vec3> {
pub fn clip(&self, min: Vec3, max: Vec3) -> Option<Vec3> {
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<Vec3> {
pub fn clip_with_from_and_to(min: Vec3, max: Vec3, from: Vec3, to: Vec3) -> Option<Vec3> {
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<AABB>,
from: &Vec3,
to: &Vec3,
boxes: &[AABB],
from: Vec3,
to: Vec3,
pos: BlockPos,
) -> Option<BlockHitResult> {
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<Direction>,
delta: &Vec3,
delta: Vec3,
) -> Option<Direction> {
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<Direction>,
delta: &Vec3,
delta: Vec3,
) -> Option<Direction> {
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<AABB>) -> 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(&center) {
if inflated.contains(new_center) || inflated.contains(center) {
return true;
}
if inflated.clip(&center, &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

57
azalea-core/src/position.rs
View file

@ -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()
}

2
azalea-entity/src/dimensions.rs
View file

@ -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 {

26
azalea-entity/src/lib.rs
View file

@ -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);

2
azalea-entity/src/plugin/mod.rs
View file

@ -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<Position>>) {
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;
}
}

28
azalea-physics/src/clip.rs
View file

@ -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<BlockHitResult> {
let block_hit_result = block_shape.clip(from, to, block_pos);
@ -255,7 +255,7 @@ pub fn traverse_blocks<C, T>(
}
}
pub fn box_traverse_blocks(from: &Vec3, to: &Vec3, aabb: &AABB) -> HashSet<BlockPos> {
pub fn box_traverse_blocks(from: Vec3, to: Vec3, aabb: &AABB) -> HashSet<BlockPos> {
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;
};

77
azalea-physics/src/collision/mod.rs
View file

@ -35,7 +35,7 @@ pub enum MoverType {
// Entity.collide
fn collide(
movement: &Vec3,
movement: Vec3,
world: &Instance,
physics: &azalea_entity::Physics,
source_entity: Option<Entity>,
@ -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<azalea_entity::Position>,
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<VoxelShape>,
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.

16
azalea-physics/src/collision/shape.rs
View file

@ -98,9 +98,9 @@ impl Shapes {
}
pub fn collide(
axis: &Axis,
axis: Axis,
entity_box: &AABB,
collision_boxes: &Vec<VoxelShape>,
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<BlockHitResult> {
pub fn clip(&self, from: Vec3, to: Vec3, block_pos: BlockPos) -> Option<BlockHitResult> {
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();

4
azalea-physics/src/fluids.rs
View file

@ -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 {

73
azalea-physics/src/lib.rs
View file

@ -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<Pose>,
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<Pose>,
) -> 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)
}

28
azalea-physics/src/travel.rs
View file

@ -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<Position>,
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<Position>,
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,

2
azalea/examples/testbot/killaura.rs
View file

@ -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;

4
azalea/src/bot.rs
View file

@ -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);

10
azalea/src/nearest_entity.rs
View file

@ -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<Entity> {
@ -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 {

2
azalea/src/pathfinder/debug.rs
View file

@ -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

10
azalea/src/pathfinder/goals.rs
View file

@ -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,
);

2
azalea/src/pathfinder/mod.rs
View file

@ -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();