diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 2d8d9420b..09ff67b48 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -134,6 +134,7 @@ mod pandas; mod passengers; mod persist; mod perspective; +mod pick_entity; mod pickups; mod piglins; mod piston_push; @@ -11883,7 +11884,18 @@ impl Game<'_> { // Minecraft.pickBlockOrEntity -> the server's handlePickItemFromBlock: // the block's clone item, with its block entity's data on Ctrl in // creative, picked from the inventory (`pick_item`). - if let Some(hit) = self.pick() { + if let Some(entity) = self.pick_entity_hit() { + // handlePickItemFromEntity: the entity's pick result. + if let Some(stack) = entity.and_then(|id| self.entity_pick_result(id)) { + let infinite = self.creative; + horizon_client::pick_item::pick( + &mut self.inventory[..36], + &mut self.selected, + &stack, + infinite, + ); + } + } else if let Some(hit) = self.pick() { let include_data = self.creative && self.has_control_down(); if let Some(stack) = self.picked_stack(hit.pos, include_data) { let infinite = self.creative; diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs index 738399811..a6a683827 100644 --- a/crates/horizon-client/src/game/lan_actions.rs +++ b/crates/horizon-client/src/game/lan_actions.rs @@ -1434,19 +1434,68 @@ impl Game<'_> { .unwrap_or_default(); host.hub.send_stats(conn, &stats); } + // handlePickItemFromBlock: a block within the block reach plus 1, its + // data only with infinite materials. S::PickItemFromBlock(p) => { - let state = self.world.block(p.pos[0], p.pos[1], p.pos[2]); - let item = self.res.facts().get(state).item.clone(); - let g = &mut host.hub.guests[gi]; - if g.creative() && &*item != "minecraft:air" { - let slot = g.selected; - g.inventory[slot] = Some(ItemStack::new(&item, 1)); - } + self.guest_pick_item(host, conn, |g| { + let eye = g.eye_position()?; + let d2: f64 = (0..3) + .map(|a| { + let lo = f64::from(p.pos[a]); + (eye[a] - eye[a].clamp(lo, lo + 1.0)).powi(2) + }) + .sum(); + let range = g.reach() + 1.0; + if d2 >= range * range { + return None; + } + g.picked_stack(p.pos, g.creative && p.include_data) + }); + } + // handlePickItemFromEntity. + S::PickItemFromEntity(p) => { + self.guest_pick_item(host, conn, |g| { + g.within_entity_range(p.id) + .then(|| g.entity_pick_result(p.id)) + .flatten() + }); } _ => {} } } + /// `ServerGamePacketListenerImpl.tryPickItem` for the guest: a matching stack + /// is selected, else a creative player gets the item; the held slot is sent + /// back and the changed slots follow with the tick's inventory changes. + fn guest_pick_item( + &mut self, + host: &mut LanHost, + conn: u32, + stack: impl FnOnce(&mut Self) -> Option, + ) { + let picked = self.as_guest(host, conn, |g| { + let stack = stack(g)?; + let infinite = g.creative; + horizon_client::pick_item::pick( + &mut g.inventory[..36], + &mut g.selected, + &stack, + infinite, + ); + Some(()) + }); + if picked.flatten().is_some() + && let Some(g) = host.hub.guests.iter().find(|g| g.conn == conn) + { + host.hub.send_to( + conn, + &C::SetHeldSlot(play::SetHeldSlot { + slot: g.selected as i32, + }), + ); + } + } + fn item_from_network( &self, host: &LanHost, diff --git a/crates/horizon-client/src/game/pick_entity.rs b/crates/horizon-client/src/game/pick_entity.rs new file mode 100644 index 000000000..5efc54d44 --- /dev/null +++ b/crates/horizon-client/src/game/pick_entity.rs @@ -0,0 +1,98 @@ +//! Pick Block on an entity (`Minecraft.pickBlockOrEntity`'s entity case and +//! `ServerGamePacketListenerImpl.handlePickItemFromEntity`): the client aims, +//! the server answers with `Entity.getPickResult`. +use super::Game; +use horizon_client::items::ItemStack; + +impl Game<'_> { + /// The entity the crosshair hits before any block, as `Entity.getId`; an + /// entity with nothing to pick (a projectile, a player, the dragon) is + /// `Some(None)`. `None` when the view hits a block or nothing. + pub(super) fn pick_entity_hit(&self) -> Option> { + let mut best: Option<(f64, Option)> = None; + let mut offer = |distance: f64, id: Option| { + if self.before_block(distance) && best.is_none_or(|b| distance < b.0) { + best = Some((distance, id)); + } + }; + if let Some(hit) = self.remote_object_hit(true) { + offer(hit.distance, Some(hit.id)); + } + if let Some((i, d)) = self.mob_hit() { + offer(d, Some(self.mobs[i].id as i32)); + } + if let Some((_, d)) = self.guest_hit() { + offer(d, None); + } + if let Some((_, d)) = self.redirectable_hit() { + offer(d, None); + } + if let Some((_, d)) = self.dragon_hit() { + offer(d, None); + } + best.map(|b| b.1) + } + + /// `Entity.getPickResult` of the entity `id`: a mob's spawn egg, the item + /// of a boat, minecart, armor stand, cushion, painting, item frame (the + /// framed item when it holds one) or end crystal. + pub(super) fn entity_pick_result(&self, id: i32) -> Option { + let id = u32::try_from(id).ok()?; + let item = if let Some(m) = self.mobs.iter().find(|m| m.id == id) { + // Mob.getPickResult: SpawnEggItem.byId. + let egg = format!("{}_spawn_egg", m.kind.id); + return self.res.items().get(&egg).map(|_| ItemStack::new(&egg, 1)); + } else if let Some(b) = self.boats.iter().find(|b| b.id == id) { + b.entity_type() + } else if let Some(c) = self.carts.iter().find(|c| c.id == id) { + c.kind.id().to_owned() + } else if self.armor_stands.iter().any(|a| a.id == id) { + "minecraft:armor_stand".to_owned() + } else if let Some(c) = self.cushions.iter().find(|c| c.id == id) { + c.item() + } else if let Some(f) = self.item_frames.iter().find(|f| f.id == id) { + // ItemFrame.getPickResult: what it frames, else the frame itself. + return Some( + f.item + .clone() + .unwrap_or_else(|| ItemStack::new(f.kind(), 1)), + ); + } else if self.paintings.iter().any(|p| p.id == id) { + "minecraft:painting".to_owned() + } else if self.crystals.iter().any(|c| c.id == id) { + "minecraft:end_crystal".to_owned() + } else { + return None; + }; + Some(ItemStack::new(&item, 1)) + } + + /// `Player.isWithinEntityInteractionRange(entity, 3.0)`: the entity's box + /// within the interaction range plus 3 of the eyes. + pub(super) fn within_entity_range(&self, id: i32) -> bool { + let Some(eye) = self.eye_position() else { + return false; + }; + let mob = u32::try_from(id) + .ok() + .and_then(|id| self.mobs.iter().find(|m| m.id == id)) + .map(|m| m.bounds()); + let Some(b) = self + .object_target(id) + .map(|(lo, hi, _)| (lo, hi)) + .or_else(|| { + mob.or_else(|| self.tracked_special_box(id)).map(|b| { + let (lo, hi) = (b.min_position(), b.max_position()); + ([lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z]) + }) + }) + else { + return false; + }; + let d2: f64 = (0..3) + .map(|a| (eye[a] - eye[a].clamp(b.0[a], b.1[a])).powi(2)) + .sum(); + let range = if self.creative { 5.0 } else { 3.0 } + 3.0; + d2 < range * range + } +} diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 75c0e8690..37340edff 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -5994,7 +5994,16 @@ impl horizon_client::interaction_input::InteractionWorld for RemoteInputWorld<'_ self.0.remote_use(); } fn pick(&mut self) { - if let Some(hit) = self.0.pick() { + // Minecraft.pickBlockOrEntity: an entity before the block is asked + // for (`handlePickItemFromEntity`), else the block. + if let Some(entity) = self.0.pick_entity_hit() { + if let Some(id) = entity { + self.0.send(S::PickItemFromEntity(play::PickItemFromEntity { + id, + include_data: self.0.has_control_down(), + })); + } + } else if let Some(hit) = self.0.pick() { self.0.send(S::PickItemFromBlock(play::PickItemFromBlock { pos: hit.pos, include_data: self.0.has_control_down(), diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs index 0229706ce..2c3aa5d18 100644 --- a/crates/horizon-protocol/src/packets/play.rs +++ b/crates/horizon-protocol/src/packets/play.rs @@ -2243,6 +2243,7 @@ packet!( PaddleBoat { left: bool => Bool, right: bool => Bool } ); packet!(PickItemFromBlock { pos: [i32; 3] => Pos, include_data: bool => Bool }); +packet!(PickItemFromEntity { id: i32 => VarInt, include_data: bool => Bool }); packet!( /// ServerboundPlayerActionPacket.Action: 0 start destroy, 1 change destroy /// direction, 2 abort, 3 stop destroy, 4 drop all, 5 drop item, 6 release @@ -2321,6 +2322,7 @@ packet_enum!(Serverbound, crate::ids::play::serverbound { MoveVehicle(MoveVehicleRequest) = MOVE_VEHICLE, PaddleBoat(PaddleBoat) = PADDLE_BOAT, PickItemFromBlock(PickItemFromBlock) = PICK_ITEM_FROM_BLOCK, + PickItemFromEntity(PickItemFromEntity) = PICK_ITEM_FROM_ENTITY, PingRequest(crate::packets::status::Ping) = PING_REQUEST, PlayerAbilities(PlayerAbilitiesRequest) = PLAYER_ABILITIES, PlayerAction(PlayerAction) = PLAYER_ACTION,