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

fix sometimes being able to mine blocks through walls

Browse source
This commit is contained in:
mat 2024-08-11 22:10:18 +00:00
parent 0c4d550303
commit 4effd77135
6 changed files with 165 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
azalea-client/src/mining.rs
View file

@ -396,16 +396,16 @@ impl MineProgress {
/// A component that stores the number of ticks that we've been mining the same
/// block for. This is a float even though it should only ever be a round
/// number.
#[derive(Component, Debug, Default, Deref, DerefMut)]
#[derive(Component, Clone, Debug, Default, Deref, DerefMut)]
pub struct MineTicks(pub f32);
/// A component that stores the position of the block we're currently mining.
#[derive(Component, Debug, Default, Deref, DerefMut)]
#[derive(Component, Clone, Debug, Default, Deref, DerefMut)]
pub struct MineBlockPos(pub Option<BlockPos>);
/// A component that contains the item we're currently using to mine. If we're
/// not mining anything, it'll be [`ItemSlot::Empty`].
#[derive(Component, Debug, Default, Deref, DerefMut)]
#[derive(Component, Clone, Debug, Default, Deref, DerefMut)]
pub struct MineItem(pub ItemSlot);
/// Sent when we completed mining a block.

6
azalea-core/src/math.rs
View file

@ -62,6 +62,12 @@ pub fn ceil_log2(x: u32) -> u32 {
u32::BITS - x.leading_zeros()
}
pub fn fract(x: f64) -> f64 {
let x_int = x as i64 as f64;
let floor = if x < x_int { x_int - 1. } else { x_int };
x - floor
}
#[cfg(test)]
mod tests {
use super::*;

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

@ -2,7 +2,7 @@ use azalea_block::BlockState;
use azalea_core::{
block_hit_result::BlockHitResult,
direction::Direction,
math::{lerp, EPSILON},
math::{self, lerp, EPSILON},
position::{BlockPos, Vec3},
};
use azalea_inventory::ItemSlot;
@ -92,13 +92,12 @@ fn clip_with_interaction_override(
block_state: &BlockState,
) -> Option<BlockHitResult> {
let block_hit_result = block_shape.clip(from, to, block_pos);
println!("block_hit_result: {block_hit_result:?}");
if let Some(block_hit_result) = block_hit_result {
// TODO: minecraft calls .getInteractionShape here
// are there even any blocks that have a physics shape different from the
// interaction shape???
// (if not then you can delete this comment)
// (if there are then you have to implement BlockState::interaction_shape, lol
// have fun)
// some blocks (like tall grass) have a physics shape that's different from the
// interaction shape, so we need to implement BlockState::interaction_shape. lol
// have fun
let interaction_shape = block_state.shape();
let interaction_hit_result = interaction_shape.clip(from, to, block_pos);
if let Some(interaction_hit_result) = interaction_hit_result {
@ -172,24 +171,27 @@ pub fn traverse_blocks<C, T>(
let mut percentage = Vec3 {
x: percentage_step.x
* if vec_sign.x > 0. {
1. - right_before_start.x.fract().abs()
1. - math::fract(right_before_start.x)
} else {
right_before_start.x.fract().abs()
math::fract(right_before_start.x)
},
y: percentage_step.y
* if vec_sign.y > 0. {
1. - right_before_start.y.fract().abs()
1. - math::fract(right_before_start.y)
} else {
right_before_start.y.fract().abs()
math::fract(right_before_start.y)
},
z: percentage_step.z
* if vec_sign.z > 0. {
1. - right_before_start.z.fract().abs()
1. - math::fract(right_before_start.z)
} else {
right_before_start.z.fract().abs()
math::fract(right_before_start.z)
},
};
println!("percentage_step: {percentage_step:?}");
println!("percentage: {percentage:?}");
loop {
if percentage.x > 1. && percentage.y > 1. && percentage.z > 1. {
return get_miss_result(&context);

132
azalea/src/pathfinder/extras/utils.rs
View file

@ -4,52 +4,6 @@ use azalea_core::position::{BlockPos, Vec3};
use azalea_entity::direction_looking_at;
use azalea_world::ChunkStorage;
/// Return the block that we'd be looking at if we were at a given position and
/// looking at a given block.
///
/// This is useful for telling if we'd be able to reach a block from a certain
/// position, like for the pathfinder's [`ReachBlockPosGoal`].
///
/// Also see [`get_hit_result_while_looking_at_with_eye_position`].
///
/// [`ReachBlockPosGoal`]: crate::pathfinder::goals::ReachBlockPosGoal
pub fn get_hit_result_while_looking_at(
chunk_storage: &ChunkStorage,
player_position: BlockPos,
look_target: BlockPos,
) -> BlockPos {
let eye_position = Vec3 {
x: player_position.x as f64 + 0.5,
y: player_position.y as f64 + 1.53,
z: player_position.z as f64 + 0.5,
};
get_hit_result_while_looking_at_with_eye_position(chunk_storage, eye_position, look_target)
}
pub fn can_reach_block(
chunk_storage: &ChunkStorage,
player_position: BlockPos,
look_target: BlockPos,
) -> bool {
let hit_result = get_hit_result_while_looking_at(chunk_storage, player_position, look_target);
hit_result == look_target
}
/// Return the block that we'd be looking at if our eyes are at a given position
/// and looking at a given block.
///
/// This is called by [`get_hit_result_while_looking_at`].
pub fn get_hit_result_while_looking_at_with_eye_position(
chunk_storage: &azalea_world::ChunkStorage,
eye_position: Vec3,
look_target: BlockPos,
) -> BlockPos {
let look_direction = direction_looking_at(&eye_position, &look_target.center());
let block_hit_result =
azalea_client::interact::pick(&look_direction, &eye_position, chunk_storage, 4.5);
block_hit_result.block_pos
}
/// Get a vec of block positions that we can reach from this position.
pub fn get_reachable_blocks_around_player(
player_position: BlockPos,
@ -111,3 +65,89 @@ pub fn pick_closest_block(position: BlockPos, blocks: &[BlockPos]) -> Option<Blo
closest_block_pos
}
/// Return the block that we'd be looking at if we were at a given position and
/// looking at a given block.
///
/// This is useful for telling if we'd be able to reach a block from a certain
/// position, like for the pathfinder's [`ReachBlockPosGoal`].
///
/// Also see [`get_hit_result_while_looking_at_with_eye_position`].
///
/// [`ReachBlockPosGoal`]: crate::pathfinder::goals::ReachBlockPosGoal
pub fn get_hit_result_while_looking_at(
chunk_storage: &ChunkStorage,
player_position: BlockPos,
look_target: BlockPos,
) -> BlockPos {
let eye_position = Vec3 {
x: player_position.x as f64 + 0.5,
y: player_position.y as f64 + 1.53,
z: player_position.z as f64 + 0.5,
};
get_hit_result_while_looking_at_with_eye_position(chunk_storage, eye_position, look_target)
}
pub fn can_reach_block(
chunk_storage: &ChunkStorage,
player_position: BlockPos,
look_target: BlockPos,
) -> bool {
let hit_result = get_hit_result_while_looking_at(chunk_storage, player_position, look_target);
hit_result == look_target
}
/// Return the block that we'd be looking at if our eyes are at a given position
/// and looking at a given block.
///
/// This is called by [`get_hit_result_while_looking_at`].
pub fn get_hit_result_while_looking_at_with_eye_position(
chunk_storage: &azalea_world::ChunkStorage,
eye_position: Vec3,
look_target: BlockPos,
) -> BlockPos {
let look_direction = direction_looking_at(&eye_position, &look_target.center());
let block_hit_result =
azalea_client::interact::pick(&look_direction, &eye_position, chunk_storage, 4.5);
block_hit_result.block_pos
}
#[cfg(test)]
mod tests {
use azalea_core::position::ChunkPos;
use azalea_world::{Chunk, PartialInstance};
use super::*;
#[test]
fn test_cannot_reach_block_through_wall_when_y_is_negative() {
let mut partial_world = PartialInstance::default();
let mut world = ChunkStorage::default();
partial_world
.chunks
.set(&ChunkPos { x: 0, z: 0 }, Some(Chunk::default()), &mut world);
let set_solid_block_at = |x, y, z| {
partial_world.chunks.set_block_state(
&BlockPos::new(x, y, z),
azalea_registry::Block::Stone.into(),
&world,
);
};
let y_offset = -8;
// walls
set_solid_block_at(1, y_offset, 0);
set_solid_block_at(1, y_offset + 1, 0);
set_solid_block_at(0, y_offset, 1);
set_solid_block_at(0, y_offset + 1, 1);
// target
set_solid_block_at(1, y_offset, 1);
let player_position = BlockPos::new(0, y_offset, 0);
let look_target = BlockPos::new(1, y_offset, 1);
assert!(!can_reach_block(&world, player_position, look_target));
}
}

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

@ -873,11 +873,33 @@ mod tests {
GotoEvent,
};
fn setup_simulation(
fn setup_blockposgoal_simulation(
partial_chunks: &mut PartialChunkStorage,
start_pos: BlockPos,
end_pos: BlockPos,
solid_blocks: Vec<BlockPos>,
) -> Simulation {
let mut simulation = setup_simulation_world(partial_chunks, start_pos, solid_blocks);
// you can uncomment this while debugging tests to get trace logs
// simulation.app.add_plugins(bevy_log::LogPlugin {
// level: bevy_log::Level::TRACE,
// filter: "".to_string(),
// });
simulation.app.world.send_event(GotoEvent {
entity: simulation.entity,
goal: Arc::new(BlockPosGoal(end_pos)),
successors_fn: moves::default_move,
allow_mining: false,
});
simulation
}
fn setup_simulation_world(
partial_chunks: &mut PartialChunkStorage,
start_pos: BlockPos,
solid_blocks: Vec<BlockPos>,
) -> Simulation {
let mut chunk_positions = HashSet::new();
for block_pos in &solid_blocks {
@ -896,43 +918,33 @@ mod tests {
start_pos.y as f64,
start_pos.z as f64 + 0.5,
));
let mut simulation = Simulation::new(chunks, player);
// you can uncomment this while debugging tests to get trace logs
// simulation.app.add_plugins(bevy_log::LogPlugin {
// level: bevy_log::Level::TRACE,
// filter: "".to_string(),
// });
simulation.app.world.send_event(GotoEvent {
entity: simulation.entity,
goal: Arc::new(BlockPosGoal(end_pos)),
successors_fn: moves::default_move,
allow_mining: false,
});
simulation
Simulation::new(chunks, player)
}
pub fn assert_simulation_reaches(simulation: &mut Simulation, ticks: usize, end_pos: BlockPos) {
// wait until the bot starts moving
wait_until_bot_starts_moving(simulation);
for _ in 0..ticks {
simulation.tick();
}
assert_eq!(BlockPos::from(simulation.position()), end_pos);
}
pub fn wait_until_bot_starts_moving(simulation: &mut Simulation) {
let start_pos = simulation.position();
let start_time = Instant::now();
while simulation.position() == start_pos
&& !simulation.is_mining()
&& start_time.elapsed() < Duration::from_millis(500)
{
simulation.tick();
std::thread::yield_now();
}
for _ in 0..ticks {
simulation.tick();
}
assert_eq!(BlockPos::from(simulation.position()), end_pos,);
}
#[test]
fn test_simple_forward() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 0),
BlockPos::new(0, 71, 1),
@ -944,7 +956,7 @@ mod tests {
#[test]
fn test_double_diagonal_with_walls() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 0),
BlockPos::new(2, 71, 2),
@ -962,7 +974,7 @@ mod tests {
#[test]
fn test_jump_with_sideways_momentum() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 3),
BlockPos::new(5, 76, 0),
@ -984,7 +996,7 @@ mod tests {
#[test]
fn test_parkour_2_block_gap() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 0),
BlockPos::new(0, 71, 3),
@ -996,7 +1008,7 @@ mod tests {
#[test]
fn test_descend_and_parkour_2_block_gap() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 0),
BlockPos::new(3, 67, 4),
@ -1015,7 +1027,7 @@ mod tests {
#[test]
fn test_small_descend_and_parkour_2_block_gap() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 0),
BlockPos::new(0, 70, 5),
@ -1032,7 +1044,7 @@ mod tests {
#[test]
fn test_quickly_descend() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 0),
BlockPos::new(0, 68, 3),
@ -1049,7 +1061,7 @@ mod tests {
#[test]
fn test_2_gap_ascend_thrice() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 0),
BlockPos::new(3, 74, 0),
@ -1066,7 +1078,7 @@ mod tests {
#[test]
fn test_consecutive_3_gap_parkour() {
let mut partial_chunks = PartialChunkStorage::default();
let mut simulation = setup_simulation(
let mut simulation = setup_blockposgoal_simulation(
&mut partial_chunks,
BlockPos::new(0, 71, 0),
BlockPos::new(4, 71, 12),

15
azalea/src/pathfinder/simulation.rs
View file

@ -145,8 +145,21 @@ impl Simulation {
self.app.update();
self.app.world.run_schedule(GameTick);
}
pub fn component<T: Component + Clone>(&self) -> T {
self.app.world.get::<T>(self.entity).unwrap().clone()
}
pub fn get_component<T: Component + Clone>(&self) -> Option<T> {
self.app.world.get::<T>(self.entity).cloned()
}
pub fn position(&self) -> Vec3 {
**self.app.world.get::<Position>(self.entity).unwrap()
*self.component::<Position>()
}
pub fn is_mining(&self) -> bool {
// return true if the component is present and Some
self.get_component::<azalea_client::mining::MineBlockPos>()
.map(|c| *c)
.flatten()
.is_some()
}
}