Merge pull request #2603 from socksprox/fix/shulker-teleport-and-look

🤖 Agent: verified by Ludovic's AI agent (contrib gate 20): shulker placement, push and look rules, with no_collision counting only canBeCollidedWith entities. It passed in this wave's union with main on the Mac mini: the selected parity harnesses (332/332, then 122/122 on the final union), clippy -D warnings and the tests, and lan_e2e with the host on its server thread and in-frame (18/18 each). Thanks @socksprox!
This commit is contained in:
Ludovic Marie
2026-10-27 08:46:39 +01:00
committed by GitHub
6 changed files with 262 additions and 37 deletions
+5
View File
@@ -3032,6 +3032,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,
@@ -980,6 +980,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.
@@ -13,6 +13,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
+6
View File
@@ -984,6 +984,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,
+17
View File
@@ -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 {
@@ -348,6 +351,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;
+213 -37
View File
@@ -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,83 @@ 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(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,
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));
!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`).
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<u8> {
(0..6).find(|&f| can_stay_at(w, p, f))
fn attachable(m: &Mob, w: &MobWorld, p: [i32; 3]) -> Option<u8> {
(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<MobEvent>) -> bool {
@@ -87,12 +162,31 @@ fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) -> 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 +200,14 @@ fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) -> 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 +229,102 @@ fn set_peek(m: &mut Mob, amount: i32, events: &mut Vec<MobEvent>) {
));
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<MobEvent>) {
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<MobEvent>) {
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<f32> {
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 +492,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 +535,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.