From 42ef865c344b8c7553313f285fbd880915ba8d68 Mon Sep 17 00:00:00 2001 From: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Tue, 27 Oct 2026 02:11:05 +0100 Subject: [PATCH 1/2] Give shulkers vanilla placement, push and look rules A shulker used to check only that its cell was air and the support block had a full collision box. canStayAt now mirrors vanilla: a moving piston in the shell's own cell does not force a teleport, the support's face toward the shell must be sturdy, and the fully opened shell's box must be clear of blocks and entities. teleportSomewhere likewise checks the target cell with noCollision and refuses faces tagged minecraft:shulker_does_not_teleport_to, emits level event 2016 (whose particles now render), and forces a position sync. The shell easing toward its peek now pushes collidable entities out of the swept box (onPeekAmountChange / MoverType.SHULKER) through a new MobEvent::Shift, so standing on a shulker lifts you instead of wedging you inside the lid. ShulkerLookControl is ported too: the head yaw is computed in the attach face's plane (new LookKind::Shulker and look_yaw) instead of the generic world-yaw, and hurtByTarget now ignores damage from other shulkers as toIgnoreDamage does. Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- crates/horizon-client/src/game.rs | 5 + crates/horizon-client/src/game/creatures.rs | 15 ++ .../src/game/level_particles.rs | 6 + crates/horizon-client/src/mobs.rs | 6 + crates/horizon-client/src/mobs/control.rs | 17 ++ crates/horizon-client/src/mobs/shulker.rs | 252 +++++++++++++++--- 6 files changed, 264 insertions(+), 37 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index db49087b2..bb24b81b1 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2921,6 +2921,11 @@ impl Game<'_> { pos, data, } => self.dragon_egg_particles([pos.x, pos.y, pos.z], data), + LevelEvent::LevelEvent { + id: 2016, + pos, + data, + } => self.shulker_teleport_particles([pos.x, pos.y, pos.z], data), LevelEvent::LevelEvent { id: 2017, pos, diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index e895cb7f7..6226dbf80 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -944,6 +944,21 @@ impl Game<'_> { } } } + MobEvent::Shift { target, delta } => { + let d = Vec3::new(delta[0], delta[1], delta[2]); + match target { + Who::Player => { + if let Some(p) = self.player.as_mut() { + p.position = p.position.add_vector(d); + } + } + Who::Mob(id) => { + if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) { + m.position = m.position.add_vector(d); + } + } + } + } MobEvent::Wololo { mob } => { if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { // DyeColor.RED. diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs index f12aedc5b..165faa4b6 100644 --- a/crates/horizon-client/src/game/level_particles.rs +++ b/crates/horizon-client/src/game/level_particles.rs @@ -12,6 +12,12 @@ impl Game<'_> { self.particles .block_teleportation(pos, data, [16, 8, 16], self.settings.particles); } + /// Event 2016: `Shulker.teleportSomewhere`'s particles between the + /// shell's old and new cells. + pub(super) fn shulker_teleport_particles(&mut self, pos: [i32; 3], data: i32) { + self.particles + .block_teleportation(pos, data, [8, 8, 8], self.settings.particles); + } /// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles. pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) { self.particles diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 0d7fb4b54..62a9974c0 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -972,6 +972,12 @@ pub enum MobEvent { target: Who, velocity: [f64; 3], }, + /// `Entity.move(MoverType.SHULKER, delta)`: shift a target's position + /// (an opening shulker lifts what stands on its shell). + Shift { + target: Who, + delta: [f64; 3], + }, /// `EvokerWololoSpellGoal`: a blue sheep turns red. Wololo { mob: u32, diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs index 3df557362..a111ff5d4 100644 --- a/crates/horizon-client/src/mobs/control.rs +++ b/crates/horizon-client/src/mobs/control.rs @@ -90,6 +90,9 @@ pub enum LookKind { Fixed, /// `HappyGhast.HappyGhastLookControl`. HappyGhast, + /// `Shulker.ShulkerLookControl`: the yaw turns in the attach face's + /// plane and the head is never clamped to the body. + Shulker, } #[derive(Clone, Debug, Default)] pub struct LookControl { @@ -345,6 +348,20 @@ impl Mob { self.body_yaw += 4.0; } } + LookKind::Shulker => { + // ShulkerLookControl: resetXRotOnTick, getXRotD 0, and the + // yaw worked out in the attach face's plane (getYRotD). + self.head_pitch = 0.0; + if look.cooldown > 0 { + self.ai.look.cooldown -= 1; + if let Some(y) = super::shulker::look_yaw(self, look.wanted) { + self.head_yaw = rotate_towards(self.head_yaw, y, look.y_max_rot_speed); + } + } else { + self.head_yaw = rotate_towards(self.head_yaw, self.body_yaw, 10.0); + } + // clampHeadRotationToBody does nothing for a shulker. + } LookKind::Default | LookKind::Fixed => { if look.kind == LookKind::Default { self.head_pitch = 0.0; diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs index 6f0edc2d7..d5bdb6888 100644 --- a/crates/horizon-client/src/mobs/shulker.rs +++ b/crates/horizon-client/src/mobs/shulker.rs @@ -5,6 +5,7 @@ use super::{ Damage, DamageKind, Mob, MobEvent, MobWorld, Species, Who, anim::{Poses, State}, + control::LookKind, goals::{ Cx, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, NearestTarget, RandomLookAround, goal_clone, reduced, @@ -37,7 +38,13 @@ pub fn register(m: &mut Mob) { g.add(4, ShulkerAttack { attack_time: 0 }); g.add(7, Peek { time: 0 }); g.add(8, RandomLookAround::default()); - m.ai.targets.add(1, HurtByTarget::new().alert()); + // `ShulkerLookControl`: the head turns in the attach face's plane. + m.ai.look.kind = LookKind::Shulker; + // `HurtByTargetGoal(this, Shulker.class).setAlertOthers()`: damage from + // another shulker draws no retaliation (`toIgnoreDamage`), but a hurt + // shulker alerts every targetless shulker around. + m.ai.targets + .add(1, HurtByTarget::new().alert().ignoring(&[Species::Shulker])); // ShulkerNearestAttackGoal: the search box is only 4 deep along the // attach axis. m.ai.targets.add( @@ -57,6 +64,10 @@ pub fn register(m: &mut Mob) { fn face_step(face: u8) -> [i32; 3] { STEPS[face.min(5) as usize] } +/// `Direction.getOpposite` for a 3D data value. +fn opposite(face: u8) -> u8 { + face.min(5) ^ 1 +} fn block_pos(m: &Mob) -> [i32; 3] { [ m.position.x.floor() as i32, @@ -64,19 +75,85 @@ fn block_pos(m: &Mob) -> [i32; 3] { m.position.z.floor() as i32, ] } -/// `Shulker.canStayAt`: an empty spot against a sturdy face. -fn can_stay_at(w: &MobWorld, p: [i32; 3], face: u8) -> bool { - if !w.facts.is_air(w.world.block(p[0], p[1], p[2])) { +/// `Shulker.getProgressDeltaAabb` at scale 1: the shell's box from `pos` +/// (the bottom centre), grown `from`..`to` along `direction`. +fn progress_aabb(direction: u8, from: f64, to: f64, pos: Vec3) -> Aabb { + let s = face_step(direction).map(f64::from); + let (max, min) = (from.max(to), from.min(to)); + Aabb::new(Vec3::new(-0.5, 0.0, -0.5), Vec3::new(0.5, 1.0, 0.5)) + .expand_towards(Vec3::new(s[0] * max, s[1] * max, s[2] * max)) + .contract(Vec3::new( + -s[0] * (1.0 + min), + -s[1] * (1.0 + min), + -s[2] * (1.0 + min), + )) + .move_by(pos) +} +/// `Level.noCollision(entity, aabb)`: no block collision under the empty +/// context, and no entity `m` can be collided with overlaps (other mobs, +/// and the player when they are not a spectator). +fn no_collision(m: &Mob, w: &MobWorld, bounds: Aabb) -> bool { + let mut scene = crate::collisions::SceneCollisions { + world: w.world, + binding: w.collision, + subject: None, + }; + if !crate::collisions::no_collision_empty(&mut scene, bounds) { return false; } + let grown = bounds.inflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7)); + if let Some(p) = &w.player + && p.alive + && !p.spectator + && p.bounds.intersects(grown) + { + return false; + } + !w.others_near(grown) + .any(|s| s.id != m.id && s.alive && s.bounds.intersects(grown)) +} +/// `Shulker.canStayAt`: an empty spot against a sturdy face, with room +/// for the fully opened shell (`canStayAt`). +fn can_stay_at(m: &Mob, w: &MobWorld, p: [i32; 3], face: u8) -> bool { + // isPositionBlocked: anything but air blocks, except a moving piston + // being driven through the shulker's own cell. + if !w.facts.is_air(w.world.block(p[0], p[1], p[2])) + && (p != block_pos(m) || w.block_name(p[0], p[1], p[2]) != "minecraft:moving_piston") + { + return false; + } + // loadedAndEntityCanStandOnFace: the supporting block's face toward + // the shell is sturdy. let s = face_step(face); - let n = w.world.block(p[0] + s[0], p[1] + s[1], p[2] + s[2]); - w.facts.get(n).full_collision + let support = w.world.block(p[0] + s[0], p[1] + s[1], p[2] + s[2]); + let open = opposite(face); + if w.facts.get(support).sturdy_full & (1 << open) == 0 { + return false; + } + // The fully opened shell's box, shrunk by the skin vanilla uses. + let opened = progress_aabb( + open, + -1.0, + 1.0, + Vec3::new( + f64::from(p[0]) + 0.5, + f64::from(p[1]), + f64::from(p[2]) + 0.5, + ), + ) + .deflate(Vec3::new(1.0e-6, 1.0e-6, 1.0e-6)); + no_collision(m, w, opened) } /// `findAttachableSurface`: the first face (down, up, north, south, west, /// east) to cling to. -fn attachable(w: &MobWorld, p: [i32; 3]) -> Option { - (0..6).find(|&f| can_stay_at(w, p, f)) +fn attachable(m: &Mob, w: &MobWorld, p: [i32; 3]) -> Option { + (0..6).find(|&f| can_stay_at(m, w, p, f)) +} +/// `BlockUtil.packDifferenceInPosition` within 8 blocks of `pos`. +fn pack_diff(pos: [i32; 3], to: [i32; 3]) -> i32 { + ((to[0] - pos[0] + 8) & 0xFF) << 16 + | ((to[1] - pos[1] + 8) & 0xFF) << 8 + | (to[2] - pos[2] + 8) & 0xFF } /// `Shulker.teleportSomewhere`: up to five tries within 8 blocks. fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec) -> bool { @@ -87,12 +164,31 @@ fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec) -> bool { for _ in 0..5 { let r = |m: &mut Mob| m.random.next_int_bound(17).unwrap_or(8) - 8; let t = [old[0] + r(m), old[1] + r(m), old[2] + r(m)]; - if t[1] <= crate::chunk::MIN_Y || !w.facts.is_air(w.world.block(t[0], t[1], t[2])) { + let unit = Aabb::new( + Vec3::new(f64::from(t[0]), f64::from(t[1]), f64::from(t[2])), + Vec3::new( + f64::from(t[0]) + 1.0, + f64::from(t[1]) + 1.0, + f64::from(t[2]) + 1.0, + ), + ); + if t[1] <= crate::chunk::MIN_Y + || !w.facts.is_air(w.world.block(t[0], t[1], t[2])) + || !no_collision(m, w, unit.deflate(Vec3::new(1.0e-6, 1.0e-6, 1.0e-6))) + { continue; } - let Some(face) = attachable(w, t) else { + let Some(face) = attachable(m, w, t) else { continue; }; + // `#minecraft:shulker_does_not_teleport_to` (bedrock) is never clung to. + let s = face_step(face); + if w.has_tag( + "minecraft:shulker_does_not_teleport_to", + w.block_name(t[0] + s[0], t[1] + s[1], t[2] + s[2]), + ) { + continue; + } m.extra.variant3 = face; events.push(MobEvent::Sound( "entity.shulker.teleport", @@ -106,6 +202,14 @@ fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec) -> bool { f64::from(t[2]) + 0.5, ); m.previous = m.position; + // Level.levelEvent(2016, oldPos, packedDiff): the teleport's + // particles at both ends, seen by the players around. + events.push(MobEvent::LevelEvent { + id: 2016, + pos: old, + data: pack_diff(old, t), + }); + m.needs_sync = true; m.extra.counter = 0; m.ai.target = None; return true; @@ -127,31 +231,102 @@ fn set_peek(m: &mut Mob, amount: i32, events: &mut Vec) { )); m.extra.counter = amount; } -/// `Shulker.tick` additions: keep a face (or teleport), ease the peek, -/// stay still and square on its block. +/// `Shulker.updatePeekAmount`/`updatePeekAmountO`: the eased peek. +fn ease_peek(m: &mut Mob) -> (f32, f32) { + let old = m.anim.v[PEEK]; + let target = m.extra.counter as f32 * 0.01; + let new = if old > target { + (old - 0.05).clamp(target, 1.0) + } else { + (old + 0.05).clamp(0.0, target) + }; + m.anim.v[PEEK] = new; + (old, new) +} +/// `Shulker.tick` additions: keep a face (or teleport), ease the peek +/// (pushing whatever it opens into), stay still and square on its block. pub fn tick(m: &mut Mob, w: &MobWorld, events: &mut Vec) { m.velocity = Vec3::ZERO; m.body_yaw = 0.0; m.yaw = 0.0; m.head_pitch = 0.0; let p = block_pos(m); - if !can_stay_at(w, p, m.extra.variant3) { - match attachable(w, p) { + if !can_stay_at(m, w, p, m.extra.variant3) { + match attachable(m, w, p) { Some(f) => m.extra.variant3 = f, None => { teleport(m, w, events); } } } - let a = &mut m.anim; - let target = m.extra.counter as f32 * 0.01; - let cur = a.v[PEEK]; - if cur > target { - a.v[PEEK] = (cur - 0.05).clamp(target, 1.0); - } else if cur < target { - a.v[PEEK] = (cur + 0.05).clamp(0.0, target); + let (old, new) = ease_peek(m); + if new != old { + on_peek_change(m, w, old, new, events); } } +/// `Shulker.getPhysicalPeek`: the lid's lift for a peek amount. +fn physical_peek(amount: f32) -> f64 { + f64::from(0.5 - ((0.5 + amount) * PI).msin() * 0.5) +} +/// `Shulker.onPeekAmountChange`: an opening shell pushes out of its way +/// every entity that can be collided with (except other shulkers). +fn on_peek_change(m: &Mob, w: &MobWorld, old: f32, new: f32, events: &mut Vec) { + let dir = opposite(m.extra.variant3); + let s = face_step(dir).map(f64::from); + let (old_p, new_p) = (physical_peek(old), physical_peek(new)); + let push = new_p - old_p; + if push <= 0.0 { + return; + } + let delta = [push * s[0], push * s[1], push * s[2]]; + let area = progress_aabb(dir, old_p, new_p, m.position); + if let Some(p) = &w.player + && p.alive + && !p.spectator + && p.bounds.intersects(area) + { + events.push(MobEvent::Shift { + target: Who::Player, + delta, + }); + } + for seen in w.others_near(area) { + if seen.id == m.id + || !seen.alive + || seen.species == Species::Shulker + || !seen.bounds.intersects(area) + { + continue; + } + events.push(MobEvent::Shift { + target: Who::Mob(seen.id), + delta, + }); + } +} +/// `ShulkerLookControl.getYRotD`: the look yaw in the open direction's +/// plane (`None`: the target is on the head's own axis). +pub fn look_yaw(m: &Mob, at: [f64; 3]) -> Option { + let open = opposite(m.extra.variant3); + // `attachFace.getRotation().transform(FORWARD)`: the model's forward + // rotated as the renderer does (`rotations` uses the same quats). + let forward = face_quat(m.extra.variant3) * glam::Vec3::Z; + let s = face_step(open).map(|v| v as f32); + let right = glam::Vec3::from_array(s).cross(forward); + let out = glam::Vec3::new( + (at[0] - m.position.x) as f32, + (at[1] - m.eye_y()) as f32, + (at[2] - m.position.z) as f32, + ); + let (delta_right, delta_forward) = (right.dot(out), forward.dot(out)); + if delta_right.abs() <= 1.0e-5 && delta_forward.abs() <= 1.0e-5 { + return None; + } + Some(horizon_core::geometry::trig::atan2_degrees( + f64::from(-delta_right), + f64::from(delta_forward), + )) +} /// `Shulker.hurtServer` before the damage: arrows bounce off a closed shell. pub fn accepts(m: &Mob, source: &Damage) -> bool { !(m.extra.counter == 0 && source.kind == DamageKind::Arrow) @@ -319,7 +494,7 @@ impl Goal for Peek { fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool { m.ai.target.is_none() && m.random.next_int_bound(reduced(40)).unwrap_or(1) == 0 - && can_stay_at(cx.w, block_pos(m), m.extra.variant3) + && can_stay_at(m, cx.w, block_pos(m), m.extra.variant3) } fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool { m.ai.target.is_none() && self.time > 0 @@ -362,24 +537,27 @@ pub fn texture(m: &Mob) -> String { None => "entity/shulker/shulker".into(), } } +/// `attachFace.getOpposite().getRotation()` by attach face: the open +/// direction's rotation (`Direction.getRotation` of `face ^ 1`). +fn face_quat(face: u8) -> glam::Quat { + match face.min(5) { + // Attached below: upright. + 0 => glam::Quat::IDENTITY, + 1 => glam::Quat::from_rotation_x(PI), + 2 => glam::Quat::from_rotation_x(PI / 2.0), + 3 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI), + 4 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, -PI / 2.0), + _ => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI / 2.0), + } +} /// `ShulkerRenderer.setupRotations`: turned onto its attach face around the /// block's centre (after a half turn of the body). pub fn rotations(m: &Mob) -> glam::Mat4 { - { - let q = match m.extra.variant3 { - // Attached below: upright. - 0 => glam::Quat::IDENTITY, - 1 => glam::Quat::from_rotation_x(PI), - 2 => glam::Quat::from_rotation_x(PI / 2.0), - 3 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI), - 4 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, -PI / 2.0), - _ => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI / 2.0), - }; - glam::Mat4::from_rotation_y(PI) - * glam::Mat4::from_translation(glam::Vec3::new(0.0, 0.5, 0.0)) - * glam::Mat4::from_quat(q) - * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.5, 0.0)) - } + let q = face_quat(m.extra.variant3); + glam::Mat4::from_rotation_y(PI) + * glam::Mat4::from_translation(glam::Vec3::new(0.0, 0.5, 0.0)) + * glam::Mat4::from_quat(q) + * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.5, 0.0)) } /// `ShulkerModel.setupAnim`: the lid rises and twists with the peek, the /// head turns. From 40f8b9600d3f54a55d73b02151485664cffbdaed Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 27 Oct 2026 06:34:02 +0100 Subject: [PATCH 2/2] Shulker canStayAt: only collidable entities block the shell Level.noCollision(shulker, box) keeps the entities whose canBeCollidedWith is true for the shulker: living shulkers and adult happy ghasts (boats and minecarts too, outside the mob world). Players and other mobs never stop a shulker from opening or landing. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/mobs/shulker.rs | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs index d5bdb6888..32f952e15 100644 --- a/crates/horizon-client/src/mobs/shulker.rs +++ b/crates/horizon-client/src/mobs/shulker.rs @@ -89,9 +89,10 @@ fn progress_aabb(direction: u8, from: f64, to: f64, pos: Vec3) -> Aabb { )) .move_by(pos) } -/// `Level.noCollision(entity, aabb)`: no block collision under the empty -/// context, and no entity `m` can be collided with overlaps (other mobs, -/// and the player when they are not a spectator). +/// `Level.noCollision(shulker, aabb)`: no block collision under the empty +/// context, and none of the entities a shulker collides with overlaps +/// (`canBeCollidedWith`: living shulkers and adult happy ghasts; players +/// and other mobs never block it). fn no_collision(m: &Mob, w: &MobWorld, bounds: Aabb) -> bool { let mut scene = crate::collisions::SceneCollisions { world: w.world, @@ -102,15 +103,12 @@ fn no_collision(m: &Mob, w: &MobWorld, bounds: Aabb) -> bool { return false; } let grown = bounds.inflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7)); - if let Some(p) = &w.player - && p.alive - && !p.spectator - && p.bounds.intersects(grown) - { - return false; - } - !w.others_near(grown) - .any(|s| s.id != m.id && s.alive && s.bounds.intersects(grown)) + !w.others_near(grown).any(|s| { + s.id != m.id + && s.alive + && (s.species == Species::Shulker || (s.species == Species::HappyGhast && !s.baby)) + && s.bounds.intersects(grown) + }) } /// `Shulker.canStayAt`: an empty spot against a sturdy face, with room /// for the fully opened shell (`canStayAt`).