implement EntityHitResult

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