From bf4fd29e7f1fe12df040f11ea3f88accb1e7e2c4 Mon Sep 17 00:00:00 2001 From: mat Date: Sun, 26 Jun 2022 00:34:45 -0500 Subject: [PATCH] port aabb --- azalea-client/src/client.rs | 12 +- azalea-client/src/movement.rs | 4 +- azalea-core/src/delta.rs | 8 +- azalea-core/src/position.rs | 29 +- azalea-entity/src/lib.rs | 12 +- azalea-entity/src/physics/aabb.rs | 440 ++++++++++++++++++ azalea-entity/src/physics/block_hit_result.rs | 9 + azalea-entity/src/physics/mod.rs | 26 +- .../game/clientbound_add_entity_packet.rs | 4 +- .../game/clientbound_add_player_packet.rs | 4 +- .../clientbound_move_entity_pos_packet.rs | 2 +- .../clientbound_move_entity_posrot_packet.rs | 2 +- azalea-protocol/src/packets/game/mod.rs | 4 +- azalea-world/src/lib.rs | 4 +- 14 files changed, 520 insertions(+), 40 deletions(-) create mode 100644 azalea-entity/src/physics/aabb.rs create mode 100644 azalea-entity/src/physics/block_hit_result.rs diff --git a/azalea-client/src/client.rs b/azalea-client/src/client.rs index e2967a10..630c7785 100644 --- a/azalea-client/src/client.rs +++ b/azalea-client/src/client.rs @@ -1,6 +1,6 @@ use crate::{Account, Player}; use azalea_auth::game_profile::GameProfile; -use azalea_core::{ChunkPos, EntityPos, PositionDelta, PositionDeltaTrait, ResourceLocation}; +use azalea_core::{ChunkPos, PositionDelta, PositionDeltaTrait, ResourceLocation, Vec3}; use azalea_entity::Entity; use azalea_protocol::{ connect::{GameConnection, HandshakeConnection}, @@ -277,7 +277,7 @@ impl Client { *dimension_lock = Some(Dimension::new(16, height, min_y)); let entity = - Entity::new(p.player_id, client.game_profile.uuid, EntityPos::default()); + Entity::new(p.player_id, client.game_profile.uuid, Vec3::default()); dimension_lock .as_mut() .expect( @@ -400,7 +400,7 @@ impl Client { player_entity.set_rotation(y_rot, x_rot); // TODO: minecraft sets "xo", "yo", and "zo" here but idk what that means // so investigate that ig - let new_pos = EntityPos { + let new_pos = Vec3 { x: new_pos_x, y: new_pos_y, z: new_pos_z, @@ -515,7 +515,7 @@ impl Client { dimension.move_entity( p.id, - EntityPos { + Vec3 { x: p.x, y: p.y, z: p.z, @@ -528,13 +528,13 @@ impl Client { GamePacket::ClientboundRotateHeadPacket(_p) => { // println!("Got rotate head packet {:?}", p); } - GamePacket::ClientboundMoveEntityPosPacket(p) => { + GamePacket::ClientboundMoveVec3Packet(p) => { let mut dimension_lock = client.dimension.lock()?; let dimension = dimension_lock.as_mut().unwrap(); dimension.move_entity_with_delta(p.entity_id, &p.delta)?; } - GamePacket::ClientboundMoveEntityPosRotPacket(p) => { + GamePacket::ClientboundMoveVec3RotPacket(p) => { let mut dimension_lock = client.dimension.lock()?; let dimension = dimension_lock.as_mut().unwrap(); diff --git a/azalea-client/src/movement.rs b/azalea-client/src/movement.rs index 4f99984f..73595ee8 100644 --- a/azalea-client/src/movement.rs +++ b/azalea-client/src/movement.rs @@ -1,10 +1,10 @@ use crate::Client; -use azalea_core::EntityPos; +use azalea_core::Vec3; use azalea_protocol::packets::game::serverbound_move_player_packet_pos_rot::ServerboundMovePlayerPacketPosRot; impl Client { /// Set the client's position to the given coordinates. - pub async fn move_to(&mut self, new_pos: EntityPos) -> Result<(), String> { + pub async fn move_to(&mut self, new_pos: Vec3) -> Result<(), String> { { let mut dimension_lock = self.dimension.lock().unwrap(); let dimension = dimension_lock.as_mut().unwrap(); diff --git a/azalea-core/src/delta.rs b/azalea-core/src/delta.rs index c0056411..c77fc7d2 100644 --- a/azalea-core/src/delta.rs +++ b/azalea-core/src/delta.rs @@ -1,4 +1,4 @@ -use crate::EntityPos; +use crate::Vec3; pub use azalea_buf::McBuf; pub trait PositionDeltaTrait { @@ -57,9 +57,9 @@ impl PositionDeltaTrait for PositionDelta8 { } } -impl EntityPos { - pub fn with_delta(&self, delta: &dyn PositionDeltaTrait) -> EntityPos { - EntityPos { +impl Vec3 { + pub fn with_delta(&self, delta: &dyn PositionDeltaTrait) -> Vec3 { + Vec3 { x: self.x + delta.x(), y: self.y + delta.y(), z: self.z + delta.z(), diff --git a/azalea-core/src/position.rs b/azalea-core/src/position.rs index 64075aa7..a34f5ee9 100644 --- a/azalea-core/src/position.rs +++ b/azalea-core/src/position.rs @@ -9,6 +9,12 @@ pub trait PositionXYZ { fn add_x(&self, n: T) -> Self; fn add_y(&self, n: T) -> Self; fn add_z(&self, n: T) -> Self; + fn add(&self, x: T, y: T, z: T) -> Self + where + Self: Sized, + { + self.add_x(x).add_y(y).add_z(z) + } } #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] @@ -123,30 +129,31 @@ pub struct GlobalPos { pub dimension: ResourceLocation, } +/// An exact point in the world. #[derive(Debug, Clone, Copy, Default)] -pub struct EntityPos { +pub struct Vec3 { pub x: f64, pub y: f64, pub z: f64, } -impl PositionXYZ for EntityPos { +impl PositionXYZ for Vec3 { fn add_x(&self, n: f64) -> Self { - EntityPos { + Vec3 { x: self.x + n, y: self.y, z: self.z, } } fn add_y(&self, n: f64) -> Self { - EntityPos { + Vec3 { x: self.x, y: self.y + n, z: self.z, } } fn add_z(&self, n: f64) -> Self { - EntityPos { + Vec3 { x: self.x, y: self.y, z: self.z + n, @@ -208,8 +215,8 @@ impl From<&ChunkBlockPos> for ChunkSectionBlockPos { } } } -impl From<&EntityPos> for BlockPos { - fn from(pos: &EntityPos) -> Self { +impl From<&Vec3> for BlockPos { + fn from(pos: &Vec3) -> Self { BlockPos { x: pos.x.floor() as i32, y: pos.y.floor() as i32, @@ -218,8 +225,8 @@ impl From<&EntityPos> for BlockPos { } } -impl From<&EntityPos> for ChunkPos { - fn from(pos: &EntityPos) -> Self { +impl From<&Vec3> for ChunkPos { + fn from(pos: &Vec3) -> Self { ChunkPos::from(&BlockPos::from(pos)) } } @@ -302,7 +309,7 @@ mod tests { #[test] fn test_from_entity_pos_to_block_pos() { - let entity_pos = EntityPos { + let entity_pos = Vec3 { x: 31.5, y: 80.0, z: -16.1, @@ -313,7 +320,7 @@ mod tests { #[test] fn test_from_entity_pos_to_chunk_pos() { - let entity_pos = EntityPos { + let entity_pos = Vec3 { x: 31.5, y: 80.0, z: -16.1, diff --git a/azalea-entity/src/lib.rs b/azalea-entity/src/lib.rs index 18bb8b2e..62860752 100644 --- a/azalea-entity/src/lib.rs +++ b/azalea-entity/src/lib.rs @@ -1,7 +1,7 @@ mod data; mod physics; -use azalea_core::{EntityPos, PositionDelta}; +use azalea_core::{PositionDelta, Vec3}; pub use data::*; use uuid::Uuid; @@ -11,9 +11,9 @@ pub struct Entity { pub id: u32, pub uuid: Uuid, /// The position of the entity right now. - pos: EntityPos, + pos: Vec3, /// The position of the entity last tick. - pub old_pos: EntityPos, + pub old_pos: Vec3, pub delta: PositionDelta, pub x_rot: f32, @@ -21,7 +21,7 @@ pub struct Entity { } impl Entity { - pub fn new(id: u32, uuid: Uuid, pos: EntityPos) -> Self { + pub fn new(id: u32, uuid: Uuid, pos: Vec3) -> Self { Self { id, uuid, @@ -33,13 +33,13 @@ impl Entity { } } - pub fn pos(&self) -> &EntityPos { + pub fn pos(&self) -> &Vec3 { &self.pos } /// Sets the position of the entity. This doesn't update the cache in /// azalea-world, and should only be used within azalea-world! - pub fn unsafe_move(&mut self, new_pos: EntityPos) { + pub fn unsafe_move(&mut self, new_pos: Vec3) { self.pos = new_pos; } diff --git a/azalea-entity/src/physics/aabb.rs b/azalea-entity/src/physics/aabb.rs new file mode 100644 index 00000000..f9edbb0f --- /dev/null +++ b/azalea-entity/src/physics/aabb.rs @@ -0,0 +1,440 @@ +use crate::physics::BlockHitResult; +use azalea_core::{BlockPos, Direction, PositionXYZ, Vec3}; + +pub const EPSILON: f64 = 1.0E-7; + +#[derive(Copy, Clone, Debug, PartialEq)] +pub struct AABB { + pub min_x: f64, + pub min_y: f64, + pub min_z: f64, + + pub max_x: f64, + pub max_y: f64, + pub max_z: f64, +} + +impl AABB { + pub fn contract(&mut self, x: f64, y: f64, z: f64) -> 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; + + if x < 0.0 { + min_x -= x; + } else if x > 0.0 { + max_x -= x; + } + + if y < 0.0 { + min_y -= y; + } else if y > 0.0 { + max_y -= y; + } + + if z < 0.0 { + min_z -= z; + } else if z > 0.0 { + max_z -= z; + } + + AABB { + min_x, + min_y, + min_z, + + max_x, + max_y, + max_z, + } + } + + pub fn expand_towards(&mut self, x: f64, y: f64, z: f64) -> 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; + + if x < 0.0 { + min_x += x; + } else if x > 0.0 { + max_x += x; + } + + if y < 0.0 { + min_y += y; + } else if y > 0.0 { + max_y += y; + } + + if z < 0.0 { + min_z += z; + } else if z > 0.0 { + max_z += z; + } + + AABB { + min_x, + min_y, + min_z, + + max_x, + max_y, + max_z, + } + } + + pub fn inflate(&mut self, x: f64, y: f64, z: f64) -> AABB { + let min_x = self.min_x - x; + let min_y = self.min_y - y; + let min_z = self.min_z - z; + + let max_x = self.max_x + x; + let max_y = self.max_y + y; + let max_z = self.max_z + z; + + AABB { + min_x, + min_y, + min_z, + + max_x, + max_y, + max_z, + } + } + + 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_x, + min_y, + min_z, + + max_x, + max_y, + max_z, + } + } + + 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_x, + min_y, + min_z, + + max_x, + max_y, + max_z, + } + } + + pub fn move_relative(&self, x: f64, y: f64, z: f64) -> AABB { + AABB { + min_x: self.min_x + x, + min_y: self.min_y + y, + min_z: self.min_z + z, + + max_x: self.max_x + x, + max_y: self.max_y + y, + max_z: self.max_z + z, + } + } + + pub fn intersects_aabb(&self, other: &AABB) -> bool { + self.min_x < other.max_x + && self.max_x > other.min_x + && self.min_y < other.max_y + && self.max_y > other.min_y + && self.min_z < other.max_z + && self.max_z > other.min_z + } + pub fn intersects_vec3(&self, other: &Vec3, other2: &Vec3) -> bool { + self.intersects_aabb(&AABB { + min_x: other.x.min(other2.x), + min_y: other.y.min(other2.y), + min_z: other.z.min(other2.z), + + max_x: other.x.max(other2.x), + max_y: other.y.max(other2.y), + max_z: other.z.max(other2.z), + }) + } + + pub fn contains(&self, x: f64, y: f64, z: f64) -> bool { + x >= self.min_x + && x < self.max_x + && y >= self.min_y + && y < self.max_y + && z >= self.min_z + && z < self.max_z + } + + pub fn size(&self) -> f64 { + let x = self.get_xsize(); + let y = self.get_ysize(); + let z = self.get_zsize(); + (x + y + z) / 3.0 + } + + pub fn get_xsize(&self) -> f64 { + self.max_x - self.min_x + } + pub fn get_ysize(&self) -> f64 { + self.max_y - self.min_y + } + pub fn get_zsize(&self) -> f64 { + self.max_z - self.min_z + } + + pub fn deflate(&mut self, x: f64, y: f64, z: f64) -> AABB { + self.inflate(-x, -y, -z) + } + + pub fn clip(&self, min: &Vec3, max: &Vec3) -> Option { + let mut t = [1.0]; + let x = max.x - min.x; + let y = max.y - min.y; + let z = max.z - min.z; + let dir = self.get_direction(self, min, &mut t, None, x, y, z); + if dir.is_none() { + return None; + } + let t = t[0]; + Some(min.add(t * x, t * y, t * z)) + } + + pub fn clip_iterable( + &self, + boxes: &Vec, + from: &Vec3, + to: &Vec3, + pos: &BlockPos, + ) -> Option { + let mut t = [1.0]; + let mut dir = None; + let x = to.x - from.x; + let y = to.y - from.y; + let z = to.z - from.z; + + for aabb in boxes { + dir = self.get_direction(aabb, from, &mut t, dir, x, y, z); + } + if dir.is_none() { + return None; + } + let t = t[0]; + Some(BlockHitResult { + location: from.add(t * x, t * y, t * z), + direction: dir.unwrap(), + block_pos: *pos, + inside: false, + miss: false, + }) + } + + fn get_direction( + &self, + aabb: &AABB, + from: &Vec3, + t: &mut [f64], + dir: Option, + x: f64, + y: f64, + z: f64, + ) -> Option { + if x > EPSILON { + return self.clip_point( + t, + dir, + x, + y, + z, + aabb.min_x, + aabb.min_y, + aabb.max_y, + aabb.min_z, + aabb.max_z, + Direction::West, + from.x, + from.y, + from.z, + ); + } else if x < -EPSILON { + return self.clip_point( + t, + dir, + x, + y, + z, + aabb.max_x, + aabb.min_y, + aabb.max_y, + aabb.min_z, + aabb.max_z, + Direction::East, + from.x, + from.y, + from.z, + ); + } + + if y > EPSILON { + return self.clip_point( + t, + dir, + y, + z, + x, + aabb.min_y, + aabb.min_z, + aabb.max_z, + aabb.min_x, + aabb.max_x, + Direction::Down, + from.y, + from.z, + from.x, + ); + } else if y < -EPSILON { + return self.clip_point( + t, + dir, + y, + z, + x, + aabb.max_y, + aabb.min_z, + aabb.max_z, + aabb.min_x, + aabb.max_x, + Direction::Up, + from.y, + from.z, + from.x, + ); + } + + if z > EPSILON { + return self.clip_point( + t, + dir, + z, + x, + y, + aabb.min_z, + aabb.min_x, + aabb.max_x, + aabb.min_y, + aabb.max_y, + Direction::North, + from.z, + from.x, + from.y, + ); + } else if z < -EPSILON { + return self.clip_point( + t, + dir, + z, + x, + y, + aabb.max_z, + aabb.min_x, + aabb.max_x, + aabb.min_y, + aabb.max_y, + Direction::South, + from.z, + from.x, + from.y, + ); + } + + dir + } + + fn clip_point( + &self, + t: &mut [f64], + approach_dir: Option, + delta_x: f64, + delta_y: f64, + delta_z: f64, + begin: f64, + min_x: f64, + max_x: f64, + min_z: f64, + max_z: f64, + result_dir: Direction, + start_x: f64, + start_y: f64, + start_z: f64, + ) -> Option { + let mut t_x = (begin - start_x) / delta_x; + let mut t_y = (begin - start_y) / delta_y; + let mut t_z = (begin - start_z) / delta_z; + if 0.0 < t_x + && t_x < t[0] + && min_x - EPSILON < t_y + && t_y < max_x + EPSILON + && max_x - EPSILON < t_z + && t_z < max_z + EPSILON + { + t[0] = t_x; + Some(result_dir) + } else { + approach_dir + } + } + + pub fn has_nan(&self) -> bool { + self.min_x.is_nan() + || self.min_y.is_nan() + || self.min_z.is_nan() + || self.max_x.is_nan() + || self.max_y.is_nan() + || self.max_z.is_nan() + } + + pub fn get_center(&self) -> Vec3 { + Vec3 { + x: (self.min_x + self.max_x) / 2.0, + y: (self.min_y + self.max_y) / 2.0, + z: (self.min_z + self.max_z) / 2.0, + } + } + + pub fn of_size(center: Vec3, dx: f64, dy: f64, dz: f64) -> AABB { + AABB { + min_x: center.x - dx / 2.0, + min_y: center.y - dy / 2.0, + min_z: center.z - dz / 2.0, + max_x: center.x + dx / 2.0, + max_y: center.y + dy / 2.0, + max_z: center.z + dz / 2.0, + } + } +} diff --git a/azalea-entity/src/physics/block_hit_result.rs b/azalea-entity/src/physics/block_hit_result.rs new file mode 100644 index 00000000..8321f43a --- /dev/null +++ b/azalea-entity/src/physics/block_hit_result.rs @@ -0,0 +1,9 @@ +use azalea_core::{BlockPos, Direction, Vec3}; + +pub struct BlockHitResult { + pub location: Vec3, + pub direction: Direction, + pub block_pos: BlockPos, + pub miss: bool, + pub inside: bool, +} diff --git a/azalea-entity/src/physics/mod.rs b/azalea-entity/src/physics/mod.rs index 473adbae..01c497cd 100644 --- a/azalea-entity/src/physics/mod.rs +++ b/azalea-entity/src/physics/mod.rs @@ -1,5 +1,10 @@ +mod aabb; +mod block_hit_result; + use crate::Entity; +pub use aabb::AABB; use azalea_core::PositionDelta; +pub use block_hit_result::BlockHitResult; pub enum MoverType { Own, @@ -10,5 +15,24 @@ pub enum MoverType { } impl Entity { - pub fn move_entity(&mut self, mover_type: &MoverType, movement: &PositionDelta) {} + pub fn move_entity(&mut self, mover_type: &MoverType, movement: &PositionDelta) { + // if self.no_physics { + // return; + // }; + + // if (var1 == MoverType.PISTON) { + // var2 = this.limitPistonMovement(var2); + // if (var2.equals(Vec3.ZERO)) { + // return; + // } + // } + + // if (this.stuckSpeedMultiplier.lengthSqr() > 1.0E-7D) { + // var2 = var2.multiply(this.stuckSpeedMultiplier); + // this.stuckSpeedMultiplier = Vec3.ZERO; + // this.setDeltaMovement(Vec3.ZERO); + // } + + // TODO + } } diff --git a/azalea-protocol/src/packets/game/clientbound_add_entity_packet.rs b/azalea-protocol/src/packets/game/clientbound_add_entity_packet.rs index 0fc7b817..9563d0f4 100644 --- a/azalea-protocol/src/packets/game/clientbound_add_entity_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_add_entity_packet.rs @@ -1,5 +1,5 @@ use azalea_buf::McBuf; -use azalea_core::EntityPos; +use azalea_core::Vec3; use azalea_entity::Entity; use packet_macros::GamePacket; use uuid::Uuid; @@ -31,7 +31,7 @@ impl From<&ClientboundAddEntityPacket> for Entity { Self::new( p.id, p.uuid, - EntityPos { + Vec3 { x: p.x, y: p.y, z: p.z, diff --git a/azalea-protocol/src/packets/game/clientbound_add_player_packet.rs b/azalea-protocol/src/packets/game/clientbound_add_player_packet.rs index ddadc73f..55206ac6 100644 --- a/azalea-protocol/src/packets/game/clientbound_add_player_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_add_player_packet.rs @@ -1,5 +1,5 @@ use azalea_buf::McBuf; -use azalea_core::EntityPos; +use azalea_core::Vec3; use azalea_entity::Entity; use packet_macros::GamePacket; use uuid::Uuid; @@ -22,7 +22,7 @@ impl From<&ClientboundAddPlayerPacket> for Entity { Self::new( p.id, p.uuid, - EntityPos { + Vec3 { x: p.x, y: p.y, z: p.z, diff --git a/azalea-protocol/src/packets/game/clientbound_move_entity_pos_packet.rs b/azalea-protocol/src/packets/game/clientbound_move_entity_pos_packet.rs index cd3e3148..e57afb3b 100644 --- a/azalea-protocol/src/packets/game/clientbound_move_entity_pos_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_move_entity_pos_packet.rs @@ -3,7 +3,7 @@ use azalea_core::PositionDelta8; use packet_macros::GamePacket; #[derive(Clone, Debug, McBuf, GamePacket)] -pub struct ClientboundMoveEntityPosPacket { +pub struct ClientboundMoveVec3Packet { #[var] pub entity_id: u32, pub delta: PositionDelta8, diff --git a/azalea-protocol/src/packets/game/clientbound_move_entity_posrot_packet.rs b/azalea-protocol/src/packets/game/clientbound_move_entity_posrot_packet.rs index e3422ac0..365f2b82 100644 --- a/azalea-protocol/src/packets/game/clientbound_move_entity_posrot_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_move_entity_posrot_packet.rs @@ -4,7 +4,7 @@ use packet_macros::GamePacket; /// This packet is sent by the server when an entity moves less then 8 blocks. #[derive(Clone, Debug, McBuf, GamePacket)] -pub struct ClientboundMoveEntityPosRotPacket { +pub struct ClientboundMoveVec3RotPacket { #[var] pub entity_id: u32, pub delta: PositionDelta8, diff --git a/azalea-protocol/src/packets/game/mod.rs b/azalea-protocol/src/packets/game/mod.rs index f407a697..acf94b3d 100755 --- a/azalea-protocol/src/packets/game/mod.rs +++ b/azalea-protocol/src/packets/game/mod.rs @@ -96,8 +96,8 @@ declare_state_packets!( 0x21: clientbound_level_particles_packet::ClientboundLevelParticlesPacket, 0x22: clientbound_light_update_packet::ClientboundLightUpdatePacket, 0x23: clientbound_login_packet::ClientboundLoginPacket, - 0x26: clientbound_move_entity_pos_packet::ClientboundMoveEntityPosPacket, - 0x27: clientbound_move_entity_posrot_packet::ClientboundMoveEntityPosRotPacket, + 0x26: clientbound_move_entity_pos_packet::ClientboundMoveVec3Packet, + 0x27: clientbound_move_entity_posrot_packet::ClientboundMoveVec3RotPacket, 0x28: clientbound_move_entity_rot_packet::ClientboundMoveEntityRotPacket, 0x2f: clientbound_player_abilities_packet::ClientboundPlayerAbilitiesPacket, 0x30: clientbound_player_chat_packet::ClientboundPlayerChatPacket, diff --git a/azalea-world/src/lib.rs b/azalea-world/src/lib.rs index 7822dcc4..5c5d316e 100644 --- a/azalea-world/src/lib.rs +++ b/azalea-world/src/lib.rs @@ -6,7 +6,7 @@ mod entity; mod palette; use azalea_block::BlockState; -use azalea_core::{BlockPos, ChunkPos, EntityPos, PositionDelta8}; +use azalea_core::{BlockPos, ChunkPos, PositionDelta8, Vec3}; use azalea_entity::Entity; pub use bit_storage::BitStorage; pub use chunk::{Chunk, ChunkStorage}; @@ -58,7 +58,7 @@ impl Dimension { self.chunk_storage.get_block_state(pos, self.min_y()) } - pub fn move_entity(&mut self, entity_id: u32, new_pos: EntityPos) -> Result<(), String> { + pub fn move_entity(&mut self, entity_id: u32, new_pos: Vec3) -> Result<(), String> { let entity = self .entity_storage .get_mut_by_id(entity_id)