|
|
|
@@ -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.
|
|
|
|
|