6897e4155b
Ports AbstractNautilus, Nautilus, ZombieNautilus and their brains (taming with pufferfish, saddles and nautilus armour, riding with a dash, breeding, spawning below sea level, drowned riders), SulfurCube on the slime code (swallowed blocks and their archetypes, shears, TNT cubes, splitting) and CamelHusk on the camel (its own saddle and sounds, husk jockeys). Camels now save their saddle and stay tame after loading, and horse armour layers load. The entity model harness compares 150 layers, all matching, including the new mobs and previously unmapped armour, harness, fish and villager layers; mob attributes pass with the new types. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
322 lines
10 KiB
Rust
322 lines
10 KiB
Rust
//! Slimes and magma cubes (`AbstractCubeMob`): sized bodies, hopping
|
|
//! movement (`CubeMobMoveControl`), random directions, contact damage,
|
|
//! squish animation and splitting.
|
|
use super::{
|
|
Mob, MobEvent, MobWorld, Species,
|
|
anim::{Poses, State},
|
|
control::{MoveKind, Operation, rotlerp},
|
|
goals::{Cx, Goal, JUMP, LOOK, MOVE, NearestTarget, Prey, goal_clone, reduced},
|
|
};
|
|
use horizon_core::{geometry::Vec3, random::RandomSource};
|
|
|
|
// AnimState slots.
|
|
const SQUISH: usize = 0;
|
|
const TARGET_SQUISH: usize = 1;
|
|
|
|
pub fn register(m: &mut Mob) {
|
|
if m.species() == Species::SulfurCube {
|
|
return super::sulfur_cube::register(m);
|
|
}
|
|
m.ai.goals.add(1, CubeFloat);
|
|
m.ai.goals.add(2, CubeAttack { tired: 0 });
|
|
m.ai.goals.add(
|
|
4,
|
|
CubeRandomDirection {
|
|
degrees: 0.0,
|
|
next: 0,
|
|
},
|
|
);
|
|
m.ai.goals.add(5, CubeKeepJumping);
|
|
m.ai.targets.add(
|
|
1,
|
|
NearestTarget::new(Prey::Player, true)
|
|
.interval(10)
|
|
.when(|m, w| {
|
|
w.player
|
|
.as_ref()
|
|
.is_some_and(|p| (p.position.y - m.position.y).abs() <= 4.0)
|
|
}),
|
|
);
|
|
m.ai.targets
|
|
.add(3, NearestTarget::species(&[Species::IronGolem], true));
|
|
m.ai.mov.kind = MoveKind::Custom;
|
|
m.ai.nav.can_float = true;
|
|
m.extra.vector[0] = f64::from(180.0 * m.yaw / std::f32::consts::PI);
|
|
set_size(m, 1);
|
|
}
|
|
/// AbstractCubeMob.setSize: health size^2, speed 0.2 + 0.1 * size, damage size.
|
|
pub fn set_size(m: &mut Mob, size: i32) {
|
|
let size = size.clamp(1, 127);
|
|
m.extra.size = size;
|
|
m.attrs.max_health = (size * size) as f32;
|
|
m.attrs.speed = 0.2 + 0.1 * f64::from(size);
|
|
m.attrs.attack_damage = size as f32;
|
|
m.health = m.attrs.max_health;
|
|
}
|
|
/// AbstractCubeMob.setSpawnSize: 1, 2 or 4 (normal difficulty special multiplier 0).
|
|
pub fn finalize(m: &mut Mob) {
|
|
let scale = m.random.next_int_bound(3).unwrap_or(0);
|
|
set_size(m, 1 << scale);
|
|
}
|
|
fn tiny(m: &Mob) -> bool {
|
|
m.extra.size <= 1
|
|
}
|
|
fn can_deal_damage(m: &Mob) -> bool {
|
|
// SulfurCube.canDealDamage: never.
|
|
m.species() == Species::MagmaCube || !tiny(m) && m.species() != Species::SulfurCube
|
|
}
|
|
fn jump_delay(m: &mut Mob) -> i32 {
|
|
let base = m.random.next_int_bound(20).unwrap_or(0) + 10;
|
|
if m.species() == Species::MagmaCube {
|
|
base * 4
|
|
} else {
|
|
base
|
|
}
|
|
}
|
|
fn sound_pitch(m: &mut Mob) -> f32 {
|
|
let adjust = if tiny(m) { 1.4 } else { 0.8 };
|
|
((m.random.next_float() - m.random.next_float()) * 0.2 + 1.0) * adjust
|
|
}
|
|
/// CubeMobMoveControl.tick
|
|
pub fn move_control(m: &mut Mob, events: &mut Vec<MobEvent>) {
|
|
// SulfurCubeMobMoveControl: still while holding a block.
|
|
if m.species() == Species::SulfurCube && super::sulfur_cube::has_body(m) {
|
|
return;
|
|
}
|
|
let want = m.extra.vector[0] as f32;
|
|
m.yaw = rotlerp(m.yaw, want, 90.0);
|
|
m.head_yaw = m.yaw;
|
|
m.body_yaw = m.yaw;
|
|
if m.ai.mov.operation != Operation::MoveTo {
|
|
m.ai.zza = 0.0;
|
|
return;
|
|
}
|
|
m.ai.mov.operation = Operation::Wait;
|
|
let speed = (m.ai.mov.speed_modifier * m.movement_speed()) as f32;
|
|
if m.on_ground {
|
|
m.set_speed(speed);
|
|
let delay = m.extra.counter;
|
|
m.extra.counter -= 1;
|
|
if delay <= 0 {
|
|
m.extra.counter = jump_delay(m);
|
|
if m.extra.flag {
|
|
m.extra.counter /= 3;
|
|
}
|
|
m.ai.jump = true;
|
|
let jump = match (m.species(), tiny(m)) {
|
|
(Species::MagmaCube, _) => "entity.magma_cube.jump",
|
|
(Species::SulfurCube, _) => super::sulfur_cube::jump_sound(m),
|
|
(_, true) => "entity.slime.jump_small",
|
|
_ => "entity.slime.jump",
|
|
};
|
|
let pitch = sound_pitch(m);
|
|
let vol = super::ai::sound_volume(m);
|
|
events.push(MobEvent::Sound(jump, m.center(), vol, pitch));
|
|
} else {
|
|
m.ai.xxa = 0.0;
|
|
m.ai.zza = 0.0;
|
|
m.set_speed(0.0);
|
|
}
|
|
} else {
|
|
m.set_speed(speed);
|
|
}
|
|
}
|
|
pub(super) fn set_direction(m: &mut Mob, y_rot: f32, aggressive: bool) {
|
|
m.extra.vector[0] = f64::from(y_rot);
|
|
m.extra.flag = aggressive;
|
|
}
|
|
pub(super) fn set_wanted(m: &mut Mob, speed: f64) {
|
|
m.ai.mov.speed_modifier = speed;
|
|
m.ai.mov.operation = Operation::MoveTo;
|
|
}
|
|
/// AbstractCubeMob.jumpFromGround (and MagmaCube's size boost).
|
|
pub fn jump(m: &mut Mob) {
|
|
let boost = if m.species() == Species::MagmaCube {
|
|
m.extra.size as f32 * 0.1
|
|
} else {
|
|
0.0
|
|
};
|
|
m.velocity.y = f64::from(m.jump_power() + boost);
|
|
}
|
|
/// AbstractCubeMob.tick squish and landing sounds, plus contact damage.
|
|
pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
|
|
let v = &mut m.anim.v;
|
|
v[SQUISH] += (v[TARGET_SQUISH] - v[SQUISH]) * 0.5;
|
|
let was = m.extra.flag2;
|
|
if m.on_ground && !was {
|
|
let squish = match (m.species(), tiny(m)) {
|
|
(Species::SulfurCube, _) => super::sulfur_cube::squish_sound(m),
|
|
(Species::MagmaCube, true) => "entity.magma_cube.squish_small",
|
|
(Species::MagmaCube, false) => "entity.magma_cube.squish",
|
|
(_, true) => "entity.slime.squish_small",
|
|
_ => "entity.slime.squish",
|
|
};
|
|
let pitch = ((m.random.next_float() - m.random.next_float()) * 0.2 + 1.0) / 0.8;
|
|
let vol = super::ai::sound_volume(m);
|
|
events.push(MobEvent::Sound(squish, m.center(), vol, pitch));
|
|
m.anim.v[TARGET_SQUISH] = -0.5;
|
|
} else if !m.on_ground && was {
|
|
m.anim.v[TARGET_SQUISH] = 1.0;
|
|
}
|
|
m.extra.flag2 = m.on_ground;
|
|
m.anim.v[TARGET_SQUISH] *= if m.species() == Species::MagmaCube {
|
|
0.9
|
|
} else {
|
|
0.6
|
|
};
|
|
// playerTouch -> dealDamage
|
|
if can_deal_damage(m)
|
|
&& m.alive()
|
|
&& let Some(p) = &w.player
|
|
&& p.alive
|
|
&& !p.creative
|
|
// Player.touch: entities within the player's box grown by (1, 0.5, 1).
|
|
&& m.bounds().intersects(p.bounds.inflate(Vec3::new(1.0, 0.5, 1.0)))
|
|
{
|
|
let reach = 2.04f32.sqrt() as f64 - 0.6;
|
|
if m.bounds()
|
|
.inflate(Vec3::new(reach, 0.0, reach))
|
|
.intersects(p.bounds)
|
|
{
|
|
let damage = m.attrs.attack_damage
|
|
+ if m.species() == Species::MagmaCube {
|
|
2.0
|
|
} else {
|
|
0.0
|
|
};
|
|
events.push(MobEvent::AttackPlayer(
|
|
damage,
|
|
[m.position.x, m.position.y, m.position.z],
|
|
));
|
|
if m.species() == Species::Slime {
|
|
let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0;
|
|
events.push(MobEvent::Sound(
|
|
"entity.slime.attack",
|
|
m.center(),
|
|
1.0,
|
|
pitch,
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// MagmaCubeModel.setupAnim (slimes have no animation).
|
|
pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
|
|
if m.species() == Species::MagmaCube {
|
|
let squish = m.anim.lerp(SQUISH, s.partial).max(0.0);
|
|
for i in 0..8 {
|
|
p.get(&format!("cube{i}"))[1] = -((4 - i) as f32) * squish * 1.7;
|
|
}
|
|
}
|
|
}
|
|
/// AbstractCubeMobRenderer.scale: size with squash and stretch.
|
|
pub fn scale(m: &Mob, alpha: f32) -> glam::Mat4 {
|
|
let size = m.extra.size.max(1) as f32;
|
|
let squish = m.anim.lerp(SQUISH, alpha) / (size * 0.5 + 1.0);
|
|
let w = 1.0 / (squish + 1.0);
|
|
let mut t = glam::Mat4::IDENTITY;
|
|
if m.species() == Species::Slime {
|
|
t = glam::Mat4::from_scale(glam::Vec3::splat(0.999))
|
|
* glam::Mat4::from_translation(glam::Vec3::new(0.0, 0.001, 0.0));
|
|
}
|
|
t * glam::Mat4::from_scale(glam::Vec3::new(w * size, 1.0 / w * size, w * size))
|
|
}
|
|
/// CubeMobFloatGoal
|
|
#[derive(Clone, Debug)]
|
|
pub(super) struct CubeFloat;
|
|
impl Goal for CubeFloat {
|
|
goal_clone!();
|
|
fn flags(&self) -> u8 {
|
|
JUMP | MOVE
|
|
}
|
|
fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
|
|
m.is_in_liquid()
|
|
}
|
|
fn every_tick(&self) -> bool {
|
|
true
|
|
}
|
|
fn tick(&mut self, m: &mut Mob, _: &mut Cx) {
|
|
if m.random.next_float() < 0.8 {
|
|
m.ai.jump = true;
|
|
}
|
|
set_wanted(m, 1.2);
|
|
}
|
|
}
|
|
/// CubeMobAttackGoal: face the target and hop at it for up to 300 ticks.
|
|
#[derive(Clone, Debug)]
|
|
struct CubeAttack {
|
|
tired: i32,
|
|
}
|
|
impl Goal for CubeAttack {
|
|
goal_clone!();
|
|
fn flags(&self) -> u8 {
|
|
LOOK
|
|
}
|
|
fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
|
|
m.target_info(cx.w)
|
|
.is_some_and(|t| t.alive && !(t.is_player && t.creative))
|
|
}
|
|
fn start(&mut self, _: &mut Mob, _: &mut Cx) {
|
|
self.tired = reduced(300);
|
|
}
|
|
fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
|
|
if !m
|
|
.target_info(cx.w)
|
|
.is_some_and(|t| t.alive && !(t.is_player && t.creative))
|
|
{
|
|
return false;
|
|
}
|
|
self.tired -= 1;
|
|
self.tired > 0
|
|
}
|
|
fn every_tick(&self) -> bool {
|
|
true
|
|
}
|
|
fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
|
|
if let Some(t) = m.target_info(cx.w) {
|
|
m.turn_to([t.position.x, t.eye_y, t.position.z], 10.0, 10.0);
|
|
}
|
|
let (yaw, aggressive) = (m.yaw, can_deal_damage(m));
|
|
set_direction(m, yaw, aggressive);
|
|
}
|
|
}
|
|
/// CubeMobRandomDirectionGoal
|
|
#[derive(Clone, Debug, Default)]
|
|
pub(super) struct CubeRandomDirection {
|
|
degrees: f32,
|
|
next: i32,
|
|
}
|
|
impl Goal for CubeRandomDirection {
|
|
goal_clone!();
|
|
fn flags(&self) -> u8 {
|
|
LOOK
|
|
}
|
|
fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
|
|
m.ai.target.is_none()
|
|
&& (m.on_ground || m.is_in_liquid() || m.has_effect("minecraft:levitation"))
|
|
}
|
|
fn tick(&mut self, m: &mut Mob, _: &mut Cx) {
|
|
self.next -= 1;
|
|
if self.next <= 0 {
|
|
self.next = reduced(40 + m.random.next_int_bound(60).unwrap_or(0));
|
|
self.degrees = m.random.next_int_bound(360).unwrap_or(0) as f32;
|
|
}
|
|
set_direction(m, self.degrees, false);
|
|
}
|
|
}
|
|
/// CubeMobKeepOnJumpingGoal
|
|
#[derive(Clone, Debug)]
|
|
pub(super) struct CubeKeepJumping;
|
|
impl Goal for CubeKeepJumping {
|
|
goal_clone!();
|
|
fn flags(&self) -> u8 {
|
|
JUMP | MOVE
|
|
}
|
|
fn can_use(&mut self, _: &mut Mob, _: &mut Cx) -> bool {
|
|
true
|
|
}
|
|
fn tick(&mut self, m: &mut Mob, _: &mut Cx) {
|
|
set_wanted(m, 1.0);
|
|
}
|
|
}
|