diff options
Diffstat (limited to 'azalea-client/src/plugins')
| -rw-r--r-- | azalea-client/src/plugins/interact/mod.rs (renamed from azalea-client/src/plugins/interact.rs) | 208 | ||||
| -rw-r--r-- | azalea-client/src/plugins/interact/pick.rs | 268 | ||||
| -rw-r--r-- | azalea-client/src/plugins/mining.rs | 8 | ||||
| -rw-r--r-- | azalea-client/src/plugins/packet/game/mod.rs | 6 |
4 files changed, 351 insertions, 139 deletions
diff --git a/azalea-client/src/plugins/interact.rs b/azalea-client/src/plugins/interact/mod.rs index da1fa78e..079b57f6 100644 --- a/azalea-client/src/plugins/interact.rs +++ b/azalea-client/src/plugins/interact/mod.rs @@ -1,3 +1,5 @@ +pub mod pick; + use std::collections::HashMap; use azalea_block::BlockState; @@ -9,27 +11,30 @@ use azalea_core::{ tick::GameTick, }; use azalea_entity::{ - Attributes, EyeHeight, LocalEntity, LookDirection, Position, clamp_look_direction, view_vector, + Attributes, LocalEntity, LookDirection, + attributes::{ + creative_block_interaction_range_modifier, creative_entity_interaction_range_modifier, + }, + clamp_look_direction, }; use azalea_inventory::{ItemStack, ItemStackData, components}; -use azalea_physics::{ - PhysicsSet, - clip::{BlockShapeType, ClipContext, FluidPickType}, -}; +use azalea_physics::PhysicsSet; use azalea_protocol::packets::game::{ - ServerboundUseItem, s_interact::InteractionHand, s_swing::ServerboundSwing, + ServerboundInteract, ServerboundUseItem, + s_interact::{self, InteractionHand}, + s_swing::ServerboundSwing, s_use_item_on::ServerboundUseItemOn, }; -use azalea_world::{Instance, InstanceContainer, InstanceName}; +use azalea_world::{Instance, MinecraftEntityId}; use bevy_app::{App, Plugin, Update}; use bevy_ecs::prelude::*; -use derive_more::{Deref, DerefMut}; use tracing::warn; use super::mining::Mining; use crate::{ Client, attack::handle_attack_event, + interact::pick::{HitResultComponent, update_hit_result_component}, inventory::{Inventory, InventorySet}, local_player::{LocalGameMode, PermissionLevel, PlayerAbilities}, movement::MoveEventsSet, @@ -47,24 +52,29 @@ impl Plugin for InteractPlugin { Update, ( ( - handle_start_use_item_event, - update_hit_result_component.after(clamp_look_direction), - handle_swing_arm_event, + update_attributes_for_held_item, + update_attributes_for_gamemode, ) - .after(InventorySet) - .after(perform_respawn) - .after(handle_attack_event) + .in_set(UpdateAttributesSet) .chain(), - update_modifiers_for_held_item - .after(InventorySet) - .after(MoveEventsSet), - ), + handle_start_use_item_event, + update_hit_result_component.after(clamp_look_direction), + handle_swing_arm_event, + ) + .after(InventorySet) + .after(MoveEventsSet) + .after(perform_respawn) + .after(handle_attack_event) + .chain(), ) .add_systems(GameTick, handle_start_use_item_queued.before(PhysicsSet)) .add_observer(handle_swing_arm_trigger); } } +#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)] +pub struct UpdateAttributesSet; + impl Client { /// Right-click a block. /// @@ -190,12 +200,6 @@ impl BlockStatePredictionHandler { } } -/// A component that contains the block or entity that the player is currently -/// looking at. -#[doc(alias("looking at", "looking at block", "crosshair"))] -#[derive(Component, Clone, Debug, Deref, DerefMut)] -pub struct HitResultComponent(HitResult); - /// An event that makes one of our clients simulate a right-click. /// /// This event just inserts the [`StartUseItemQueued`] component on the given @@ -248,6 +252,7 @@ pub fn handle_start_use_item_queued( &LookDirection, Option<&Mining>, )>, + entity_id_query: Query<&MinecraftEntityId>, ) { for (entity, start_use_item, mut prediction_handler, hit_result, look_direction, mining) in query @@ -261,7 +266,7 @@ pub fn handle_start_use_item_queued( // TODO: this also skips if LocalPlayer.handsBusy is true, which is used when // rowing a boat - let mut hit_result = hit_result.0.clone(); + let mut hit_result = (**hit_result).clone(); if let Some(force_block) = start_use_item.force_block { let hit_result_matches = if let HitResult::Block(block_hit_result) = &hit_result { @@ -284,9 +289,9 @@ pub fn handle_start_use_item_queued( } match &hit_result { - HitResult::Block(block_hit_result) => { + HitResult::Block(r) => { let seq = prediction_handler.start_predicting(); - if block_hit_result.miss { + if r.miss { commands.trigger(SendPacketEvent::new( entity, ServerboundUseItem { @@ -301,124 +306,41 @@ pub fn handle_start_use_item_queued( entity, ServerboundUseItemOn { hand: start_use_item.hand, - block_hit: block_hit_result.into(), + block_hit: r.into(), seq, }, )); // TODO: depending on the result of useItemOn, this might // also need to send a SwingArmEvent. - // basically, this TODO is for - // simulating block interactions/placements on the - // client-side. + // basically, this TODO is for simulating block + // interactions/placements on the client-side. } } - HitResult::Entity => { - // TODO: implement HitResult::Entity - + HitResult::Entity(r) => { // TODO: worldborder check - // commands.trigger(SendPacketEvent::new( - // entity, - // ServerboundInteract { - // entity_id: todo!(), - // action: todo!(), - // using_secondary_action: todo!(), - // }, - // )); + let Ok(entity_id) = entity_id_query.get(r.entity).copied() else { + warn!("tried to interact with an entity that doesn't have MinecraftEntityId"); + continue; + }; + + commands.trigger(SendPacketEvent::new( + entity, + ServerboundInteract { + entity_id, + action: s_interact::ActionType::InteractAt { + location: r.location, + hand: InteractionHand::MainHand, + }, + // TODO: sneaking + using_secondary_action: false, + }, + )); } } } } -#[allow(clippy::type_complexity)] -pub fn update_hit_result_component( - mut commands: Commands, - mut query: Query<( - Entity, - Option<&mut HitResultComponent>, - &LocalGameMode, - &Position, - &EyeHeight, - &LookDirection, - &InstanceName, - )>, - instance_container: Res<InstanceContainer>, -) { - for (entity, hit_result_ref, game_mode, position, eye_height, look_direction, world_name) in - &mut query - { - let pick_range = if game_mode.current == GameMode::Creative { - 6. - } else { - 4.5 - }; - let eye_position = Vec3 { - x: position.x, - y: position.y + **eye_height as f64, - z: position.z, - }; - - let Some(instance_lock) = instance_container.get(world_name) else { - continue; - }; - let instance = instance_lock.read(); - - 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 { - commands - .entity(entity) - .insert(HitResultComponent(hit_result)); - } - } -} - -/// Get the block or entity that a player would be looking at if their eyes were -/// at the given direction and position. -/// -/// If you need to get the block/entity the player is looking at right now, use -/// [`HitResultComponent`]. -/// -/// Also see [`pick_block`]. -/// -/// TODO: does not currently check for entities -pub fn pick( - look_direction: LookDirection, - eye_position: Vec3, - chunks: &azalea_world::ChunkStorage, - pick_range: f64, -) -> HitResult { - // TODO - // let entity_hit_result = ; - - HitResult::Block(pick_block(look_direction, eye_position, chunks, pick_range)) -} - -/// Get the block that a player would be looking at if their eyes were at the -/// given direction and position. -/// -/// Also see [`pick`]. -pub fn pick_block( - 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); - - azalea_physics::clip::clip( - chunks, - ClipContext { - from: eye_position, - to: end_position, - block_shape_type: BlockShapeType::Outline, - fluid_pick_type: FluidPickType::None, - }, - ) -} - /// Whether we can't interact with the block, based on your gamemode. If /// this is false, then we can interact with the block. /// @@ -504,7 +426,7 @@ pub fn handle_swing_arm_event(mut events: EventReader<SwingArmEvent>, mut comman } #[allow(clippy::type_complexity)] -fn update_modifiers_for_held_item( +fn update_attributes_for_held_item( mut query: Query<(&mut Attributes, &Inventory), (With<LocalEntity>, Changed<Inventory>)>, ) { for (mut attributes, inventory) in &mut query { @@ -558,3 +480,25 @@ fn update_modifiers_for_held_item( )); } } + +fn update_attributes_for_gamemode( + query: Query<(&mut Attributes, &LocalGameMode), (With<LocalEntity>, Changed<LocalGameMode>)>, +) { + for (mut attributes, game_mode) in query { + if game_mode.current == GameMode::Creative { + attributes + .block_interaction_range + .insert(creative_block_interaction_range_modifier()); + attributes + .entity_interaction_range + .insert(creative_entity_interaction_range_modifier()); + } else { + attributes + .block_interaction_range + .remove(&creative_block_interaction_range_modifier().id); + attributes + .entity_interaction_range + .remove(&creative_entity_interaction_range_modifier().id); + } + } +} diff --git a/azalea-client/src/plugins/interact/pick.rs b/azalea-client/src/plugins/interact/pick.rs new file mode 100644 index 00000000..5b62762c --- /dev/null +++ b/azalea-client/src/plugins/interact/pick.rs @@ -0,0 +1,268 @@ +use azalea_core::{ + aabb::AABB, + direction::Direction, + hit_result::{BlockHitResult, EntityHitResult, HitResult}, + position::Vec3, +}; +use azalea_entity::{ + Attributes, Dead, EyeHeight, LocalEntity, LookDirection, Physics, Position, + metadata::{ArmorStandMarker, Marker}, + view_vector, +}; +use azalea_physics::{ + clip::{BlockShapeType, ClipContext, FluidPickType}, + collision::entity_collisions::{PhysicsQuery, get_entities}, +}; +use azalea_world::{Instance, InstanceContainer, InstanceName}; +use bevy_ecs::prelude::*; +use derive_more::{Deref, DerefMut}; + +/// A component that contains the block or entity that the player is currently +/// looking at. +#[doc(alias("looking at", "looking at block", "crosshair"))] +#[derive(Component, Clone, Debug, Deref, DerefMut)] +pub struct HitResultComponent(HitResult); + +#[allow(clippy::type_complexity)] +pub fn update_hit_result_component( + mut commands: Commands, + mut query: Query< + ( + Entity, + Option<&mut HitResultComponent>, + &Position, + &EyeHeight, + &LookDirection, + &InstanceName, + &Physics, + &Attributes, + ), + With<LocalEntity>, + >, + instance_container: Res<InstanceContainer>, + physics_query: PhysicsQuery, + pickable_query: PickableEntityQuery, +) { + for ( + entity, + hit_result_ref, + position, + eye_height, + look_direction, + world_name, + physics, + attributes, + ) in &mut query + { + let block_pick_range = attributes.block_interaction_range.calculate(); + let entity_pick_range = attributes.entity_interaction_range.calculate(); + + let eye_position = position.up(eye_height.into()); + + let Some(world_lock) = instance_container.get(world_name) else { + continue; + }; + let world = world_lock.read(); + + let aabb = &physics.bounding_box; + let hit_result = pick( + entity, + *look_direction, + eye_position, + aabb, + &world, + entity_pick_range, + block_pick_range, + &physics_query, + &pickable_query, + ); + if let Some(mut hit_result_ref) = hit_result_ref { + **hit_result_ref = hit_result; + } else { + commands + .entity(entity) + .insert(HitResultComponent(hit_result)); + } + } +} + +pub type PickableEntityQuery<'world, 'state, 'a> = Query< + 'world, + 'state, + Option<&'a ArmorStandMarker>, + (Without<Dead>, Without<Marker>, Without<LocalEntity>), +>; + +/// Get the block or entity that a player would be looking at if their eyes were +/// at the given direction and position. +/// +/// If you need to get the block/entity the player is looking at right now, use +/// [`HitResultComponent`]. +/// +/// Also see [`pick_block`]. +/// +/// TODO: does not currently check for entities +pub fn pick( + source_entity: Entity, + look_direction: LookDirection, + eye_position: Vec3, + aabb: &AABB, + world: &Instance, + entity_pick_range: f64, + block_pick_range: f64, + physics_query: &PhysicsQuery, + pickable_query: &PickableEntityQuery, +) -> HitResult { + // vanilla does extra math here to calculate the pick result in between ticks by + // interpolating, but since clients can still only interact on exact ticks, that + // isn't relevant for us. + + let mut max_range = entity_pick_range.max(block_pick_range); + let mut max_range_squared = max_range.powi(2); + + let block_hit_result = pick_block(look_direction, eye_position, &world.chunks, max_range); + let block_hit_result_dist_squared = block_hit_result.location.distance_squared_to(eye_position); + if !block_hit_result.miss { + max_range_squared = block_hit_result_dist_squared; + max_range = block_hit_result_dist_squared.sqrt(); + } + + let view_vector = view_vector(look_direction); + let end_position = eye_position + (view_vector * max_range); + let inflate_by = 1.; + let pick_aabb = aabb + .expand_towards(view_vector * max_range) + .inflate_all(inflate_by); + + let is_pickable = |entity: Entity| { + // TODO: ender dragon and projectiles have extra logic here. also, we shouldn't + // be able to pick spectators. + if let Ok(armor_stand_marker) = pickable_query.get(entity) { + if let Some(armor_stand_marker) = armor_stand_marker + && armor_stand_marker.0 + { + false + } else { + true + } + } else { + true + } + }; + let entity_hit_result = pick_entity( + source_entity, + eye_position, + end_position, + world, + max_range_squared, + &is_pickable, + &pick_aabb, + physics_query, + ); + + // TODO + if let Some(entity_hit_result) = entity_hit_result + && entity_hit_result.location.distance_squared_to(eye_position) + < block_hit_result_dist_squared + { + filter_hit_result( + HitResult::Entity(entity_hit_result), + eye_position, + entity_pick_range, + ) + } else { + filter_hit_result( + HitResult::Block(block_hit_result), + eye_position, + block_pick_range, + ) + } +} + +fn filter_hit_result(hit_result: HitResult, eye_position: Vec3, range: f64) -> HitResult { + let location = hit_result.location(); + if !location.closer_than(eye_position, range) { + let direction = Direction::nearest(location - eye_position); + HitResult::new_miss(location, direction, location.into()) + } else { + hit_result + } +} + +/// Get the block that a player would be looking at if their eyes were at the +/// given direction and position. +/// +/// Also see [`pick`]. +pub fn pick_block( + 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); + + azalea_physics::clip::clip( + chunks, + ClipContext { + from: eye_position, + to: end_position, + block_shape_type: BlockShapeType::Outline, + fluid_pick_type: FluidPickType::None, + }, + ) +} + +// port of getEntityHitResult +fn pick_entity( + source_entity: Entity, + eye_position: Vec3, + end_position: Vec3, + world: &azalea_world::Instance, + pick_range_squared: f64, + predicate: &dyn Fn(Entity) -> bool, + aabb: &AABB, + physics_query: &PhysicsQuery, +) -> Option<EntityHitResult> { + let mut picked_distance_squared = pick_range_squared; + let mut result = None; + + for (candidate, candidate_aabb) in + get_entities(world, Some(source_entity), aabb, predicate, physics_query) + { + // TODO: if the entity is "REDIRECTABLE_PROJECTILE" then this should be 1.0. + // azalea needs support for entity tags first for this to be possible. see + // getPickRadius in decompiled minecraft source + let candidate_pick_radius = 0.; + let candidate_aabb = candidate_aabb.inflate_all(candidate_pick_radius); + let clip_location = candidate_aabb.clip(eye_position, end_position); + + if candidate_aabb.contains(eye_position) { + if picked_distance_squared >= 0. { + result = Some(EntityHitResult { + location: clip_location.unwrap_or(eye_position), + entity: candidate, + }); + picked_distance_squared = 0.; + } + } else if let Some(clip_location) = clip_location { + let distance_squared = eye_position.distance_squared_to(clip_location); + if distance_squared < picked_distance_squared || picked_distance_squared == 0. { + // TODO: don't pick the entity we're riding on + // if candidate_root_vehicle == entity_root_vehicle { + // if picked_distance_squared == 0. { + // picked_entity = Some(candidate); + // picked_location = Some(clip_location); + // } + // } else { + result = Some(EntityHitResult { + location: clip_location, + entity: candidate, + }); + picked_distance_squared = distance_squared; + } + } + } + + result +} diff --git a/azalea-client/src/plugins/mining.rs b/azalea-client/src/plugins/mining.rs index 88bd3be8..541633df 100644 --- a/azalea-client/src/plugins/mining.rs +++ b/azalea-client/src/plugins/mining.rs @@ -13,8 +13,8 @@ use tracing::trace; use crate::{ Client, interact::{ - BlockStatePredictionHandler, HitResultComponent, SwingArmEvent, can_use_game_master_blocks, - check_is_interaction_restricted, + BlockStatePredictionHandler, SwingArmEvent, can_use_game_master_blocks, + check_is_interaction_restricted, pick::HitResultComponent, }, inventory::{Inventory, InventorySet}, local_player::{InstanceHolder, LocalGameMode, PermissionLevel, PlayerAbilities}, @@ -57,7 +57,7 @@ impl Plugin for MiningPlugin { .after(MoveEventsSet) .before(azalea_entity::update_bounding_box) .after(azalea_entity::update_fluid_on_eyes) - .after(crate::interact::update_hit_result_component) + .after(crate::interact::pick::update_hit_result_component) .after(crate::attack::handle_attack_event) .after(crate::interact::handle_start_use_item_queued) .before(crate::interact::handle_swing_arm_event), @@ -143,7 +143,7 @@ fn handle_auto_mine( entity, position: block_pos, }); - } else if mining.is_some() && hit_result_component.is_miss() { + } else if mining.is_some() && hit_result_component.miss() { stop_mining_block_event.write(StopMiningBlockEvent { entity }); } } diff --git a/azalea-client/src/plugins/packet/game/mod.rs b/azalea-client/src/plugins/packet/game/mod.rs index e1477d21..de226e49 100644 --- a/azalea-client/src/plugins/packet/game/mod.rs +++ b/azalea-client/src/plugins/packet/game/mod.rs @@ -7,8 +7,8 @@ use azalea_core::{ position::{ChunkPos, Vec3}, }; use azalea_entity::{ - Dead, EntityBundle, EntityKind, LastSentPosition, LoadedBy, LocalEntity, LookDirection, - Physics, Position, RelativeEntityUpdate, + Dead, EntityBundle, EntityKindComponent, LastSentPosition, LoadedBy, LocalEntity, + LookDirection, Physics, Position, RelativeEntityUpdate, indexing::{EntityIdIndex, EntityUuidIndex}, metadata::{Health, apply_metadata}, }; @@ -665,7 +665,7 @@ impl GamePacketHandler<'_> { Query<(&EntityIdIndex, &InstanceHolder)>, // this is a separate query since it's applied on the entity id that's being updated // instead of the player that received the packet - Query<&EntityKind>, + Query<&EntityKindComponent>, )>(self.ecs, |(mut commands, query, entity_kind_query)| { let (entity_id_index, instance_holder) = query.get(self.player).unwrap(); |